R Under development (unstable) (2023-12-20 r85711 ucrt) -- "Unsuffered Consequences"
Copyright (C) 2023 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
[13:14:23.632] plan(): Setting new future strategy stack:
[13:14:23.633] List of future strategies:
[13:14:23.633] 1. sequential:
[13:14:23.633]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[13:14:23.633]    - tweaked: FALSE
[13:14:23.633]    - call: future::plan("sequential")
[13:14:23.649] plan(): nbrOfWorkers() = 1
> 
> message("*** future_*apply() and 'future.stdout' ...")
*** future_*apply() and 'future.stdout' ...
> 
> options(future.debug = TRUE)
> 
> truth <- list()
> 
> out <- utils::capture.output({
+   y <- lapply(1:0, FUN = function(x) {
+     print(x)
+   })
+ })
> truth[["lapply"]] <- list(value = y, stdout = out)
> 
> out <- utils::capture.output({
+   y <- mapply(1:0, 0:1, FUN = function(x, y) {
+     print(list(x = x, y = y))
+   })
+ })
> truth[["mapply"]] <- list(value = y, stdout = out)
> 
> for (cores in 1:availCores) {
+   message(sprintf("  - Testing with %d cores ...", cores))
+   options(mc.cores = cores)
+   
+   for (strategy in supportedStrategies(cores)) {
+     message(sprintf("* plan('%s') ...", strategy))
+     plan(strategy)
+ 
+     for (fun in names(truth)) {
+       for (stdout in c(FALSE, TRUE, NA)) {
+         message(sprintf("* future_%s(x, ..., future.stdout = %s) ...", fun, stdout))
+   
+         out <- utils::capture.output({
+           if (fun == "lapply") {
+             y <- future_lapply(1:0, FUN = function(x) {
+               Sys.sleep(x / 2)  ## make futures resolve out of order
+ 	      print(x)
+             }, future.stdout = stdout)
+ 	  } else if (fun == "mapply") {
+             y <- future_mapply(1:0, 0:1, FUN = function(x, y) {
+               Sys.sleep(x / 2)  ## make futures resolve out of order
+               print(list(x = x, y = y))
+             }, future.stdout = stdout)
+ 	  }
+         })
+         stopifnot(identical(y, truth[[fun]]$value))
+   
+         if (isTRUE(stdout)) {
+           stopifnot(identical(out, truth[[fun]]$stdout))
+         } else if (is.na(stdout)) {
+         } else {
+           stopifnot(nchar(out) == 0)
+         }
+       
+         message(sprintf("* future_%s(x, ..., future.stdout = %s) ... DONE", fun, stdout))
+       } ## for (stdout ...)
+     } ## for (fun ...)
+     
+     message(sprintf("* plan('%s') ... DONE", strategy))
+   }
+   
+   message(sprintf("  - Testing with %d cores ... DONE", cores))
+ }
  - Testing with 1 cores ...
* plan('sequential') ...
[13:14:23.684] plan(): Setting new future strategy stack:
[13:14:23.684] List of future strategies:
[13:14:23.684] 1. sequential:
[13:14:23.684]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[13:14:23.684]    - tweaked: FALSE
[13:14:23.684]    - call: plan(strategy)
[13:14:23.698] plan(): nbrOfWorkers() = 1
* future_lapply(x, ..., future.stdout = FALSE) ...
[13:14:23.698] future_lapply() ...
[13:14:23.703] Number of chunks: 1
[13:14:23.703] getGlobalsAndPackagesXApply() ...
[13:14:23.704]  - future.globals: TRUE
[13:14:23.704] getGlobalsAndPackages() ...
[13:14:23.705] Searching for globals...
[13:14:23.708] - globals found: [5] 'FUN', '{', 'Sys.sleep', '/', 'print'
[13:14:23.708] Searching for globals ... DONE
[13:14:23.708] Resolving globals: FALSE
[13:14:23.709] The total size of the 1 globals is 4.61 KiB (4720 bytes)
[13:14:23.710] The total size of the 1 globals exported for future expression ('FUN()') is 4.61 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.61 KiB of class 'function')
[13:14:23.710] - globals: [1] 'FUN'
[13:14:23.710] 
[13:14:23.711] getGlobalsAndPackages() ... DONE
[13:14:23.711]  - globals found/used: [n=1] 'FUN'
[13:14:23.711]  - needed namespaces: [n=0] 
[13:14:23.711] Finding globals ... DONE
[13:14:23.711]  - use_args: TRUE
[13:14:23.711]  - Getting '...' globals ...
[13:14:23.712] resolve() on list ...
[13:14:23.713]  recursive: 0
[13:14:23.713]  length: 1
[13:14:23.713]  elements: '...'
[13:14:23.713]  length: 0 (resolved future 1)
[13:14:23.714] resolve() on list ... DONE
[13:14:23.714]    - '...' content: [n=0] 
[13:14:23.714] List of 1
[13:14:23.714]  $ ...: list()
[13:14:23.714]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[13:14:23.714]  - attr(*, "where")=List of 1
[13:14:23.714]   ..$ ...:<environment: 0x0000022a2ed29bf8> 
[13:14:23.714]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[13:14:23.714]  - attr(*, "resolved")= logi TRUE
[13:14:23.714]  - attr(*, "total_size")= num NA
[13:14:23.720]  - Getting '...' globals ... DONE
[13:14:23.720] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[13:14:23.721] List of 2
[13:14:23.721]  $ ...future.FUN:function (x)  
[13:14:23.721]  $ ...          : list()
[13:14:23.721]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[13:14:23.721]  - attr(*, "where")=List of 2
[13:14:23.721]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[13:14:23.721]   ..$ ...          :<environment: 0x0000022a2ed29bf8> 
[13:14:23.721]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[13:14:23.721]  - attr(*, "resolved")= logi FALSE
[13:14:23.721]  - attr(*, "total_size")= num 4720
[13:14:23.724] Packages to be attached in all futures: [n=0] 
[13:14:23.724] getGlobalsAndPackagesXApply() ... DONE
[13:14:23.724] Number of futures (= number of chunks): 1
[13:14:23.725] Launching 1 futures (chunks) ...
[13:14:23.725] Chunk #1 of 1 ...
[13:14:23.725]  - Finding globals in 'X' for chunk #1 ...
[13:14:23.725] getGlobalsAndPackages() ...
[13:14:23.726] Searching for globals...
[13:14:23.726] 
[13:14:23.726] Searching for globals ... DONE
[13:14:23.726] - globals: [0] <none>
[13:14:23.726] getGlobalsAndPackages() ... DONE
[13:14:23.727]    + additional globals found: [n=0] 
[13:14:23.727]    + additional namespaces needed: [n=0] 
[13:14:23.727]  - Finding globals in 'X' for chunk #1 ... DONE
[13:14:23.727]  - seeds: <none>
[13:14:23.727]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:23.728] getGlobalsAndPackages() ...
[13:14:23.728] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:23.728] Resolving globals: FALSE
[13:14:23.728] Tweak future expression to call with '...' arguments ...
[13:14:23.728] {
[13:14:23.728]     do.call(function(...) {
[13:14:23.728]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[13:14:23.728]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[13:14:23.728]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[13:14:23.728]             on.exit(options(oopts), add = TRUE)
[13:14:23.728]         }
[13:14:23.728]         {
[13:14:23.728]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[13:14:23.728]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[13:14:23.728]                 ...future.FUN(...future.X_jj, ...)
[13:14:23.728]             })
[13:14:23.728]         }
[13:14:23.728]     }, args = future.call.arguments)
[13:14:23.728] }
[13:14:23.729] Tweak future expression to call with '...' arguments ... DONE
[13:14:23.729] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:23.730] 
[13:14:23.730] getGlobalsAndPackages() ... DONE
[13:14:23.731] run() for 'Future' ...
[13:14:23.731] - state: 'created'
[13:14:23.731] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[13:14:23.732] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[13:14:23.732] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[13:14:23.732]   - Field: 'label'
[13:14:23.732]   - Field: 'local'
[13:14:23.732]   - Field: 'owner'
[13:14:23.733]   - Field: 'envir'
[13:14:23.733]   - Field: 'packages'
[13:14:23.733]   - Field: 'gc'
[13:14:23.733]   - Field: 'conditions'
[13:14:23.733]   - Field: 'expr'
[13:14:23.735]   - Field: 'uuid'
[13:14:23.735]   - Field: 'seed'
[13:14:23.736]   - Field: 'version'
[13:14:23.736]   - Field: 'result'
[13:14:23.736]   - Field: 'asynchronous'
[13:14:23.736]   - Field: 'calls'
[13:14:23.736]   - Field: 'globals'
[13:14:23.736]   - Field: 'stdout'
[13:14:23.737]   - Field: 'earlySignal'
[13:14:23.737]   - Field: 'lazy'
[13:14:23.737]   - Field: 'state'
[13:14:23.737] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[13:14:23.737] - Launch lazy future ...
[13:14:23.738] Packages needed by the future expression (n = 0): <none>
[13:14:23.738] Packages needed by future strategies (n = 0): <none>
[13:14:23.739] {
[13:14:23.739]     {
[13:14:23.739]         {
[13:14:23.739]             ...future.startTime <- base::Sys.time()
[13:14:23.739]             {
[13:14:23.739]                 {
[13:14:23.739]                   {
[13:14:23.739]                     base::local({
[13:14:23.739]                       has_future <- base::requireNamespace("future", 
[13:14:23.739]                         quietly = TRUE)
[13:14:23.739]                       if (has_future) {
[13:14:23.739]                         ns <- base::getNamespace("future")
[13:14:23.739]                         version <- ns[[".package"]][["version"]]
[13:14:23.739]                         if (is.null(version)) 
[13:14:23.739]                           version <- utils::packageVersion("future")
[13:14:23.739]                       }
[13:14:23.739]                       else {
[13:14:23.739]                         version <- NULL
[13:14:23.739]                       }
[13:14:23.739]                       if (!has_future || version < "1.8.0") {
[13:14:23.739]                         info <- base::c(r_version = base::gsub("R version ", 
[13:14:23.739]                           "", base::R.version$version.string), 
[13:14:23.739]                           platform = base::sprintf("%s (%s-bit)", 
[13:14:23.739]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[13:14:23.739]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[13:14:23.739]                             "release", "version")], collapse = " "), 
[13:14:23.739]                           hostname = base::Sys.info()[["nodename"]])
[13:14:23.739]                         info <- base::sprintf("%s: %s", base::names(info), 
[13:14:23.739]                           info)
[13:14:23.739]                         info <- base::paste(info, collapse = "; ")
[13:14:23.739]                         if (!has_future) {
[13:14:23.739]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[13:14:23.739]                             info)
[13:14:23.739]                         }
[13:14:23.739]                         else {
[13:14:23.739]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[13:14:23.739]                             info, version)
[13:14:23.739]                         }
[13:14:23.739]                         base::stop(msg)
[13:14:23.739]                       }
[13:14:23.739]                     })
[13:14:23.739]                   }
[13:14:23.739]                   options(future.plan = NULL)
[13:14:23.739]                   Sys.unsetenv("R_FUTURE_PLAN")
[13:14:23.739]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[13:14:23.739]                 }
[13:14:23.739]                 ...future.workdir <- getwd()
[13:14:23.739]             }
[13:14:23.739]             ...future.oldOptions <- base::as.list(base::.Options)
[13:14:23.739]             ...future.oldEnvVars <- base::Sys.getenv()
[13:14:23.739]         }
[13:14:23.739]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[13:14:23.739]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[13:14:23.739]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[13:14:23.739]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[13:14:23.739]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[13:14:23.739]             future.stdout.windows.reencode = NULL, width = 80L)
[13:14:23.739]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[13:14:23.739]             base::names(...future.oldOptions))
[13:14:23.739]     }
[13:14:23.739]     if (FALSE) {
[13:14:23.739]     }
[13:14:23.739]     else {
[13:14:23.739]         if (FALSE) {
[13:14:23.739]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[13:14:23.739]                 open = "w")
[13:14:23.739]         }
[13:14:23.739]         else {
[13:14:23.739]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[13:14:23.739]                 windows = "NUL", "/dev/null"), open = "w")
[13:14:23.739]         }
[13:14:23.739]         base::sink(...future.stdout, type = "output", split = FALSE)
[13:14:23.739]         base::on.exit(if (!base::is.null(...future.stdout)) {
[13:14:23.739]             base::sink(type = "output", split = FALSE)
[13:14:23.739]             base::close(...future.stdout)
[13:14:23.739]         }, add = TRUE)
[13:14:23.739]     }
[13:14:23.739]     ...future.frame <- base::sys.nframe()
[13:14:23.739]     ...future.conditions <- base::list()
[13:14:23.739]     ...future.rng <- base::globalenv()$.Random.seed
[13:14:23.739]     if (FALSE) {
[13:14:23.739]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[13:14:23.739]             "...future.value", "...future.globalenv.names", ".Random.seed")
[13:14:23.739]     }
[13:14:23.739]     ...future.result <- base::tryCatch({
[13:14:23.739]         base::withCallingHandlers({
[13:14:23.739]             ...future.value <- base::withVisible(base::local({
[13:14:23.739]                 do.call(function(...) {
[13:14:23.739]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[13:14:23.739]                   if (!identical(...future.globals.maxSize.org, 
[13:14:23.739]                     ...future.globals.maxSize)) {
[13:14:23.739]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[13:14:23.739]                     on.exit(options(oopts), add = TRUE)
[13:14:23.739]                   }
[13:14:23.739]                   {
[13:14:23.739]                     lapply(seq_along(...future.elements_ii), 
[13:14:23.739]                       FUN = function(jj) {
[13:14:23.739]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[13:14:23.739]                         ...future.FUN(...future.X_jj, ...)
[13:14:23.739]                       })
[13:14:23.739]                   }
[13:14:23.739]                 }, args = future.call.arguments)
[13:14:23.739]             }))
[13:14:23.739]             future::FutureResult(value = ...future.value$value, 
[13:14:23.739]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[13:14:23.739]                   ...future.rng), globalenv = if (FALSE) 
[13:14:23.739]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[13:14:23.739]                     ...future.globalenv.names))
[13:14:23.739]                 else NULL, started = ...future.startTime, version = "1.8")
[13:14:23.739]         }, condition = base::local({
[13:14:23.739]             c <- base::c
[13:14:23.739]             inherits <- base::inherits
[13:14:23.739]             invokeRestart <- base::invokeRestart
[13:14:23.739]             length <- base::length
[13:14:23.739]             list <- base::list
[13:14:23.739]             seq.int <- base::seq.int
[13:14:23.739]             signalCondition <- base::signalCondition
[13:14:23.739]             sys.calls <- base::sys.calls
[13:14:23.739]             `[[` <- base::`[[`
[13:14:23.739]             `+` <- base::`+`
[13:14:23.739]             `<<-` <- base::`<<-`
[13:14:23.739]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[13:14:23.739]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[13:14:23.739]                   3L)]
[13:14:23.739]             }
[13:14:23.739]             function(cond) {
[13:14:23.739]                 is_error <- inherits(cond, "error")
[13:14:23.739]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[13:14:23.739]                   NULL)
[13:14:23.739]                 if (is_error) {
[13:14:23.739]                   sessionInformation <- function() {
[13:14:23.739]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[13:14:23.739]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[13:14:23.739]                       search = base::search(), system = base::Sys.info())
[13:14:23.739]                   }
[13:14:23.739]                   ...future.conditions[[length(...future.conditions) + 
[13:14:23.739]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[13:14:23.739]                     cond$call), session = sessionInformation(), 
[13:14:23.739]                     timestamp = base::Sys.time(), signaled = 0L)
[13:14:23.739]                   signalCondition(cond)
[13:14:23.739]                 }
[13:14:23.739]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[13:14:23.739]                 "immediateCondition"))) {
[13:14:23.739]                   signal <- TRUE && inherits(cond, "immediateCondition")
[13:14:23.739]                   ...future.conditions[[length(...future.conditions) + 
[13:14:23.739]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[13:14:23.739]                   if (TRUE && !signal) {
[13:14:23.739]                     muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:23.739]                     {
[13:14:23.739]                       inherits <- base::inherits
[13:14:23.739]                       invokeRestart <- base::invokeRestart
[13:14:23.739]                       is.null <- base::is.null
[13:14:23.739]                       muffled <- FALSE
[13:14:23.739]                       if (inherits(cond, "message")) {
[13:14:23.739]                         muffled <- grepl(pattern, "muffleMessage")
[13:14:23.739]                         if (muffled) 
[13:14:23.739]                           invokeRestart("muffleMessage")
[13:14:23.739]                       }
[13:14:23.739]                       else if (inherits(cond, "warning")) {
[13:14:23.739]                         muffled <- grepl(pattern, "muffleWarning")
[13:14:23.739]                         if (muffled) 
[13:14:23.739]                           invokeRestart("muffleWarning")
[13:14:23.739]                       }
[13:14:23.739]                       else if (inherits(cond, "condition")) {
[13:14:23.739]                         if (!is.null(pattern)) {
[13:14:23.739]                           computeRestarts <- base::computeRestarts
[13:14:23.739]                           grepl <- base::grepl
[13:14:23.739]                           restarts <- computeRestarts(cond)
[13:14:23.739]                           for (restart in restarts) {
[13:14:23.739]                             name <- restart$name
[13:14:23.739]                             if (is.null(name)) 
[13:14:23.739]                               next
[13:14:23.739]                             if (!grepl(pattern, name)) 
[13:14:23.739]                               next
[13:14:23.739]                             invokeRestart(restart)
[13:14:23.739]                             muffled <- TRUE
[13:14:23.739]                             break
[13:14:23.739]                           }
[13:14:23.739]                         }
[13:14:23.739]                       }
[13:14:23.739]                       invisible(muffled)
[13:14:23.739]                     }
[13:14:23.739]                     muffleCondition(cond, pattern = "^muffle")
[13:14:23.739]                   }
[13:14:23.739]                 }
[13:14:23.739]                 else {
[13:14:23.739]                   if (TRUE) {
[13:14:23.739]                     muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:23.739]                     {
[13:14:23.739]                       inherits <- base::inherits
[13:14:23.739]                       invokeRestart <- base::invokeRestart
[13:14:23.739]                       is.null <- base::is.null
[13:14:23.739]                       muffled <- FALSE
[13:14:23.739]                       if (inherits(cond, "message")) {
[13:14:23.739]                         muffled <- grepl(pattern, "muffleMessage")
[13:14:23.739]                         if (muffled) 
[13:14:23.739]                           invokeRestart("muffleMessage")
[13:14:23.739]                       }
[13:14:23.739]                       else if (inherits(cond, "warning")) {
[13:14:23.739]                         muffled <- grepl(pattern, "muffleWarning")
[13:14:23.739]                         if (muffled) 
[13:14:23.739]                           invokeRestart("muffleWarning")
[13:14:23.739]                       }
[13:14:23.739]                       else if (inherits(cond, "condition")) {
[13:14:23.739]                         if (!is.null(pattern)) {
[13:14:23.739]                           computeRestarts <- base::computeRestarts
[13:14:23.739]                           grepl <- base::grepl
[13:14:23.739]                           restarts <- computeRestarts(cond)
[13:14:23.739]                           for (restart in restarts) {
[13:14:23.739]                             name <- restart$name
[13:14:23.739]                             if (is.null(name)) 
[13:14:23.739]                               next
[13:14:23.739]                             if (!grepl(pattern, name)) 
[13:14:23.739]                               next
[13:14:23.739]                             invokeRestart(restart)
[13:14:23.739]                             muffled <- TRUE
[13:14:23.739]                             break
[13:14:23.739]                           }
[13:14:23.739]                         }
[13:14:23.739]                       }
[13:14:23.739]                       invisible(muffled)
[13:14:23.739]                     }
[13:14:23.739]                     muffleCondition(cond, pattern = "^muffle")
[13:14:23.739]                   }
[13:14:23.739]                 }
[13:14:23.739]             }
[13:14:23.739]         }))
[13:14:23.739]     }, error = function(ex) {
[13:14:23.739]         base::structure(base::list(value = NULL, visible = NULL, 
[13:14:23.739]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[13:14:23.739]                 ...future.rng), started = ...future.startTime, 
[13:14:23.739]             finished = Sys.time(), session_uuid = NA_character_, 
[13:14:23.739]             version = "1.8"), class = "FutureResult")
[13:14:23.739]     }, finally = {
[13:14:23.739]         if (!identical(...future.workdir, getwd())) 
[13:14:23.739]             setwd(...future.workdir)
[13:14:23.739]         {
[13:14:23.739]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[13:14:23.739]                 ...future.oldOptions$nwarnings <- NULL
[13:14:23.739]             }
[13:14:23.739]             base::options(...future.oldOptions)
[13:14:23.739]             if (.Platform$OS.type == "windows") {
[13:14:23.739]                 old_names <- names(...future.oldEnvVars)
[13:14:23.739]                 envs <- base::Sys.getenv()
[13:14:23.739]                 names <- names(envs)
[13:14:23.739]                 common <- intersect(names, old_names)
[13:14:23.739]                 added <- setdiff(names, old_names)
[13:14:23.739]                 removed <- setdiff(old_names, names)
[13:14:23.739]                 changed <- common[...future.oldEnvVars[common] != 
[13:14:23.739]                   envs[common]]
[13:14:23.739]                 NAMES <- toupper(changed)
[13:14:23.739]                 args <- list()
[13:14:23.739]                 for (kk in seq_along(NAMES)) {
[13:14:23.739]                   name <- changed[[kk]]
[13:14:23.739]                   NAME <- NAMES[[kk]]
[13:14:23.739]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:23.739]                     next
[13:14:23.739]                   args[[name]] <- ...future.oldEnvVars[[name]]
[13:14:23.739]                 }
[13:14:23.739]                 NAMES <- toupper(added)
[13:14:23.739]                 for (kk in seq_along(NAMES)) {
[13:14:23.739]                   name <- added[[kk]]
[13:14:23.739]                   NAME <- NAMES[[kk]]
[13:14:23.739]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:23.739]                     next
[13:14:23.739]                   args[[name]] <- ""
[13:14:23.739]                 }
[13:14:23.739]                 NAMES <- toupper(removed)
[13:14:23.739]                 for (kk in seq_along(NAMES)) {
[13:14:23.739]                   name <- removed[[kk]]
[13:14:23.739]                   NAME <- NAMES[[kk]]
[13:14:23.739]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:23.739]                     next
[13:14:23.739]                   args[[name]] <- ...future.oldEnvVars[[name]]
[13:14:23.739]                 }
[13:14:23.739]                 if (length(args) > 0) 
[13:14:23.739]                   base::do.call(base::Sys.setenv, args = args)
[13:14:23.739]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[13:14:23.739]             }
[13:14:23.739]             else {
[13:14:23.739]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[13:14:23.739]             }
[13:14:23.739]             {
[13:14:23.739]                 if (base::length(...future.futureOptionsAdded) > 
[13:14:23.739]                   0L) {
[13:14:23.739]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[13:14:23.739]                   base::names(opts) <- ...future.futureOptionsAdded
[13:14:23.739]                   base::options(opts)
[13:14:23.739]                 }
[13:14:23.739]                 {
[13:14:23.739]                   {
[13:14:23.739]                     NULL
[13:14:23.739]                     RNGkind("Mersenne-Twister")
[13:14:23.739]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[13:14:23.739]                       inherits = FALSE)
[13:14:23.739]                   }
[13:14:23.739]                   options(future.plan = NULL)
[13:14:23.739]                   if (is.na(NA_character_)) 
[13:14:23.739]                     Sys.unsetenv("R_FUTURE_PLAN")
[13:14:23.739]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[13:14:23.739]                   future::plan(list(function (..., envir = parent.frame()) 
[13:14:23.739]                   {
[13:14:23.739]                     future <- SequentialFuture(..., envir = envir)
[13:14:23.739]                     if (!future$lazy) 
[13:14:23.739]                       future <- run(future)
[13:14:23.739]                     invisible(future)
[13:14:23.739]                   }), .cleanup = FALSE, .init = FALSE)
[13:14:23.739]                 }
[13:14:23.739]             }
[13:14:23.739]         }
[13:14:23.739]     })
[13:14:23.739]     if (TRUE) {
[13:14:23.739]         base::sink(type = "output", split = FALSE)
[13:14:23.739]         if (FALSE) {
[13:14:23.739]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[13:14:23.739]         }
[13:14:23.739]         else {
[13:14:23.739]             ...future.result["stdout"] <- base::list(NULL)
[13:14:23.739]         }
[13:14:23.739]         base::close(...future.stdout)
[13:14:23.739]         ...future.stdout <- NULL
[13:14:23.739]     }
[13:14:23.739]     ...future.result$conditions <- ...future.conditions
[13:14:23.739]     ...future.result$finished <- base::Sys.time()
[13:14:23.739]     ...future.result
[13:14:23.739] }
[13:14:23.744] assign_globals() ...
[13:14:23.744] List of 5
[13:14:23.744]  $ ...future.FUN            :function (x)  
[13:14:23.744]  $ future.call.arguments    : list()
[13:14:23.744]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[13:14:23.744]  $ ...future.elements_ii    :List of 2
[13:14:23.744]   ..$ : int 1
[13:14:23.744]   ..$ : int 0
[13:14:23.744]  $ ...future.seeds_ii       : NULL
[13:14:23.744]  $ ...future.globals.maxSize: NULL
[13:14:23.744]  - attr(*, "where")=List of 5
[13:14:23.744]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[13:14:23.744]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[13:14:23.744]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[13:14:23.744]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[13:14:23.744]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[13:14:23.744]  - attr(*, "resolved")= logi FALSE
[13:14:23.744]  - attr(*, "total_size")= num 4720
[13:14:23.744]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[13:14:23.744]  - attr(*, "already-done")= logi TRUE
[13:14:23.750] - reassign environment for '...future.FUN'
[13:14:23.750] - copied '...future.FUN' to environment
[13:14:23.750] - copied 'future.call.arguments' to environment
[13:14:23.750] - copied '...future.elements_ii' to environment
[13:14:23.750] - copied '...future.seeds_ii' to environment
[13:14:23.750] - copied '...future.globals.maxSize' to environment
[13:14:23.751] assign_globals() ... done
[13:14:23.751] plan(): Setting new future strategy stack:
[13:14:23.751] List of future strategies:
[13:14:23.751] 1. sequential:
[13:14:23.751]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[13:14:23.751]    - tweaked: FALSE
[13:14:23.751]    - call: NULL
[13:14:23.752] plan(): nbrOfWorkers() = 1
[13:14:24.261] plan(): Setting new future strategy stack:
[13:14:24.261] List of future strategies:
[13:14:24.261] 1. sequential:
[13:14:24.261]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[13:14:24.261]    - tweaked: FALSE
[13:14:24.261]    - call: plan(strategy)
[13:14:24.261] plan(): nbrOfWorkers() = 1
[13:14:24.262] SequentialFuture started (and completed)
[13:14:24.262] - Launch lazy future ... done
[13:14:24.262] run() for 'SequentialFuture' ... done
[13:14:24.263] Created future:
[13:14:24.263] SequentialFuture:
[13:14:24.263] Label: 'future_lapply-1'
[13:14:24.263] Expression:
[13:14:24.263] {
[13:14:24.263]     do.call(function(...) {
[13:14:24.263]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[13:14:24.263]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[13:14:24.263]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[13:14:24.263]             on.exit(options(oopts), add = TRUE)
[13:14:24.263]         }
[13:14:24.263]         {
[13:14:24.263]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[13:14:24.263]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[13:14:24.263]                 ...future.FUN(...future.X_jj, ...)
[13:14:24.263]             })
[13:14:24.263]         }
[13:14:24.263]     }, args = future.call.arguments)
[13:14:24.263] }
[13:14:24.263] Lazy evaluation: FALSE
[13:14:24.263] Asynchronous evaluation: FALSE
[13:14:24.263] Local evaluation: TRUE
[13:14:24.263] Environment: R_GlobalEnv
[13:14:24.263] Capture standard output: FALSE
[13:14:24.263] Capture condition classes: 'condition' (excluding 'nothing')
[13:14:24.263] Globals: 5 objects totaling 4.72 KiB (function '...future.FUN' of 4.61 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 112 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[13:14:24.263] Packages: <none>
[13:14:24.263] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[13:14:24.263] Resolved: TRUE
[13:14:24.263] Value: 112 bytes of class 'list'
[13:14:24.263] Early signaling: FALSE
[13:14:24.263] Owner process: 68097d82-3b31-293d-2920-9b7259f27083
[13:14:24.263] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[13:14:24.265] Chunk #1 of 1 ... DONE
[13:14:24.265] Launching 1 futures (chunks) ... DONE
[13:14:24.265] Resolving 1 futures (chunks) ...
[13:14:24.265] resolve() on list ...
[13:14:24.266]  recursive: 0
[13:14:24.266]  length: 1
[13:14:24.266] 
[13:14:24.266] resolved() for 'SequentialFuture' ...
[13:14:24.266] - state: 'finished'
[13:14:24.267] - run: TRUE
[13:14:24.267] - result: 'FutureResult'
[13:14:24.267] resolved() for 'SequentialFuture' ... done
[13:14:24.267] Future #1
[13:14:24.268] signalConditionsASAP(SequentialFuture, pos=1) ...
[13:14:24.268] - nx: 1
[13:14:24.268] - relay: TRUE
[13:14:24.268] - stdout: TRUE
[13:14:24.268] - signal: TRUE
[13:14:24.268] - resignal: FALSE
[13:14:24.269] - force: TRUE
[13:14:24.269] - relayed: [n=1] FALSE
[13:14:24.269] - queued futures: [n=1] FALSE
[13:14:24.269]  - until=1
[13:14:24.269]  - relaying element #1
[13:14:24.269] - relayed: [n=1] TRUE
[13:14:24.270] - queued futures: [n=1] TRUE
[13:14:24.270] signalConditionsASAP(SequentialFuture, pos=1) ... done
[13:14:24.270]  length: 0 (resolved future 1)
[13:14:24.270] Relaying remaining futures
[13:14:24.270] signalConditionsASAP(NULL, pos=0) ...
[13:14:24.271] - nx: 1
[13:14:24.271] - relay: TRUE
[13:14:24.271] - stdout: TRUE
[13:14:24.271] - signal: TRUE
[13:14:24.271] - resignal: FALSE
[13:14:24.271] - force: TRUE
[13:14:24.272] - relayed: [n=1] TRUE
[13:14:24.272] - queued futures: [n=1] TRUE
 - flush all
[13:14:24.272] - relayed: [n=1] TRUE
[13:14:24.272] - queued futures: [n=1] TRUE
[13:14:24.272] signalConditionsASAP(NULL, pos=0) ... done
[13:14:24.272] resolve() on list ... DONE
[13:14:24.273]  - Number of value chunks collected: 1
[13:14:24.273] Resolving 1 futures (chunks) ... DONE
[13:14:24.273] Reducing values from 1 chunks ...
[13:14:24.273]  - Number of values collected after concatenation: 2
[13:14:24.273]  - Number of values expected: 2
[13:14:24.273] Reducing values from 1 chunks ... DONE
[13:14:24.274] future_lapply() ... DONE
* future_lapply(x, ..., future.stdout = FALSE) ... DONE
* future_lapply(x, ..., future.stdout = TRUE) ...
[13:14:24.274] future_lapply() ...
[13:14:24.275] Number of chunks: 1
[13:14:24.275] getGlobalsAndPackagesXApply() ...
[13:14:24.275]  - future.globals: TRUE
[13:14:24.276] getGlobalsAndPackages() ...
[13:14:24.276] Searching for globals...
[13:14:24.279] - globals found: [5] 'FUN', '{', 'Sys.sleep', '/', 'print'
[13:14:24.279] Searching for globals ... DONE
[13:14:24.279] Resolving globals: FALSE
[13:14:24.280] The total size of the 1 globals is 4.61 KiB (4720 bytes)
[13:14:24.280] The total size of the 1 globals exported for future expression ('FUN()') is 4.61 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.61 KiB of class 'function')
[13:14:24.280] - globals: [1] 'FUN'
[13:14:24.281] 
[13:14:24.281] getGlobalsAndPackages() ... DONE
[13:14:24.281]  - globals found/used: [n=1] 'FUN'
[13:14:24.281]  - needed namespaces: [n=0] 
[13:14:24.281] Finding globals ... DONE
[13:14:24.281]  - use_args: TRUE
[13:14:24.282]  - Getting '...' globals ...
[13:14:24.282] resolve() on list ...
[13:14:24.282]  recursive: 0
[13:14:24.282]  length: 1
[13:14:24.282]  elements: '...'
[13:14:24.283]  length: 0 (resolved future 1)
[13:14:24.283] resolve() on list ... DONE
[13:14:24.283]    - '...' content: [n=0] 
[13:14:24.283] List of 1
[13:14:24.283]  $ ...: list()
[13:14:24.283]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[13:14:24.283]  - attr(*, "where")=List of 1
[13:14:24.283]   ..$ ...:<environment: 0x0000022a324a6148> 
[13:14:24.283]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[13:14:24.283]  - attr(*, "resolved")= logi TRUE
[13:14:24.283]  - attr(*, "total_size")= num NA
[13:14:24.286]  - Getting '...' globals ... DONE
[13:14:24.286] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[13:14:24.287] List of 2
[13:14:24.287]  $ ...future.FUN:function (x)  
[13:14:24.287]  $ ...          : list()
[13:14:24.287]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[13:14:24.287]  - attr(*, "where")=List of 2
[13:14:24.287]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[13:14:24.287]   ..$ ...          :<environment: 0x0000022a324a6148> 
[13:14:24.287]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[13:14:24.287]  - attr(*, "resolved")= logi FALSE
[13:14:24.287]  - attr(*, "total_size")= num 4720
[13:14:24.290] Packages to be attached in all futures: [n=0] 
[13:14:24.290] getGlobalsAndPackagesXApply() ... DONE
[13:14:24.290] Number of futures (= number of chunks): 1
[13:14:24.291] Launching 1 futures (chunks) ...
[13:14:24.291] Chunk #1 of 1 ...
[13:14:24.291]  - Finding globals in 'X' for chunk #1 ...
[13:14:24.291] getGlobalsAndPackages() ...
[13:14:24.291] Searching for globals...
[13:14:24.292] 
[13:14:24.292] Searching for globals ... DONE
[13:14:24.292] - globals: [0] <none>
[13:14:24.292] getGlobalsAndPackages() ... DONE
[13:14:24.292]    + additional globals found: [n=0] 
[13:14:24.292]    + additional namespaces needed: [n=0] 
[13:14:24.293]  - Finding globals in 'X' for chunk #1 ... DONE
[13:14:24.293]  - seeds: <none>
[13:14:24.293]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:24.293] getGlobalsAndPackages() ...
[13:14:24.293] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:24.293] Resolving globals: FALSE
[13:14:24.293] Tweak future expression to call with '...' arguments ...
[13:14:24.294] {
[13:14:24.294]     do.call(function(...) {
[13:14:24.294]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[13:14:24.294]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[13:14:24.294]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[13:14:24.294]             on.exit(options(oopts), add = TRUE)
[13:14:24.294]         }
[13:14:24.294]         {
[13:14:24.294]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[13:14:24.294]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[13:14:24.294]                 ...future.FUN(...future.X_jj, ...)
[13:14:24.294]             })
[13:14:24.294]         }
[13:14:24.294]     }, args = future.call.arguments)
[13:14:24.294] }
[13:14:24.294] Tweak future expression to call with '...' arguments ... DONE
[13:14:24.295] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:24.295] 
[13:14:24.295] getGlobalsAndPackages() ... DONE
[13:14:24.295] run() for 'Future' ...
[13:14:24.295] - state: 'created'
[13:14:24.296] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[13:14:24.296] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[13:14:24.296] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[13:14:24.296]   - Field: 'label'
[13:14:24.297]   - Field: 'local'
[13:14:24.297]   - Field: 'owner'
[13:14:24.297]   - Field: 'envir'
[13:14:24.297]   - Field: 'packages'
[13:14:24.297]   - Field: 'gc'
[13:14:24.297]   - Field: 'conditions'
[13:14:24.298]   - Field: 'expr'
[13:14:24.298]   - Field: 'uuid'
[13:14:24.298]   - Field: 'seed'
[13:14:24.298]   - Field: 'version'
[13:14:24.298]   - Field: 'result'
[13:14:24.299]   - Field: 'asynchronous'
[13:14:24.299]   - Field: 'calls'
[13:14:24.299]   - Field: 'globals'
[13:14:24.299]   - Field: 'stdout'
[13:14:24.299]   - Field: 'earlySignal'
[13:14:24.299]   - Field: 'lazy'
[13:14:24.300]   - Field: 'state'
[13:14:24.300] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[13:14:24.300] - Launch lazy future ...
[13:14:24.300] Packages needed by the future expression (n = 0): <none>
[13:14:24.300] Packages needed by future strategies (n = 0): <none>
[13:14:24.301] {
[13:14:24.301]     {
[13:14:24.301]         {
[13:14:24.301]             ...future.startTime <- base::Sys.time()
[13:14:24.301]             {
[13:14:24.301]                 {
[13:14:24.301]                   {
[13:14:24.301]                     base::local({
[13:14:24.301]                       has_future <- base::requireNamespace("future", 
[13:14:24.301]                         quietly = TRUE)
[13:14:24.301]                       if (has_future) {
[13:14:24.301]                         ns <- base::getNamespace("future")
[13:14:24.301]                         version <- ns[[".package"]][["version"]]
[13:14:24.301]                         if (is.null(version)) 
[13:14:24.301]                           version <- utils::packageVersion("future")
[13:14:24.301]                       }
[13:14:24.301]                       else {
[13:14:24.301]                         version <- NULL
[13:14:24.301]                       }
[13:14:24.301]                       if (!has_future || version < "1.8.0") {
[13:14:24.301]                         info <- base::c(r_version = base::gsub("R version ", 
[13:14:24.301]                           "", base::R.version$version.string), 
[13:14:24.301]                           platform = base::sprintf("%s (%s-bit)", 
[13:14:24.301]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[13:14:24.301]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[13:14:24.301]                             "release", "version")], collapse = " "), 
[13:14:24.301]                           hostname = base::Sys.info()[["nodename"]])
[13:14:24.301]                         info <- base::sprintf("%s: %s", base::names(info), 
[13:14:24.301]                           info)
[13:14:24.301]                         info <- base::paste(info, collapse = "; ")
[13:14:24.301]                         if (!has_future) {
[13:14:24.301]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[13:14:24.301]                             info)
[13:14:24.301]                         }
[13:14:24.301]                         else {
[13:14:24.301]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[13:14:24.301]                             info, version)
[13:14:24.301]                         }
[13:14:24.301]                         base::stop(msg)
[13:14:24.301]                       }
[13:14:24.301]                     })
[13:14:24.301]                   }
[13:14:24.301]                   options(future.plan = NULL)
[13:14:24.301]                   Sys.unsetenv("R_FUTURE_PLAN")
[13:14:24.301]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[13:14:24.301]                 }
[13:14:24.301]                 ...future.workdir <- getwd()
[13:14:24.301]             }
[13:14:24.301]             ...future.oldOptions <- base::as.list(base::.Options)
[13:14:24.301]             ...future.oldEnvVars <- base::Sys.getenv()
[13:14:24.301]         }
[13:14:24.301]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[13:14:24.301]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[13:14:24.301]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[13:14:24.301]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[13:14:24.301]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[13:14:24.301]             future.stdout.windows.reencode = NULL, width = 80L)
[13:14:24.301]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[13:14:24.301]             base::names(...future.oldOptions))
[13:14:24.301]     }
[13:14:24.301]     if (FALSE) {
[13:14:24.301]     }
[13:14:24.301]     else {
[13:14:24.301]         if (TRUE) {
[13:14:24.301]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[13:14:24.301]                 open = "w")
[13:14:24.301]         }
[13:14:24.301]         else {
[13:14:24.301]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[13:14:24.301]                 windows = "NUL", "/dev/null"), open = "w")
[13:14:24.301]         }
[13:14:24.301]         base::sink(...future.stdout, type = "output", split = FALSE)
[13:14:24.301]         base::on.exit(if (!base::is.null(...future.stdout)) {
[13:14:24.301]             base::sink(type = "output", split = FALSE)
[13:14:24.301]             base::close(...future.stdout)
[13:14:24.301]         }, add = TRUE)
[13:14:24.301]     }
[13:14:24.301]     ...future.frame <- base::sys.nframe()
[13:14:24.301]     ...future.conditions <- base::list()
[13:14:24.301]     ...future.rng <- base::globalenv()$.Random.seed
[13:14:24.301]     if (FALSE) {
[13:14:24.301]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[13:14:24.301]             "...future.value", "...future.globalenv.names", ".Random.seed")
[13:14:24.301]     }
[13:14:24.301]     ...future.result <- base::tryCatch({
[13:14:24.301]         base::withCallingHandlers({
[13:14:24.301]             ...future.value <- base::withVisible(base::local({
[13:14:24.301]                 do.call(function(...) {
[13:14:24.301]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[13:14:24.301]                   if (!identical(...future.globals.maxSize.org, 
[13:14:24.301]                     ...future.globals.maxSize)) {
[13:14:24.301]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[13:14:24.301]                     on.exit(options(oopts), add = TRUE)
[13:14:24.301]                   }
[13:14:24.301]                   {
[13:14:24.301]                     lapply(seq_along(...future.elements_ii), 
[13:14:24.301]                       FUN = function(jj) {
[13:14:24.301]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[13:14:24.301]                         ...future.FUN(...future.X_jj, ...)
[13:14:24.301]                       })
[13:14:24.301]                   }
[13:14:24.301]                 }, args = future.call.arguments)
[13:14:24.301]             }))
[13:14:24.301]             future::FutureResult(value = ...future.value$value, 
[13:14:24.301]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[13:14:24.301]                   ...future.rng), globalenv = if (FALSE) 
[13:14:24.301]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[13:14:24.301]                     ...future.globalenv.names))
[13:14:24.301]                 else NULL, started = ...future.startTime, version = "1.8")
[13:14:24.301]         }, condition = base::local({
[13:14:24.301]             c <- base::c
[13:14:24.301]             inherits <- base::inherits
[13:14:24.301]             invokeRestart <- base::invokeRestart
[13:14:24.301]             length <- base::length
[13:14:24.301]             list <- base::list
[13:14:24.301]             seq.int <- base::seq.int
[13:14:24.301]             signalCondition <- base::signalCondition
[13:14:24.301]             sys.calls <- base::sys.calls
[13:14:24.301]             `[[` <- base::`[[`
[13:14:24.301]             `+` <- base::`+`
[13:14:24.301]             `<<-` <- base::`<<-`
[13:14:24.301]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[13:14:24.301]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[13:14:24.301]                   3L)]
[13:14:24.301]             }
[13:14:24.301]             function(cond) {
[13:14:24.301]                 is_error <- inherits(cond, "error")
[13:14:24.301]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[13:14:24.301]                   NULL)
[13:14:24.301]                 if (is_error) {
[13:14:24.301]                   sessionInformation <- function() {
[13:14:24.301]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[13:14:24.301]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[13:14:24.301]                       search = base::search(), system = base::Sys.info())
[13:14:24.301]                   }
[13:14:24.301]                   ...future.conditions[[length(...future.conditions) + 
[13:14:24.301]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[13:14:24.301]                     cond$call), session = sessionInformation(), 
[13:14:24.301]                     timestamp = base::Sys.time(), signaled = 0L)
[13:14:24.301]                   signalCondition(cond)
[13:14:24.301]                 }
[13:14:24.301]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[13:14:24.301]                 "immediateCondition"))) {
[13:14:24.301]                   signal <- TRUE && inherits(cond, "immediateCondition")
[13:14:24.301]                   ...future.conditions[[length(...future.conditions) + 
[13:14:24.301]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[13:14:24.301]                   if (TRUE && !signal) {
[13:14:24.301]                     muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:24.301]                     {
[13:14:24.301]                       inherits <- base::inherits
[13:14:24.301]                       invokeRestart <- base::invokeRestart
[13:14:24.301]                       is.null <- base::is.null
[13:14:24.301]                       muffled <- FALSE
[13:14:24.301]                       if (inherits(cond, "message")) {
[13:14:24.301]                         muffled <- grepl(pattern, "muffleMessage")
[13:14:24.301]                         if (muffled) 
[13:14:24.301]                           invokeRestart("muffleMessage")
[13:14:24.301]                       }
[13:14:24.301]                       else if (inherits(cond, "warning")) {
[13:14:24.301]                         muffled <- grepl(pattern, "muffleWarning")
[13:14:24.301]                         if (muffled) 
[13:14:24.301]                           invokeRestart("muffleWarning")
[13:14:24.301]                       }
[13:14:24.301]                       else if (inherits(cond, "condition")) {
[13:14:24.301]                         if (!is.null(pattern)) {
[13:14:24.301]                           computeRestarts <- base::computeRestarts
[13:14:24.301]                           grepl <- base::grepl
[13:14:24.301]                           restarts <- computeRestarts(cond)
[13:14:24.301]                           for (restart in restarts) {
[13:14:24.301]                             name <- restart$name
[13:14:24.301]                             if (is.null(name)) 
[13:14:24.301]                               next
[13:14:24.301]                             if (!grepl(pattern, name)) 
[13:14:24.301]                               next
[13:14:24.301]                             invokeRestart(restart)
[13:14:24.301]                             muffled <- TRUE
[13:14:24.301]                             break
[13:14:24.301]                           }
[13:14:24.301]                         }
[13:14:24.301]                       }
[13:14:24.301]                       invisible(muffled)
[13:14:24.301]                     }
[13:14:24.301]                     muffleCondition(cond, pattern = "^muffle")
[13:14:24.301]                   }
[13:14:24.301]                 }
[13:14:24.301]                 else {
[13:14:24.301]                   if (TRUE) {
[13:14:24.301]                     muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:24.301]                     {
[13:14:24.301]                       inherits <- base::inherits
[13:14:24.301]                       invokeRestart <- base::invokeRestart
[13:14:24.301]                       is.null <- base::is.null
[13:14:24.301]                       muffled <- FALSE
[13:14:24.301]                       if (inherits(cond, "message")) {
[13:14:24.301]                         muffled <- grepl(pattern, "muffleMessage")
[13:14:24.301]                         if (muffled) 
[13:14:24.301]                           invokeRestart("muffleMessage")
[13:14:24.301]                       }
[13:14:24.301]                       else if (inherits(cond, "warning")) {
[13:14:24.301]                         muffled <- grepl(pattern, "muffleWarning")
[13:14:24.301]                         if (muffled) 
[13:14:24.301]                           invokeRestart("muffleWarning")
[13:14:24.301]                       }
[13:14:24.301]                       else if (inherits(cond, "condition")) {
[13:14:24.301]                         if (!is.null(pattern)) {
[13:14:24.301]                           computeRestarts <- base::computeRestarts
[13:14:24.301]                           grepl <- base::grepl
[13:14:24.301]                           restarts <- computeRestarts(cond)
[13:14:24.301]                           for (restart in restarts) {
[13:14:24.301]                             name <- restart$name
[13:14:24.301]                             if (is.null(name)) 
[13:14:24.301]                               next
[13:14:24.301]                             if (!grepl(pattern, name)) 
[13:14:24.301]                               next
[13:14:24.301]                             invokeRestart(restart)
[13:14:24.301]                             muffled <- TRUE
[13:14:24.301]                             break
[13:14:24.301]                           }
[13:14:24.301]                         }
[13:14:24.301]                       }
[13:14:24.301]                       invisible(muffled)
[13:14:24.301]                     }
[13:14:24.301]                     muffleCondition(cond, pattern = "^muffle")
[13:14:24.301]                   }
[13:14:24.301]                 }
[13:14:24.301]             }
[13:14:24.301]         }))
[13:14:24.301]     }, error = function(ex) {
[13:14:24.301]         base::structure(base::list(value = NULL, visible = NULL, 
[13:14:24.301]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[13:14:24.301]                 ...future.rng), started = ...future.startTime, 
[13:14:24.301]             finished = Sys.time(), session_uuid = NA_character_, 
[13:14:24.301]             version = "1.8"), class = "FutureResult")
[13:14:24.301]     }, finally = {
[13:14:24.301]         if (!identical(...future.workdir, getwd())) 
[13:14:24.301]             setwd(...future.workdir)
[13:14:24.301]         {
[13:14:24.301]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[13:14:24.301]                 ...future.oldOptions$nwarnings <- NULL
[13:14:24.301]             }
[13:14:24.301]             base::options(...future.oldOptions)
[13:14:24.301]             if (.Platform$OS.type == "windows") {
[13:14:24.301]                 old_names <- names(...future.oldEnvVars)
[13:14:24.301]                 envs <- base::Sys.getenv()
[13:14:24.301]                 names <- names(envs)
[13:14:24.301]                 common <- intersect(names, old_names)
[13:14:24.301]                 added <- setdiff(names, old_names)
[13:14:24.301]                 removed <- setdiff(old_names, names)
[13:14:24.301]                 changed <- common[...future.oldEnvVars[common] != 
[13:14:24.301]                   envs[common]]
[13:14:24.301]                 NAMES <- toupper(changed)
[13:14:24.301]                 args <- list()
[13:14:24.301]                 for (kk in seq_along(NAMES)) {
[13:14:24.301]                   name <- changed[[kk]]
[13:14:24.301]                   NAME <- NAMES[[kk]]
[13:14:24.301]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:24.301]                     next
[13:14:24.301]                   args[[name]] <- ...future.oldEnvVars[[name]]
[13:14:24.301]                 }
[13:14:24.301]                 NAMES <- toupper(added)
[13:14:24.301]                 for (kk in seq_along(NAMES)) {
[13:14:24.301]                   name <- added[[kk]]
[13:14:24.301]                   NAME <- NAMES[[kk]]
[13:14:24.301]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:24.301]                     next
[13:14:24.301]                   args[[name]] <- ""
[13:14:24.301]                 }
[13:14:24.301]                 NAMES <- toupper(removed)
[13:14:24.301]                 for (kk in seq_along(NAMES)) {
[13:14:24.301]                   name <- removed[[kk]]
[13:14:24.301]                   NAME <- NAMES[[kk]]
[13:14:24.301]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:24.301]                     next
[13:14:24.301]                   args[[name]] <- ...future.oldEnvVars[[name]]
[13:14:24.301]                 }
[13:14:24.301]                 if (length(args) > 0) 
[13:14:24.301]                   base::do.call(base::Sys.setenv, args = args)
[13:14:24.301]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[13:14:24.301]             }
[13:14:24.301]             else {
[13:14:24.301]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[13:14:24.301]             }
[13:14:24.301]             {
[13:14:24.301]                 if (base::length(...future.futureOptionsAdded) > 
[13:14:24.301]                   0L) {
[13:14:24.301]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[13:14:24.301]                   base::names(opts) <- ...future.futureOptionsAdded
[13:14:24.301]                   base::options(opts)
[13:14:24.301]                 }
[13:14:24.301]                 {
[13:14:24.301]                   {
[13:14:24.301]                     NULL
[13:14:24.301]                     RNGkind("Mersenne-Twister")
[13:14:24.301]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[13:14:24.301]                       inherits = FALSE)
[13:14:24.301]                   }
[13:14:24.301]                   options(future.plan = NULL)
[13:14:24.301]                   if (is.na(NA_character_)) 
[13:14:24.301]                     Sys.unsetenv("R_FUTURE_PLAN")
[13:14:24.301]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[13:14:24.301]                   future::plan(list(function (..., envir = parent.frame()) 
[13:14:24.301]                   {
[13:14:24.301]                     future <- SequentialFuture(..., envir = envir)
[13:14:24.301]                     if (!future$lazy) 
[13:14:24.301]                       future <- run(future)
[13:14:24.301]                     invisible(future)
[13:14:24.301]                   }), .cleanup = FALSE, .init = FALSE)
[13:14:24.301]                 }
[13:14:24.301]             }
[13:14:24.301]         }
[13:14:24.301]     })
[13:14:24.301]     if (TRUE) {
[13:14:24.301]         base::sink(type = "output", split = FALSE)
[13:14:24.301]         if (TRUE) {
[13:14:24.301]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[13:14:24.301]         }
[13:14:24.301]         else {
[13:14:24.301]             ...future.result["stdout"] <- base::list(NULL)
[13:14:24.301]         }
[13:14:24.301]         base::close(...future.stdout)
[13:14:24.301]         ...future.stdout <- NULL
[13:14:24.301]     }
[13:14:24.301]     ...future.result$conditions <- ...future.conditions
[13:14:24.301]     ...future.result$finished <- base::Sys.time()
[13:14:24.301]     ...future.result
[13:14:24.301] }
[13:14:24.305] assign_globals() ...
[13:14:24.305] List of 5
[13:14:24.305]  $ ...future.FUN            :function (x)  
[13:14:24.305]  $ future.call.arguments    : list()
[13:14:24.305]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[13:14:24.305]  $ ...future.elements_ii    :List of 2
[13:14:24.305]   ..$ : int 1
[13:14:24.305]   ..$ : int 0
[13:14:24.305]  $ ...future.seeds_ii       : NULL
[13:14:24.305]  $ ...future.globals.maxSize: NULL
[13:14:24.305]  - attr(*, "where")=List of 5
[13:14:24.305]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[13:14:24.305]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[13:14:24.305]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[13:14:24.305]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[13:14:24.305]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[13:14:24.305]  - attr(*, "resolved")= logi FALSE
[13:14:24.305]  - attr(*, "total_size")= num 4720
[13:14:24.305]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[13:14:24.305]  - attr(*, "already-done")= logi TRUE
[13:14:24.312] - reassign environment for '...future.FUN'
[13:14:24.312] - copied '...future.FUN' to environment
[13:14:24.312] - copied 'future.call.arguments' to environment
[13:14:24.312] - copied '...future.elements_ii' to environment
[13:14:24.312] - copied '...future.seeds_ii' to environment
[13:14:24.313] - copied '...future.globals.maxSize' to environment
[13:14:24.313] assign_globals() ... done
[13:14:24.313] plan(): Setting new future strategy stack:
[13:14:24.313] List of future strategies:
[13:14:24.313] 1. sequential:
[13:14:24.313]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[13:14:24.313]    - tweaked: FALSE
[13:14:24.313]    - call: NULL
[13:14:24.314] plan(): nbrOfWorkers() = 1
[13:14:24.828] plan(): Setting new future strategy stack:
[13:14:24.828] List of future strategies:
[13:14:24.828] 1. sequential:
[13:14:24.828]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[13:14:24.828]    - tweaked: FALSE
[13:14:24.828]    - call: plan(strategy)
[13:14:24.829] plan(): nbrOfWorkers() = 1
[13:14:24.829] SequentialFuture started (and completed)
[13:14:24.829] - Launch lazy future ... done
[13:14:24.830] run() for 'SequentialFuture' ... done
[13:14:24.830] Created future:
[13:14:24.830] SequentialFuture:
[13:14:24.830] Label: 'future_lapply-1'
[13:14:24.830] Expression:
[13:14:24.830] {
[13:14:24.830]     do.call(function(...) {
[13:14:24.830]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[13:14:24.830]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[13:14:24.830]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[13:14:24.830]             on.exit(options(oopts), add = TRUE)
[13:14:24.830]         }
[13:14:24.830]         {
[13:14:24.830]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[13:14:24.830]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[13:14:24.830]                 ...future.FUN(...future.X_jj, ...)
[13:14:24.830]             })
[13:14:24.830]         }
[13:14:24.830]     }, args = future.call.arguments)
[13:14:24.830] }
[13:14:24.830] Lazy evaluation: FALSE
[13:14:24.830] Asynchronous evaluation: FALSE
[13:14:24.830] Local evaluation: TRUE
[13:14:24.830] Environment: R_GlobalEnv
[13:14:24.830] Capture standard output: TRUE
[13:14:24.830] Capture condition classes: 'condition' (excluding 'nothing')
[13:14:24.830] Globals: 5 objects totaling 4.72 KiB (function '...future.FUN' of 4.61 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 112 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[13:14:24.830] Packages: <none>
[13:14:24.830] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[13:14:24.830] Resolved: TRUE
[13:14:24.830] Value: 112 bytes of class 'list'
[13:14:24.830] Early signaling: FALSE
[13:14:24.830] Owner process: 68097d82-3b31-293d-2920-9b7259f27083
[13:14:24.830] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[13:14:24.831] Chunk #1 of 1 ... DONE
[13:14:24.832] Launching 1 futures (chunks) ... DONE
[13:14:24.832] Resolving 1 futures (chunks) ...
[13:14:24.832] resolve() on list ...
[13:14:24.832]  recursive: 0
[13:14:24.832]  length: 1
[13:14:24.832] 
[13:14:24.833] resolved() for 'SequentialFuture' ...
[13:14:24.833] - state: 'finished'
[13:14:24.833] - run: TRUE
[13:14:24.833] - result: 'FutureResult'
[13:14:24.833] resolved() for 'SequentialFuture' ... done
[13:14:24.833] Future #1
[13:14:24.834] signalConditionsASAP(SequentialFuture, pos=1) ...
[13:14:24.834] - nx: 1
[13:14:24.834] - relay: TRUE
[13:14:24.834] - stdout: TRUE
[13:14:24.834] - signal: TRUE
[13:14:24.834] - resignal: FALSE
[13:14:24.835] - force: TRUE
[13:14:24.835] - relayed: [n=1] FALSE
[13:14:24.835] - queued futures: [n=1] FALSE
[13:14:24.835]  - until=1
[13:14:24.835]  - relaying element #1
[13:14:24.836] - relayed: [n=1] TRUE
[13:14:24.836] - queued futures: [n=1] TRUE
[13:14:24.836] signalConditionsASAP(SequentialFuture, pos=1) ... done
[13:14:24.836]  length: 0 (resolved future 1)
[13:14:24.836] Relaying remaining futures
[13:14:24.836] signalConditionsASAP(NULL, pos=0) ...
[13:14:24.837] - nx: 1
[13:14:24.837] - relay: TRUE
[13:14:24.837] - stdout: TRUE
[13:14:24.837] - signal: TRUE
[13:14:24.837] - resignal: FALSE
[13:14:24.837] - force: TRUE
[13:14:24.837] - relayed: [n=1] TRUE
[13:14:24.838] - queued futures: [n=1] TRUE
 - flush all
[13:14:24.838] - relayed: [n=1] TRUE
[13:14:24.838] - queued futures: [n=1] TRUE
[13:14:24.838] signalConditionsASAP(NULL, pos=0) ... done
[13:14:24.838] resolve() on list ... DONE
[13:14:24.839]  - Number of value chunks collected: 1
[13:14:24.839] Resolving 1 futures (chunks) ... DONE
[13:14:24.839] Reducing values from 1 chunks ...
[13:14:24.839]  - Number of values collected after concatenation: 2
[13:14:24.839]  - Number of values expected: 2
[13:14:24.839] Reducing values from 1 chunks ... DONE
[13:14:24.839] future_lapply() ... DONE
* future_lapply(x, ..., future.stdout = TRUE) ... DONE
* future_lapply(x, ..., future.stdout = NA) ...
[13:14:24.840] future_lapply() ...
[13:14:24.841] Number of chunks: 1
[13:14:24.841] getGlobalsAndPackagesXApply() ...
[13:14:24.841]  - future.globals: TRUE
[13:14:24.841] getGlobalsAndPackages() ...
[13:14:24.842] Searching for globals...
[13:14:24.843] - globals found: [5] 'FUN', '{', 'Sys.sleep', '/', 'print'
[13:14:24.843] Searching for globals ... DONE
[13:14:24.844] Resolving globals: FALSE
[13:14:24.844] The total size of the 1 globals is 4.61 KiB (4720 bytes)
[13:14:24.844] The total size of the 1 globals exported for future expression ('FUN()') is 4.61 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.61 KiB of class 'function')
[13:14:24.845] - globals: [1] 'FUN'
[13:14:24.845] 
[13:14:24.845] getGlobalsAndPackages() ... DONE
[13:14:24.845]  - globals found/used: [n=1] 'FUN'
[13:14:24.845]  - needed namespaces: [n=0] 
[13:14:24.845] Finding globals ... DONE
[13:14:24.846]  - use_args: TRUE
[13:14:24.846]  - Getting '...' globals ...
[13:14:24.846] resolve() on list ...
[13:14:24.846]  recursive: 0
[13:14:24.846]  length: 1
[13:14:24.847]  elements: '...'
[13:14:24.847]  length: 0 (resolved future 1)
[13:14:24.847] resolve() on list ... DONE
[13:14:24.847]    - '...' content: [n=0] 
[13:14:24.847] List of 1
[13:14:24.847]  $ ...: list()
[13:14:24.847]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[13:14:24.847]  - attr(*, "where")=List of 1
[13:14:24.847]   ..$ ...:<environment: 0x0000022a3213c4c8> 
[13:14:24.847]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[13:14:24.847]  - attr(*, "resolved")= logi TRUE
[13:14:24.847]  - attr(*, "total_size")= num NA
[13:14:24.851]  - Getting '...' globals ... DONE
[13:14:24.851] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[13:14:24.852] List of 2
[13:14:24.852]  $ ...future.FUN:function (x)  
[13:14:24.852]  $ ...          : list()
[13:14:24.852]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[13:14:24.852]  - attr(*, "where")=List of 2
[13:14:24.852]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[13:14:24.852]   ..$ ...          :<environment: 0x0000022a3213c4c8> 
[13:14:24.852]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[13:14:24.852]  - attr(*, "resolved")= logi FALSE
[13:14:24.852]  - attr(*, "total_size")= num 4720
[13:14:24.855] Packages to be attached in all futures: [n=0] 
[13:14:24.855] getGlobalsAndPackagesXApply() ... DONE
[13:14:24.855] Number of futures (= number of chunks): 1
[13:14:24.855] Launching 1 futures (chunks) ...
[13:14:24.856] Chunk #1 of 1 ...
[13:14:24.856]  - Finding globals in 'X' for chunk #1 ...
[13:14:24.856] getGlobalsAndPackages() ...
[13:14:24.856] Searching for globals...
[13:14:24.856] 
[13:14:24.857] Searching for globals ... DONE
[13:14:24.857] - globals: [0] <none>
[13:14:24.857] getGlobalsAndPackages() ... DONE
[13:14:24.857]    + additional globals found: [n=0] 
[13:14:24.857]    + additional namespaces needed: [n=0] 
[13:14:24.857]  - Finding globals in 'X' for chunk #1 ... DONE
[13:14:24.857]  - seeds: <none>
[13:14:24.858]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:24.858] getGlobalsAndPackages() ...
[13:14:24.858] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:24.858] Resolving globals: FALSE
[13:14:24.858] Tweak future expression to call with '...' arguments ...
[13:14:24.859] {
[13:14:24.859]     do.call(function(...) {
[13:14:24.859]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[13:14:24.859]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[13:14:24.859]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[13:14:24.859]             on.exit(options(oopts), add = TRUE)
[13:14:24.859]         }
[13:14:24.859]         {
[13:14:24.859]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[13:14:24.859]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[13:14:24.859]                 ...future.FUN(...future.X_jj, ...)
[13:14:24.859]             })
[13:14:24.859]         }
[13:14:24.859]     }, args = future.call.arguments)
[13:14:24.859] }
[13:14:24.859] Tweak future expression to call with '...' arguments ... DONE
[13:14:24.860] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:24.860] 
[13:14:24.860] getGlobalsAndPackages() ... DONE
[13:14:24.860] run() for 'Future' ...
[13:14:24.860] - state: 'created'
[13:14:24.861] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[13:14:24.861] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[13:14:24.861] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[13:14:24.861]   - Field: 'label'
[13:14:24.862]   - Field: 'local'
[13:14:24.862]   - Field: 'owner'
[13:14:24.862]   - Field: 'envir'
[13:14:24.862]   - Field: 'packages'
[13:14:24.862]   - Field: 'gc'
[13:14:24.862]   - Field: 'conditions'
[13:14:24.863]   - Field: 'expr'
[13:14:24.863]   - Field: 'uuid'
[13:14:24.863]   - Field: 'seed'
[13:14:24.863]   - Field: 'version'
[13:14:24.863]   - Field: 'result'
[13:14:24.863]   - Field: 'asynchronous'
[13:14:24.864]   - Field: 'calls'
[13:14:24.864]   - Field: 'globals'
[13:14:24.864]   - Field: 'stdout'
[13:14:24.864]   - Field: 'earlySignal'
[13:14:24.864]   - Field: 'lazy'
[13:14:24.864]   - Field: 'state'
[13:14:24.865] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[13:14:24.865] - Launch lazy future ...
[13:14:24.865] Packages needed by the future expression (n = 0): <none>
[13:14:24.865] Packages needed by future strategies (n = 0): <none>
[13:14:24.866] {
[13:14:24.866]     {
[13:14:24.866]         {
[13:14:24.866]             ...future.startTime <- base::Sys.time()
[13:14:24.866]             {
[13:14:24.866]                 {
[13:14:24.866]                   {
[13:14:24.866]                     base::local({
[13:14:24.866]                       has_future <- base::requireNamespace("future", 
[13:14:24.866]                         quietly = TRUE)
[13:14:24.866]                       if (has_future) {
[13:14:24.866]                         ns <- base::getNamespace("future")
[13:14:24.866]                         version <- ns[[".package"]][["version"]]
[13:14:24.866]                         if (is.null(version)) 
[13:14:24.866]                           version <- utils::packageVersion("future")
[13:14:24.866]                       }
[13:14:24.866]                       else {
[13:14:24.866]                         version <- NULL
[13:14:24.866]                       }
[13:14:24.866]                       if (!has_future || version < "1.8.0") {
[13:14:24.866]                         info <- base::c(r_version = base::gsub("R version ", 
[13:14:24.866]                           "", base::R.version$version.string), 
[13:14:24.866]                           platform = base::sprintf("%s (%s-bit)", 
[13:14:24.866]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[13:14:24.866]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[13:14:24.866]                             "release", "version")], collapse = " "), 
[13:14:24.866]                           hostname = base::Sys.info()[["nodename"]])
[13:14:24.866]                         info <- base::sprintf("%s: %s", base::names(info), 
[13:14:24.866]                           info)
[13:14:24.866]                         info <- base::paste(info, collapse = "; ")
[13:14:24.866]                         if (!has_future) {
[13:14:24.866]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[13:14:24.866]                             info)
[13:14:24.866]                         }
[13:14:24.866]                         else {
[13:14:24.866]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[13:14:24.866]                             info, version)
[13:14:24.866]                         }
[13:14:24.866]                         base::stop(msg)
[13:14:24.866]                       }
[13:14:24.866]                     })
[13:14:24.866]                   }
[13:14:24.866]                   options(future.plan = NULL)
[13:14:24.866]                   Sys.unsetenv("R_FUTURE_PLAN")
[13:14:24.866]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[13:14:24.866]                 }
[13:14:24.866]                 ...future.workdir <- getwd()
[13:14:24.866]             }
[13:14:24.866]             ...future.oldOptions <- base::as.list(base::.Options)
[13:14:24.866]             ...future.oldEnvVars <- base::Sys.getenv()
[13:14:24.866]         }
[13:14:24.866]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[13:14:24.866]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[13:14:24.866]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[13:14:24.866]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[13:14:24.866]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[13:14:24.866]             future.stdout.windows.reencode = NULL, width = 80L)
[13:14:24.866]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[13:14:24.866]             base::names(...future.oldOptions))
[13:14:24.866]     }
[13:14:24.866]     if (TRUE) {
[13:14:24.866]     }
[13:14:24.866]     else {
[13:14:24.866]         if (NA) {
[13:14:24.866]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[13:14:24.866]                 open = "w")
[13:14:24.866]         }
[13:14:24.866]         else {
[13:14:24.866]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[13:14:24.866]                 windows = "NUL", "/dev/null"), open = "w")
[13:14:24.866]         }
[13:14:24.866]         base::sink(...future.stdout, type = "output", split = FALSE)
[13:14:24.866]         base::on.exit(if (!base::is.null(...future.stdout)) {
[13:14:24.866]             base::sink(type = "output", split = FALSE)
[13:14:24.866]             base::close(...future.stdout)
[13:14:24.866]         }, add = TRUE)
[13:14:24.866]     }
[13:14:24.866]     ...future.frame <- base::sys.nframe()
[13:14:24.866]     ...future.conditions <- base::list()
[13:14:24.866]     ...future.rng <- base::globalenv()$.Random.seed
[13:14:24.866]     if (FALSE) {
[13:14:24.866]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[13:14:24.866]             "...future.value", "...future.globalenv.names", ".Random.seed")
[13:14:24.866]     }
[13:14:24.866]     ...future.result <- base::tryCatch({
[13:14:24.866]         base::withCallingHandlers({
[13:14:24.866]             ...future.value <- base::withVisible(base::local({
[13:14:24.866]                 do.call(function(...) {
[13:14:24.866]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[13:14:24.866]                   if (!identical(...future.globals.maxSize.org, 
[13:14:24.866]                     ...future.globals.maxSize)) {
[13:14:24.866]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[13:14:24.866]                     on.exit(options(oopts), add = TRUE)
[13:14:24.866]                   }
[13:14:24.866]                   {
[13:14:24.866]                     lapply(seq_along(...future.elements_ii), 
[13:14:24.866]                       FUN = function(jj) {
[13:14:24.866]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[13:14:24.866]                         ...future.FUN(...future.X_jj, ...)
[13:14:24.866]                       })
[13:14:24.866]                   }
[13:14:24.866]                 }, args = future.call.arguments)
[13:14:24.866]             }))
[13:14:24.866]             future::FutureResult(value = ...future.value$value, 
[13:14:24.866]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[13:14:24.866]                   ...future.rng), globalenv = if (FALSE) 
[13:14:24.866]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[13:14:24.866]                     ...future.globalenv.names))
[13:14:24.866]                 else NULL, started = ...future.startTime, version = "1.8")
[13:14:24.866]         }, condition = base::local({
[13:14:24.866]             c <- base::c
[13:14:24.866]             inherits <- base::inherits
[13:14:24.866]             invokeRestart <- base::invokeRestart
[13:14:24.866]             length <- base::length
[13:14:24.866]             list <- base::list
[13:14:24.866]             seq.int <- base::seq.int
[13:14:24.866]             signalCondition <- base::signalCondition
[13:14:24.866]             sys.calls <- base::sys.calls
[13:14:24.866]             `[[` <- base::`[[`
[13:14:24.866]             `+` <- base::`+`
[13:14:24.866]             `<<-` <- base::`<<-`
[13:14:24.866]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[13:14:24.866]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[13:14:24.866]                   3L)]
[13:14:24.866]             }
[13:14:24.866]             function(cond) {
[13:14:24.866]                 is_error <- inherits(cond, "error")
[13:14:24.866]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[13:14:24.866]                   NULL)
[13:14:24.866]                 if (is_error) {
[13:14:24.866]                   sessionInformation <- function() {
[13:14:24.866]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[13:14:24.866]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[13:14:24.866]                       search = base::search(), system = base::Sys.info())
[13:14:24.866]                   }
[13:14:24.866]                   ...future.conditions[[length(...future.conditions) + 
[13:14:24.866]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[13:14:24.866]                     cond$call), session = sessionInformation(), 
[13:14:24.866]                     timestamp = base::Sys.time(), signaled = 0L)
[13:14:24.866]                   signalCondition(cond)
[13:14:24.866]                 }
[13:14:24.866]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[13:14:24.866]                 "immediateCondition"))) {
[13:14:24.866]                   signal <- TRUE && inherits(cond, "immediateCondition")
[13:14:24.866]                   ...future.conditions[[length(...future.conditions) + 
[13:14:24.866]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[13:14:24.866]                   if (TRUE && !signal) {
[13:14:24.866]                     muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:24.866]                     {
[13:14:24.866]                       inherits <- base::inherits
[13:14:24.866]                       invokeRestart <- base::invokeRestart
[13:14:24.866]                       is.null <- base::is.null
[13:14:24.866]                       muffled <- FALSE
[13:14:24.866]                       if (inherits(cond, "message")) {
[13:14:24.866]                         muffled <- grepl(pattern, "muffleMessage")
[13:14:24.866]                         if (muffled) 
[13:14:24.866]                           invokeRestart("muffleMessage")
[13:14:24.866]                       }
[13:14:24.866]                       else if (inherits(cond, "warning")) {
[13:14:24.866]                         muffled <- grepl(pattern, "muffleWarning")
[13:14:24.866]                         if (muffled) 
[13:14:24.866]                           invokeRestart("muffleWarning")
[13:14:24.866]                       }
[13:14:24.866]                       else if (inherits(cond, "condition")) {
[13:14:24.866]                         if (!is.null(pattern)) {
[13:14:24.866]                           computeRestarts <- base::computeRestarts
[13:14:24.866]                           grepl <- base::grepl
[13:14:24.866]                           restarts <- computeRestarts(cond)
[13:14:24.866]                           for (restart in restarts) {
[13:14:24.866]                             name <- restart$name
[13:14:24.866]                             if (is.null(name)) 
[13:14:24.866]                               next
[13:14:24.866]                             if (!grepl(pattern, name)) 
[13:14:24.866]                               next
[13:14:24.866]                             invokeRestart(restart)
[13:14:24.866]                             muffled <- TRUE
[13:14:24.866]                             break
[13:14:24.866]                           }
[13:14:24.866]                         }
[13:14:24.866]                       }
[13:14:24.866]                       invisible(muffled)
[13:14:24.866]                     }
[13:14:24.866]                     muffleCondition(cond, pattern = "^muffle")
[13:14:24.866]                   }
[13:14:24.866]                 }
[13:14:24.866]                 else {
[13:14:24.866]                   if (TRUE) {
[13:14:24.866]                     muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:24.866]                     {
[13:14:24.866]                       inherits <- base::inherits
[13:14:24.866]                       invokeRestart <- base::invokeRestart
[13:14:24.866]                       is.null <- base::is.null
[13:14:24.866]                       muffled <- FALSE
[13:14:24.866]                       if (inherits(cond, "message")) {
[13:14:24.866]                         muffled <- grepl(pattern, "muffleMessage")
[13:14:24.866]                         if (muffled) 
[13:14:24.866]                           invokeRestart("muffleMessage")
[13:14:24.866]                       }
[13:14:24.866]                       else if (inherits(cond, "warning")) {
[13:14:24.866]                         muffled <- grepl(pattern, "muffleWarning")
[13:14:24.866]                         if (muffled) 
[13:14:24.866]                           invokeRestart("muffleWarning")
[13:14:24.866]                       }
[13:14:24.866]                       else if (inherits(cond, "condition")) {
[13:14:24.866]                         if (!is.null(pattern)) {
[13:14:24.866]                           computeRestarts <- base::computeRestarts
[13:14:24.866]                           grepl <- base::grepl
[13:14:24.866]                           restarts <- computeRestarts(cond)
[13:14:24.866]                           for (restart in restarts) {
[13:14:24.866]                             name <- restart$name
[13:14:24.866]                             if (is.null(name)) 
[13:14:24.866]                               next
[13:14:24.866]                             if (!grepl(pattern, name)) 
[13:14:24.866]                               next
[13:14:24.866]                             invokeRestart(restart)
[13:14:24.866]                             muffled <- TRUE
[13:14:24.866]                             break
[13:14:24.866]                           }
[13:14:24.866]                         }
[13:14:24.866]                       }
[13:14:24.866]                       invisible(muffled)
[13:14:24.866]                     }
[13:14:24.866]                     muffleCondition(cond, pattern = "^muffle")
[13:14:24.866]                   }
[13:14:24.866]                 }
[13:14:24.866]             }
[13:14:24.866]         }))
[13:14:24.866]     }, error = function(ex) {
[13:14:24.866]         base::structure(base::list(value = NULL, visible = NULL, 
[13:14:24.866]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[13:14:24.866]                 ...future.rng), started = ...future.startTime, 
[13:14:24.866]             finished = Sys.time(), session_uuid = NA_character_, 
[13:14:24.866]             version = "1.8"), class = "FutureResult")
[13:14:24.866]     }, finally = {
[13:14:24.866]         if (!identical(...future.workdir, getwd())) 
[13:14:24.866]             setwd(...future.workdir)
[13:14:24.866]         {
[13:14:24.866]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[13:14:24.866]                 ...future.oldOptions$nwarnings <- NULL
[13:14:24.866]             }
[13:14:24.866]             base::options(...future.oldOptions)
[13:14:24.866]             if (.Platform$OS.type == "windows") {
[13:14:24.866]                 old_names <- names(...future.oldEnvVars)
[13:14:24.866]                 envs <- base::Sys.getenv()
[13:14:24.866]                 names <- names(envs)
[13:14:24.866]                 common <- intersect(names, old_names)
[13:14:24.866]                 added <- setdiff(names, old_names)
[13:14:24.866]                 removed <- setdiff(old_names, names)
[13:14:24.866]                 changed <- common[...future.oldEnvVars[common] != 
[13:14:24.866]                   envs[common]]
[13:14:24.866]                 NAMES <- toupper(changed)
[13:14:24.866]                 args <- list()
[13:14:24.866]                 for (kk in seq_along(NAMES)) {
[13:14:24.866]                   name <- changed[[kk]]
[13:14:24.866]                   NAME <- NAMES[[kk]]
[13:14:24.866]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:24.866]                     next
[13:14:24.866]                   args[[name]] <- ...future.oldEnvVars[[name]]
[13:14:24.866]                 }
[13:14:24.866]                 NAMES <- toupper(added)
[13:14:24.866]                 for (kk in seq_along(NAMES)) {
[13:14:24.866]                   name <- added[[kk]]
[13:14:24.866]                   NAME <- NAMES[[kk]]
[13:14:24.866]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:24.866]                     next
[13:14:24.866]                   args[[name]] <- ""
[13:14:24.866]                 }
[13:14:24.866]                 NAMES <- toupper(removed)
[13:14:24.866]                 for (kk in seq_along(NAMES)) {
[13:14:24.866]                   name <- removed[[kk]]
[13:14:24.866]                   NAME <- NAMES[[kk]]
[13:14:24.866]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:24.866]                     next
[13:14:24.866]                   args[[name]] <- ...future.oldEnvVars[[name]]
[13:14:24.866]                 }
[13:14:24.866]                 if (length(args) > 0) 
[13:14:24.866]                   base::do.call(base::Sys.setenv, args = args)
[13:14:24.866]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[13:14:24.866]             }
[13:14:24.866]             else {
[13:14:24.866]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[13:14:24.866]             }
[13:14:24.866]             {
[13:14:24.866]                 if (base::length(...future.futureOptionsAdded) > 
[13:14:24.866]                   0L) {
[13:14:24.866]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[13:14:24.866]                   base::names(opts) <- ...future.futureOptionsAdded
[13:14:24.866]                   base::options(opts)
[13:14:24.866]                 }
[13:14:24.866]                 {
[13:14:24.866]                   {
[13:14:24.866]                     NULL
[13:14:24.866]                     RNGkind("Mersenne-Twister")
[13:14:24.866]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[13:14:24.866]                       inherits = FALSE)
[13:14:24.866]                   }
[13:14:24.866]                   options(future.plan = NULL)
[13:14:24.866]                   if (is.na(NA_character_)) 
[13:14:24.866]                     Sys.unsetenv("R_FUTURE_PLAN")
[13:14:24.866]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[13:14:24.866]                   future::plan(list(function (..., envir = parent.frame()) 
[13:14:24.866]                   {
[13:14:24.866]                     future <- SequentialFuture(..., envir = envir)
[13:14:24.866]                     if (!future$lazy) 
[13:14:24.866]                       future <- run(future)
[13:14:24.866]                     invisible(future)
[13:14:24.866]                   }), .cleanup = FALSE, .init = FALSE)
[13:14:24.866]                 }
[13:14:24.866]             }
[13:14:24.866]         }
[13:14:24.866]     })
[13:14:24.866]     if (FALSE) {
[13:14:24.866]         base::sink(type = "output", split = FALSE)
[13:14:24.866]         if (NA) {
[13:14:24.866]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[13:14:24.866]         }
[13:14:24.866]         else {
[13:14:24.866]             ...future.result["stdout"] <- base::list(NULL)
[13:14:24.866]         }
[13:14:24.866]         base::close(...future.stdout)
[13:14:24.866]         ...future.stdout <- NULL
[13:14:24.866]     }
[13:14:24.866]     ...future.result$conditions <- ...future.conditions
[13:14:24.866]     ...future.result$finished <- base::Sys.time()
[13:14:24.866]     ...future.result
[13:14:24.866] }
[13:14:24.870] assign_globals() ...
[13:14:24.870] List of 5
[13:14:24.870]  $ ...future.FUN            :function (x)  
[13:14:24.870]  $ future.call.arguments    : list()
[13:14:24.870]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[13:14:24.870]  $ ...future.elements_ii    :List of 2
[13:14:24.870]   ..$ : int 1
[13:14:24.870]   ..$ : int 0
[13:14:24.870]  $ ...future.seeds_ii       : NULL
[13:14:24.870]  $ ...future.globals.maxSize: NULL
[13:14:24.870]  - attr(*, "where")=List of 5
[13:14:24.870]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[13:14:24.870]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[13:14:24.870]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[13:14:24.870]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[13:14:24.870]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[13:14:24.870]  - attr(*, "resolved")= logi FALSE
[13:14:24.870]  - attr(*, "total_size")= num 4720
[13:14:24.870]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[13:14:24.870]  - attr(*, "already-done")= logi TRUE
[13:14:24.876] - reassign environment for '...future.FUN'
[13:14:24.876] - copied '...future.FUN' to environment
[13:14:24.876] - copied 'future.call.arguments' to environment
[13:14:24.876] - copied '...future.elements_ii' to environment
[13:14:24.876] - copied '...future.seeds_ii' to environment
[13:14:24.877] - copied '...future.globals.maxSize' to environment
[13:14:24.877] assign_globals() ... done
[13:14:24.877] plan(): Setting new future strategy stack:
[13:14:24.877] List of future strategies:
[13:14:24.877] 1. sequential:
[13:14:24.877]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[13:14:24.877]    - tweaked: FALSE
[13:14:24.877]    - call: NULL
[13:14:24.879] plan(): nbrOfWorkers() = 1
[13:14:25.394] plan(): Setting new future strategy stack:
[13:14:25.394] List of future strategies:
[13:14:25.394] 1. sequential:
[13:14:25.394]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[13:14:25.394]    - tweaked: FALSE
[13:14:25.394]    - call: plan(strategy)
[13:14:25.395] plan(): nbrOfWorkers() = 1
[13:14:25.395] SequentialFuture started (and completed)
[13:14:25.395] - Launch lazy future ... done
[13:14:25.396] run() for 'SequentialFuture' ... done
[13:14:25.396] Created future:
[13:14:25.396] SequentialFuture:
[13:14:25.396] Label: 'future_lapply-1'
[13:14:25.396] Expression:
[13:14:25.396] {
[13:14:25.396]     do.call(function(...) {
[13:14:25.396]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[13:14:25.396]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[13:14:25.396]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[13:14:25.396]             on.exit(options(oopts), add = TRUE)
[13:14:25.396]         }
[13:14:25.396]         {
[13:14:25.396]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[13:14:25.396]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[13:14:25.396]                 ...future.FUN(...future.X_jj, ...)
[13:14:25.396]             })
[13:14:25.396]         }
[13:14:25.396]     }, args = future.call.arguments)
[13:14:25.396] }
[13:14:25.396] Lazy evaluation: FALSE
[13:14:25.396] Asynchronous evaluation: FALSE
[13:14:25.396] Local evaluation: TRUE
[13:14:25.396] Environment: R_GlobalEnv
[13:14:25.396] Capture standard output: NA
[13:14:25.396] Capture condition classes: 'condition' (excluding 'nothing')
[13:14:25.396] Globals: 5 objects totaling 4.72 KiB (function '...future.FUN' of 4.61 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 112 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[13:14:25.396] Packages: <none>
[13:14:25.396] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[13:14:25.396] Resolved: TRUE
[13:14:25.396] Value: 112 bytes of class 'list'
[13:14:25.396] Early signaling: FALSE
[13:14:25.396] Owner process: 68097d82-3b31-293d-2920-9b7259f27083
[13:14:25.396] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[13:14:25.397] Chunk #1 of 1 ... DONE
[13:14:25.397] Launching 1 futures (chunks) ... DONE
[13:14:25.398] Resolving 1 futures (chunks) ...
[13:14:25.398] resolve() on list ...
[13:14:25.398]  recursive: 0
[13:14:25.398]  length: 1
[13:14:25.398] 
[13:14:25.398] resolved() for 'SequentialFuture' ...
[13:14:25.399] - state: 'finished'
[13:14:25.399] - run: TRUE
[13:14:25.399] - result: 'FutureResult'
[13:14:25.399] resolved() for 'SequentialFuture' ... done
[13:14:25.399] Future #1
[13:14:25.400] signalConditionsASAP(SequentialFuture, pos=1) ...
[13:14:25.400] - nx: 1
[13:14:25.400] - relay: TRUE
[13:14:25.400] - stdout: TRUE
[13:14:25.400] - signal: TRUE
[13:14:25.400] - resignal: FALSE
[13:14:25.400] - force: TRUE
[13:14:25.401] - relayed: [n=1] FALSE
[13:14:25.401] - queued futures: [n=1] FALSE
[13:14:25.401]  - until=1
[13:14:25.401]  - relaying element #1
[13:14:25.401] - relayed: [n=1] TRUE
[13:14:25.401] - queued futures: [n=1] TRUE
[13:14:25.402] signalConditionsASAP(SequentialFuture, pos=1) ... done
[13:14:25.402]  length: 0 (resolved future 1)
[13:14:25.402] Relaying remaining futures
[13:14:25.402] signalConditionsASAP(NULL, pos=0) ...
[13:14:25.402] - nx: 1
[13:14:25.402] - relay: TRUE
[13:14:25.403] - stdout: TRUE
[13:14:25.403] - signal: TRUE
[13:14:25.403] - resignal: FALSE
[13:14:25.403] - force: TRUE
[13:14:25.403] - relayed: [n=1] TRUE
[13:14:25.403] - queued futures: [n=1] TRUE
 - flush all
[13:14:25.404] - relayed: [n=1] TRUE
[13:14:25.404] - queued futures: [n=1] TRUE
[13:14:25.404] signalConditionsASAP(NULL, pos=0) ... done
[13:14:25.404] resolve() on list ... DONE
[13:14:25.404]  - Number of value chunks collected: 1
[13:14:25.404] Resolving 1 futures (chunks) ... DONE
[13:14:25.405] Reducing values from 1 chunks ...
[13:14:25.405]  - Number of values collected after concatenation: 2
[13:14:25.405]  - Number of values expected: 2
[13:14:25.405] Reducing values from 1 chunks ... DONE
[13:14:25.405] future_lapply() ... DONE
* future_lapply(x, ..., future.stdout = NA) ... DONE
* future_mapply(x, ..., future.stdout = FALSE) ...
[13:14:25.406] future_mapply() ...
[13:14:25.406] Number of chunks: 1
[13:14:25.406] getGlobalsAndPackagesXApply() ...
[13:14:25.406]  - future.globals: TRUE
[13:14:25.406] getGlobalsAndPackages() ...
[13:14:25.407] Searching for globals...
[13:14:25.408] - globals found: [6] 'FUN', '{', 'Sys.sleep', '/', 'print', 'list'
[13:14:25.409] Searching for globals ... DONE
[13:14:25.409] Resolving globals: FALSE
[13:14:25.409] The total size of the 1 globals is 6.11 KiB (6256 bytes)
[13:14:25.410] The total size of the 1 globals exported for future expression ('FUN()') is 6.11 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (6.11 KiB of class 'function')
[13:14:25.410] - globals: [1] 'FUN'
[13:14:25.410] 
[13:14:25.410] getGlobalsAndPackages() ... DONE
[13:14:25.410]  - globals found/used: [n=1] 'FUN'
[13:14:25.411]  - needed namespaces: [n=0] 
[13:14:25.411] Finding globals ... DONE
[13:14:25.411] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[13:14:25.411] List of 2
[13:14:25.411]  $ ...future.FUN:function (x, y)  
[13:14:25.411]  $ MoreArgs     : NULL
[13:14:25.411]  - attr(*, "where")=List of 2
[13:14:25.411]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[13:14:25.411]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[13:14:25.411]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[13:14:25.411]  - attr(*, "resolved")= logi FALSE
[13:14:25.411]  - attr(*, "total_size")= num NA
[13:14:25.414] Packages to be attached in all futures: [n=0] 
[13:14:25.414] getGlobalsAndPackagesXApply() ... DONE
[13:14:25.415] Number of futures (= number of chunks): 1
[13:14:25.415] Launching 1 futures (chunks) ...
[13:14:25.415] Chunk #1 of 1 ...
[13:14:25.415]  - Finding globals in '...' for chunk #1 ...
[13:14:25.415] getGlobalsAndPackages() ...
[13:14:25.415] Searching for globals...
[13:14:25.416] 
[13:14:25.416] Searching for globals ... DONE
[13:14:25.416] - globals: [0] <none>
[13:14:25.416] getGlobalsAndPackages() ... DONE
[13:14:25.416]    + additional globals found: [n=0] 
[13:14:25.417]    + additional namespaces needed: [n=0] 
[13:14:25.417]  - Finding globals in '...' for chunk #1 ... DONE
[13:14:25.417]  - seeds: <none>
[13:14:25.417]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:25.417] getGlobalsAndPackages() ...
[13:14:25.417] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:25.418] Resolving globals: FALSE
[13:14:25.418] The total size of the 5 globals is 6.33 KiB (6480 bytes)
[13:14:25.419] The total size of the 5 globals exported for future expression ('{; ...future.globals.maxSize.org <- getOption("future.globals.maxSize"); if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {; oopts <- options(future.globals.maxSize = ...future.globals.maxSize); on.exit(options(oopts), add = TRUE); }; ...; do.call(mapply, args = args); }; }') is 6.33 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (6.11 KiB of class 'function'), '...future.elements_ii' (224 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[13:14:25.419] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:25.419] 
[13:14:25.419] getGlobalsAndPackages() ... DONE
[13:14:25.420] run() for 'Future' ...
[13:14:25.420] - state: 'created'
[13:14:25.421] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[13:14:25.421] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[13:14:25.422] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[13:14:25.422]   - Field: 'label'
[13:14:25.422]   - Field: 'local'
[13:14:25.422]   - Field: 'owner'
[13:14:25.422]   - Field: 'envir'
[13:14:25.422]   - Field: 'packages'
[13:14:25.423]   - Field: 'gc'
[13:14:25.423]   - Field: 'conditions'
[13:14:25.423]   - Field: 'expr'
[13:14:25.423]   - Field: 'uuid'
[13:14:25.423]   - Field: 'seed'
[13:14:25.423]   - Field: 'version'
[13:14:25.424]   - Field: 'result'
[13:14:25.424]   - Field: 'asynchronous'
[13:14:25.424]   - Field: 'calls'
[13:14:25.424]   - Field: 'globals'
[13:14:25.424]   - Field: 'stdout'
[13:14:25.424]   - Field: 'earlySignal'
[13:14:25.425]   - Field: 'lazy'
[13:14:25.425]   - Field: 'state'
[13:14:25.425] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[13:14:25.425] - Launch lazy future ...
[13:14:25.425] Packages needed by the future expression (n = 0): <none>
[13:14:25.426] Packages needed by future strategies (n = 0): <none>
[13:14:25.426] {
[13:14:25.426]     {
[13:14:25.426]         {
[13:14:25.426]             ...future.startTime <- base::Sys.time()
[13:14:25.426]             {
[13:14:25.426]                 {
[13:14:25.426]                   {
[13:14:25.426]                     base::local({
[13:14:25.426]                       has_future <- base::requireNamespace("future", 
[13:14:25.426]                         quietly = TRUE)
[13:14:25.426]                       if (has_future) {
[13:14:25.426]                         ns <- base::getNamespace("future")
[13:14:25.426]                         version <- ns[[".package"]][["version"]]
[13:14:25.426]                         if (is.null(version)) 
[13:14:25.426]                           version <- utils::packageVersion("future")
[13:14:25.426]                       }
[13:14:25.426]                       else {
[13:14:25.426]                         version <- NULL
[13:14:25.426]                       }
[13:14:25.426]                       if (!has_future || version < "1.8.0") {
[13:14:25.426]                         info <- base::c(r_version = base::gsub("R version ", 
[13:14:25.426]                           "", base::R.version$version.string), 
[13:14:25.426]                           platform = base::sprintf("%s (%s-bit)", 
[13:14:25.426]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[13:14:25.426]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[13:14:25.426]                             "release", "version")], collapse = " "), 
[13:14:25.426]                           hostname = base::Sys.info()[["nodename"]])
[13:14:25.426]                         info <- base::sprintf("%s: %s", base::names(info), 
[13:14:25.426]                           info)
[13:14:25.426]                         info <- base::paste(info, collapse = "; ")
[13:14:25.426]                         if (!has_future) {
[13:14:25.426]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[13:14:25.426]                             info)
[13:14:25.426]                         }
[13:14:25.426]                         else {
[13:14:25.426]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[13:14:25.426]                             info, version)
[13:14:25.426]                         }
[13:14:25.426]                         base::stop(msg)
[13:14:25.426]                       }
[13:14:25.426]                     })
[13:14:25.426]                   }
[13:14:25.426]                   options(future.plan = NULL)
[13:14:25.426]                   Sys.unsetenv("R_FUTURE_PLAN")
[13:14:25.426]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[13:14:25.426]                 }
[13:14:25.426]                 ...future.workdir <- getwd()
[13:14:25.426]             }
[13:14:25.426]             ...future.oldOptions <- base::as.list(base::.Options)
[13:14:25.426]             ...future.oldEnvVars <- base::Sys.getenv()
[13:14:25.426]         }
[13:14:25.426]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[13:14:25.426]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[13:14:25.426]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[13:14:25.426]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[13:14:25.426]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[13:14:25.426]             future.stdout.windows.reencode = NULL, width = 80L)
[13:14:25.426]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[13:14:25.426]             base::names(...future.oldOptions))
[13:14:25.426]     }
[13:14:25.426]     if (FALSE) {
[13:14:25.426]     }
[13:14:25.426]     else {
[13:14:25.426]         if (FALSE) {
[13:14:25.426]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[13:14:25.426]                 open = "w")
[13:14:25.426]         }
[13:14:25.426]         else {
[13:14:25.426]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[13:14:25.426]                 windows = "NUL", "/dev/null"), open = "w")
[13:14:25.426]         }
[13:14:25.426]         base::sink(...future.stdout, type = "output", split = FALSE)
[13:14:25.426]         base::on.exit(if (!base::is.null(...future.stdout)) {
[13:14:25.426]             base::sink(type = "output", split = FALSE)
[13:14:25.426]             base::close(...future.stdout)
[13:14:25.426]         }, add = TRUE)
[13:14:25.426]     }
[13:14:25.426]     ...future.frame <- base::sys.nframe()
[13:14:25.426]     ...future.conditions <- base::list()
[13:14:25.426]     ...future.rng <- base::globalenv()$.Random.seed
[13:14:25.426]     if (FALSE) {
[13:14:25.426]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[13:14:25.426]             "...future.value", "...future.globalenv.names", ".Random.seed")
[13:14:25.426]     }
[13:14:25.426]     ...future.result <- base::tryCatch({
[13:14:25.426]         base::withCallingHandlers({
[13:14:25.426]             ...future.value <- base::withVisible(base::local({
[13:14:25.426]                 ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[13:14:25.426]                 if (!identical(...future.globals.maxSize.org, 
[13:14:25.426]                   ...future.globals.maxSize)) {
[13:14:25.426]                   oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[13:14:25.426]                   on.exit(options(oopts), add = TRUE)
[13:14:25.426]                 }
[13:14:25.426]                 {
[13:14:25.426]                   args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[13:14:25.426]                     MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[13:14:25.426]                     USE.NAMES = FALSE)
[13:14:25.426]                   do.call(mapply, args = args)
[13:14:25.426]                 }
[13:14:25.426]             }))
[13:14:25.426]             future::FutureResult(value = ...future.value$value, 
[13:14:25.426]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[13:14:25.426]                   ...future.rng), globalenv = if (FALSE) 
[13:14:25.426]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[13:14:25.426]                     ...future.globalenv.names))
[13:14:25.426]                 else NULL, started = ...future.startTime, version = "1.8")
[13:14:25.426]         }, condition = base::local({
[13:14:25.426]             c <- base::c
[13:14:25.426]             inherits <- base::inherits
[13:14:25.426]             invokeRestart <- base::invokeRestart
[13:14:25.426]             length <- base::length
[13:14:25.426]             list <- base::list
[13:14:25.426]             seq.int <- base::seq.int
[13:14:25.426]             signalCondition <- base::signalCondition
[13:14:25.426]             sys.calls <- base::sys.calls
[13:14:25.426]             `[[` <- base::`[[`
[13:14:25.426]             `+` <- base::`+`
[13:14:25.426]             `<<-` <- base::`<<-`
[13:14:25.426]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[13:14:25.426]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[13:14:25.426]                   3L)]
[13:14:25.426]             }
[13:14:25.426]             function(cond) {
[13:14:25.426]                 is_error <- inherits(cond, "error")
[13:14:25.426]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[13:14:25.426]                   NULL)
[13:14:25.426]                 if (is_error) {
[13:14:25.426]                   sessionInformation <- function() {
[13:14:25.426]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[13:14:25.426]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[13:14:25.426]                       search = base::search(), system = base::Sys.info())
[13:14:25.426]                   }
[13:14:25.426]                   ...future.conditions[[length(...future.conditions) + 
[13:14:25.426]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[13:14:25.426]                     cond$call), session = sessionInformation(), 
[13:14:25.426]                     timestamp = base::Sys.time(), signaled = 0L)
[13:14:25.426]                   signalCondition(cond)
[13:14:25.426]                 }
[13:14:25.426]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[13:14:25.426]                 "immediateCondition"))) {
[13:14:25.426]                   signal <- TRUE && inherits(cond, "immediateCondition")
[13:14:25.426]                   ...future.conditions[[length(...future.conditions) + 
[13:14:25.426]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[13:14:25.426]                   if (TRUE && !signal) {
[13:14:25.426]                     muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:25.426]                     {
[13:14:25.426]                       inherits <- base::inherits
[13:14:25.426]                       invokeRestart <- base::invokeRestart
[13:14:25.426]                       is.null <- base::is.null
[13:14:25.426]                       muffled <- FALSE
[13:14:25.426]                       if (inherits(cond, "message")) {
[13:14:25.426]                         muffled <- grepl(pattern, "muffleMessage")
[13:14:25.426]                         if (muffled) 
[13:14:25.426]                           invokeRestart("muffleMessage")
[13:14:25.426]                       }
[13:14:25.426]                       else if (inherits(cond, "warning")) {
[13:14:25.426]                         muffled <- grepl(pattern, "muffleWarning")
[13:14:25.426]                         if (muffled) 
[13:14:25.426]                           invokeRestart("muffleWarning")
[13:14:25.426]                       }
[13:14:25.426]                       else if (inherits(cond, "condition")) {
[13:14:25.426]                         if (!is.null(pattern)) {
[13:14:25.426]                           computeRestarts <- base::computeRestarts
[13:14:25.426]                           grepl <- base::grepl
[13:14:25.426]                           restarts <- computeRestarts(cond)
[13:14:25.426]                           for (restart in restarts) {
[13:14:25.426]                             name <- restart$name
[13:14:25.426]                             if (is.null(name)) 
[13:14:25.426]                               next
[13:14:25.426]                             if (!grepl(pattern, name)) 
[13:14:25.426]                               next
[13:14:25.426]                             invokeRestart(restart)
[13:14:25.426]                             muffled <- TRUE
[13:14:25.426]                             break
[13:14:25.426]                           }
[13:14:25.426]                         }
[13:14:25.426]                       }
[13:14:25.426]                       invisible(muffled)
[13:14:25.426]                     }
[13:14:25.426]                     muffleCondition(cond, pattern = "^muffle")
[13:14:25.426]                   }
[13:14:25.426]                 }
[13:14:25.426]                 else {
[13:14:25.426]                   if (TRUE) {
[13:14:25.426]                     muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:25.426]                     {
[13:14:25.426]                       inherits <- base::inherits
[13:14:25.426]                       invokeRestart <- base::invokeRestart
[13:14:25.426]                       is.null <- base::is.null
[13:14:25.426]                       muffled <- FALSE
[13:14:25.426]                       if (inherits(cond, "message")) {
[13:14:25.426]                         muffled <- grepl(pattern, "muffleMessage")
[13:14:25.426]                         if (muffled) 
[13:14:25.426]                           invokeRestart("muffleMessage")
[13:14:25.426]                       }
[13:14:25.426]                       else if (inherits(cond, "warning")) {
[13:14:25.426]                         muffled <- grepl(pattern, "muffleWarning")
[13:14:25.426]                         if (muffled) 
[13:14:25.426]                           invokeRestart("muffleWarning")
[13:14:25.426]                       }
[13:14:25.426]                       else if (inherits(cond, "condition")) {
[13:14:25.426]                         if (!is.null(pattern)) {
[13:14:25.426]                           computeRestarts <- base::computeRestarts
[13:14:25.426]                           grepl <- base::grepl
[13:14:25.426]                           restarts <- computeRestarts(cond)
[13:14:25.426]                           for (restart in restarts) {
[13:14:25.426]                             name <- restart$name
[13:14:25.426]                             if (is.null(name)) 
[13:14:25.426]                               next
[13:14:25.426]                             if (!grepl(pattern, name)) 
[13:14:25.426]                               next
[13:14:25.426]                             invokeRestart(restart)
[13:14:25.426]                             muffled <- TRUE
[13:14:25.426]                             break
[13:14:25.426]                           }
[13:14:25.426]                         }
[13:14:25.426]                       }
[13:14:25.426]                       invisible(muffled)
[13:14:25.426]                     }
[13:14:25.426]                     muffleCondition(cond, pattern = "^muffle")
[13:14:25.426]                   }
[13:14:25.426]                 }
[13:14:25.426]             }
[13:14:25.426]         }))
[13:14:25.426]     }, error = function(ex) {
[13:14:25.426]         base::structure(base::list(value = NULL, visible = NULL, 
[13:14:25.426]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[13:14:25.426]                 ...future.rng), started = ...future.startTime, 
[13:14:25.426]             finished = Sys.time(), session_uuid = NA_character_, 
[13:14:25.426]             version = "1.8"), class = "FutureResult")
[13:14:25.426]     }, finally = {
[13:14:25.426]         if (!identical(...future.workdir, getwd())) 
[13:14:25.426]             setwd(...future.workdir)
[13:14:25.426]         {
[13:14:25.426]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[13:14:25.426]                 ...future.oldOptions$nwarnings <- NULL
[13:14:25.426]             }
[13:14:25.426]             base::options(...future.oldOptions)
[13:14:25.426]             if (.Platform$OS.type == "windows") {
[13:14:25.426]                 old_names <- names(...future.oldEnvVars)
[13:14:25.426]                 envs <- base::Sys.getenv()
[13:14:25.426]                 names <- names(envs)
[13:14:25.426]                 common <- intersect(names, old_names)
[13:14:25.426]                 added <- setdiff(names, old_names)
[13:14:25.426]                 removed <- setdiff(old_names, names)
[13:14:25.426]                 changed <- common[...future.oldEnvVars[common] != 
[13:14:25.426]                   envs[common]]
[13:14:25.426]                 NAMES <- toupper(changed)
[13:14:25.426]                 args <- list()
[13:14:25.426]                 for (kk in seq_along(NAMES)) {
[13:14:25.426]                   name <- changed[[kk]]
[13:14:25.426]                   NAME <- NAMES[[kk]]
[13:14:25.426]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:25.426]                     next
[13:14:25.426]                   args[[name]] <- ...future.oldEnvVars[[name]]
[13:14:25.426]                 }
[13:14:25.426]                 NAMES <- toupper(added)
[13:14:25.426]                 for (kk in seq_along(NAMES)) {
[13:14:25.426]                   name <- added[[kk]]
[13:14:25.426]                   NAME <- NAMES[[kk]]
[13:14:25.426]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:25.426]                     next
[13:14:25.426]                   args[[name]] <- ""
[13:14:25.426]                 }
[13:14:25.426]                 NAMES <- toupper(removed)
[13:14:25.426]                 for (kk in seq_along(NAMES)) {
[13:14:25.426]                   name <- removed[[kk]]
[13:14:25.426]                   NAME <- NAMES[[kk]]
[13:14:25.426]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:25.426]                     next
[13:14:25.426]                   args[[name]] <- ...future.oldEnvVars[[name]]
[13:14:25.426]                 }
[13:14:25.426]                 if (length(args) > 0) 
[13:14:25.426]                   base::do.call(base::Sys.setenv, args = args)
[13:14:25.426]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[13:14:25.426]             }
[13:14:25.426]             else {
[13:14:25.426]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[13:14:25.426]             }
[13:14:25.426]             {
[13:14:25.426]                 if (base::length(...future.futureOptionsAdded) > 
[13:14:25.426]                   0L) {
[13:14:25.426]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[13:14:25.426]                   base::names(opts) <- ...future.futureOptionsAdded
[13:14:25.426]                   base::options(opts)
[13:14:25.426]                 }
[13:14:25.426]                 {
[13:14:25.426]                   {
[13:14:25.426]                     NULL
[13:14:25.426]                     RNGkind("Mersenne-Twister")
[13:14:25.426]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[13:14:25.426]                       inherits = FALSE)
[13:14:25.426]                   }
[13:14:25.426]                   options(future.plan = NULL)
[13:14:25.426]                   if (is.na(NA_character_)) 
[13:14:25.426]                     Sys.unsetenv("R_FUTURE_PLAN")
[13:14:25.426]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[13:14:25.426]                   future::plan(list(function (..., envir = parent.frame()) 
[13:14:25.426]                   {
[13:14:25.426]                     future <- SequentialFuture(..., envir = envir)
[13:14:25.426]                     if (!future$lazy) 
[13:14:25.426]                       future <- run(future)
[13:14:25.426]                     invisible(future)
[13:14:25.426]                   }), .cleanup = FALSE, .init = FALSE)
[13:14:25.426]                 }
[13:14:25.426]             }
[13:14:25.426]         }
[13:14:25.426]     })
[13:14:25.426]     if (TRUE) {
[13:14:25.426]         base::sink(type = "output", split = FALSE)
[13:14:25.426]         if (FALSE) {
[13:14:25.426]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[13:14:25.426]         }
[13:14:25.426]         else {
[13:14:25.426]             ...future.result["stdout"] <- base::list(NULL)
[13:14:25.426]         }
[13:14:25.426]         base::close(...future.stdout)
[13:14:25.426]         ...future.stdout <- NULL
[13:14:25.426]     }
[13:14:25.426]     ...future.result$conditions <- ...future.conditions
[13:14:25.426]     ...future.result$finished <- base::Sys.time()
[13:14:25.426]     ...future.result
[13:14:25.426] }
[13:14:25.430] assign_globals() ...
[13:14:25.430] List of 5
[13:14:25.430]  $ ...future.FUN            :function (x, y)  
[13:14:25.430]  $ MoreArgs                 : NULL
[13:14:25.430]  $ ...future.elements_ii    :List of 2
[13:14:25.430]   ..$ :List of 2
[13:14:25.430]   .. ..$ : int 1
[13:14:25.430]   .. ..$ : int 0
[13:14:25.430]   ..$ :List of 2
[13:14:25.430]   .. ..$ : int 0
[13:14:25.430]   .. ..$ : int 1
[13:14:25.430]  $ ...future.seeds_ii       : NULL
[13:14:25.430]  $ ...future.globals.maxSize: NULL
[13:14:25.430]  - attr(*, "where")=List of 5
[13:14:25.430]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[13:14:25.430]   ..$ MoreArgs                 :<environment: R_EmptyEnv> 
[13:14:25.430]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[13:14:25.430]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[13:14:25.430]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[13:14:25.430]  - attr(*, "resolved")= logi FALSE
[13:14:25.430]  - attr(*, "total_size")= num 6480
[13:14:25.430]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[13:14:25.430]  - attr(*, "already-done")= logi TRUE
[13:14:25.437] - reassign environment for '...future.FUN'
[13:14:25.437] - copied '...future.FUN' to environment
[13:14:25.437] - copied 'MoreArgs' to environment
[13:14:25.437] - copied '...future.elements_ii' to environment
[13:14:25.437] - copied '...future.seeds_ii' to environment
[13:14:25.437] - copied '...future.globals.maxSize' to environment
[13:14:25.438] assign_globals() ... done
[13:14:25.438] plan(): Setting new future strategy stack:
[13:14:25.438] List of future strategies:
[13:14:25.438] 1. sequential:
[13:14:25.438]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[13:14:25.438]    - tweaked: FALSE
[13:14:25.438]    - call: NULL
[13:14:25.439] plan(): nbrOfWorkers() = 1
[13:14:25.941] plan(): Setting new future strategy stack:
[13:14:25.941] List of future strategies:
[13:14:25.941] 1. sequential:
[13:14:25.941]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[13:14:25.941]    - tweaked: FALSE
[13:14:25.941]    - call: plan(strategy)
[13:14:25.942] plan(): nbrOfWorkers() = 1
[13:14:25.942] SequentialFuture started (and completed)
[13:14:25.942] - Launch lazy future ... done
[13:14:25.943] run() for 'SequentialFuture' ... done
[13:14:25.943] Created future:
[13:14:25.943] SequentialFuture:
[13:14:25.943] Label: 'future_mapply-1'
[13:14:25.943] Expression:
[13:14:25.943] {
[13:14:25.943]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[13:14:25.943]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[13:14:25.943]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[13:14:25.943]         on.exit(options(oopts), add = TRUE)
[13:14:25.943]     }
[13:14:25.943]     {
[13:14:25.943]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[13:14:25.943]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[13:14:25.943]         do.call(mapply, args = args)
[13:14:25.943]     }
[13:14:25.943] }
[13:14:25.943] Lazy evaluation: FALSE
[13:14:25.943] Asynchronous evaluation: FALSE
[13:14:25.943] Local evaluation: TRUE
[13:14:25.943] Environment: R_GlobalEnv
[13:14:25.943] Capture standard output: FALSE
[13:14:25.943] Capture condition classes: 'condition' (excluding 'nothing')
[13:14:25.943] Globals: 5 objects totaling 6.33 KiB (function '...future.FUN' of 6.11 KiB, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 224 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[13:14:25.943] Packages: <none>
[13:14:25.943] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[13:14:25.943] Resolved: TRUE
[13:14:25.943] Value: 224 bytes of class 'list'
[13:14:25.943] Early signaling: FALSE
[13:14:25.943] Owner process: 68097d82-3b31-293d-2920-9b7259f27083
[13:14:25.943] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[13:14:25.944] Chunk #1 of 1 ... DONE
[13:14:25.944] Launching 1 futures (chunks) ... DONE
[13:14:25.945] Resolving 1 futures (chunks) ...
[13:14:25.945] resolve() on list ...
[13:14:25.945]  recursive: 0
[13:14:25.945]  length: 1
[13:14:25.945] 
[13:14:25.945] resolved() for 'SequentialFuture' ...
[13:14:25.946] - state: 'finished'
[13:14:25.946] - run: TRUE
[13:14:25.946] - result: 'FutureResult'
[13:14:25.946] resolved() for 'SequentialFuture' ... done
[13:14:25.946] Future #1
[13:14:25.947] signalConditionsASAP(SequentialFuture, pos=1) ...
[13:14:25.947] - nx: 1
[13:14:25.947] - relay: TRUE
[13:14:25.947] - stdout: TRUE
[13:14:25.947] - signal: TRUE
[13:14:25.947] - resignal: FALSE
[13:14:25.947] - force: TRUE
[13:14:25.948] - relayed: [n=1] FALSE
[13:14:25.948] - queued futures: [n=1] FALSE
[13:14:25.948]  - until=1
[13:14:25.948]  - relaying element #1
[13:14:25.948] - relayed: [n=1] TRUE
[13:14:25.948] - queued futures: [n=1] TRUE
[13:14:25.949] signalConditionsASAP(SequentialFuture, pos=1) ... done
[13:14:25.949]  length: 0 (resolved future 1)
[13:14:25.949] Relaying remaining futures
[13:14:25.949] signalConditionsASAP(NULL, pos=0) ...
[13:14:25.949] - nx: 1
[13:14:25.949] - relay: TRUE
[13:14:25.950] - stdout: TRUE
[13:14:25.950] - signal: TRUE
[13:14:25.950] - resignal: FALSE
[13:14:25.950] - force: TRUE
[13:14:25.950] - relayed: [n=1] TRUE
[13:14:25.950] - queued futures: [n=1] TRUE
 - flush all
[13:14:25.951] - relayed: [n=1] TRUE
[13:14:25.951] - queued futures: [n=1] TRUE
[13:14:25.951] signalConditionsASAP(NULL, pos=0) ... done
[13:14:25.951] resolve() on list ... DONE
[13:14:25.951]  - Number of value chunks collected: 1
[13:14:25.952] Resolving 1 futures (chunks) ... DONE
[13:14:25.953] Reducing values from 1 chunks ...
[13:14:25.953]  - Number of values collected after concatenation: 2
[13:14:25.953]  - Number of values expected: 2
[13:14:25.953] Reducing values from 1 chunks ... DONE
[13:14:25.953] future_mapply() ... DONE
* future_mapply(x, ..., future.stdout = FALSE) ... DONE
* future_mapply(x, ..., future.stdout = TRUE) ...
[13:14:25.954] future_mapply() ...
[13:14:25.954] Number of chunks: 1
[13:14:25.954] getGlobalsAndPackagesXApply() ...
[13:14:25.954]  - future.globals: TRUE
[13:14:25.955] getGlobalsAndPackages() ...
[13:14:25.955] Searching for globals...
[13:14:25.957] - globals found: [6] 'FUN', '{', 'Sys.sleep', '/', 'print', 'list'
[13:14:25.957] Searching for globals ... DONE
[13:14:25.957] Resolving globals: FALSE
[13:14:25.958] The total size of the 1 globals is 6.11 KiB (6256 bytes)
[13:14:25.958] The total size of the 1 globals exported for future expression ('FUN()') is 6.11 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (6.11 KiB of class 'function')
[13:14:25.958] - globals: [1] 'FUN'
[13:14:25.958] 
[13:14:25.959] getGlobalsAndPackages() ... DONE
[13:14:25.959]  - globals found/used: [n=1] 'FUN'
[13:14:25.959]  - needed namespaces: [n=0] 
[13:14:25.959] Finding globals ... DONE
[13:14:25.959] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[13:14:25.959] List of 2
[13:14:25.959]  $ ...future.FUN:function (x, y)  
[13:14:25.959]  $ MoreArgs     : NULL
[13:14:25.959]  - attr(*, "where")=List of 2
[13:14:25.959]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[13:14:25.959]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[13:14:25.959]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[13:14:25.959]  - attr(*, "resolved")= logi FALSE
[13:14:25.959]  - attr(*, "total_size")= num NA
[13:14:25.962] Packages to be attached in all futures: [n=0] 
[13:14:25.963] getGlobalsAndPackagesXApply() ... DONE
[13:14:25.963] Number of futures (= number of chunks): 1
[13:14:25.963] Launching 1 futures (chunks) ...
[13:14:25.963] Chunk #1 of 1 ...
[13:14:25.963]  - Finding globals in '...' for chunk #1 ...
[13:14:25.963] getGlobalsAndPackages() ...
[13:14:25.964] Searching for globals...
[13:14:25.964] 
[13:14:25.964] Searching for globals ... DONE
[13:14:25.964] - globals: [0] <none>
[13:14:25.964] getGlobalsAndPackages() ... DONE
[13:14:25.965]    + additional globals found: [n=0] 
[13:14:25.965]    + additional namespaces needed: [n=0] 
[13:14:25.965]  - Finding globals in '...' for chunk #1 ... DONE
[13:14:25.965]  - seeds: <none>
[13:14:25.965]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:25.965] getGlobalsAndPackages() ...
[13:14:25.966] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:25.966] Resolving globals: FALSE
[13:14:25.966] The total size of the 5 globals is 6.33 KiB (6480 bytes)
[13:14:25.967] The total size of the 5 globals exported for future expression ('{; ...future.globals.maxSize.org <- getOption("future.globals.maxSize"); if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {; oopts <- options(future.globals.maxSize = ...future.globals.maxSize); on.exit(options(oopts), add = TRUE); }; ...; do.call(mapply, args = args); }; }') is 6.33 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (6.11 KiB of class 'function'), '...future.elements_ii' (224 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[13:14:25.967] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:25.967] 
[13:14:25.968] getGlobalsAndPackages() ... DONE
[13:14:25.968] run() for 'Future' ...
[13:14:25.968] - state: 'created'
[13:14:25.968] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[13:14:25.969] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[13:14:25.969] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[13:14:25.969]   - Field: 'label'
[13:14:25.969]   - Field: 'local'
[13:14:25.969]   - Field: 'owner'
[13:14:25.970]   - Field: 'envir'
[13:14:25.970]   - Field: 'packages'
[13:14:25.970]   - Field: 'gc'
[13:14:25.970]   - Field: 'conditions'
[13:14:25.970]   - Field: 'expr'
[13:14:25.970]   - Field: 'uuid'
[13:14:25.971]   - Field: 'seed'
[13:14:25.971]   - Field: 'version'
[13:14:25.971]   - Field: 'result'
[13:14:25.971]   - Field: 'asynchronous'
[13:14:25.971]   - Field: 'calls'
[13:14:25.971]   - Field: 'globals'
[13:14:25.972]   - Field: 'stdout'
[13:14:25.972]   - Field: 'earlySignal'
[13:14:25.972]   - Field: 'lazy'
[13:14:25.972]   - Field: 'state'
[13:14:25.972] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[13:14:25.972] - Launch lazy future ...
[13:14:25.973] Packages needed by the future expression (n = 0): <none>
[13:14:25.973] Packages needed by future strategies (n = 0): <none>
[13:14:25.973] {
[13:14:25.973]     {
[13:14:25.973]         {
[13:14:25.973]             ...future.startTime <- base::Sys.time()
[13:14:25.973]             {
[13:14:25.973]                 {
[13:14:25.973]                   {
[13:14:25.973]                     base::local({
[13:14:25.973]                       has_future <- base::requireNamespace("future", 
[13:14:25.973]                         quietly = TRUE)
[13:14:25.973]                       if (has_future) {
[13:14:25.973]                         ns <- base::getNamespace("future")
[13:14:25.973]                         version <- ns[[".package"]][["version"]]
[13:14:25.973]                         if (is.null(version)) 
[13:14:25.973]                           version <- utils::packageVersion("future")
[13:14:25.973]                       }
[13:14:25.973]                       else {
[13:14:25.973]                         version <- NULL
[13:14:25.973]                       }
[13:14:25.973]                       if (!has_future || version < "1.8.0") {
[13:14:25.973]                         info <- base::c(r_version = base::gsub("R version ", 
[13:14:25.973]                           "", base::R.version$version.string), 
[13:14:25.973]                           platform = base::sprintf("%s (%s-bit)", 
[13:14:25.973]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[13:14:25.973]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[13:14:25.973]                             "release", "version")], collapse = " "), 
[13:14:25.973]                           hostname = base::Sys.info()[["nodename"]])
[13:14:25.973]                         info <- base::sprintf("%s: %s", base::names(info), 
[13:14:25.973]                           info)
[13:14:25.973]                         info <- base::paste(info, collapse = "; ")
[13:14:25.973]                         if (!has_future) {
[13:14:25.973]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[13:14:25.973]                             info)
[13:14:25.973]                         }
[13:14:25.973]                         else {
[13:14:25.973]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[13:14:25.973]                             info, version)
[13:14:25.973]                         }
[13:14:25.973]                         base::stop(msg)
[13:14:25.973]                       }
[13:14:25.973]                     })
[13:14:25.973]                   }
[13:14:25.973]                   options(future.plan = NULL)
[13:14:25.973]                   Sys.unsetenv("R_FUTURE_PLAN")
[13:14:25.973]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[13:14:25.973]                 }
[13:14:25.973]                 ...future.workdir <- getwd()
[13:14:25.973]             }
[13:14:25.973]             ...future.oldOptions <- base::as.list(base::.Options)
[13:14:25.973]             ...future.oldEnvVars <- base::Sys.getenv()
[13:14:25.973]         }
[13:14:25.973]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[13:14:25.973]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[13:14:25.973]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[13:14:25.973]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[13:14:25.973]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[13:14:25.973]             future.stdout.windows.reencode = NULL, width = 80L)
[13:14:25.973]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[13:14:25.973]             base::names(...future.oldOptions))
[13:14:25.973]     }
[13:14:25.973]     if (FALSE) {
[13:14:25.973]     }
[13:14:25.973]     else {
[13:14:25.973]         if (TRUE) {
[13:14:25.973]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[13:14:25.973]                 open = "w")
[13:14:25.973]         }
[13:14:25.973]         else {
[13:14:25.973]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[13:14:25.973]                 windows = "NUL", "/dev/null"), open = "w")
[13:14:25.973]         }
[13:14:25.973]         base::sink(...future.stdout, type = "output", split = FALSE)
[13:14:25.973]         base::on.exit(if (!base::is.null(...future.stdout)) {
[13:14:25.973]             base::sink(type = "output", split = FALSE)
[13:14:25.973]             base::close(...future.stdout)
[13:14:25.973]         }, add = TRUE)
[13:14:25.973]     }
[13:14:25.973]     ...future.frame <- base::sys.nframe()
[13:14:25.973]     ...future.conditions <- base::list()
[13:14:25.973]     ...future.rng <- base::globalenv()$.Random.seed
[13:14:25.973]     if (FALSE) {
[13:14:25.973]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[13:14:25.973]             "...future.value", "...future.globalenv.names", ".Random.seed")
[13:14:25.973]     }
[13:14:25.973]     ...future.result <- base::tryCatch({
[13:14:25.973]         base::withCallingHandlers({
[13:14:25.973]             ...future.value <- base::withVisible(base::local({
[13:14:25.973]                 ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[13:14:25.973]                 if (!identical(...future.globals.maxSize.org, 
[13:14:25.973]                   ...future.globals.maxSize)) {
[13:14:25.973]                   oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[13:14:25.973]                   on.exit(options(oopts), add = TRUE)
[13:14:25.973]                 }
[13:14:25.973]                 {
[13:14:25.973]                   args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[13:14:25.973]                     MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[13:14:25.973]                     USE.NAMES = FALSE)
[13:14:25.973]                   do.call(mapply, args = args)
[13:14:25.973]                 }
[13:14:25.973]             }))
[13:14:25.973]             future::FutureResult(value = ...future.value$value, 
[13:14:25.973]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[13:14:25.973]                   ...future.rng), globalenv = if (FALSE) 
[13:14:25.973]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[13:14:25.973]                     ...future.globalenv.names))
[13:14:25.973]                 else NULL, started = ...future.startTime, version = "1.8")
[13:14:25.973]         }, condition = base::local({
[13:14:25.973]             c <- base::c
[13:14:25.973]             inherits <- base::inherits
[13:14:25.973]             invokeRestart <- base::invokeRestart
[13:14:25.973]             length <- base::length
[13:14:25.973]             list <- base::list
[13:14:25.973]             seq.int <- base::seq.int
[13:14:25.973]             signalCondition <- base::signalCondition
[13:14:25.973]             sys.calls <- base::sys.calls
[13:14:25.973]             `[[` <- base::`[[`
[13:14:25.973]             `+` <- base::`+`
[13:14:25.973]             `<<-` <- base::`<<-`
[13:14:25.973]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[13:14:25.973]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[13:14:25.973]                   3L)]
[13:14:25.973]             }
[13:14:25.973]             function(cond) {
[13:14:25.973]                 is_error <- inherits(cond, "error")
[13:14:25.973]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[13:14:25.973]                   NULL)
[13:14:25.973]                 if (is_error) {
[13:14:25.973]                   sessionInformation <- function() {
[13:14:25.973]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[13:14:25.973]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[13:14:25.973]                       search = base::search(), system = base::Sys.info())
[13:14:25.973]                   }
[13:14:25.973]                   ...future.conditions[[length(...future.conditions) + 
[13:14:25.973]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[13:14:25.973]                     cond$call), session = sessionInformation(), 
[13:14:25.973]                     timestamp = base::Sys.time(), signaled = 0L)
[13:14:25.973]                   signalCondition(cond)
[13:14:25.973]                 }
[13:14:25.973]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[13:14:25.973]                 "immediateCondition"))) {
[13:14:25.973]                   signal <- TRUE && inherits(cond, "immediateCondition")
[13:14:25.973]                   ...future.conditions[[length(...future.conditions) + 
[13:14:25.973]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[13:14:25.973]                   if (TRUE && !signal) {
[13:14:25.973]                     muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:25.973]                     {
[13:14:25.973]                       inherits <- base::inherits
[13:14:25.973]                       invokeRestart <- base::invokeRestart
[13:14:25.973]                       is.null <- base::is.null
[13:14:25.973]                       muffled <- FALSE
[13:14:25.973]                       if (inherits(cond, "message")) {
[13:14:25.973]                         muffled <- grepl(pattern, "muffleMessage")
[13:14:25.973]                         if (muffled) 
[13:14:25.973]                           invokeRestart("muffleMessage")
[13:14:25.973]                       }
[13:14:25.973]                       else if (inherits(cond, "warning")) {
[13:14:25.973]                         muffled <- grepl(pattern, "muffleWarning")
[13:14:25.973]                         if (muffled) 
[13:14:25.973]                           invokeRestart("muffleWarning")
[13:14:25.973]                       }
[13:14:25.973]                       else if (inherits(cond, "condition")) {
[13:14:25.973]                         if (!is.null(pattern)) {
[13:14:25.973]                           computeRestarts <- base::computeRestarts
[13:14:25.973]                           grepl <- base::grepl
[13:14:25.973]                           restarts <- computeRestarts(cond)
[13:14:25.973]                           for (restart in restarts) {
[13:14:25.973]                             name <- restart$name
[13:14:25.973]                             if (is.null(name)) 
[13:14:25.973]                               next
[13:14:25.973]                             if (!grepl(pattern, name)) 
[13:14:25.973]                               next
[13:14:25.973]                             invokeRestart(restart)
[13:14:25.973]                             muffled <- TRUE
[13:14:25.973]                             break
[13:14:25.973]                           }
[13:14:25.973]                         }
[13:14:25.973]                       }
[13:14:25.973]                       invisible(muffled)
[13:14:25.973]                     }
[13:14:25.973]                     muffleCondition(cond, pattern = "^muffle")
[13:14:25.973]                   }
[13:14:25.973]                 }
[13:14:25.973]                 else {
[13:14:25.973]                   if (TRUE) {
[13:14:25.973]                     muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:25.973]                     {
[13:14:25.973]                       inherits <- base::inherits
[13:14:25.973]                       invokeRestart <- base::invokeRestart
[13:14:25.973]                       is.null <- base::is.null
[13:14:25.973]                       muffled <- FALSE
[13:14:25.973]                       if (inherits(cond, "message")) {
[13:14:25.973]                         muffled <- grepl(pattern, "muffleMessage")
[13:14:25.973]                         if (muffled) 
[13:14:25.973]                           invokeRestart("muffleMessage")
[13:14:25.973]                       }
[13:14:25.973]                       else if (inherits(cond, "warning")) {
[13:14:25.973]                         muffled <- grepl(pattern, "muffleWarning")
[13:14:25.973]                         if (muffled) 
[13:14:25.973]                           invokeRestart("muffleWarning")
[13:14:25.973]                       }
[13:14:25.973]                       else if (inherits(cond, "condition")) {
[13:14:25.973]                         if (!is.null(pattern)) {
[13:14:25.973]                           computeRestarts <- base::computeRestarts
[13:14:25.973]                           grepl <- base::grepl
[13:14:25.973]                           restarts <- computeRestarts(cond)
[13:14:25.973]                           for (restart in restarts) {
[13:14:25.973]                             name <- restart$name
[13:14:25.973]                             if (is.null(name)) 
[13:14:25.973]                               next
[13:14:25.973]                             if (!grepl(pattern, name)) 
[13:14:25.973]                               next
[13:14:25.973]                             invokeRestart(restart)
[13:14:25.973]                             muffled <- TRUE
[13:14:25.973]                             break
[13:14:25.973]                           }
[13:14:25.973]                         }
[13:14:25.973]                       }
[13:14:25.973]                       invisible(muffled)
[13:14:25.973]                     }
[13:14:25.973]                     muffleCondition(cond, pattern = "^muffle")
[13:14:25.973]                   }
[13:14:25.973]                 }
[13:14:25.973]             }
[13:14:25.973]         }))
[13:14:25.973]     }, error = function(ex) {
[13:14:25.973]         base::structure(base::list(value = NULL, visible = NULL, 
[13:14:25.973]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[13:14:25.973]                 ...future.rng), started = ...future.startTime, 
[13:14:25.973]             finished = Sys.time(), session_uuid = NA_character_, 
[13:14:25.973]             version = "1.8"), class = "FutureResult")
[13:14:25.973]     }, finally = {
[13:14:25.973]         if (!identical(...future.workdir, getwd())) 
[13:14:25.973]             setwd(...future.workdir)
[13:14:25.973]         {
[13:14:25.973]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[13:14:25.973]                 ...future.oldOptions$nwarnings <- NULL
[13:14:25.973]             }
[13:14:25.973]             base::options(...future.oldOptions)
[13:14:25.973]             if (.Platform$OS.type == "windows") {
[13:14:25.973]                 old_names <- names(...future.oldEnvVars)
[13:14:25.973]                 envs <- base::Sys.getenv()
[13:14:25.973]                 names <- names(envs)
[13:14:25.973]                 common <- intersect(names, old_names)
[13:14:25.973]                 added <- setdiff(names, old_names)
[13:14:25.973]                 removed <- setdiff(old_names, names)
[13:14:25.973]                 changed <- common[...future.oldEnvVars[common] != 
[13:14:25.973]                   envs[common]]
[13:14:25.973]                 NAMES <- toupper(changed)
[13:14:25.973]                 args <- list()
[13:14:25.973]                 for (kk in seq_along(NAMES)) {
[13:14:25.973]                   name <- changed[[kk]]
[13:14:25.973]                   NAME <- NAMES[[kk]]
[13:14:25.973]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:25.973]                     next
[13:14:25.973]                   args[[name]] <- ...future.oldEnvVars[[name]]
[13:14:25.973]                 }
[13:14:25.973]                 NAMES <- toupper(added)
[13:14:25.973]                 for (kk in seq_along(NAMES)) {
[13:14:25.973]                   name <- added[[kk]]
[13:14:25.973]                   NAME <- NAMES[[kk]]
[13:14:25.973]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:25.973]                     next
[13:14:25.973]                   args[[name]] <- ""
[13:14:25.973]                 }
[13:14:25.973]                 NAMES <- toupper(removed)
[13:14:25.973]                 for (kk in seq_along(NAMES)) {
[13:14:25.973]                   name <- removed[[kk]]
[13:14:25.973]                   NAME <- NAMES[[kk]]
[13:14:25.973]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:25.973]                     next
[13:14:25.973]                   args[[name]] <- ...future.oldEnvVars[[name]]
[13:14:25.973]                 }
[13:14:25.973]                 if (length(args) > 0) 
[13:14:25.973]                   base::do.call(base::Sys.setenv, args = args)
[13:14:25.973]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[13:14:25.973]             }
[13:14:25.973]             else {
[13:14:25.973]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[13:14:25.973]             }
[13:14:25.973]             {
[13:14:25.973]                 if (base::length(...future.futureOptionsAdded) > 
[13:14:25.973]                   0L) {
[13:14:25.973]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[13:14:25.973]                   base::names(opts) <- ...future.futureOptionsAdded
[13:14:25.973]                   base::options(opts)
[13:14:25.973]                 }
[13:14:25.973]                 {
[13:14:25.973]                   {
[13:14:25.973]                     NULL
[13:14:25.973]                     RNGkind("Mersenne-Twister")
[13:14:25.973]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[13:14:25.973]                       inherits = FALSE)
[13:14:25.973]                   }
[13:14:25.973]                   options(future.plan = NULL)
[13:14:25.973]                   if (is.na(NA_character_)) 
[13:14:25.973]                     Sys.unsetenv("R_FUTURE_PLAN")
[13:14:25.973]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[13:14:25.973]                   future::plan(list(function (..., envir = parent.frame()) 
[13:14:25.973]                   {
[13:14:25.973]                     future <- SequentialFuture(..., envir = envir)
[13:14:25.973]                     if (!future$lazy) 
[13:14:25.973]                       future <- run(future)
[13:14:25.973]                     invisible(future)
[13:14:25.973]                   }), .cleanup = FALSE, .init = FALSE)
[13:14:25.973]                 }
[13:14:25.973]             }
[13:14:25.973]         }
[13:14:25.973]     })
[13:14:25.973]     if (TRUE) {
[13:14:25.973]         base::sink(type = "output", split = FALSE)
[13:14:25.973]         if (TRUE) {
[13:14:25.973]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[13:14:25.973]         }
[13:14:25.973]         else {
[13:14:25.973]             ...future.result["stdout"] <- base::list(NULL)
[13:14:25.973]         }
[13:14:25.973]         base::close(...future.stdout)
[13:14:25.973]         ...future.stdout <- NULL
[13:14:25.973]     }
[13:14:25.973]     ...future.result$conditions <- ...future.conditions
[13:14:25.973]     ...future.result$finished <- base::Sys.time()
[13:14:25.973]     ...future.result
[13:14:25.973] }
[13:14:25.977] assign_globals() ...
[13:14:25.977] List of 5
[13:14:25.977]  $ ...future.FUN            :function (x, y)  
[13:14:25.977]  $ MoreArgs                 : NULL
[13:14:25.977]  $ ...future.elements_ii    :List of 2
[13:14:25.977]   ..$ :List of 2
[13:14:25.977]   .. ..$ : int 1
[13:14:25.977]   .. ..$ : int 0
[13:14:25.977]   ..$ :List of 2
[13:14:25.977]   .. ..$ : int 0
[13:14:25.977]   .. ..$ : int 1
[13:14:25.977]  $ ...future.seeds_ii       : NULL
[13:14:25.977]  $ ...future.globals.maxSize: NULL
[13:14:25.977]  - attr(*, "where")=List of 5
[13:14:25.977]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[13:14:25.977]   ..$ MoreArgs                 :<environment: R_EmptyEnv> 
[13:14:25.977]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[13:14:25.977]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[13:14:25.977]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[13:14:25.977]  - attr(*, "resolved")= logi FALSE
[13:14:25.977]  - attr(*, "total_size")= num 6480
[13:14:25.977]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[13:14:25.977]  - attr(*, "already-done")= logi TRUE
[13:14:25.985] - reassign environment for '...future.FUN'
[13:14:25.985] - copied '...future.FUN' to environment
[13:14:25.985] - copied 'MoreArgs' to environment
[13:14:25.985] - copied '...future.elements_ii' to environment
[13:14:25.985] - copied '...future.seeds_ii' to environment
[13:14:25.986] - copied '...future.globals.maxSize' to environment
[13:14:25.986] assign_globals() ... done
[13:14:25.986] plan(): Setting new future strategy stack:
[13:14:25.986] List of future strategies:
[13:14:25.986] 1. sequential:
[13:14:25.986]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[13:14:25.986]    - tweaked: FALSE
[13:14:25.986]    - call: NULL
[13:14:25.987] plan(): nbrOfWorkers() = 1
[13:14:26.490] plan(): Setting new future strategy stack:
[13:14:26.490] List of future strategies:
[13:14:26.490] 1. sequential:
[13:14:26.490]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[13:14:26.490]    - tweaked: FALSE
[13:14:26.490]    - call: plan(strategy)
[13:14:26.491] plan(): nbrOfWorkers() = 1
[13:14:26.491] SequentialFuture started (and completed)
[13:14:26.491] - Launch lazy future ... done
[13:14:26.491] run() for 'SequentialFuture' ... done
[13:14:26.492] Created future:
[13:14:26.492] SequentialFuture:
[13:14:26.492] Label: 'future_mapply-1'
[13:14:26.492] Expression:
[13:14:26.492] {
[13:14:26.492]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[13:14:26.492]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[13:14:26.492]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[13:14:26.492]         on.exit(options(oopts), add = TRUE)
[13:14:26.492]     }
[13:14:26.492]     {
[13:14:26.492]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[13:14:26.492]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[13:14:26.492]         do.call(mapply, args = args)
[13:14:26.492]     }
[13:14:26.492] }
[13:14:26.492] Lazy evaluation: FALSE
[13:14:26.492] Asynchronous evaluation: FALSE
[13:14:26.492] Local evaluation: TRUE
[13:14:26.492] Environment: R_GlobalEnv
[13:14:26.492] Capture standard output: TRUE
[13:14:26.492] Capture condition classes: 'condition' (excluding 'nothing')
[13:14:26.492] Globals: 5 objects totaling 6.33 KiB (function '...future.FUN' of 6.11 KiB, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 224 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[13:14:26.492] Packages: <none>
[13:14:26.492] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[13:14:26.492] Resolved: TRUE
[13:14:26.492] Value: 224 bytes of class 'list'
[13:14:26.492] Early signaling: FALSE
[13:14:26.492] Owner process: 68097d82-3b31-293d-2920-9b7259f27083
[13:14:26.492] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[13:14:26.493] Chunk #1 of 1 ... DONE
[13:14:26.493] Launching 1 futures (chunks) ... DONE
[13:14:26.493] Resolving 1 futures (chunks) ...
[13:14:26.493] resolve() on list ...
[13:14:26.494]  recursive: 0
[13:14:26.494]  length: 1
[13:14:26.494] 
[13:14:26.494] resolved() for 'SequentialFuture' ...
[13:14:26.494] - state: 'finished'
[13:14:26.494] - run: TRUE
[13:14:26.495] - result: 'FutureResult'
[13:14:26.495] resolved() for 'SequentialFuture' ... done
[13:14:26.495] Future #1
[13:14:26.495] signalConditionsASAP(SequentialFuture, pos=1) ...
[13:14:26.495] - nx: 1
[13:14:26.496] - relay: TRUE
[13:14:26.496] - stdout: TRUE
[13:14:26.496] - signal: TRUE
[13:14:26.496] - resignal: FALSE
[13:14:26.496] - force: TRUE
[13:14:26.496] - relayed: [n=1] FALSE
[13:14:26.496] - queued futures: [n=1] FALSE
[13:14:26.497]  - until=1
[13:14:26.497]  - relaying element #1
[13:14:26.497] - relayed: [n=1] TRUE
[13:14:26.497] - queued futures: [n=1] TRUE
[13:14:26.497] signalConditionsASAP(SequentialFuture, pos=1) ... done
[13:14:26.498]  length: 0 (resolved future 1)
[13:14:26.498] Relaying remaining futures
[13:14:26.498] signalConditionsASAP(NULL, pos=0) ...
[13:14:26.498] - nx: 1
[13:14:26.498] - relay: TRUE
[13:14:26.498] - stdout: TRUE
[13:14:26.499] - signal: TRUE
[13:14:26.499] - resignal: FALSE
[13:14:26.499] - force: TRUE
[13:14:26.499] - relayed: [n=1] TRUE
[13:14:26.499] - queued futures: [n=1] TRUE
 - flush all
[13:14:26.499] - relayed: [n=1] TRUE
[13:14:26.500] - queued futures: [n=1] TRUE
[13:14:26.500] signalConditionsASAP(NULL, pos=0) ... done
[13:14:26.500] resolve() on list ... DONE
[13:14:26.500]  - Number of value chunks collected: 1
[13:14:26.500] Resolving 1 futures (chunks) ... DONE
[13:14:26.500] Reducing values from 1 chunks ...
[13:14:26.501]  - Number of values collected after concatenation: 2
[13:14:26.501]  - Number of values expected: 2
[13:14:26.501] Reducing values from 1 chunks ... DONE
[13:14:26.501] future_mapply() ... DONE
* future_mapply(x, ..., future.stdout = TRUE) ... DONE
* future_mapply(x, ..., future.stdout = NA) ...
[13:14:26.502] future_mapply() ...
[13:14:26.502] Number of chunks: 1
[13:14:26.502] getGlobalsAndPackagesXApply() ...
[13:14:26.502]  - future.globals: TRUE
[13:14:26.502] getGlobalsAndPackages() ...
[13:14:26.502] Searching for globals...
[13:14:26.504] - globals found: [6] 'FUN', '{', 'Sys.sleep', '/', 'print', 'list'
[13:14:26.504] Searching for globals ... DONE
[13:14:26.505] Resolving globals: FALSE
[13:14:26.505] The total size of the 1 globals is 6.11 KiB (6256 bytes)
[13:14:26.506] The total size of the 1 globals exported for future expression ('FUN()') is 6.11 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (6.11 KiB of class 'function')
[13:14:26.506] - globals: [1] 'FUN'
[13:14:26.506] 
[13:14:26.506] getGlobalsAndPackages() ... DONE
[13:14:26.506]  - globals found/used: [n=1] 'FUN'
[13:14:26.506]  - needed namespaces: [n=0] 
[13:14:26.507] Finding globals ... DONE
[13:14:26.507] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[13:14:26.507] List of 2
[13:14:26.507]  $ ...future.FUN:function (x, y)  
[13:14:26.507]  $ MoreArgs     : NULL
[13:14:26.507]  - attr(*, "where")=List of 2
[13:14:26.507]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[13:14:26.507]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[13:14:26.507]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[13:14:26.507]  - attr(*, "resolved")= logi FALSE
[13:14:26.507]  - attr(*, "total_size")= num NA
[13:14:26.511] Packages to be attached in all futures: [n=0] 
[13:14:26.511] getGlobalsAndPackagesXApply() ... DONE
[13:14:26.511] Number of futures (= number of chunks): 1
[13:14:26.511] Launching 1 futures (chunks) ...
[13:14:26.512] Chunk #1 of 1 ...
[13:14:26.512]  - Finding globals in '...' for chunk #1 ...
[13:14:26.512] getGlobalsAndPackages() ...
[13:14:26.512] Searching for globals...
[13:14:26.512] 
[13:14:26.513] Searching for globals ... DONE
[13:14:26.513] - globals: [0] <none>
[13:14:26.513] getGlobalsAndPackages() ... DONE
[13:14:26.513]    + additional globals found: [n=0] 
[13:14:26.513]    + additional namespaces needed: [n=0] 
[13:14:26.513]  - Finding globals in '...' for chunk #1 ... DONE
[13:14:26.514]  - seeds: <none>
[13:14:26.514]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:26.514] getGlobalsAndPackages() ...
[13:14:26.514] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:26.514] Resolving globals: FALSE
[13:14:26.515] The total size of the 5 globals is 6.33 KiB (6480 bytes)
[13:14:26.515] The total size of the 5 globals exported for future expression ('{; ...future.globals.maxSize.org <- getOption("future.globals.maxSize"); if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {; oopts <- options(future.globals.maxSize = ...future.globals.maxSize); on.exit(options(oopts), add = TRUE); }; ...; do.call(mapply, args = args); }; }') is 6.33 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (6.11 KiB of class 'function'), '...future.elements_ii' (224 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[13:14:26.516] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:26.516] 
[13:14:26.516] getGlobalsAndPackages() ... DONE
[13:14:26.516] run() for 'Future' ...
[13:14:26.516] - state: 'created'
[13:14:26.517] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[13:14:26.517] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[13:14:26.517] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[13:14:26.517]   - Field: 'label'
[13:14:26.518]   - Field: 'local'
[13:14:26.518]   - Field: 'owner'
[13:14:26.518]   - Field: 'envir'
[13:14:26.518]   - Field: 'packages'
[13:14:26.518]   - Field: 'gc'
[13:14:26.518]   - Field: 'conditions'
[13:14:26.519]   - Field: 'expr'
[13:14:26.519]   - Field: 'uuid'
[13:14:26.519]   - Field: 'seed'
[13:14:26.519]   - Field: 'version'
[13:14:26.519]   - Field: 'result'
[13:14:26.519]   - Field: 'asynchronous'
[13:14:26.520]   - Field: 'calls'
[13:14:26.520]   - Field: 'globals'
[13:14:26.520]   - Field: 'stdout'
[13:14:26.520]   - Field: 'earlySignal'
[13:14:26.520]   - Field: 'lazy'
[13:14:26.521]   - Field: 'state'
[13:14:26.521] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[13:14:26.521] - Launch lazy future ...
[13:14:26.521] Packages needed by the future expression (n = 0): <none>
[13:14:26.521] Packages needed by future strategies (n = 0): <none>
[13:14:26.522] {
[13:14:26.522]     {
[13:14:26.522]         {
[13:14:26.522]             ...future.startTime <- base::Sys.time()
[13:14:26.522]             {
[13:14:26.522]                 {
[13:14:26.522]                   {
[13:14:26.522]                     base::local({
[13:14:26.522]                       has_future <- base::requireNamespace("future", 
[13:14:26.522]                         quietly = TRUE)
[13:14:26.522]                       if (has_future) {
[13:14:26.522]                         ns <- base::getNamespace("future")
[13:14:26.522]                         version <- ns[[".package"]][["version"]]
[13:14:26.522]                         if (is.null(version)) 
[13:14:26.522]                           version <- utils::packageVersion("future")
[13:14:26.522]                       }
[13:14:26.522]                       else {
[13:14:26.522]                         version <- NULL
[13:14:26.522]                       }
[13:14:26.522]                       if (!has_future || version < "1.8.0") {
[13:14:26.522]                         info <- base::c(r_version = base::gsub("R version ", 
[13:14:26.522]                           "", base::R.version$version.string), 
[13:14:26.522]                           platform = base::sprintf("%s (%s-bit)", 
[13:14:26.522]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[13:14:26.522]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[13:14:26.522]                             "release", "version")], collapse = " "), 
[13:14:26.522]                           hostname = base::Sys.info()[["nodename"]])
[13:14:26.522]                         info <- base::sprintf("%s: %s", base::names(info), 
[13:14:26.522]                           info)
[13:14:26.522]                         info <- base::paste(info, collapse = "; ")
[13:14:26.522]                         if (!has_future) {
[13:14:26.522]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[13:14:26.522]                             info)
[13:14:26.522]                         }
[13:14:26.522]                         else {
[13:14:26.522]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[13:14:26.522]                             info, version)
[13:14:26.522]                         }
[13:14:26.522]                         base::stop(msg)
[13:14:26.522]                       }
[13:14:26.522]                     })
[13:14:26.522]                   }
[13:14:26.522]                   options(future.plan = NULL)
[13:14:26.522]                   Sys.unsetenv("R_FUTURE_PLAN")
[13:14:26.522]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[13:14:26.522]                 }
[13:14:26.522]                 ...future.workdir <- getwd()
[13:14:26.522]             }
[13:14:26.522]             ...future.oldOptions <- base::as.list(base::.Options)
[13:14:26.522]             ...future.oldEnvVars <- base::Sys.getenv()
[13:14:26.522]         }
[13:14:26.522]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[13:14:26.522]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[13:14:26.522]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[13:14:26.522]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[13:14:26.522]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[13:14:26.522]             future.stdout.windows.reencode = NULL, width = 80L)
[13:14:26.522]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[13:14:26.522]             base::names(...future.oldOptions))
[13:14:26.522]     }
[13:14:26.522]     if (TRUE) {
[13:14:26.522]     }
[13:14:26.522]     else {
[13:14:26.522]         if (NA) {
[13:14:26.522]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[13:14:26.522]                 open = "w")
[13:14:26.522]         }
[13:14:26.522]         else {
[13:14:26.522]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[13:14:26.522]                 windows = "NUL", "/dev/null"), open = "w")
[13:14:26.522]         }
[13:14:26.522]         base::sink(...future.stdout, type = "output", split = FALSE)
[13:14:26.522]         base::on.exit(if (!base::is.null(...future.stdout)) {
[13:14:26.522]             base::sink(type = "output", split = FALSE)
[13:14:26.522]             base::close(...future.stdout)
[13:14:26.522]         }, add = TRUE)
[13:14:26.522]     }
[13:14:26.522]     ...future.frame <- base::sys.nframe()
[13:14:26.522]     ...future.conditions <- base::list()
[13:14:26.522]     ...future.rng <- base::globalenv()$.Random.seed
[13:14:26.522]     if (FALSE) {
[13:14:26.522]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[13:14:26.522]             "...future.value", "...future.globalenv.names", ".Random.seed")
[13:14:26.522]     }
[13:14:26.522]     ...future.result <- base::tryCatch({
[13:14:26.522]         base::withCallingHandlers({
[13:14:26.522]             ...future.value <- base::withVisible(base::local({
[13:14:26.522]                 ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[13:14:26.522]                 if (!identical(...future.globals.maxSize.org, 
[13:14:26.522]                   ...future.globals.maxSize)) {
[13:14:26.522]                   oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[13:14:26.522]                   on.exit(options(oopts), add = TRUE)
[13:14:26.522]                 }
[13:14:26.522]                 {
[13:14:26.522]                   args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[13:14:26.522]                     MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[13:14:26.522]                     USE.NAMES = FALSE)
[13:14:26.522]                   do.call(mapply, args = args)
[13:14:26.522]                 }
[13:14:26.522]             }))
[13:14:26.522]             future::FutureResult(value = ...future.value$value, 
[13:14:26.522]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[13:14:26.522]                   ...future.rng), globalenv = if (FALSE) 
[13:14:26.522]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[13:14:26.522]                     ...future.globalenv.names))
[13:14:26.522]                 else NULL, started = ...future.startTime, version = "1.8")
[13:14:26.522]         }, condition = base::local({
[13:14:26.522]             c <- base::c
[13:14:26.522]             inherits <- base::inherits
[13:14:26.522]             invokeRestart <- base::invokeRestart
[13:14:26.522]             length <- base::length
[13:14:26.522]             list <- base::list
[13:14:26.522]             seq.int <- base::seq.int
[13:14:26.522]             signalCondition <- base::signalCondition
[13:14:26.522]             sys.calls <- base::sys.calls
[13:14:26.522]             `[[` <- base::`[[`
[13:14:26.522]             `+` <- base::`+`
[13:14:26.522]             `<<-` <- base::`<<-`
[13:14:26.522]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[13:14:26.522]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[13:14:26.522]                   3L)]
[13:14:26.522]             }
[13:14:26.522]             function(cond) {
[13:14:26.522]                 is_error <- inherits(cond, "error")
[13:14:26.522]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[13:14:26.522]                   NULL)
[13:14:26.522]                 if (is_error) {
[13:14:26.522]                   sessionInformation <- function() {
[13:14:26.522]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[13:14:26.522]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[13:14:26.522]                       search = base::search(), system = base::Sys.info())
[13:14:26.522]                   }
[13:14:26.522]                   ...future.conditions[[length(...future.conditions) + 
[13:14:26.522]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[13:14:26.522]                     cond$call), session = sessionInformation(), 
[13:14:26.522]                     timestamp = base::Sys.time(), signaled = 0L)
[13:14:26.522]                   signalCondition(cond)
[13:14:26.522]                 }
[13:14:26.522]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[13:14:26.522]                 "immediateCondition"))) {
[13:14:26.522]                   signal <- TRUE && inherits(cond, "immediateCondition")
[13:14:26.522]                   ...future.conditions[[length(...future.conditions) + 
[13:14:26.522]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[13:14:26.522]                   if (TRUE && !signal) {
[13:14:26.522]                     muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:26.522]                     {
[13:14:26.522]                       inherits <- base::inherits
[13:14:26.522]                       invokeRestart <- base::invokeRestart
[13:14:26.522]                       is.null <- base::is.null
[13:14:26.522]                       muffled <- FALSE
[13:14:26.522]                       if (inherits(cond, "message")) {
[13:14:26.522]                         muffled <- grepl(pattern, "muffleMessage")
[13:14:26.522]                         if (muffled) 
[13:14:26.522]                           invokeRestart("muffleMessage")
[13:14:26.522]                       }
[13:14:26.522]                       else if (inherits(cond, "warning")) {
[13:14:26.522]                         muffled <- grepl(pattern, "muffleWarning")
[13:14:26.522]                         if (muffled) 
[13:14:26.522]                           invokeRestart("muffleWarning")
[13:14:26.522]                       }
[13:14:26.522]                       else if (inherits(cond, "condition")) {
[13:14:26.522]                         if (!is.null(pattern)) {
[13:14:26.522]                           computeRestarts <- base::computeRestarts
[13:14:26.522]                           grepl <- base::grepl
[13:14:26.522]                           restarts <- computeRestarts(cond)
[13:14:26.522]                           for (restart in restarts) {
[13:14:26.522]                             name <- restart$name
[13:14:26.522]                             if (is.null(name)) 
[13:14:26.522]                               next
[13:14:26.522]                             if (!grepl(pattern, name)) 
[13:14:26.522]                               next
[13:14:26.522]                             invokeRestart(restart)
[13:14:26.522]                             muffled <- TRUE
[13:14:26.522]                             break
[13:14:26.522]                           }
[13:14:26.522]                         }
[13:14:26.522]                       }
[13:14:26.522]                       invisible(muffled)
[13:14:26.522]                     }
[13:14:26.522]                     muffleCondition(cond, pattern = "^muffle")
[13:14:26.522]                   }
[13:14:26.522]                 }
[13:14:26.522]                 else {
[13:14:26.522]                   if (TRUE) {
[13:14:26.522]                     muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:26.522]                     {
[13:14:26.522]                       inherits <- base::inherits
[13:14:26.522]                       invokeRestart <- base::invokeRestart
[13:14:26.522]                       is.null <- base::is.null
[13:14:26.522]                       muffled <- FALSE
[13:14:26.522]                       if (inherits(cond, "message")) {
[13:14:26.522]                         muffled <- grepl(pattern, "muffleMessage")
[13:14:26.522]                         if (muffled) 
[13:14:26.522]                           invokeRestart("muffleMessage")
[13:14:26.522]                       }
[13:14:26.522]                       else if (inherits(cond, "warning")) {
[13:14:26.522]                         muffled <- grepl(pattern, "muffleWarning")
[13:14:26.522]                         if (muffled) 
[13:14:26.522]                           invokeRestart("muffleWarning")
[13:14:26.522]                       }
[13:14:26.522]                       else if (inherits(cond, "condition")) {
[13:14:26.522]                         if (!is.null(pattern)) {
[13:14:26.522]                           computeRestarts <- base::computeRestarts
[13:14:26.522]                           grepl <- base::grepl
[13:14:26.522]                           restarts <- computeRestarts(cond)
[13:14:26.522]                           for (restart in restarts) {
[13:14:26.522]                             name <- restart$name
[13:14:26.522]                             if (is.null(name)) 
[13:14:26.522]                               next
[13:14:26.522]                             if (!grepl(pattern, name)) 
[13:14:26.522]                               next
[13:14:26.522]                             invokeRestart(restart)
[13:14:26.522]                             muffled <- TRUE
[13:14:26.522]                             break
[13:14:26.522]                           }
[13:14:26.522]                         }
[13:14:26.522]                       }
[13:14:26.522]                       invisible(muffled)
[13:14:26.522]                     }
[13:14:26.522]                     muffleCondition(cond, pattern = "^muffle")
[13:14:26.522]                   }
[13:14:26.522]                 }
[13:14:26.522]             }
[13:14:26.522]         }))
[13:14:26.522]     }, error = function(ex) {
[13:14:26.522]         base::structure(base::list(value = NULL, visible = NULL, 
[13:14:26.522]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[13:14:26.522]                 ...future.rng), started = ...future.startTime, 
[13:14:26.522]             finished = Sys.time(), session_uuid = NA_character_, 
[13:14:26.522]             version = "1.8"), class = "FutureResult")
[13:14:26.522]     }, finally = {
[13:14:26.522]         if (!identical(...future.workdir, getwd())) 
[13:14:26.522]             setwd(...future.workdir)
[13:14:26.522]         {
[13:14:26.522]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[13:14:26.522]                 ...future.oldOptions$nwarnings <- NULL
[13:14:26.522]             }
[13:14:26.522]             base::options(...future.oldOptions)
[13:14:26.522]             if (.Platform$OS.type == "windows") {
[13:14:26.522]                 old_names <- names(...future.oldEnvVars)
[13:14:26.522]                 envs <- base::Sys.getenv()
[13:14:26.522]                 names <- names(envs)
[13:14:26.522]                 common <- intersect(names, old_names)
[13:14:26.522]                 added <- setdiff(names, old_names)
[13:14:26.522]                 removed <- setdiff(old_names, names)
[13:14:26.522]                 changed <- common[...future.oldEnvVars[common] != 
[13:14:26.522]                   envs[common]]
[13:14:26.522]                 NAMES <- toupper(changed)
[13:14:26.522]                 args <- list()
[13:14:26.522]                 for (kk in seq_along(NAMES)) {
[13:14:26.522]                   name <- changed[[kk]]
[13:14:26.522]                   NAME <- NAMES[[kk]]
[13:14:26.522]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:26.522]                     next
[13:14:26.522]                   args[[name]] <- ...future.oldEnvVars[[name]]
[13:14:26.522]                 }
[13:14:26.522]                 NAMES <- toupper(added)
[13:14:26.522]                 for (kk in seq_along(NAMES)) {
[13:14:26.522]                   name <- added[[kk]]
[13:14:26.522]                   NAME <- NAMES[[kk]]
[13:14:26.522]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:26.522]                     next
[13:14:26.522]                   args[[name]] <- ""
[13:14:26.522]                 }
[13:14:26.522]                 NAMES <- toupper(removed)
[13:14:26.522]                 for (kk in seq_along(NAMES)) {
[13:14:26.522]                   name <- removed[[kk]]
[13:14:26.522]                   NAME <- NAMES[[kk]]
[13:14:26.522]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:26.522]                     next
[13:14:26.522]                   args[[name]] <- ...future.oldEnvVars[[name]]
[13:14:26.522]                 }
[13:14:26.522]                 if (length(args) > 0) 
[13:14:26.522]                   base::do.call(base::Sys.setenv, args = args)
[13:14:26.522]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[13:14:26.522]             }
[13:14:26.522]             else {
[13:14:26.522]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[13:14:26.522]             }
[13:14:26.522]             {
[13:14:26.522]                 if (base::length(...future.futureOptionsAdded) > 
[13:14:26.522]                   0L) {
[13:14:26.522]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[13:14:26.522]                   base::names(opts) <- ...future.futureOptionsAdded
[13:14:26.522]                   base::options(opts)
[13:14:26.522]                 }
[13:14:26.522]                 {
[13:14:26.522]                   {
[13:14:26.522]                     NULL
[13:14:26.522]                     RNGkind("Mersenne-Twister")
[13:14:26.522]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[13:14:26.522]                       inherits = FALSE)
[13:14:26.522]                   }
[13:14:26.522]                   options(future.plan = NULL)
[13:14:26.522]                   if (is.na(NA_character_)) 
[13:14:26.522]                     Sys.unsetenv("R_FUTURE_PLAN")
[13:14:26.522]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[13:14:26.522]                   future::plan(list(function (..., envir = parent.frame()) 
[13:14:26.522]                   {
[13:14:26.522]                     future <- SequentialFuture(..., envir = envir)
[13:14:26.522]                     if (!future$lazy) 
[13:14:26.522]                       future <- run(future)
[13:14:26.522]                     invisible(future)
[13:14:26.522]                   }), .cleanup = FALSE, .init = FALSE)
[13:14:26.522]                 }
[13:14:26.522]             }
[13:14:26.522]         }
[13:14:26.522]     })
[13:14:26.522]     if (FALSE) {
[13:14:26.522]         base::sink(type = "output", split = FALSE)
[13:14:26.522]         if (NA) {
[13:14:26.522]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[13:14:26.522]         }
[13:14:26.522]         else {
[13:14:26.522]             ...future.result["stdout"] <- base::list(NULL)
[13:14:26.522]         }
[13:14:26.522]         base::close(...future.stdout)
[13:14:26.522]         ...future.stdout <- NULL
[13:14:26.522]     }
[13:14:26.522]     ...future.result$conditions <- ...future.conditions
[13:14:26.522]     ...future.result$finished <- base::Sys.time()
[13:14:26.522]     ...future.result
[13:14:26.522] }
[13:14:26.526] assign_globals() ...
[13:14:26.526] List of 5
[13:14:26.526]  $ ...future.FUN            :function (x, y)  
[13:14:26.526]  $ MoreArgs                 : NULL
[13:14:26.526]  $ ...future.elements_ii    :List of 2
[13:14:26.526]   ..$ :List of 2
[13:14:26.526]   .. ..$ : int 1
[13:14:26.526]   .. ..$ : int 0
[13:14:26.526]   ..$ :List of 2
[13:14:26.526]   .. ..$ : int 0
[13:14:26.526]   .. ..$ : int 1
[13:14:26.526]  $ ...future.seeds_ii       : NULL
[13:14:26.526]  $ ...future.globals.maxSize: NULL
[13:14:26.526]  - attr(*, "where")=List of 5
[13:14:26.526]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[13:14:26.526]   ..$ MoreArgs                 :<environment: R_EmptyEnv> 
[13:14:26.526]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[13:14:26.526]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[13:14:26.526]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[13:14:26.526]  - attr(*, "resolved")= logi FALSE
[13:14:26.526]  - attr(*, "total_size")= num 6480
[13:14:26.526]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[13:14:26.526]  - attr(*, "already-done")= logi TRUE
[13:14:26.532] - reassign environment for '...future.FUN'
[13:14:26.533] - copied '...future.FUN' to environment
[13:14:26.533] - copied 'MoreArgs' to environment
[13:14:26.533] - copied '...future.elements_ii' to environment
[13:14:26.533] - copied '...future.seeds_ii' to environment
[13:14:26.533] - copied '...future.globals.maxSize' to environment
[13:14:26.533] assign_globals() ... done
[13:14:26.534] plan(): Setting new future strategy stack:
[13:14:26.534] List of future strategies:
[13:14:26.534] 1. sequential:
[13:14:26.534]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[13:14:26.534]    - tweaked: FALSE
[13:14:26.534]    - call: NULL
[13:14:26.535] plan(): nbrOfWorkers() = 1
[13:14:27.037] plan(): Setting new future strategy stack:
[13:14:27.037] List of future strategies:
[13:14:27.037] 1. sequential:
[13:14:27.037]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[13:14:27.037]    - tweaked: FALSE
[13:14:27.037]    - call: plan(strategy)
[13:14:27.037] plan(): nbrOfWorkers() = 1
[13:14:27.038] SequentialFuture started (and completed)
[13:14:27.038] - Launch lazy future ... done
[13:14:27.038] run() for 'SequentialFuture' ... done
[13:14:27.038] Created future:
[13:14:27.038] SequentialFuture:
[13:14:27.038] Label: 'future_mapply-1'
[13:14:27.038] Expression:
[13:14:27.038] {
[13:14:27.038]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[13:14:27.038]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[13:14:27.038]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[13:14:27.038]         on.exit(options(oopts), add = TRUE)
[13:14:27.038]     }
[13:14:27.038]     {
[13:14:27.038]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[13:14:27.038]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[13:14:27.038]         do.call(mapply, args = args)
[13:14:27.038]     }
[13:14:27.038] }
[13:14:27.038] Lazy evaluation: FALSE
[13:14:27.038] Asynchronous evaluation: FALSE
[13:14:27.038] Local evaluation: TRUE
[13:14:27.038] Environment: R_GlobalEnv
[13:14:27.038] Capture standard output: NA
[13:14:27.038] Capture condition classes: 'condition' (excluding 'nothing')
[13:14:27.038] Globals: 5 objects totaling 6.33 KiB (function '...future.FUN' of 6.11 KiB, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 224 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[13:14:27.038] Packages: <none>
[13:14:27.038] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[13:14:27.038] Resolved: TRUE
[13:14:27.038] Value: 224 bytes of class 'list'
[13:14:27.038] Early signaling: FALSE
[13:14:27.038] Owner process: 68097d82-3b31-293d-2920-9b7259f27083
[13:14:27.038] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[13:14:27.041] Chunk #1 of 1 ... DONE
[13:14:27.041] Launching 1 futures (chunks) ... DONE
[13:14:27.041] Resolving 1 futures (chunks) ...
[13:14:27.041] resolve() on list ...
[13:14:27.041]  recursive: 0
[13:14:27.041]  length: 1
[13:14:27.042] 
[13:14:27.042] resolved() for 'SequentialFuture' ...
[13:14:27.042] - state: 'finished'
[13:14:27.042] - run: TRUE
[13:14:27.042] - result: 'FutureResult'
[13:14:27.042] resolved() for 'SequentialFuture' ... done
[13:14:27.043] Future #1
[13:14:27.043] signalConditionsASAP(SequentialFuture, pos=1) ...
[13:14:27.043] - nx: 1
[13:14:27.043] - relay: TRUE
[13:14:27.043] - stdout: TRUE
[13:14:27.043] - signal: TRUE
[13:14:27.044] - resignal: FALSE
[13:14:27.044] - force: TRUE
[13:14:27.044] - relayed: [n=1] FALSE
[13:14:27.044] - queued futures: [n=1] FALSE
[13:14:27.044]  - until=1
[13:14:27.044]  - relaying element #1
[13:14:27.045] - relayed: [n=1] TRUE
[13:14:27.045] - queued futures: [n=1] TRUE
[13:14:27.045] signalConditionsASAP(SequentialFuture, pos=1) ... done
[13:14:27.045]  length: 0 (resolved future 1)
[13:14:27.045] Relaying remaining futures
[13:14:27.045] signalConditionsASAP(NULL, pos=0) ...
[13:14:27.046] - nx: 1
[13:14:27.046] - relay: TRUE
[13:14:27.046] - stdout: TRUE
[13:14:27.046] - signal: TRUE
[13:14:27.046] - resignal: FALSE
[13:14:27.046] - force: TRUE
[13:14:27.046] - relayed: [n=1] TRUE
[13:14:27.047] - queued futures: [n=1] TRUE
 - flush all
[13:14:27.047] - relayed: [n=1] TRUE
[13:14:27.047] - queued futures: [n=1] TRUE
[13:14:27.047] signalConditionsASAP(NULL, pos=0) ... done
[13:14:27.047] resolve() on list ... DONE
[13:14:27.048]  - Number of value chunks collected: 1
[13:14:27.048] Resolving 1 futures (chunks) ... DONE
[13:14:27.048] Reducing values from 1 chunks ...
[13:14:27.048]  - Number of values collected after concatenation: 2
[13:14:27.048]  - Number of values expected: 2
[13:14:27.048] Reducing values from 1 chunks ... DONE
[13:14:27.048] future_mapply() ... DONE
* future_mapply(x, ..., future.stdout = NA) ... DONE
* plan('sequential') ... DONE
* plan('multisession') ...
[13:14:27.049] plan(): Setting new future strategy stack:
[13:14:27.049] List of future strategies:
[13:14:27.049] 1. multisession:
[13:14:27.049]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[13:14:27.049]    - tweaked: FALSE
[13:14:27.049]    - call: plan(strategy)
[13:14:27.050] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
[13:14:27.050] multisession:
[13:14:27.050] - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[13:14:27.050] - tweaked: FALSE
[13:14:27.050] - call: plan(strategy)
[13:14:27.052] getGlobalsAndPackages() ...
[13:14:27.053] Not searching for globals
[13:14:27.053] - globals: [0] <none>
[13:14:27.053] getGlobalsAndPackages() ... DONE
[13:14:27.053] Packages needed by the future expression (n = 0): <none>
[13:14:27.054] Packages needed by future strategies (n = 0): <none>
[13:14:27.054] {
[13:14:27.054]     {
[13:14:27.054]         {
[13:14:27.054]             ...future.startTime <- base::Sys.time()
[13:14:27.054]             {
[13:14:27.054]                 {
[13:14:27.054]                   {
[13:14:27.054]                     base::local({
[13:14:27.054]                       has_future <- base::requireNamespace("future", 
[13:14:27.054]                         quietly = TRUE)
[13:14:27.054]                       if (has_future) {
[13:14:27.054]                         ns <- base::getNamespace("future")
[13:14:27.054]                         version <- ns[[".package"]][["version"]]
[13:14:27.054]                         if (is.null(version)) 
[13:14:27.054]                           version <- utils::packageVersion("future")
[13:14:27.054]                       }
[13:14:27.054]                       else {
[13:14:27.054]                         version <- NULL
[13:14:27.054]                       }
[13:14:27.054]                       if (!has_future || version < "1.8.0") {
[13:14:27.054]                         info <- base::c(r_version = base::gsub("R version ", 
[13:14:27.054]                           "", base::R.version$version.string), 
[13:14:27.054]                           platform = base::sprintf("%s (%s-bit)", 
[13:14:27.054]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[13:14:27.054]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[13:14:27.054]                             "release", "version")], collapse = " "), 
[13:14:27.054]                           hostname = base::Sys.info()[["nodename"]])
[13:14:27.054]                         info <- base::sprintf("%s: %s", base::names(info), 
[13:14:27.054]                           info)
[13:14:27.054]                         info <- base::paste(info, collapse = "; ")
[13:14:27.054]                         if (!has_future) {
[13:14:27.054]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[13:14:27.054]                             info)
[13:14:27.054]                         }
[13:14:27.054]                         else {
[13:14:27.054]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[13:14:27.054]                             info, version)
[13:14:27.054]                         }
[13:14:27.054]                         base::stop(msg)
[13:14:27.054]                       }
[13:14:27.054]                     })
[13:14:27.054]                   }
[13:14:27.054]                   options(future.plan = NULL)
[13:14:27.054]                   Sys.unsetenv("R_FUTURE_PLAN")
[13:14:27.054]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[13:14:27.054]                 }
[13:14:27.054]                 ...future.workdir <- getwd()
[13:14:27.054]             }
[13:14:27.054]             ...future.oldOptions <- base::as.list(base::.Options)
[13:14:27.054]             ...future.oldEnvVars <- base::Sys.getenv()
[13:14:27.054]         }
[13:14:27.054]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[13:14:27.054]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[13:14:27.054]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[13:14:27.054]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[13:14:27.054]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[13:14:27.054]             future.stdout.windows.reencode = NULL, width = 80L)
[13:14:27.054]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[13:14:27.054]             base::names(...future.oldOptions))
[13:14:27.054]     }
[13:14:27.054]     if (FALSE) {
[13:14:27.054]     }
[13:14:27.054]     else {
[13:14:27.054]         if (TRUE) {
[13:14:27.054]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[13:14:27.054]                 open = "w")
[13:14:27.054]         }
[13:14:27.054]         else {
[13:14:27.054]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[13:14:27.054]                 windows = "NUL", "/dev/null"), open = "w")
[13:14:27.054]         }
[13:14:27.054]         base::sink(...future.stdout, type = "output", split = FALSE)
[13:14:27.054]         base::on.exit(if (!base::is.null(...future.stdout)) {
[13:14:27.054]             base::sink(type = "output", split = FALSE)
[13:14:27.054]             base::close(...future.stdout)
[13:14:27.054]         }, add = TRUE)
[13:14:27.054]     }
[13:14:27.054]     ...future.frame <- base::sys.nframe()
[13:14:27.054]     ...future.conditions <- base::list()
[13:14:27.054]     ...future.rng <- base::globalenv()$.Random.seed
[13:14:27.054]     if (FALSE) {
[13:14:27.054]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[13:14:27.054]             "...future.value", "...future.globalenv.names", ".Random.seed")
[13:14:27.054]     }
[13:14:27.054]     ...future.result <- base::tryCatch({
[13:14:27.054]         base::withCallingHandlers({
[13:14:27.054]             ...future.value <- base::withVisible(base::local(NA))
[13:14:27.054]             future::FutureResult(value = ...future.value$value, 
[13:14:27.054]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[13:14:27.054]                   ...future.rng), globalenv = if (FALSE) 
[13:14:27.054]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[13:14:27.054]                     ...future.globalenv.names))
[13:14:27.054]                 else NULL, started = ...future.startTime, version = "1.8")
[13:14:27.054]         }, condition = base::local({
[13:14:27.054]             c <- base::c
[13:14:27.054]             inherits <- base::inherits
[13:14:27.054]             invokeRestart <- base::invokeRestart
[13:14:27.054]             length <- base::length
[13:14:27.054]             list <- base::list
[13:14:27.054]             seq.int <- base::seq.int
[13:14:27.054]             signalCondition <- base::signalCondition
[13:14:27.054]             sys.calls <- base::sys.calls
[13:14:27.054]             `[[` <- base::`[[`
[13:14:27.054]             `+` <- base::`+`
[13:14:27.054]             `<<-` <- base::`<<-`
[13:14:27.054]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[13:14:27.054]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[13:14:27.054]                   3L)]
[13:14:27.054]             }
[13:14:27.054]             function(cond) {
[13:14:27.054]                 is_error <- inherits(cond, "error")
[13:14:27.054]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[13:14:27.054]                   NULL)
[13:14:27.054]                 if (is_error) {
[13:14:27.054]                   sessionInformation <- function() {
[13:14:27.054]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[13:14:27.054]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[13:14:27.054]                       search = base::search(), system = base::Sys.info())
[13:14:27.054]                   }
[13:14:27.054]                   ...future.conditions[[length(...future.conditions) + 
[13:14:27.054]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[13:14:27.054]                     cond$call), session = sessionInformation(), 
[13:14:27.054]                     timestamp = base::Sys.time(), signaled = 0L)
[13:14:27.054]                   signalCondition(cond)
[13:14:27.054]                 }
[13:14:27.054]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[13:14:27.054]                 "immediateCondition"))) {
[13:14:27.054]                   signal <- TRUE && inherits(cond, "immediateCondition")
[13:14:27.054]                   ...future.conditions[[length(...future.conditions) + 
[13:14:27.054]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[13:14:27.054]                   if (TRUE && !signal) {
[13:14:27.054]                     muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:27.054]                     {
[13:14:27.054]                       inherits <- base::inherits
[13:14:27.054]                       invokeRestart <- base::invokeRestart
[13:14:27.054]                       is.null <- base::is.null
[13:14:27.054]                       muffled <- FALSE
[13:14:27.054]                       if (inherits(cond, "message")) {
[13:14:27.054]                         muffled <- grepl(pattern, "muffleMessage")
[13:14:27.054]                         if (muffled) 
[13:14:27.054]                           invokeRestart("muffleMessage")
[13:14:27.054]                       }
[13:14:27.054]                       else if (inherits(cond, "warning")) {
[13:14:27.054]                         muffled <- grepl(pattern, "muffleWarning")
[13:14:27.054]                         if (muffled) 
[13:14:27.054]                           invokeRestart("muffleWarning")
[13:14:27.054]                       }
[13:14:27.054]                       else if (inherits(cond, "condition")) {
[13:14:27.054]                         if (!is.null(pattern)) {
[13:14:27.054]                           computeRestarts <- base::computeRestarts
[13:14:27.054]                           grepl <- base::grepl
[13:14:27.054]                           restarts <- computeRestarts(cond)
[13:14:27.054]                           for (restart in restarts) {
[13:14:27.054]                             name <- restart$name
[13:14:27.054]                             if (is.null(name)) 
[13:14:27.054]                               next
[13:14:27.054]                             if (!grepl(pattern, name)) 
[13:14:27.054]                               next
[13:14:27.054]                             invokeRestart(restart)
[13:14:27.054]                             muffled <- TRUE
[13:14:27.054]                             break
[13:14:27.054]                           }
[13:14:27.054]                         }
[13:14:27.054]                       }
[13:14:27.054]                       invisible(muffled)
[13:14:27.054]                     }
[13:14:27.054]                     muffleCondition(cond, pattern = "^muffle")
[13:14:27.054]                   }
[13:14:27.054]                 }
[13:14:27.054]                 else {
[13:14:27.054]                   if (TRUE) {
[13:14:27.054]                     muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:27.054]                     {
[13:14:27.054]                       inherits <- base::inherits
[13:14:27.054]                       invokeRestart <- base::invokeRestart
[13:14:27.054]                       is.null <- base::is.null
[13:14:27.054]                       muffled <- FALSE
[13:14:27.054]                       if (inherits(cond, "message")) {
[13:14:27.054]                         muffled <- grepl(pattern, "muffleMessage")
[13:14:27.054]                         if (muffled) 
[13:14:27.054]                           invokeRestart("muffleMessage")
[13:14:27.054]                       }
[13:14:27.054]                       else if (inherits(cond, "warning")) {
[13:14:27.054]                         muffled <- grepl(pattern, "muffleWarning")
[13:14:27.054]                         if (muffled) 
[13:14:27.054]                           invokeRestart("muffleWarning")
[13:14:27.054]                       }
[13:14:27.054]                       else if (inherits(cond, "condition")) {
[13:14:27.054]                         if (!is.null(pattern)) {
[13:14:27.054]                           computeRestarts <- base::computeRestarts
[13:14:27.054]                           grepl <- base::grepl
[13:14:27.054]                           restarts <- computeRestarts(cond)
[13:14:27.054]                           for (restart in restarts) {
[13:14:27.054]                             name <- restart$name
[13:14:27.054]                             if (is.null(name)) 
[13:14:27.054]                               next
[13:14:27.054]                             if (!grepl(pattern, name)) 
[13:14:27.054]                               next
[13:14:27.054]                             invokeRestart(restart)
[13:14:27.054]                             muffled <- TRUE
[13:14:27.054]                             break
[13:14:27.054]                           }
[13:14:27.054]                         }
[13:14:27.054]                       }
[13:14:27.054]                       invisible(muffled)
[13:14:27.054]                     }
[13:14:27.054]                     muffleCondition(cond, pattern = "^muffle")
[13:14:27.054]                   }
[13:14:27.054]                 }
[13:14:27.054]             }
[13:14:27.054]         }))
[13:14:27.054]     }, error = function(ex) {
[13:14:27.054]         base::structure(base::list(value = NULL, visible = NULL, 
[13:14:27.054]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[13:14:27.054]                 ...future.rng), started = ...future.startTime, 
[13:14:27.054]             finished = Sys.time(), session_uuid = NA_character_, 
[13:14:27.054]             version = "1.8"), class = "FutureResult")
[13:14:27.054]     }, finally = {
[13:14:27.054]         if (!identical(...future.workdir, getwd())) 
[13:14:27.054]             setwd(...future.workdir)
[13:14:27.054]         {
[13:14:27.054]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[13:14:27.054]                 ...future.oldOptions$nwarnings <- NULL
[13:14:27.054]             }
[13:14:27.054]             base::options(...future.oldOptions)
[13:14:27.054]             if (.Platform$OS.type == "windows") {
[13:14:27.054]                 old_names <- names(...future.oldEnvVars)
[13:14:27.054]                 envs <- base::Sys.getenv()
[13:14:27.054]                 names <- names(envs)
[13:14:27.054]                 common <- intersect(names, old_names)
[13:14:27.054]                 added <- setdiff(names, old_names)
[13:14:27.054]                 removed <- setdiff(old_names, names)
[13:14:27.054]                 changed <- common[...future.oldEnvVars[common] != 
[13:14:27.054]                   envs[common]]
[13:14:27.054]                 NAMES <- toupper(changed)
[13:14:27.054]                 args <- list()
[13:14:27.054]                 for (kk in seq_along(NAMES)) {
[13:14:27.054]                   name <- changed[[kk]]
[13:14:27.054]                   NAME <- NAMES[[kk]]
[13:14:27.054]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:27.054]                     next
[13:14:27.054]                   args[[name]] <- ...future.oldEnvVars[[name]]
[13:14:27.054]                 }
[13:14:27.054]                 NAMES <- toupper(added)
[13:14:27.054]                 for (kk in seq_along(NAMES)) {
[13:14:27.054]                   name <- added[[kk]]
[13:14:27.054]                   NAME <- NAMES[[kk]]
[13:14:27.054]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:27.054]                     next
[13:14:27.054]                   args[[name]] <- ""
[13:14:27.054]                 }
[13:14:27.054]                 NAMES <- toupper(removed)
[13:14:27.054]                 for (kk in seq_along(NAMES)) {
[13:14:27.054]                   name <- removed[[kk]]
[13:14:27.054]                   NAME <- NAMES[[kk]]
[13:14:27.054]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:27.054]                     next
[13:14:27.054]                   args[[name]] <- ...future.oldEnvVars[[name]]
[13:14:27.054]                 }
[13:14:27.054]                 if (length(args) > 0) 
[13:14:27.054]                   base::do.call(base::Sys.setenv, args = args)
[13:14:27.054]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[13:14:27.054]             }
[13:14:27.054]             else {
[13:14:27.054]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[13:14:27.054]             }
[13:14:27.054]             {
[13:14:27.054]                 if (base::length(...future.futureOptionsAdded) > 
[13:14:27.054]                   0L) {
[13:14:27.054]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[13:14:27.054]                   base::names(opts) <- ...future.futureOptionsAdded
[13:14:27.054]                   base::options(opts)
[13:14:27.054]                 }
[13:14:27.054]                 {
[13:14:27.054]                   {
[13:14:27.054]                     NULL
[13:14:27.054]                     RNGkind("Mersenne-Twister")
[13:14:27.054]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[13:14:27.054]                       inherits = FALSE)
[13:14:27.054]                   }
[13:14:27.054]                   options(future.plan = NULL)
[13:14:27.054]                   if (is.na(NA_character_)) 
[13:14:27.054]                     Sys.unsetenv("R_FUTURE_PLAN")
[13:14:27.054]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[13:14:27.054]                   future::plan(list(function (..., workers = availableCores(), 
[13:14:27.054]                     lazy = FALSE, rscript_libs = .libPaths(), 
[13:14:27.054]                     envir = parent.frame()) 
[13:14:27.054]                   {
[13:14:27.054]                     if (is.function(workers)) 
[13:14:27.054]                       workers <- workers()
[13:14:27.054]                     workers <- structure(as.integer(workers), 
[13:14:27.054]                       class = class(workers))
[13:14:27.054]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[13:14:27.054]                       workers >= 1)
[13:14:27.054]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[13:14:27.054]                       return(sequential(..., lazy = TRUE, envir = envir))
[13:14:27.054]                     }
[13:14:27.054]                     future <- MultisessionFuture(..., workers = workers, 
[13:14:27.054]                       lazy = lazy, rscript_libs = rscript_libs, 
[13:14:27.054]                       envir = envir)
[13:14:27.054]                     if (!future$lazy) 
[13:14:27.054]                       future <- run(future)
[13:14:27.054]                     invisible(future)
[13:14:27.054]                   }), .cleanup = FALSE, .init = FALSE)
[13:14:27.054]                 }
[13:14:27.054]             }
[13:14:27.054]         }
[13:14:27.054]     })
[13:14:27.054]     if (TRUE) {
[13:14:27.054]         base::sink(type = "output", split = FALSE)
[13:14:27.054]         if (TRUE) {
[13:14:27.054]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[13:14:27.054]         }
[13:14:27.054]         else {
[13:14:27.054]             ...future.result["stdout"] <- base::list(NULL)
[13:14:27.054]         }
[13:14:27.054]         base::close(...future.stdout)
[13:14:27.054]         ...future.stdout <- NULL
[13:14:27.054]     }
[13:14:27.054]     ...future.result$conditions <- ...future.conditions
[13:14:27.054]     ...future.result$finished <- base::Sys.time()
[13:14:27.054]     ...future.result
[13:14:27.054] }
[13:14:27.058] plan(): Setting new future strategy stack:
[13:14:27.058] List of future strategies:
[13:14:27.058] 1. sequential:
[13:14:27.058]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[13:14:27.058]    - tweaked: FALSE
[13:14:27.058]    - call: NULL
[13:14:27.059] plan(): nbrOfWorkers() = 1
[13:14:27.060] plan(): Setting new future strategy stack:
[13:14:27.060] List of future strategies:
[13:14:27.060] 1. multisession:
[13:14:27.060]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[13:14:27.060]    - tweaked: FALSE
[13:14:27.060]    - call: plan(strategy)
[13:14:27.063] plan(): nbrOfWorkers() = 1
[13:14:27.063] SequentialFuture started (and completed)
[13:14:27.063] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
[13:14:27.065] plan(): nbrOfWorkers() = 1
* future_lapply(x, ..., future.stdout = FALSE) ...
[13:14:27.066] future_lapply() ...
[13:14:27.069] Number of chunks: 1
[13:14:27.069] getGlobalsAndPackagesXApply() ...
[13:14:27.069]  - future.globals: TRUE
[13:14:27.069] getGlobalsAndPackages() ...
[13:14:27.069] Searching for globals...
[13:14:27.071] - globals found: [5] 'FUN', '{', 'Sys.sleep', '/', 'print'
[13:14:27.071] Searching for globals ... DONE
[13:14:27.071] Resolving globals: FALSE
[13:14:27.072] The total size of the 1 globals is 4.61 KiB (4720 bytes)
[13:14:27.072] The total size of the 1 globals exported for future expression ('FUN()') is 4.61 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.61 KiB of class 'function')
[13:14:27.073] - globals: [1] 'FUN'
[13:14:27.074] 
[13:14:27.074] getGlobalsAndPackages() ... DONE
[13:14:27.074]  - globals found/used: [n=1] 'FUN'
[13:14:27.074]  - needed namespaces: [n=0] 
[13:14:27.074] Finding globals ... DONE
[13:14:27.074]  - use_args: TRUE
[13:14:27.075]  - Getting '...' globals ...
[13:14:27.075] resolve() on list ...
[13:14:27.075]  recursive: 0
[13:14:27.075]  length: 1
[13:14:27.075]  elements: '...'
[13:14:27.076]  length: 0 (resolved future 1)
[13:14:27.076] resolve() on list ... DONE
[13:14:27.076]    - '...' content: [n=0] 
[13:14:27.076] List of 1
[13:14:27.076]  $ ...: list()
[13:14:27.076]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[13:14:27.076]  - attr(*, "where")=List of 1
[13:14:27.076]   ..$ ...:<environment: 0x0000022a321ba228> 
[13:14:27.076]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[13:14:27.076]  - attr(*, "resolved")= logi TRUE
[13:14:27.076]  - attr(*, "total_size")= num NA
[13:14:27.079]  - Getting '...' globals ... DONE
[13:14:27.079] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[13:14:27.080] List of 2
[13:14:27.080]  $ ...future.FUN:function (x)  
[13:14:27.080]  $ ...          : list()
[13:14:27.080]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[13:14:27.080]  - attr(*, "where")=List of 2
[13:14:27.080]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[13:14:27.080]   ..$ ...          :<environment: 0x0000022a321ba228> 
[13:14:27.080]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[13:14:27.080]  - attr(*, "resolved")= logi FALSE
[13:14:27.080]  - attr(*, "total_size")= num 4720
[13:14:27.083] Packages to be attached in all futures: [n=0] 
[13:14:27.083] getGlobalsAndPackagesXApply() ... DONE
[13:14:27.083] Number of futures (= number of chunks): 1
[13:14:27.083] Launching 1 futures (chunks) ...
[13:14:27.083] Chunk #1 of 1 ...
[13:14:27.084]  - Finding globals in 'X' for chunk #1 ...
[13:14:27.084] getGlobalsAndPackages() ...
[13:14:27.084] Searching for globals...
[13:14:27.084] 
[13:14:27.084] Searching for globals ... DONE
[13:14:27.085] - globals: [0] <none>
[13:14:27.085] getGlobalsAndPackages() ... DONE
[13:14:27.085]    + additional globals found: [n=0] 
[13:14:27.085]    + additional namespaces needed: [n=0] 
[13:14:27.085]  - Finding globals in 'X' for chunk #1 ... DONE
[13:14:27.085]  - seeds: <none>
[13:14:27.086]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:27.086] getGlobalsAndPackages() ...
[13:14:27.086] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:27.086] Resolving globals: FALSE
[13:14:27.086] Tweak future expression to call with '...' arguments ...
[13:14:27.086] {
[13:14:27.086]     do.call(function(...) {
[13:14:27.086]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[13:14:27.086]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[13:14:27.086]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[13:14:27.086]             on.exit(options(oopts), add = TRUE)
[13:14:27.086]         }
[13:14:27.086]         {
[13:14:27.086]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[13:14:27.086]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[13:14:27.086]                 ...future.FUN(...future.X_jj, ...)
[13:14:27.086]             })
[13:14:27.086]         }
[13:14:27.086]     }, args = future.call.arguments)
[13:14:27.086] }
[13:14:27.087] Tweak future expression to call with '...' arguments ... DONE
[13:14:27.087] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:27.088] 
[13:14:27.088] getGlobalsAndPackages() ... DONE
[13:14:27.088] run() for 'Future' ...
[13:14:27.088] - state: 'created'
[13:14:27.088] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[13:14:27.091] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[13:14:27.091] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[13:14:27.091]   - Field: 'label'
[13:14:27.091]   - Field: 'local'
[13:14:27.091]   - Field: 'owner'
[13:14:27.092]   - Field: 'envir'
[13:14:27.092]   - Field: 'packages'
[13:14:27.092]   - Field: 'gc'
[13:14:27.092]   - Field: 'conditions'
[13:14:27.092]   - Field: 'expr'
[13:14:27.093]   - Field: 'uuid'
[13:14:27.093]   - Field: 'seed'
[13:14:27.093]   - Field: 'version'
[13:14:27.093]   - Field: 'result'
[13:14:27.093]   - Field: 'asynchronous'
[13:14:27.093]   - Field: 'calls'
[13:14:27.094]   - Field: 'globals'
[13:14:27.094]   - Field: 'stdout'
[13:14:27.094]   - Field: 'earlySignal'
[13:14:27.094]   - Field: 'lazy'
[13:14:27.094]   - Field: 'state'
[13:14:27.094] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[13:14:27.095] - Launch lazy future ...
[13:14:27.095] Packages needed by the future expression (n = 0): <none>
[13:14:27.095] Packages needed by future strategies (n = 0): <none>
[13:14:27.096] {
[13:14:27.096]     {
[13:14:27.096]         {
[13:14:27.096]             ...future.startTime <- base::Sys.time()
[13:14:27.096]             {
[13:14:27.096]                 {
[13:14:27.096]                   {
[13:14:27.096]                     base::local({
[13:14:27.096]                       has_future <- base::requireNamespace("future", 
[13:14:27.096]                         quietly = TRUE)
[13:14:27.096]                       if (has_future) {
[13:14:27.096]                         ns <- base::getNamespace("future")
[13:14:27.096]                         version <- ns[[".package"]][["version"]]
[13:14:27.096]                         if (is.null(version)) 
[13:14:27.096]                           version <- utils::packageVersion("future")
[13:14:27.096]                       }
[13:14:27.096]                       else {
[13:14:27.096]                         version <- NULL
[13:14:27.096]                       }
[13:14:27.096]                       if (!has_future || version < "1.8.0") {
[13:14:27.096]                         info <- base::c(r_version = base::gsub("R version ", 
[13:14:27.096]                           "", base::R.version$version.string), 
[13:14:27.096]                           platform = base::sprintf("%s (%s-bit)", 
[13:14:27.096]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[13:14:27.096]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[13:14:27.096]                             "release", "version")], collapse = " "), 
[13:14:27.096]                           hostname = base::Sys.info()[["nodename"]])
[13:14:27.096]                         info <- base::sprintf("%s: %s", base::names(info), 
[13:14:27.096]                           info)
[13:14:27.096]                         info <- base::paste(info, collapse = "; ")
[13:14:27.096]                         if (!has_future) {
[13:14:27.096]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[13:14:27.096]                             info)
[13:14:27.096]                         }
[13:14:27.096]                         else {
[13:14:27.096]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[13:14:27.096]                             info, version)
[13:14:27.096]                         }
[13:14:27.096]                         base::stop(msg)
[13:14:27.096]                       }
[13:14:27.096]                     })
[13:14:27.096]                   }
[13:14:27.096]                   options(future.plan = NULL)
[13:14:27.096]                   Sys.unsetenv("R_FUTURE_PLAN")
[13:14:27.096]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[13:14:27.096]                 }
[13:14:27.096]                 ...future.workdir <- getwd()
[13:14:27.096]             }
[13:14:27.096]             ...future.oldOptions <- base::as.list(base::.Options)
[13:14:27.096]             ...future.oldEnvVars <- base::Sys.getenv()
[13:14:27.096]         }
[13:14:27.096]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[13:14:27.096]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[13:14:27.096]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[13:14:27.096]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[13:14:27.096]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[13:14:27.096]             future.stdout.windows.reencode = NULL, width = 80L)
[13:14:27.096]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[13:14:27.096]             base::names(...future.oldOptions))
[13:14:27.096]     }
[13:14:27.096]     if (FALSE) {
[13:14:27.096]     }
[13:14:27.096]     else {
[13:14:27.096]         if (FALSE) {
[13:14:27.096]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[13:14:27.096]                 open = "w")
[13:14:27.096]         }
[13:14:27.096]         else {
[13:14:27.096]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[13:14:27.096]                 windows = "NUL", "/dev/null"), open = "w")
[13:14:27.096]         }
[13:14:27.096]         base::sink(...future.stdout, type = "output", split = FALSE)
[13:14:27.096]         base::on.exit(if (!base::is.null(...future.stdout)) {
[13:14:27.096]             base::sink(type = "output", split = FALSE)
[13:14:27.096]             base::close(...future.stdout)
[13:14:27.096]         }, add = TRUE)
[13:14:27.096]     }
[13:14:27.096]     ...future.frame <- base::sys.nframe()
[13:14:27.096]     ...future.conditions <- base::list()
[13:14:27.096]     ...future.rng <- base::globalenv()$.Random.seed
[13:14:27.096]     if (FALSE) {
[13:14:27.096]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[13:14:27.096]             "...future.value", "...future.globalenv.names", ".Random.seed")
[13:14:27.096]     }
[13:14:27.096]     ...future.result <- base::tryCatch({
[13:14:27.096]         base::withCallingHandlers({
[13:14:27.096]             ...future.value <- base::withVisible(base::local({
[13:14:27.096]                 do.call(function(...) {
[13:14:27.096]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[13:14:27.096]                   if (!identical(...future.globals.maxSize.org, 
[13:14:27.096]                     ...future.globals.maxSize)) {
[13:14:27.096]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[13:14:27.096]                     on.exit(options(oopts), add = TRUE)
[13:14:27.096]                   }
[13:14:27.096]                   {
[13:14:27.096]                     lapply(seq_along(...future.elements_ii), 
[13:14:27.096]                       FUN = function(jj) {
[13:14:27.096]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[13:14:27.096]                         ...future.FUN(...future.X_jj, ...)
[13:14:27.096]                       })
[13:14:27.096]                   }
[13:14:27.096]                 }, args = future.call.arguments)
[13:14:27.096]             }))
[13:14:27.096]             future::FutureResult(value = ...future.value$value, 
[13:14:27.096]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[13:14:27.096]                   ...future.rng), globalenv = if (FALSE) 
[13:14:27.096]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[13:14:27.096]                     ...future.globalenv.names))
[13:14:27.096]                 else NULL, started = ...future.startTime, version = "1.8")
[13:14:27.096]         }, condition = base::local({
[13:14:27.096]             c <- base::c
[13:14:27.096]             inherits <- base::inherits
[13:14:27.096]             invokeRestart <- base::invokeRestart
[13:14:27.096]             length <- base::length
[13:14:27.096]             list <- base::list
[13:14:27.096]             seq.int <- base::seq.int
[13:14:27.096]             signalCondition <- base::signalCondition
[13:14:27.096]             sys.calls <- base::sys.calls
[13:14:27.096]             `[[` <- base::`[[`
[13:14:27.096]             `+` <- base::`+`
[13:14:27.096]             `<<-` <- base::`<<-`
[13:14:27.096]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[13:14:27.096]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[13:14:27.096]                   3L)]
[13:14:27.096]             }
[13:14:27.096]             function(cond) {
[13:14:27.096]                 is_error <- inherits(cond, "error")
[13:14:27.096]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[13:14:27.096]                   NULL)
[13:14:27.096]                 if (is_error) {
[13:14:27.096]                   sessionInformation <- function() {
[13:14:27.096]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[13:14:27.096]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[13:14:27.096]                       search = base::search(), system = base::Sys.info())
[13:14:27.096]                   }
[13:14:27.096]                   ...future.conditions[[length(...future.conditions) + 
[13:14:27.096]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[13:14:27.096]                     cond$call), session = sessionInformation(), 
[13:14:27.096]                     timestamp = base::Sys.time(), signaled = 0L)
[13:14:27.096]                   signalCondition(cond)
[13:14:27.096]                 }
[13:14:27.096]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[13:14:27.096]                 "immediateCondition"))) {
[13:14:27.096]                   signal <- TRUE && inherits(cond, "immediateCondition")
[13:14:27.096]                   ...future.conditions[[length(...future.conditions) + 
[13:14:27.096]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[13:14:27.096]                   if (TRUE && !signal) {
[13:14:27.096]                     muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:27.096]                     {
[13:14:27.096]                       inherits <- base::inherits
[13:14:27.096]                       invokeRestart <- base::invokeRestart
[13:14:27.096]                       is.null <- base::is.null
[13:14:27.096]                       muffled <- FALSE
[13:14:27.096]                       if (inherits(cond, "message")) {
[13:14:27.096]                         muffled <- grepl(pattern, "muffleMessage")
[13:14:27.096]                         if (muffled) 
[13:14:27.096]                           invokeRestart("muffleMessage")
[13:14:27.096]                       }
[13:14:27.096]                       else if (inherits(cond, "warning")) {
[13:14:27.096]                         muffled <- grepl(pattern, "muffleWarning")
[13:14:27.096]                         if (muffled) 
[13:14:27.096]                           invokeRestart("muffleWarning")
[13:14:27.096]                       }
[13:14:27.096]                       else if (inherits(cond, "condition")) {
[13:14:27.096]                         if (!is.null(pattern)) {
[13:14:27.096]                           computeRestarts <- base::computeRestarts
[13:14:27.096]                           grepl <- base::grepl
[13:14:27.096]                           restarts <- computeRestarts(cond)
[13:14:27.096]                           for (restart in restarts) {
[13:14:27.096]                             name <- restart$name
[13:14:27.096]                             if (is.null(name)) 
[13:14:27.096]                               next
[13:14:27.096]                             if (!grepl(pattern, name)) 
[13:14:27.096]                               next
[13:14:27.096]                             invokeRestart(restart)
[13:14:27.096]                             muffled <- TRUE
[13:14:27.096]                             break
[13:14:27.096]                           }
[13:14:27.096]                         }
[13:14:27.096]                       }
[13:14:27.096]                       invisible(muffled)
[13:14:27.096]                     }
[13:14:27.096]                     muffleCondition(cond, pattern = "^muffle")
[13:14:27.096]                   }
[13:14:27.096]                 }
[13:14:27.096]                 else {
[13:14:27.096]                   if (TRUE) {
[13:14:27.096]                     muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:27.096]                     {
[13:14:27.096]                       inherits <- base::inherits
[13:14:27.096]                       invokeRestart <- base::invokeRestart
[13:14:27.096]                       is.null <- base::is.null
[13:14:27.096]                       muffled <- FALSE
[13:14:27.096]                       if (inherits(cond, "message")) {
[13:14:27.096]                         muffled <- grepl(pattern, "muffleMessage")
[13:14:27.096]                         if (muffled) 
[13:14:27.096]                           invokeRestart("muffleMessage")
[13:14:27.096]                       }
[13:14:27.096]                       else if (inherits(cond, "warning")) {
[13:14:27.096]                         muffled <- grepl(pattern, "muffleWarning")
[13:14:27.096]                         if (muffled) 
[13:14:27.096]                           invokeRestart("muffleWarning")
[13:14:27.096]                       }
[13:14:27.096]                       else if (inherits(cond, "condition")) {
[13:14:27.096]                         if (!is.null(pattern)) {
[13:14:27.096]                           computeRestarts <- base::computeRestarts
[13:14:27.096]                           grepl <- base::grepl
[13:14:27.096]                           restarts <- computeRestarts(cond)
[13:14:27.096]                           for (restart in restarts) {
[13:14:27.096]                             name <- restart$name
[13:14:27.096]                             if (is.null(name)) 
[13:14:27.096]                               next
[13:14:27.096]                             if (!grepl(pattern, name)) 
[13:14:27.096]                               next
[13:14:27.096]                             invokeRestart(restart)
[13:14:27.096]                             muffled <- TRUE
[13:14:27.096]                             break
[13:14:27.096]                           }
[13:14:27.096]                         }
[13:14:27.096]                       }
[13:14:27.096]                       invisible(muffled)
[13:14:27.096]                     }
[13:14:27.096]                     muffleCondition(cond, pattern = "^muffle")
[13:14:27.096]                   }
[13:14:27.096]                 }
[13:14:27.096]             }
[13:14:27.096]         }))
[13:14:27.096]     }, error = function(ex) {
[13:14:27.096]         base::structure(base::list(value = NULL, visible = NULL, 
[13:14:27.096]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[13:14:27.096]                 ...future.rng), started = ...future.startTime, 
[13:14:27.096]             finished = Sys.time(), session_uuid = NA_character_, 
[13:14:27.096]             version = "1.8"), class = "FutureResult")
[13:14:27.096]     }, finally = {
[13:14:27.096]         if (!identical(...future.workdir, getwd())) 
[13:14:27.096]             setwd(...future.workdir)
[13:14:27.096]         {
[13:14:27.096]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[13:14:27.096]                 ...future.oldOptions$nwarnings <- NULL
[13:14:27.096]             }
[13:14:27.096]             base::options(...future.oldOptions)
[13:14:27.096]             if (.Platform$OS.type == "windows") {
[13:14:27.096]                 old_names <- names(...future.oldEnvVars)
[13:14:27.096]                 envs <- base::Sys.getenv()
[13:14:27.096]                 names <- names(envs)
[13:14:27.096]                 common <- intersect(names, old_names)
[13:14:27.096]                 added <- setdiff(names, old_names)
[13:14:27.096]                 removed <- setdiff(old_names, names)
[13:14:27.096]                 changed <- common[...future.oldEnvVars[common] != 
[13:14:27.096]                   envs[common]]
[13:14:27.096]                 NAMES <- toupper(changed)
[13:14:27.096]                 args <- list()
[13:14:27.096]                 for (kk in seq_along(NAMES)) {
[13:14:27.096]                   name <- changed[[kk]]
[13:14:27.096]                   NAME <- NAMES[[kk]]
[13:14:27.096]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:27.096]                     next
[13:14:27.096]                   args[[name]] <- ...future.oldEnvVars[[name]]
[13:14:27.096]                 }
[13:14:27.096]                 NAMES <- toupper(added)
[13:14:27.096]                 for (kk in seq_along(NAMES)) {
[13:14:27.096]                   name <- added[[kk]]
[13:14:27.096]                   NAME <- NAMES[[kk]]
[13:14:27.096]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:27.096]                     next
[13:14:27.096]                   args[[name]] <- ""
[13:14:27.096]                 }
[13:14:27.096]                 NAMES <- toupper(removed)
[13:14:27.096]                 for (kk in seq_along(NAMES)) {
[13:14:27.096]                   name <- removed[[kk]]
[13:14:27.096]                   NAME <- NAMES[[kk]]
[13:14:27.096]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:27.096]                     next
[13:14:27.096]                   args[[name]] <- ...future.oldEnvVars[[name]]
[13:14:27.096]                 }
[13:14:27.096]                 if (length(args) > 0) 
[13:14:27.096]                   base::do.call(base::Sys.setenv, args = args)
[13:14:27.096]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[13:14:27.096]             }
[13:14:27.096]             else {
[13:14:27.096]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[13:14:27.096]             }
[13:14:27.096]             {
[13:14:27.096]                 if (base::length(...future.futureOptionsAdded) > 
[13:14:27.096]                   0L) {
[13:14:27.096]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[13:14:27.096]                   base::names(opts) <- ...future.futureOptionsAdded
[13:14:27.096]                   base::options(opts)
[13:14:27.096]                 }
[13:14:27.096]                 {
[13:14:27.096]                   {
[13:14:27.096]                     NULL
[13:14:27.096]                     RNGkind("Mersenne-Twister")
[13:14:27.096]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[13:14:27.096]                       inherits = FALSE)
[13:14:27.096]                   }
[13:14:27.096]                   options(future.plan = NULL)
[13:14:27.096]                   if (is.na(NA_character_)) 
[13:14:27.096]                     Sys.unsetenv("R_FUTURE_PLAN")
[13:14:27.096]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[13:14:27.096]                   future::plan(list(function (..., workers = availableCores(), 
[13:14:27.096]                     lazy = FALSE, rscript_libs = .libPaths(), 
[13:14:27.096]                     envir = parent.frame()) 
[13:14:27.096]                   {
[13:14:27.096]                     if (is.function(workers)) 
[13:14:27.096]                       workers <- workers()
[13:14:27.096]                     workers <- structure(as.integer(workers), 
[13:14:27.096]                       class = class(workers))
[13:14:27.096]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[13:14:27.096]                       workers >= 1)
[13:14:27.096]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[13:14:27.096]                       return(sequential(..., lazy = TRUE, envir = envir))
[13:14:27.096]                     }
[13:14:27.096]                     future <- MultisessionFuture(..., workers = workers, 
[13:14:27.096]                       lazy = lazy, rscript_libs = rscript_libs, 
[13:14:27.096]                       envir = envir)
[13:14:27.096]                     if (!future$lazy) 
[13:14:27.096]                       future <- run(future)
[13:14:27.096]                     invisible(future)
[13:14:27.096]                   }), .cleanup = FALSE, .init = FALSE)
[13:14:27.096]                 }
[13:14:27.096]             }
[13:14:27.096]         }
[13:14:27.096]     })
[13:14:27.096]     if (TRUE) {
[13:14:27.096]         base::sink(type = "output", split = FALSE)
[13:14:27.096]         if (FALSE) {
[13:14:27.096]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[13:14:27.096]         }
[13:14:27.096]         else {
[13:14:27.096]             ...future.result["stdout"] <- base::list(NULL)
[13:14:27.096]         }
[13:14:27.096]         base::close(...future.stdout)
[13:14:27.096]         ...future.stdout <- NULL
[13:14:27.096]     }
[13:14:27.096]     ...future.result$conditions <- ...future.conditions
[13:14:27.096]     ...future.result$finished <- base::Sys.time()
[13:14:27.096]     ...future.result
[13:14:27.096] }
[13:14:27.100] assign_globals() ...
[13:14:27.100] List of 5
[13:14:27.100]  $ ...future.FUN            :function (x)  
[13:14:27.100]  $ future.call.arguments    : list()
[13:14:27.100]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[13:14:27.100]  $ ...future.elements_ii    :List of 2
[13:14:27.100]   ..$ : int 1
[13:14:27.100]   ..$ : int 0
[13:14:27.100]  $ ...future.seeds_ii       : NULL
[13:14:27.100]  $ ...future.globals.maxSize: NULL
[13:14:27.100]  - attr(*, "where")=List of 5
[13:14:27.100]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[13:14:27.100]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[13:14:27.100]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[13:14:27.100]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[13:14:27.100]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[13:14:27.100]  - attr(*, "resolved")= logi FALSE
[13:14:27.100]  - attr(*, "total_size")= num 4720
[13:14:27.100]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[13:14:27.100]  - attr(*, "already-done")= logi TRUE
[13:14:27.106] - reassign environment for '...future.FUN'
[13:14:27.107] - copied '...future.FUN' to environment
[13:14:27.107] - copied 'future.call.arguments' to environment
[13:14:27.107] - copied '...future.elements_ii' to environment
[13:14:27.107] - copied '...future.seeds_ii' to environment
[13:14:27.107] - copied '...future.globals.maxSize' to environment
[13:14:27.107] assign_globals() ... done
[13:14:27.108] plan(): Setting new future strategy stack:
[13:14:27.108] List of future strategies:
[13:14:27.108] 1. sequential:
[13:14:27.108]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[13:14:27.108]    - tweaked: FALSE
[13:14:27.108]    - call: NULL
[13:14:27.109] plan(): nbrOfWorkers() = 1
[13:14:27.622] plan(): Setting new future strategy stack:
[13:14:27.622] List of future strategies:
[13:14:27.622] 1. multisession:
[13:14:27.622]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[13:14:27.622]    - tweaked: FALSE
[13:14:27.622]    - call: plan(strategy)
[13:14:27.624] plan(): nbrOfWorkers() = 1
[13:14:27.625] SequentialFuture started (and completed)
[13:14:27.625] - Launch lazy future ... done
[13:14:27.625] run() for 'SequentialFuture' ... done
[13:14:27.625] Created future:
[13:14:27.625] SequentialFuture:
[13:14:27.625] Label: 'future_lapply-1'
[13:14:27.625] Expression:
[13:14:27.625] {
[13:14:27.625]     do.call(function(...) {
[13:14:27.625]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[13:14:27.625]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[13:14:27.625]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[13:14:27.625]             on.exit(options(oopts), add = TRUE)
[13:14:27.625]         }
[13:14:27.625]         {
[13:14:27.625]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[13:14:27.625]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[13:14:27.625]                 ...future.FUN(...future.X_jj, ...)
[13:14:27.625]             })
[13:14:27.625]         }
[13:14:27.625]     }, args = future.call.arguments)
[13:14:27.625] }
[13:14:27.625] Lazy evaluation: FALSE
[13:14:27.625] Asynchronous evaluation: FALSE
[13:14:27.625] Local evaluation: TRUE
[13:14:27.625] Environment: R_GlobalEnv
[13:14:27.625] Capture standard output: FALSE
[13:14:27.625] Capture condition classes: 'condition' (excluding 'nothing')
[13:14:27.625] Globals: 5 objects totaling 4.72 KiB (function '...future.FUN' of 4.61 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 112 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[13:14:27.625] Packages: <none>
[13:14:27.625] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[13:14:27.625] Resolved: TRUE
[13:14:27.625] Value: 112 bytes of class 'list'
[13:14:27.625] Early signaling: FALSE
[13:14:27.625] Owner process: 68097d82-3b31-293d-2920-9b7259f27083
[13:14:27.625] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[13:14:27.627] Chunk #1 of 1 ... DONE
[13:14:27.627] Launching 1 futures (chunks) ... DONE
[13:14:27.627] Resolving 1 futures (chunks) ...
[13:14:27.627] resolve() on list ...
[13:14:27.627]  recursive: 0
[13:14:27.627]  length: 1
[13:14:27.628] 
[13:14:27.628] resolved() for 'SequentialFuture' ...
[13:14:27.628] - state: 'finished'
[13:14:27.628] - run: TRUE
[13:14:27.628] - result: 'FutureResult'
[13:14:27.628] resolved() for 'SequentialFuture' ... done
[13:14:27.629] Future #1
[13:14:27.629] signalConditionsASAP(SequentialFuture, pos=1) ...
[13:14:27.629] - nx: 1
[13:14:27.629] - relay: TRUE
[13:14:27.629] - stdout: TRUE
[13:14:27.629] - signal: TRUE
[13:14:27.630] - resignal: FALSE
[13:14:27.630] - force: TRUE
[13:14:27.630] - relayed: [n=1] FALSE
[13:14:27.630] - queued futures: [n=1] FALSE
[13:14:27.630]  - until=1
[13:14:27.630]  - relaying element #1
[13:14:27.631] - relayed: [n=1] TRUE
[13:14:27.631] - queued futures: [n=1] TRUE
[13:14:27.631] signalConditionsASAP(SequentialFuture, pos=1) ... done
[13:14:27.631]  length: 0 (resolved future 1)
[13:14:27.631] Relaying remaining futures
[13:14:27.632] signalConditionsASAP(NULL, pos=0) ...
[13:14:27.632] - nx: 1
[13:14:27.632] - relay: TRUE
[13:14:27.632] - stdout: TRUE
[13:14:27.632] - signal: TRUE
[13:14:27.632] - resignal: FALSE
[13:14:27.632] - force: TRUE
[13:14:27.633] - relayed: [n=1] TRUE
[13:14:27.633] - queued futures: [n=1] TRUE
 - flush all
[13:14:27.633] - relayed: [n=1] TRUE
[13:14:27.633] - queued futures: [n=1] TRUE
[13:14:27.633] signalConditionsASAP(NULL, pos=0) ... done
[13:14:27.633] resolve() on list ... DONE
[13:14:27.634]  - Number of value chunks collected: 1
[13:14:27.634] Resolving 1 futures (chunks) ... DONE
[13:14:27.634] Reducing values from 1 chunks ...
[13:14:27.634]  - Number of values collected after concatenation: 2
[13:14:27.634]  - Number of values expected: 2
[13:14:27.634] Reducing values from 1 chunks ... DONE
[13:14:27.635] future_lapply() ... DONE
* future_lapply(x, ..., future.stdout = FALSE) ... DONE
* future_lapply(x, ..., future.stdout = TRUE) ...
[13:14:27.635] future_lapply() ...
[13:14:27.638] Number of chunks: 1
[13:14:27.638] getGlobalsAndPackagesXApply() ...
[13:14:27.638]  - future.globals: TRUE
[13:14:27.638] getGlobalsAndPackages() ...
[13:14:27.639] Searching for globals...
[13:14:27.640] - globals found: [5] 'FUN', '{', 'Sys.sleep', '/', 'print'
[13:14:27.640] Searching for globals ... DONE
[13:14:27.642] Resolving globals: FALSE
[13:14:27.642] The total size of the 1 globals is 4.61 KiB (4720 bytes)
[13:14:27.643] The total size of the 1 globals exported for future expression ('FUN()') is 4.61 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.61 KiB of class 'function')
[13:14:27.643] - globals: [1] 'FUN'
[13:14:27.643] 
[13:14:27.643] getGlobalsAndPackages() ... DONE
[13:14:27.643]  - globals found/used: [n=1] 'FUN'
[13:14:27.643]  - needed namespaces: [n=0] 
[13:14:27.644] Finding globals ... DONE
[13:14:27.644]  - use_args: TRUE
[13:14:27.644]  - Getting '...' globals ...
[13:14:27.644] resolve() on list ...
[13:14:27.644]  recursive: 0
[13:14:27.645]  length: 1
[13:14:27.645]  elements: '...'
[13:14:27.645]  length: 0 (resolved future 1)
[13:14:27.645] resolve() on list ... DONE
[13:14:27.645]    - '...' content: [n=0] 
[13:14:27.645] List of 1
[13:14:27.645]  $ ...: list()
[13:14:27.645]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[13:14:27.645]  - attr(*, "where")=List of 1
[13:14:27.645]   ..$ ...:<environment: 0x0000022a32276aa8> 
[13:14:27.645]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[13:14:27.645]  - attr(*, "resolved")= logi TRUE
[13:14:27.645]  - attr(*, "total_size")= num NA
[13:14:27.648]  - Getting '...' globals ... DONE
[13:14:27.649] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[13:14:27.649] List of 2
[13:14:27.649]  $ ...future.FUN:function (x)  
[13:14:27.649]  $ ...          : list()
[13:14:27.649]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[13:14:27.649]  - attr(*, "where")=List of 2
[13:14:27.649]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[13:14:27.649]   ..$ ...          :<environment: 0x0000022a32276aa8> 
[13:14:27.649]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[13:14:27.649]  - attr(*, "resolved")= logi FALSE
[13:14:27.649]  - attr(*, "total_size")= num 4720
[13:14:27.652] Packages to be attached in all futures: [n=0] 
[13:14:27.652] getGlobalsAndPackagesXApply() ... DONE
[13:14:27.652] Number of futures (= number of chunks): 1
[13:14:27.653] Launching 1 futures (chunks) ...
[13:14:27.653] Chunk #1 of 1 ...
[13:14:27.653]  - Finding globals in 'X' for chunk #1 ...
[13:14:27.653] getGlobalsAndPackages() ...
[13:14:27.653] Searching for globals...
[13:14:27.654] 
[13:14:27.654] Searching for globals ... DONE
[13:14:27.654] - globals: [0] <none>
[13:14:27.654] getGlobalsAndPackages() ... DONE
[13:14:27.654]    + additional globals found: [n=0] 
[13:14:27.654]    + additional namespaces needed: [n=0] 
[13:14:27.654]  - Finding globals in 'X' for chunk #1 ... DONE
[13:14:27.655]  - seeds: <none>
[13:14:27.655]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:27.655] getGlobalsAndPackages() ...
[13:14:27.655] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:27.655] Resolving globals: FALSE
[13:14:27.655] Tweak future expression to call with '...' arguments ...
[13:14:27.656] {
[13:14:27.656]     do.call(function(...) {
[13:14:27.656]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[13:14:27.656]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[13:14:27.656]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[13:14:27.656]             on.exit(options(oopts), add = TRUE)
[13:14:27.656]         }
[13:14:27.656]         {
[13:14:27.656]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[13:14:27.656]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[13:14:27.656]                 ...future.FUN(...future.X_jj, ...)
[13:14:27.656]             })
[13:14:27.656]         }
[13:14:27.656]     }, args = future.call.arguments)
[13:14:27.656] }
[13:14:27.656] Tweak future expression to call with '...' arguments ... DONE
[13:14:27.657] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:27.657] 
[13:14:27.657] getGlobalsAndPackages() ... DONE
[13:14:27.657] run() for 'Future' ...
[13:14:27.657] - state: 'created'
[13:14:27.658] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[13:14:27.660] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[13:14:27.660] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[13:14:27.660]   - Field: 'label'
[13:14:27.660]   - Field: 'local'
[13:14:27.661]   - Field: 'owner'
[13:14:27.661]   - Field: 'envir'
[13:14:27.661]   - Field: 'packages'
[13:14:27.661]   - Field: 'gc'
[13:14:27.661]   - Field: 'conditions'
[13:14:27.662]   - Field: 'expr'
[13:14:27.662]   - Field: 'uuid'
[13:14:27.662]   - Field: 'seed'
[13:14:27.662]   - Field: 'version'
[13:14:27.662]   - Field: 'result'
[13:14:27.662]   - Field: 'asynchronous'
[13:14:27.663]   - Field: 'calls'
[13:14:27.663]   - Field: 'globals'
[13:14:27.663]   - Field: 'stdout'
[13:14:27.663]   - Field: 'earlySignal'
[13:14:27.663]   - Field: 'lazy'
[13:14:27.663]   - Field: 'state'
[13:14:27.664] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[13:14:27.664] - Launch lazy future ...
[13:14:27.664] Packages needed by the future expression (n = 0): <none>
[13:14:27.664] Packages needed by future strategies (n = 0): <none>
[13:14:27.665] {
[13:14:27.665]     {
[13:14:27.665]         {
[13:14:27.665]             ...future.startTime <- base::Sys.time()
[13:14:27.665]             {
[13:14:27.665]                 {
[13:14:27.665]                   {
[13:14:27.665]                     base::local({
[13:14:27.665]                       has_future <- base::requireNamespace("future", 
[13:14:27.665]                         quietly = TRUE)
[13:14:27.665]                       if (has_future) {
[13:14:27.665]                         ns <- base::getNamespace("future")
[13:14:27.665]                         version <- ns[[".package"]][["version"]]
[13:14:27.665]                         if (is.null(version)) 
[13:14:27.665]                           version <- utils::packageVersion("future")
[13:14:27.665]                       }
[13:14:27.665]                       else {
[13:14:27.665]                         version <- NULL
[13:14:27.665]                       }
[13:14:27.665]                       if (!has_future || version < "1.8.0") {
[13:14:27.665]                         info <- base::c(r_version = base::gsub("R version ", 
[13:14:27.665]                           "", base::R.version$version.string), 
[13:14:27.665]                           platform = base::sprintf("%s (%s-bit)", 
[13:14:27.665]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[13:14:27.665]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[13:14:27.665]                             "release", "version")], collapse = " "), 
[13:14:27.665]                           hostname = base::Sys.info()[["nodename"]])
[13:14:27.665]                         info <- base::sprintf("%s: %s", base::names(info), 
[13:14:27.665]                           info)
[13:14:27.665]                         info <- base::paste(info, collapse = "; ")
[13:14:27.665]                         if (!has_future) {
[13:14:27.665]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[13:14:27.665]                             info)
[13:14:27.665]                         }
[13:14:27.665]                         else {
[13:14:27.665]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[13:14:27.665]                             info, version)
[13:14:27.665]                         }
[13:14:27.665]                         base::stop(msg)
[13:14:27.665]                       }
[13:14:27.665]                     })
[13:14:27.665]                   }
[13:14:27.665]                   options(future.plan = NULL)
[13:14:27.665]                   Sys.unsetenv("R_FUTURE_PLAN")
[13:14:27.665]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[13:14:27.665]                 }
[13:14:27.665]                 ...future.workdir <- getwd()
[13:14:27.665]             }
[13:14:27.665]             ...future.oldOptions <- base::as.list(base::.Options)
[13:14:27.665]             ...future.oldEnvVars <- base::Sys.getenv()
[13:14:27.665]         }
[13:14:27.665]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[13:14:27.665]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[13:14:27.665]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[13:14:27.665]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[13:14:27.665]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[13:14:27.665]             future.stdout.windows.reencode = NULL, width = 80L)
[13:14:27.665]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[13:14:27.665]             base::names(...future.oldOptions))
[13:14:27.665]     }
[13:14:27.665]     if (FALSE) {
[13:14:27.665]     }
[13:14:27.665]     else {
[13:14:27.665]         if (TRUE) {
[13:14:27.665]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[13:14:27.665]                 open = "w")
[13:14:27.665]         }
[13:14:27.665]         else {
[13:14:27.665]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[13:14:27.665]                 windows = "NUL", "/dev/null"), open = "w")
[13:14:27.665]         }
[13:14:27.665]         base::sink(...future.stdout, type = "output", split = FALSE)
[13:14:27.665]         base::on.exit(if (!base::is.null(...future.stdout)) {
[13:14:27.665]             base::sink(type = "output", split = FALSE)
[13:14:27.665]             base::close(...future.stdout)
[13:14:27.665]         }, add = TRUE)
[13:14:27.665]     }
[13:14:27.665]     ...future.frame <- base::sys.nframe()
[13:14:27.665]     ...future.conditions <- base::list()
[13:14:27.665]     ...future.rng <- base::globalenv()$.Random.seed
[13:14:27.665]     if (FALSE) {
[13:14:27.665]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[13:14:27.665]             "...future.value", "...future.globalenv.names", ".Random.seed")
[13:14:27.665]     }
[13:14:27.665]     ...future.result <- base::tryCatch({
[13:14:27.665]         base::withCallingHandlers({
[13:14:27.665]             ...future.value <- base::withVisible(base::local({
[13:14:27.665]                 do.call(function(...) {
[13:14:27.665]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[13:14:27.665]                   if (!identical(...future.globals.maxSize.org, 
[13:14:27.665]                     ...future.globals.maxSize)) {
[13:14:27.665]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[13:14:27.665]                     on.exit(options(oopts), add = TRUE)
[13:14:27.665]                   }
[13:14:27.665]                   {
[13:14:27.665]                     lapply(seq_along(...future.elements_ii), 
[13:14:27.665]                       FUN = function(jj) {
[13:14:27.665]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[13:14:27.665]                         ...future.FUN(...future.X_jj, ...)
[13:14:27.665]                       })
[13:14:27.665]                   }
[13:14:27.665]                 }, args = future.call.arguments)
[13:14:27.665]             }))
[13:14:27.665]             future::FutureResult(value = ...future.value$value, 
[13:14:27.665]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[13:14:27.665]                   ...future.rng), globalenv = if (FALSE) 
[13:14:27.665]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[13:14:27.665]                     ...future.globalenv.names))
[13:14:27.665]                 else NULL, started = ...future.startTime, version = "1.8")
[13:14:27.665]         }, condition = base::local({
[13:14:27.665]             c <- base::c
[13:14:27.665]             inherits <- base::inherits
[13:14:27.665]             invokeRestart <- base::invokeRestart
[13:14:27.665]             length <- base::length
[13:14:27.665]             list <- base::list
[13:14:27.665]             seq.int <- base::seq.int
[13:14:27.665]             signalCondition <- base::signalCondition
[13:14:27.665]             sys.calls <- base::sys.calls
[13:14:27.665]             `[[` <- base::`[[`
[13:14:27.665]             `+` <- base::`+`
[13:14:27.665]             `<<-` <- base::`<<-`
[13:14:27.665]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[13:14:27.665]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[13:14:27.665]                   3L)]
[13:14:27.665]             }
[13:14:27.665]             function(cond) {
[13:14:27.665]                 is_error <- inherits(cond, "error")
[13:14:27.665]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[13:14:27.665]                   NULL)
[13:14:27.665]                 if (is_error) {
[13:14:27.665]                   sessionInformation <- function() {
[13:14:27.665]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[13:14:27.665]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[13:14:27.665]                       search = base::search(), system = base::Sys.info())
[13:14:27.665]                   }
[13:14:27.665]                   ...future.conditions[[length(...future.conditions) + 
[13:14:27.665]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[13:14:27.665]                     cond$call), session = sessionInformation(), 
[13:14:27.665]                     timestamp = base::Sys.time(), signaled = 0L)
[13:14:27.665]                   signalCondition(cond)
[13:14:27.665]                 }
[13:14:27.665]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[13:14:27.665]                 "immediateCondition"))) {
[13:14:27.665]                   signal <- TRUE && inherits(cond, "immediateCondition")
[13:14:27.665]                   ...future.conditions[[length(...future.conditions) + 
[13:14:27.665]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[13:14:27.665]                   if (TRUE && !signal) {
[13:14:27.665]                     muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:27.665]                     {
[13:14:27.665]                       inherits <- base::inherits
[13:14:27.665]                       invokeRestart <- base::invokeRestart
[13:14:27.665]                       is.null <- base::is.null
[13:14:27.665]                       muffled <- FALSE
[13:14:27.665]                       if (inherits(cond, "message")) {
[13:14:27.665]                         muffled <- grepl(pattern, "muffleMessage")
[13:14:27.665]                         if (muffled) 
[13:14:27.665]                           invokeRestart("muffleMessage")
[13:14:27.665]                       }
[13:14:27.665]                       else if (inherits(cond, "warning")) {
[13:14:27.665]                         muffled <- grepl(pattern, "muffleWarning")
[13:14:27.665]                         if (muffled) 
[13:14:27.665]                           invokeRestart("muffleWarning")
[13:14:27.665]                       }
[13:14:27.665]                       else if (inherits(cond, "condition")) {
[13:14:27.665]                         if (!is.null(pattern)) {
[13:14:27.665]                           computeRestarts <- base::computeRestarts
[13:14:27.665]                           grepl <- base::grepl
[13:14:27.665]                           restarts <- computeRestarts(cond)
[13:14:27.665]                           for (restart in restarts) {
[13:14:27.665]                             name <- restart$name
[13:14:27.665]                             if (is.null(name)) 
[13:14:27.665]                               next
[13:14:27.665]                             if (!grepl(pattern, name)) 
[13:14:27.665]                               next
[13:14:27.665]                             invokeRestart(restart)
[13:14:27.665]                             muffled <- TRUE
[13:14:27.665]                             break
[13:14:27.665]                           }
[13:14:27.665]                         }
[13:14:27.665]                       }
[13:14:27.665]                       invisible(muffled)
[13:14:27.665]                     }
[13:14:27.665]                     muffleCondition(cond, pattern = "^muffle")
[13:14:27.665]                   }
[13:14:27.665]                 }
[13:14:27.665]                 else {
[13:14:27.665]                   if (TRUE) {
[13:14:27.665]                     muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:27.665]                     {
[13:14:27.665]                       inherits <- base::inherits
[13:14:27.665]                       invokeRestart <- base::invokeRestart
[13:14:27.665]                       is.null <- base::is.null
[13:14:27.665]                       muffled <- FALSE
[13:14:27.665]                       if (inherits(cond, "message")) {
[13:14:27.665]                         muffled <- grepl(pattern, "muffleMessage")
[13:14:27.665]                         if (muffled) 
[13:14:27.665]                           invokeRestart("muffleMessage")
[13:14:27.665]                       }
[13:14:27.665]                       else if (inherits(cond, "warning")) {
[13:14:27.665]                         muffled <- grepl(pattern, "muffleWarning")
[13:14:27.665]                         if (muffled) 
[13:14:27.665]                           invokeRestart("muffleWarning")
[13:14:27.665]                       }
[13:14:27.665]                       else if (inherits(cond, "condition")) {
[13:14:27.665]                         if (!is.null(pattern)) {
[13:14:27.665]                           computeRestarts <- base::computeRestarts
[13:14:27.665]                           grepl <- base::grepl
[13:14:27.665]                           restarts <- computeRestarts(cond)
[13:14:27.665]                           for (restart in restarts) {
[13:14:27.665]                             name <- restart$name
[13:14:27.665]                             if (is.null(name)) 
[13:14:27.665]                               next
[13:14:27.665]                             if (!grepl(pattern, name)) 
[13:14:27.665]                               next
[13:14:27.665]                             invokeRestart(restart)
[13:14:27.665]                             muffled <- TRUE
[13:14:27.665]                             break
[13:14:27.665]                           }
[13:14:27.665]                         }
[13:14:27.665]                       }
[13:14:27.665]                       invisible(muffled)
[13:14:27.665]                     }
[13:14:27.665]                     muffleCondition(cond, pattern = "^muffle")
[13:14:27.665]                   }
[13:14:27.665]                 }
[13:14:27.665]             }
[13:14:27.665]         }))
[13:14:27.665]     }, error = function(ex) {
[13:14:27.665]         base::structure(base::list(value = NULL, visible = NULL, 
[13:14:27.665]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[13:14:27.665]                 ...future.rng), started = ...future.startTime, 
[13:14:27.665]             finished = Sys.time(), session_uuid = NA_character_, 
[13:14:27.665]             version = "1.8"), class = "FutureResult")
[13:14:27.665]     }, finally = {
[13:14:27.665]         if (!identical(...future.workdir, getwd())) 
[13:14:27.665]             setwd(...future.workdir)
[13:14:27.665]         {
[13:14:27.665]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[13:14:27.665]                 ...future.oldOptions$nwarnings <- NULL
[13:14:27.665]             }
[13:14:27.665]             base::options(...future.oldOptions)
[13:14:27.665]             if (.Platform$OS.type == "windows") {
[13:14:27.665]                 old_names <- names(...future.oldEnvVars)
[13:14:27.665]                 envs <- base::Sys.getenv()
[13:14:27.665]                 names <- names(envs)
[13:14:27.665]                 common <- intersect(names, old_names)
[13:14:27.665]                 added <- setdiff(names, old_names)
[13:14:27.665]                 removed <- setdiff(old_names, names)
[13:14:27.665]                 changed <- common[...future.oldEnvVars[common] != 
[13:14:27.665]                   envs[common]]
[13:14:27.665]                 NAMES <- toupper(changed)
[13:14:27.665]                 args <- list()
[13:14:27.665]                 for (kk in seq_along(NAMES)) {
[13:14:27.665]                   name <- changed[[kk]]
[13:14:27.665]                   NAME <- NAMES[[kk]]
[13:14:27.665]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:27.665]                     next
[13:14:27.665]                   args[[name]] <- ...future.oldEnvVars[[name]]
[13:14:27.665]                 }
[13:14:27.665]                 NAMES <- toupper(added)
[13:14:27.665]                 for (kk in seq_along(NAMES)) {
[13:14:27.665]                   name <- added[[kk]]
[13:14:27.665]                   NAME <- NAMES[[kk]]
[13:14:27.665]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:27.665]                     next
[13:14:27.665]                   args[[name]] <- ""
[13:14:27.665]                 }
[13:14:27.665]                 NAMES <- toupper(removed)
[13:14:27.665]                 for (kk in seq_along(NAMES)) {
[13:14:27.665]                   name <- removed[[kk]]
[13:14:27.665]                   NAME <- NAMES[[kk]]
[13:14:27.665]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:27.665]                     next
[13:14:27.665]                   args[[name]] <- ...future.oldEnvVars[[name]]
[13:14:27.665]                 }
[13:14:27.665]                 if (length(args) > 0) 
[13:14:27.665]                   base::do.call(base::Sys.setenv, args = args)
[13:14:27.665]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[13:14:27.665]             }
[13:14:27.665]             else {
[13:14:27.665]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[13:14:27.665]             }
[13:14:27.665]             {
[13:14:27.665]                 if (base::length(...future.futureOptionsAdded) > 
[13:14:27.665]                   0L) {
[13:14:27.665]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[13:14:27.665]                   base::names(opts) <- ...future.futureOptionsAdded
[13:14:27.665]                   base::options(opts)
[13:14:27.665]                 }
[13:14:27.665]                 {
[13:14:27.665]                   {
[13:14:27.665]                     NULL
[13:14:27.665]                     RNGkind("Mersenne-Twister")
[13:14:27.665]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[13:14:27.665]                       inherits = FALSE)
[13:14:27.665]                   }
[13:14:27.665]                   options(future.plan = NULL)
[13:14:27.665]                   if (is.na(NA_character_)) 
[13:14:27.665]                     Sys.unsetenv("R_FUTURE_PLAN")
[13:14:27.665]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[13:14:27.665]                   future::plan(list(function (..., workers = availableCores(), 
[13:14:27.665]                     lazy = FALSE, rscript_libs = .libPaths(), 
[13:14:27.665]                     envir = parent.frame()) 
[13:14:27.665]                   {
[13:14:27.665]                     if (is.function(workers)) 
[13:14:27.665]                       workers <- workers()
[13:14:27.665]                     workers <- structure(as.integer(workers), 
[13:14:27.665]                       class = class(workers))
[13:14:27.665]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[13:14:27.665]                       workers >= 1)
[13:14:27.665]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[13:14:27.665]                       return(sequential(..., lazy = TRUE, envir = envir))
[13:14:27.665]                     }
[13:14:27.665]                     future <- MultisessionFuture(..., workers = workers, 
[13:14:27.665]                       lazy = lazy, rscript_libs = rscript_libs, 
[13:14:27.665]                       envir = envir)
[13:14:27.665]                     if (!future$lazy) 
[13:14:27.665]                       future <- run(future)
[13:14:27.665]                     invisible(future)
[13:14:27.665]                   }), .cleanup = FALSE, .init = FALSE)
[13:14:27.665]                 }
[13:14:27.665]             }
[13:14:27.665]         }
[13:14:27.665]     })
[13:14:27.665]     if (TRUE) {
[13:14:27.665]         base::sink(type = "output", split = FALSE)
[13:14:27.665]         if (TRUE) {
[13:14:27.665]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[13:14:27.665]         }
[13:14:27.665]         else {
[13:14:27.665]             ...future.result["stdout"] <- base::list(NULL)
[13:14:27.665]         }
[13:14:27.665]         base::close(...future.stdout)
[13:14:27.665]         ...future.stdout <- NULL
[13:14:27.665]     }
[13:14:27.665]     ...future.result$conditions <- ...future.conditions
[13:14:27.665]     ...future.result$finished <- base::Sys.time()
[13:14:27.665]     ...future.result
[13:14:27.665] }
[13:14:27.669] assign_globals() ...
[13:14:27.669] List of 5
[13:14:27.669]  $ ...future.FUN            :function (x)  
[13:14:27.669]  $ future.call.arguments    : list()
[13:14:27.669]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[13:14:27.669]  $ ...future.elements_ii    :List of 2
[13:14:27.669]   ..$ : int 1
[13:14:27.669]   ..$ : int 0
[13:14:27.669]  $ ...future.seeds_ii       : NULL
[13:14:27.669]  $ ...future.globals.maxSize: NULL
[13:14:27.669]  - attr(*, "where")=List of 5
[13:14:27.669]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[13:14:27.669]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[13:14:27.669]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[13:14:27.669]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[13:14:27.669]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[13:14:27.669]  - attr(*, "resolved")= logi FALSE
[13:14:27.669]  - attr(*, "total_size")= num 4720
[13:14:27.669]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[13:14:27.669]  - attr(*, "already-done")= logi TRUE
[13:14:27.676] - reassign environment for '...future.FUN'
[13:14:27.676] - copied '...future.FUN' to environment
[13:14:27.676] - copied 'future.call.arguments' to environment
[13:14:27.676] - copied '...future.elements_ii' to environment
[13:14:27.676] - copied '...future.seeds_ii' to environment
[13:14:27.677] - copied '...future.globals.maxSize' to environment
[13:14:27.677] assign_globals() ... done
[13:14:27.677] plan(): Setting new future strategy stack:
[13:14:27.677] List of future strategies:
[13:14:27.677] 1. sequential:
[13:14:27.677]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[13:14:27.677]    - tweaked: FALSE
[13:14:27.677]    - call: NULL
[13:14:27.678] plan(): nbrOfWorkers() = 1
[13:14:28.184] plan(): Setting new future strategy stack:
[13:14:28.184] List of future strategies:
[13:14:28.184] 1. multisession:
[13:14:28.184]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[13:14:28.184]    - tweaked: FALSE
[13:14:28.184]    - call: plan(strategy)
[13:14:28.187] plan(): nbrOfWorkers() = 1
[13:14:28.187] SequentialFuture started (and completed)
[13:14:28.187] - Launch lazy future ... done
[13:14:28.188] run() for 'SequentialFuture' ... done
[13:14:28.188] Created future:
[13:14:28.188] SequentialFuture:
[13:14:28.188] Label: 'future_lapply-1'
[13:14:28.188] Expression:
[13:14:28.188] {
[13:14:28.188]     do.call(function(...) {
[13:14:28.188]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[13:14:28.188]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[13:14:28.188]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[13:14:28.188]             on.exit(options(oopts), add = TRUE)
[13:14:28.188]         }
[13:14:28.188]         {
[13:14:28.188]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[13:14:28.188]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[13:14:28.188]                 ...future.FUN(...future.X_jj, ...)
[13:14:28.188]             })
[13:14:28.188]         }
[13:14:28.188]     }, args = future.call.arguments)
[13:14:28.188] }
[13:14:28.188] Lazy evaluation: FALSE
[13:14:28.188] Asynchronous evaluation: FALSE
[13:14:28.188] Local evaluation: TRUE
[13:14:28.188] Environment: R_GlobalEnv
[13:14:28.188] Capture standard output: TRUE
[13:14:28.188] Capture condition classes: 'condition' (excluding 'nothing')
[13:14:28.188] Globals: 5 objects totaling 4.72 KiB (function '...future.FUN' of 4.61 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 112 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[13:14:28.188] Packages: <none>
[13:14:28.188] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[13:14:28.188] Resolved: TRUE
[13:14:28.188] Value: 112 bytes of class 'list'
[13:14:28.188] Early signaling: FALSE
[13:14:28.188] Owner process: 68097d82-3b31-293d-2920-9b7259f27083
[13:14:28.188] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[13:14:28.189] Chunk #1 of 1 ... DONE
[13:14:28.189] Launching 1 futures (chunks) ... DONE
[13:14:28.190] Resolving 1 futures (chunks) ...
[13:14:28.190] resolve() on list ...
[13:14:28.190]  recursive: 0
[13:14:28.190]  length: 1
[13:14:28.190] 
[13:14:28.190] resolved() for 'SequentialFuture' ...
[13:14:28.191] - state: 'finished'
[13:14:28.191] - run: TRUE
[13:14:28.191] - result: 'FutureResult'
[13:14:28.191] resolved() for 'SequentialFuture' ... done
[13:14:28.191] Future #1
[13:14:28.192] signalConditionsASAP(SequentialFuture, pos=1) ...
[13:14:28.192] - nx: 1
[13:14:28.192] - relay: TRUE
[13:14:28.192] - stdout: TRUE
[13:14:28.192] - signal: TRUE
[13:14:28.192] - resignal: FALSE
[13:14:28.192] - force: TRUE
[13:14:28.193] - relayed: [n=1] FALSE
[13:14:28.193] - queued futures: [n=1] FALSE
[13:14:28.193]  - until=1
[13:14:28.193]  - relaying element #1
[13:14:28.193] - relayed: [n=1] TRUE
[13:14:28.194] - queued futures: [n=1] TRUE
[13:14:28.194] signalConditionsASAP(SequentialFuture, pos=1) ... done
[13:14:28.194]  length: 0 (resolved future 1)
[13:14:28.194] Relaying remaining futures
[13:14:28.194] signalConditionsASAP(NULL, pos=0) ...
[13:14:28.194] - nx: 1
[13:14:28.195] - relay: TRUE
[13:14:28.195] - stdout: TRUE
[13:14:28.195] - signal: TRUE
[13:14:28.195] - resignal: FALSE
[13:14:28.195] - force: TRUE
[13:14:28.195] - relayed: [n=1] TRUE
[13:14:28.195] - queued futures: [n=1] TRUE
 - flush all
[13:14:28.196] - relayed: [n=1] TRUE
[13:14:28.196] - queued futures: [n=1] TRUE
[13:14:28.196] signalConditionsASAP(NULL, pos=0) ... done
[13:14:28.196] resolve() on list ... DONE
[13:14:28.196]  - Number of value chunks collected: 1
[13:14:28.197] Resolving 1 futures (chunks) ... DONE
[13:14:28.197] Reducing values from 1 chunks ...
[13:14:28.197]  - Number of values collected after concatenation: 2
[13:14:28.197]  - Number of values expected: 2
[13:14:28.197] Reducing values from 1 chunks ... DONE
[13:14:28.197] future_lapply() ... DONE
* future_lapply(x, ..., future.stdout = TRUE) ... DONE
* future_lapply(x, ..., future.stdout = NA) ...
[13:14:28.198] future_lapply() ...
[13:14:28.201] Number of chunks: 1
[13:14:28.201] getGlobalsAndPackagesXApply() ...
[13:14:28.201]  - future.globals: TRUE
[13:14:28.201] getGlobalsAndPackages() ...
[13:14:28.201] Searching for globals...
[13:14:28.204] - globals found: [5] 'FUN', '{', 'Sys.sleep', '/', 'print'
[13:14:28.204] Searching for globals ... DONE
[13:14:28.204] Resolving globals: FALSE
[13:14:28.205] The total size of the 1 globals is 4.61 KiB (4720 bytes)
[13:14:28.205] The total size of the 1 globals exported for future expression ('FUN()') is 4.61 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.61 KiB of class 'function')
[13:14:28.205] - globals: [1] 'FUN'
[13:14:28.205] 
[13:14:28.206] getGlobalsAndPackages() ... DONE
[13:14:28.206]  - globals found/used: [n=1] 'FUN'
[13:14:28.206]  - needed namespaces: [n=0] 
[13:14:28.206] Finding globals ... DONE
[13:14:28.206]  - use_args: TRUE
[13:14:28.206]  - Getting '...' globals ...
[13:14:28.207] resolve() on list ...
[13:14:28.207]  recursive: 0
[13:14:28.207]  length: 1
[13:14:28.207]  elements: '...'
[13:14:28.207]  length: 0 (resolved future 1)
[13:14:28.208] resolve() on list ... DONE
[13:14:28.208]    - '...' content: [n=0] 
[13:14:28.208] List of 1
[13:14:28.208]  $ ...: list()
[13:14:28.208]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[13:14:28.208]  - attr(*, "where")=List of 1
[13:14:28.208]   ..$ ...:<environment: 0x0000022a3237ce98> 
[13:14:28.208]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[13:14:28.208]  - attr(*, "resolved")= logi TRUE
[13:14:28.208]  - attr(*, "total_size")= num NA
[13:14:28.211]  - Getting '...' globals ... DONE
[13:14:28.211] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[13:14:28.211] List of 2
[13:14:28.211]  $ ...future.FUN:function (x)  
[13:14:28.211]  $ ...          : list()
[13:14:28.211]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[13:14:28.211]  - attr(*, "where")=List of 2
[13:14:28.211]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[13:14:28.211]   ..$ ...          :<environment: 0x0000022a3237ce98> 
[13:14:28.211]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[13:14:28.211]  - attr(*, "resolved")= logi FALSE
[13:14:28.211]  - attr(*, "total_size")= num 4720
[13:14:28.214] Packages to be attached in all futures: [n=0] 
[13:14:28.215] getGlobalsAndPackagesXApply() ... DONE
[13:14:28.215] Number of futures (= number of chunks): 1
[13:14:28.215] Launching 1 futures (chunks) ...
[13:14:28.215] Chunk #1 of 1 ...
[13:14:28.215]  - Finding globals in 'X' for chunk #1 ...
[13:14:28.216] getGlobalsAndPackages() ...
[13:14:28.216] Searching for globals...
[13:14:28.216] 
[13:14:28.216] Searching for globals ... DONE
[13:14:28.216] - globals: [0] <none>
[13:14:28.217] getGlobalsAndPackages() ... DONE
[13:14:28.217]    + additional globals found: [n=0] 
[13:14:28.217]    + additional namespaces needed: [n=0] 
[13:14:28.217]  - Finding globals in 'X' for chunk #1 ... DONE
[13:14:28.217]  - seeds: <none>
[13:14:28.217]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:28.218] getGlobalsAndPackages() ...
[13:14:28.218] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:28.218] Resolving globals: FALSE
[13:14:28.218] Tweak future expression to call with '...' arguments ...
[13:14:28.218] {
[13:14:28.218]     do.call(function(...) {
[13:14:28.218]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[13:14:28.218]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[13:14:28.218]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[13:14:28.218]             on.exit(options(oopts), add = TRUE)
[13:14:28.218]         }
[13:14:28.218]         {
[13:14:28.218]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[13:14:28.218]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[13:14:28.218]                 ...future.FUN(...future.X_jj, ...)
[13:14:28.218]             })
[13:14:28.218]         }
[13:14:28.218]     }, args = future.call.arguments)
[13:14:28.218] }
[13:14:28.219] Tweak future expression to call with '...' arguments ... DONE
[13:14:28.219] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:28.219] 
[13:14:28.219] getGlobalsAndPackages() ... DONE
[13:14:28.220] run() for 'Future' ...
[13:14:28.220] - state: 'created'
[13:14:28.220] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[13:14:28.222] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[13:14:28.223] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[13:14:28.223]   - Field: 'label'
[13:14:28.223]   - Field: 'local'
[13:14:28.223]   - Field: 'owner'
[13:14:28.223]   - Field: 'envir'
[13:14:28.224]   - Field: 'packages'
[13:14:28.224]   - Field: 'gc'
[13:14:28.224]   - Field: 'conditions'
[13:14:28.224]   - Field: 'expr'
[13:14:28.224]   - Field: 'uuid'
[13:14:28.224]   - Field: 'seed'
[13:14:28.225]   - Field: 'version'
[13:14:28.225]   - Field: 'result'
[13:14:28.225]   - Field: 'asynchronous'
[13:14:28.225]   - Field: 'calls'
[13:14:28.225]   - Field: 'globals'
[13:14:28.225]   - Field: 'stdout'
[13:14:28.226]   - Field: 'earlySignal'
[13:14:28.226]   - Field: 'lazy'
[13:14:28.226]   - Field: 'state'
[13:14:28.226] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[13:14:28.226] - Launch lazy future ...
[13:14:28.227] Packages needed by the future expression (n = 0): <none>
[13:14:28.228] Packages needed by future strategies (n = 0): <none>
[13:14:28.228] {
[13:14:28.228]     {
[13:14:28.228]         {
[13:14:28.228]             ...future.startTime <- base::Sys.time()
[13:14:28.228]             {
[13:14:28.228]                 {
[13:14:28.228]                   {
[13:14:28.228]                     base::local({
[13:14:28.228]                       has_future <- base::requireNamespace("future", 
[13:14:28.228]                         quietly = TRUE)
[13:14:28.228]                       if (has_future) {
[13:14:28.228]                         ns <- base::getNamespace("future")
[13:14:28.228]                         version <- ns[[".package"]][["version"]]
[13:14:28.228]                         if (is.null(version)) 
[13:14:28.228]                           version <- utils::packageVersion("future")
[13:14:28.228]                       }
[13:14:28.228]                       else {
[13:14:28.228]                         version <- NULL
[13:14:28.228]                       }
[13:14:28.228]                       if (!has_future || version < "1.8.0") {
[13:14:28.228]                         info <- base::c(r_version = base::gsub("R version ", 
[13:14:28.228]                           "", base::R.version$version.string), 
[13:14:28.228]                           platform = base::sprintf("%s (%s-bit)", 
[13:14:28.228]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[13:14:28.228]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[13:14:28.228]                             "release", "version")], collapse = " "), 
[13:14:28.228]                           hostname = base::Sys.info()[["nodename"]])
[13:14:28.228]                         info <- base::sprintf("%s: %s", base::names(info), 
[13:14:28.228]                           info)
[13:14:28.228]                         info <- base::paste(info, collapse = "; ")
[13:14:28.228]                         if (!has_future) {
[13:14:28.228]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[13:14:28.228]                             info)
[13:14:28.228]                         }
[13:14:28.228]                         else {
[13:14:28.228]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[13:14:28.228]                             info, version)
[13:14:28.228]                         }
[13:14:28.228]                         base::stop(msg)
[13:14:28.228]                       }
[13:14:28.228]                     })
[13:14:28.228]                   }
[13:14:28.228]                   options(future.plan = NULL)
[13:14:28.228]                   Sys.unsetenv("R_FUTURE_PLAN")
[13:14:28.228]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[13:14:28.228]                 }
[13:14:28.228]                 ...future.workdir <- getwd()
[13:14:28.228]             }
[13:14:28.228]             ...future.oldOptions <- base::as.list(base::.Options)
[13:14:28.228]             ...future.oldEnvVars <- base::Sys.getenv()
[13:14:28.228]         }
[13:14:28.228]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[13:14:28.228]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[13:14:28.228]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[13:14:28.228]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[13:14:28.228]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[13:14:28.228]             future.stdout.windows.reencode = NULL, width = 80L)
[13:14:28.228]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[13:14:28.228]             base::names(...future.oldOptions))
[13:14:28.228]     }
[13:14:28.228]     if (TRUE) {
[13:14:28.228]     }
[13:14:28.228]     else {
[13:14:28.228]         if (NA) {
[13:14:28.228]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[13:14:28.228]                 open = "w")
[13:14:28.228]         }
[13:14:28.228]         else {
[13:14:28.228]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[13:14:28.228]                 windows = "NUL", "/dev/null"), open = "w")
[13:14:28.228]         }
[13:14:28.228]         base::sink(...future.stdout, type = "output", split = FALSE)
[13:14:28.228]         base::on.exit(if (!base::is.null(...future.stdout)) {
[13:14:28.228]             base::sink(type = "output", split = FALSE)
[13:14:28.228]             base::close(...future.stdout)
[13:14:28.228]         }, add = TRUE)
[13:14:28.228]     }
[13:14:28.228]     ...future.frame <- base::sys.nframe()
[13:14:28.228]     ...future.conditions <- base::list()
[13:14:28.228]     ...future.rng <- base::globalenv()$.Random.seed
[13:14:28.228]     if (FALSE) {
[13:14:28.228]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[13:14:28.228]             "...future.value", "...future.globalenv.names", ".Random.seed")
[13:14:28.228]     }
[13:14:28.228]     ...future.result <- base::tryCatch({
[13:14:28.228]         base::withCallingHandlers({
[13:14:28.228]             ...future.value <- base::withVisible(base::local({
[13:14:28.228]                 do.call(function(...) {
[13:14:28.228]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[13:14:28.228]                   if (!identical(...future.globals.maxSize.org, 
[13:14:28.228]                     ...future.globals.maxSize)) {
[13:14:28.228]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[13:14:28.228]                     on.exit(options(oopts), add = TRUE)
[13:14:28.228]                   }
[13:14:28.228]                   {
[13:14:28.228]                     lapply(seq_along(...future.elements_ii), 
[13:14:28.228]                       FUN = function(jj) {
[13:14:28.228]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[13:14:28.228]                         ...future.FUN(...future.X_jj, ...)
[13:14:28.228]                       })
[13:14:28.228]                   }
[13:14:28.228]                 }, args = future.call.arguments)
[13:14:28.228]             }))
[13:14:28.228]             future::FutureResult(value = ...future.value$value, 
[13:14:28.228]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[13:14:28.228]                   ...future.rng), globalenv = if (FALSE) 
[13:14:28.228]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[13:14:28.228]                     ...future.globalenv.names))
[13:14:28.228]                 else NULL, started = ...future.startTime, version = "1.8")
[13:14:28.228]         }, condition = base::local({
[13:14:28.228]             c <- base::c
[13:14:28.228]             inherits <- base::inherits
[13:14:28.228]             invokeRestart <- base::invokeRestart
[13:14:28.228]             length <- base::length
[13:14:28.228]             list <- base::list
[13:14:28.228]             seq.int <- base::seq.int
[13:14:28.228]             signalCondition <- base::signalCondition
[13:14:28.228]             sys.calls <- base::sys.calls
[13:14:28.228]             `[[` <- base::`[[`
[13:14:28.228]             `+` <- base::`+`
[13:14:28.228]             `<<-` <- base::`<<-`
[13:14:28.228]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[13:14:28.228]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[13:14:28.228]                   3L)]
[13:14:28.228]             }
[13:14:28.228]             function(cond) {
[13:14:28.228]                 is_error <- inherits(cond, "error")
[13:14:28.228]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[13:14:28.228]                   NULL)
[13:14:28.228]                 if (is_error) {
[13:14:28.228]                   sessionInformation <- function() {
[13:14:28.228]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[13:14:28.228]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[13:14:28.228]                       search = base::search(), system = base::Sys.info())
[13:14:28.228]                   }
[13:14:28.228]                   ...future.conditions[[length(...future.conditions) + 
[13:14:28.228]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[13:14:28.228]                     cond$call), session = sessionInformation(), 
[13:14:28.228]                     timestamp = base::Sys.time(), signaled = 0L)
[13:14:28.228]                   signalCondition(cond)
[13:14:28.228]                 }
[13:14:28.228]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[13:14:28.228]                 "immediateCondition"))) {
[13:14:28.228]                   signal <- TRUE && inherits(cond, "immediateCondition")
[13:14:28.228]                   ...future.conditions[[length(...future.conditions) + 
[13:14:28.228]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[13:14:28.228]                   if (TRUE && !signal) {
[13:14:28.228]                     muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:28.228]                     {
[13:14:28.228]                       inherits <- base::inherits
[13:14:28.228]                       invokeRestart <- base::invokeRestart
[13:14:28.228]                       is.null <- base::is.null
[13:14:28.228]                       muffled <- FALSE
[13:14:28.228]                       if (inherits(cond, "message")) {
[13:14:28.228]                         muffled <- grepl(pattern, "muffleMessage")
[13:14:28.228]                         if (muffled) 
[13:14:28.228]                           invokeRestart("muffleMessage")
[13:14:28.228]                       }
[13:14:28.228]                       else if (inherits(cond, "warning")) {
[13:14:28.228]                         muffled <- grepl(pattern, "muffleWarning")
[13:14:28.228]                         if (muffled) 
[13:14:28.228]                           invokeRestart("muffleWarning")
[13:14:28.228]                       }
[13:14:28.228]                       else if (inherits(cond, "condition")) {
[13:14:28.228]                         if (!is.null(pattern)) {
[13:14:28.228]                           computeRestarts <- base::computeRestarts
[13:14:28.228]                           grepl <- base::grepl
[13:14:28.228]                           restarts <- computeRestarts(cond)
[13:14:28.228]                           for (restart in restarts) {
[13:14:28.228]                             name <- restart$name
[13:14:28.228]                             if (is.null(name)) 
[13:14:28.228]                               next
[13:14:28.228]                             if (!grepl(pattern, name)) 
[13:14:28.228]                               next
[13:14:28.228]                             invokeRestart(restart)
[13:14:28.228]                             muffled <- TRUE
[13:14:28.228]                             break
[13:14:28.228]                           }
[13:14:28.228]                         }
[13:14:28.228]                       }
[13:14:28.228]                       invisible(muffled)
[13:14:28.228]                     }
[13:14:28.228]                     muffleCondition(cond, pattern = "^muffle")
[13:14:28.228]                   }
[13:14:28.228]                 }
[13:14:28.228]                 else {
[13:14:28.228]                   if (TRUE) {
[13:14:28.228]                     muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:28.228]                     {
[13:14:28.228]                       inherits <- base::inherits
[13:14:28.228]                       invokeRestart <- base::invokeRestart
[13:14:28.228]                       is.null <- base::is.null
[13:14:28.228]                       muffled <- FALSE
[13:14:28.228]                       if (inherits(cond, "message")) {
[13:14:28.228]                         muffled <- grepl(pattern, "muffleMessage")
[13:14:28.228]                         if (muffled) 
[13:14:28.228]                           invokeRestart("muffleMessage")
[13:14:28.228]                       }
[13:14:28.228]                       else if (inherits(cond, "warning")) {
[13:14:28.228]                         muffled <- grepl(pattern, "muffleWarning")
[13:14:28.228]                         if (muffled) 
[13:14:28.228]                           invokeRestart("muffleWarning")
[13:14:28.228]                       }
[13:14:28.228]                       else if (inherits(cond, "condition")) {
[13:14:28.228]                         if (!is.null(pattern)) {
[13:14:28.228]                           computeRestarts <- base::computeRestarts
[13:14:28.228]                           grepl <- base::grepl
[13:14:28.228]                           restarts <- computeRestarts(cond)
[13:14:28.228]                           for (restart in restarts) {
[13:14:28.228]                             name <- restart$name
[13:14:28.228]                             if (is.null(name)) 
[13:14:28.228]                               next
[13:14:28.228]                             if (!grepl(pattern, name)) 
[13:14:28.228]                               next
[13:14:28.228]                             invokeRestart(restart)
[13:14:28.228]                             muffled <- TRUE
[13:14:28.228]                             break
[13:14:28.228]                           }
[13:14:28.228]                         }
[13:14:28.228]                       }
[13:14:28.228]                       invisible(muffled)
[13:14:28.228]                     }
[13:14:28.228]                     muffleCondition(cond, pattern = "^muffle")
[13:14:28.228]                   }
[13:14:28.228]                 }
[13:14:28.228]             }
[13:14:28.228]         }))
[13:14:28.228]     }, error = function(ex) {
[13:14:28.228]         base::structure(base::list(value = NULL, visible = NULL, 
[13:14:28.228]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[13:14:28.228]                 ...future.rng), started = ...future.startTime, 
[13:14:28.228]             finished = Sys.time(), session_uuid = NA_character_, 
[13:14:28.228]             version = "1.8"), class = "FutureResult")
[13:14:28.228]     }, finally = {
[13:14:28.228]         if (!identical(...future.workdir, getwd())) 
[13:14:28.228]             setwd(...future.workdir)
[13:14:28.228]         {
[13:14:28.228]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[13:14:28.228]                 ...future.oldOptions$nwarnings <- NULL
[13:14:28.228]             }
[13:14:28.228]             base::options(...future.oldOptions)
[13:14:28.228]             if (.Platform$OS.type == "windows") {
[13:14:28.228]                 old_names <- names(...future.oldEnvVars)
[13:14:28.228]                 envs <- base::Sys.getenv()
[13:14:28.228]                 names <- names(envs)
[13:14:28.228]                 common <- intersect(names, old_names)
[13:14:28.228]                 added <- setdiff(names, old_names)
[13:14:28.228]                 removed <- setdiff(old_names, names)
[13:14:28.228]                 changed <- common[...future.oldEnvVars[common] != 
[13:14:28.228]                   envs[common]]
[13:14:28.228]                 NAMES <- toupper(changed)
[13:14:28.228]                 args <- list()
[13:14:28.228]                 for (kk in seq_along(NAMES)) {
[13:14:28.228]                   name <- changed[[kk]]
[13:14:28.228]                   NAME <- NAMES[[kk]]
[13:14:28.228]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:28.228]                     next
[13:14:28.228]                   args[[name]] <- ...future.oldEnvVars[[name]]
[13:14:28.228]                 }
[13:14:28.228]                 NAMES <- toupper(added)
[13:14:28.228]                 for (kk in seq_along(NAMES)) {
[13:14:28.228]                   name <- added[[kk]]
[13:14:28.228]                   NAME <- NAMES[[kk]]
[13:14:28.228]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:28.228]                     next
[13:14:28.228]                   args[[name]] <- ""
[13:14:28.228]                 }
[13:14:28.228]                 NAMES <- toupper(removed)
[13:14:28.228]                 for (kk in seq_along(NAMES)) {
[13:14:28.228]                   name <- removed[[kk]]
[13:14:28.228]                   NAME <- NAMES[[kk]]
[13:14:28.228]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:28.228]                     next
[13:14:28.228]                   args[[name]] <- ...future.oldEnvVars[[name]]
[13:14:28.228]                 }
[13:14:28.228]                 if (length(args) > 0) 
[13:14:28.228]                   base::do.call(base::Sys.setenv, args = args)
[13:14:28.228]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[13:14:28.228]             }
[13:14:28.228]             else {
[13:14:28.228]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[13:14:28.228]             }
[13:14:28.228]             {
[13:14:28.228]                 if (base::length(...future.futureOptionsAdded) > 
[13:14:28.228]                   0L) {
[13:14:28.228]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[13:14:28.228]                   base::names(opts) <- ...future.futureOptionsAdded
[13:14:28.228]                   base::options(opts)
[13:14:28.228]                 }
[13:14:28.228]                 {
[13:14:28.228]                   {
[13:14:28.228]                     NULL
[13:14:28.228]                     RNGkind("Mersenne-Twister")
[13:14:28.228]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[13:14:28.228]                       inherits = FALSE)
[13:14:28.228]                   }
[13:14:28.228]                   options(future.plan = NULL)
[13:14:28.228]                   if (is.na(NA_character_)) 
[13:14:28.228]                     Sys.unsetenv("R_FUTURE_PLAN")
[13:14:28.228]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[13:14:28.228]                   future::plan(list(function (..., workers = availableCores(), 
[13:14:28.228]                     lazy = FALSE, rscript_libs = .libPaths(), 
[13:14:28.228]                     envir = parent.frame()) 
[13:14:28.228]                   {
[13:14:28.228]                     if (is.function(workers)) 
[13:14:28.228]                       workers <- workers()
[13:14:28.228]                     workers <- structure(as.integer(workers), 
[13:14:28.228]                       class = class(workers))
[13:14:28.228]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[13:14:28.228]                       workers >= 1)
[13:14:28.228]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[13:14:28.228]                       return(sequential(..., lazy = TRUE, envir = envir))
[13:14:28.228]                     }
[13:14:28.228]                     future <- MultisessionFuture(..., workers = workers, 
[13:14:28.228]                       lazy = lazy, rscript_libs = rscript_libs, 
[13:14:28.228]                       envir = envir)
[13:14:28.228]                     if (!future$lazy) 
[13:14:28.228]                       future <- run(future)
[13:14:28.228]                     invisible(future)
[13:14:28.228]                   }), .cleanup = FALSE, .init = FALSE)
[13:14:28.228]                 }
[13:14:28.228]             }
[13:14:28.228]         }
[13:14:28.228]     })
[13:14:28.228]     if (FALSE) {
[13:14:28.228]         base::sink(type = "output", split = FALSE)
[13:14:28.228]         if (NA) {
[13:14:28.228]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[13:14:28.228]         }
[13:14:28.228]         else {
[13:14:28.228]             ...future.result["stdout"] <- base::list(NULL)
[13:14:28.228]         }
[13:14:28.228]         base::close(...future.stdout)
[13:14:28.228]         ...future.stdout <- NULL
[13:14:28.228]     }
[13:14:28.228]     ...future.result$conditions <- ...future.conditions
[13:14:28.228]     ...future.result$finished <- base::Sys.time()
[13:14:28.228]     ...future.result
[13:14:28.228] }
[13:14:28.232] assign_globals() ...
[13:14:28.232] List of 5
[13:14:28.232]  $ ...future.FUN            :function (x)  
[13:14:28.232]  $ future.call.arguments    : list()
[13:14:28.232]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[13:14:28.232]  $ ...future.elements_ii    :List of 2
[13:14:28.232]   ..$ : int 1
[13:14:28.232]   ..$ : int 0
[13:14:28.232]  $ ...future.seeds_ii       : NULL
[13:14:28.232]  $ ...future.globals.maxSize: NULL
[13:14:28.232]  - attr(*, "where")=List of 5
[13:14:28.232]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[13:14:28.232]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[13:14:28.232]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[13:14:28.232]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[13:14:28.232]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[13:14:28.232]  - attr(*, "resolved")= logi FALSE
[13:14:28.232]  - attr(*, "total_size")= num 4720
[13:14:28.232]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[13:14:28.232]  - attr(*, "already-done")= logi TRUE
[13:14:28.238] - reassign environment for '...future.FUN'
[13:14:28.238] - copied '...future.FUN' to environment
[13:14:28.239] - copied 'future.call.arguments' to environment
[13:14:28.239] - copied '...future.elements_ii' to environment
[13:14:28.239] - copied '...future.seeds_ii' to environment
[13:14:28.239] - copied '...future.globals.maxSize' to environment
[13:14:28.239] assign_globals() ... done
[13:14:28.240] plan(): Setting new future strategy stack:
[13:14:28.240] List of future strategies:
[13:14:28.240] 1. sequential:
[13:14:28.240]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[13:14:28.240]    - tweaked: FALSE
[13:14:28.240]    - call: NULL
[13:14:28.240] plan(): nbrOfWorkers() = 1
[13:14:28.744] plan(): Setting new future strategy stack:
[13:14:28.744] List of future strategies:
[13:14:28.744] 1. multisession:
[13:14:28.744]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[13:14:28.744]    - tweaked: FALSE
[13:14:28.744]    - call: plan(strategy)
[13:14:28.747] plan(): nbrOfWorkers() = 1
[13:14:28.747] SequentialFuture started (and completed)
[13:14:28.747] - Launch lazy future ... done
[13:14:28.748] run() for 'SequentialFuture' ... done
[13:14:28.748] Created future:
[13:14:28.748] SequentialFuture:
[13:14:28.748] Label: 'future_lapply-1'
[13:14:28.748] Expression:
[13:14:28.748] {
[13:14:28.748]     do.call(function(...) {
[13:14:28.748]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[13:14:28.748]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[13:14:28.748]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[13:14:28.748]             on.exit(options(oopts), add = TRUE)
[13:14:28.748]         }
[13:14:28.748]         {
[13:14:28.748]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[13:14:28.748]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[13:14:28.748]                 ...future.FUN(...future.X_jj, ...)
[13:14:28.748]             })
[13:14:28.748]         }
[13:14:28.748]     }, args = future.call.arguments)
[13:14:28.748] }
[13:14:28.748] Lazy evaluation: FALSE
[13:14:28.748] Asynchronous evaluation: FALSE
[13:14:28.748] Local evaluation: TRUE
[13:14:28.748] Environment: R_GlobalEnv
[13:14:28.748] Capture standard output: NA
[13:14:28.748] Capture condition classes: 'condition' (excluding 'nothing')
[13:14:28.748] Globals: 5 objects totaling 4.72 KiB (function '...future.FUN' of 4.61 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 112 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[13:14:28.748] Packages: <none>
[13:14:28.748] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[13:14:28.748] Resolved: TRUE
[13:14:28.748] Value: 112 bytes of class 'list'
[13:14:28.748] Early signaling: FALSE
[13:14:28.748] Owner process: 68097d82-3b31-293d-2920-9b7259f27083
[13:14:28.748] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[13:14:28.749] Chunk #1 of 1 ... DONE
[13:14:28.749] Launching 1 futures (chunks) ... DONE
[13:14:28.750] Resolving 1 futures (chunks) ...
[13:14:28.750] resolve() on list ...
[13:14:28.750]  recursive: 0
[13:14:28.750]  length: 1
[13:14:28.750] 
[13:14:28.750] resolved() for 'SequentialFuture' ...
[13:14:28.751] - state: 'finished'
[13:14:28.751] - run: TRUE
[13:14:28.751] - result: 'FutureResult'
[13:14:28.751] resolved() for 'SequentialFuture' ... done
[13:14:28.751] Future #1
[13:14:28.752] signalConditionsASAP(SequentialFuture, pos=1) ...
[13:14:28.752] - nx: 1
[13:14:28.752] - relay: TRUE
[13:14:28.752] - stdout: TRUE
[13:14:28.752] - signal: TRUE
[13:14:28.752] - resignal: FALSE
[13:14:28.752] - force: TRUE
[13:14:28.753] - relayed: [n=1] FALSE
[13:14:28.753] - queued futures: [n=1] FALSE
[13:14:28.753]  - until=1
[13:14:28.753]  - relaying element #1
[13:14:28.753] - relayed: [n=1] TRUE
[13:14:28.754] - queued futures: [n=1] TRUE
[13:14:28.754] signalConditionsASAP(SequentialFuture, pos=1) ... done
[13:14:28.754]  length: 0 (resolved future 1)
[13:14:28.754] Relaying remaining futures
[13:14:28.754] signalConditionsASAP(NULL, pos=0) ...
[13:14:28.754] - nx: 1
[13:14:28.754] - relay: TRUE
[13:14:28.755] - stdout: TRUE
[13:14:28.755] - signal: TRUE
[13:14:28.755] - resignal: FALSE
[13:14:28.755] - force: TRUE
[13:14:28.755] - relayed: [n=1] TRUE
[13:14:28.755] - queued futures: [n=1] TRUE
 - flush all
[13:14:28.756] - relayed: [n=1] TRUE
[13:14:28.756] - queued futures: [n=1] TRUE
[13:14:28.756] signalConditionsASAP(NULL, pos=0) ... done
[13:14:28.756] resolve() on list ... DONE
[13:14:28.756]  - Number of value chunks collected: 1
[13:14:28.756] Resolving 1 futures (chunks) ... DONE
[13:14:28.757] Reducing values from 1 chunks ...
[13:14:28.757]  - Number of values collected after concatenation: 2
[13:14:28.757]  - Number of values expected: 2
[13:14:28.757] Reducing values from 1 chunks ... DONE
[13:14:28.757] future_lapply() ... DONE
* future_lapply(x, ..., future.stdout = NA) ... DONE
* future_mapply(x, ..., future.stdout = FALSE) ...
[13:14:28.758] future_mapply() ...
[13:14:28.784] Number of chunks: 1
[13:14:28.784] getGlobalsAndPackagesXApply() ...
[13:14:28.785]  - future.globals: TRUE
[13:14:28.785] getGlobalsAndPackages() ...
[13:14:28.785] Searching for globals...
[13:14:28.787] - globals found: [6] 'FUN', '{', 'Sys.sleep', '/', 'print', 'list'
[13:14:28.787] Searching for globals ... DONE
[13:14:28.787] Resolving globals: FALSE
[13:14:28.788] The total size of the 1 globals is 6.11 KiB (6256 bytes)
[13:14:28.788] The total size of the 1 globals exported for future expression ('FUN()') is 6.11 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (6.11 KiB of class 'function')
[13:14:28.789] - globals: [1] 'FUN'
[13:14:28.789] 
[13:14:28.789] getGlobalsAndPackages() ... DONE
[13:14:28.789]  - globals found/used: [n=1] 'FUN'
[13:14:28.789]  - needed namespaces: [n=0] 
[13:14:28.789] Finding globals ... DONE
[13:14:28.790] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[13:14:28.790] List of 2
[13:14:28.790]  $ ...future.FUN:function (x, y)  
[13:14:28.790]  $ MoreArgs     : NULL
[13:14:28.790]  - attr(*, "where")=List of 2
[13:14:28.790]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[13:14:28.790]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[13:14:28.790]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[13:14:28.790]  - attr(*, "resolved")= logi FALSE
[13:14:28.790]  - attr(*, "total_size")= num NA
[13:14:28.793] Packages to be attached in all futures: [n=0] 
[13:14:28.793] getGlobalsAndPackagesXApply() ... DONE
[13:14:28.793] Number of futures (= number of chunks): 1
[13:14:28.794] Launching 1 futures (chunks) ...
[13:14:28.794] Chunk #1 of 1 ...
[13:14:28.794]  - Finding globals in '...' for chunk #1 ...
[13:14:28.794] getGlobalsAndPackages() ...
[13:14:28.794] Searching for globals...
[13:14:28.795] 
[13:14:28.795] Searching for globals ... DONE
[13:14:28.795] - globals: [0] <none>
[13:14:28.795] getGlobalsAndPackages() ... DONE
[13:14:28.795]    + additional globals found: [n=0] 
[13:14:28.795]    + additional namespaces needed: [n=0] 
[13:14:28.796]  - Finding globals in '...' for chunk #1 ... DONE
[13:14:28.796]  - seeds: <none>
[13:14:28.796]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:28.796] getGlobalsAndPackages() ...
[13:14:28.796] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:28.796] Resolving globals: FALSE
[13:14:28.797] The total size of the 5 globals is 6.33 KiB (6480 bytes)
[13:14:28.798] The total size of the 5 globals exported for future expression ('{; ...future.globals.maxSize.org <- getOption("future.globals.maxSize"); if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {; oopts <- options(future.globals.maxSize = ...future.globals.maxSize); on.exit(options(oopts), add = TRUE); }; ...; do.call(mapply, args = args); }; }') is 6.33 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (6.11 KiB of class 'function'), '...future.elements_ii' (224 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[13:14:28.798] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:28.798] 
[13:14:28.798] getGlobalsAndPackages() ... DONE
[13:14:28.799] run() for 'Future' ...
[13:14:28.799] - state: 'created'
[13:14:28.799] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[13:14:28.801] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[13:14:28.802] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[13:14:28.802]   - Field: 'label'
[13:14:28.802]   - Field: 'local'
[13:14:28.802]   - Field: 'owner'
[13:14:28.802]   - Field: 'envir'
[13:14:28.802]   - Field: 'packages'
[13:14:28.803]   - Field: 'gc'
[13:14:28.803]   - Field: 'conditions'
[13:14:28.803]   - Field: 'expr'
[13:14:28.803]   - Field: 'uuid'
[13:14:28.803]   - Field: 'seed'
[13:14:28.804]   - Field: 'version'
[13:14:28.804]   - Field: 'result'
[13:14:28.804]   - Field: 'asynchronous'
[13:14:28.804]   - Field: 'calls'
[13:14:28.804]   - Field: 'globals'
[13:14:28.804]   - Field: 'stdout'
[13:14:28.805]   - Field: 'earlySignal'
[13:14:28.805]   - Field: 'lazy'
[13:14:28.805]   - Field: 'state'
[13:14:28.805] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[13:14:28.805] - Launch lazy future ...
[13:14:28.806] Packages needed by the future expression (n = 0): <none>
[13:14:28.806] Packages needed by future strategies (n = 0): <none>
[13:14:28.806] {
[13:14:28.806]     {
[13:14:28.806]         {
[13:14:28.806]             ...future.startTime <- base::Sys.time()
[13:14:28.806]             {
[13:14:28.806]                 {
[13:14:28.806]                   {
[13:14:28.806]                     base::local({
[13:14:28.806]                       has_future <- base::requireNamespace("future", 
[13:14:28.806]                         quietly = TRUE)
[13:14:28.806]                       if (has_future) {
[13:14:28.806]                         ns <- base::getNamespace("future")
[13:14:28.806]                         version <- ns[[".package"]][["version"]]
[13:14:28.806]                         if (is.null(version)) 
[13:14:28.806]                           version <- utils::packageVersion("future")
[13:14:28.806]                       }
[13:14:28.806]                       else {
[13:14:28.806]                         version <- NULL
[13:14:28.806]                       }
[13:14:28.806]                       if (!has_future || version < "1.8.0") {
[13:14:28.806]                         info <- base::c(r_version = base::gsub("R version ", 
[13:14:28.806]                           "", base::R.version$version.string), 
[13:14:28.806]                           platform = base::sprintf("%s (%s-bit)", 
[13:14:28.806]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[13:14:28.806]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[13:14:28.806]                             "release", "version")], collapse = " "), 
[13:14:28.806]                           hostname = base::Sys.info()[["nodename"]])
[13:14:28.806]                         info <- base::sprintf("%s: %s", base::names(info), 
[13:14:28.806]                           info)
[13:14:28.806]                         info <- base::paste(info, collapse = "; ")
[13:14:28.806]                         if (!has_future) {
[13:14:28.806]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[13:14:28.806]                             info)
[13:14:28.806]                         }
[13:14:28.806]                         else {
[13:14:28.806]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[13:14:28.806]                             info, version)
[13:14:28.806]                         }
[13:14:28.806]                         base::stop(msg)
[13:14:28.806]                       }
[13:14:28.806]                     })
[13:14:28.806]                   }
[13:14:28.806]                   options(future.plan = NULL)
[13:14:28.806]                   Sys.unsetenv("R_FUTURE_PLAN")
[13:14:28.806]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[13:14:28.806]                 }
[13:14:28.806]                 ...future.workdir <- getwd()
[13:14:28.806]             }
[13:14:28.806]             ...future.oldOptions <- base::as.list(base::.Options)
[13:14:28.806]             ...future.oldEnvVars <- base::Sys.getenv()
[13:14:28.806]         }
[13:14:28.806]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[13:14:28.806]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[13:14:28.806]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[13:14:28.806]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[13:14:28.806]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[13:14:28.806]             future.stdout.windows.reencode = NULL, width = 80L)
[13:14:28.806]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[13:14:28.806]             base::names(...future.oldOptions))
[13:14:28.806]     }
[13:14:28.806]     if (FALSE) {
[13:14:28.806]     }
[13:14:28.806]     else {
[13:14:28.806]         if (FALSE) {
[13:14:28.806]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[13:14:28.806]                 open = "w")
[13:14:28.806]         }
[13:14:28.806]         else {
[13:14:28.806]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[13:14:28.806]                 windows = "NUL", "/dev/null"), open = "w")
[13:14:28.806]         }
[13:14:28.806]         base::sink(...future.stdout, type = "output", split = FALSE)
[13:14:28.806]         base::on.exit(if (!base::is.null(...future.stdout)) {
[13:14:28.806]             base::sink(type = "output", split = FALSE)
[13:14:28.806]             base::close(...future.stdout)
[13:14:28.806]         }, add = TRUE)
[13:14:28.806]     }
[13:14:28.806]     ...future.frame <- base::sys.nframe()
[13:14:28.806]     ...future.conditions <- base::list()
[13:14:28.806]     ...future.rng <- base::globalenv()$.Random.seed
[13:14:28.806]     if (FALSE) {
[13:14:28.806]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[13:14:28.806]             "...future.value", "...future.globalenv.names", ".Random.seed")
[13:14:28.806]     }
[13:14:28.806]     ...future.result <- base::tryCatch({
[13:14:28.806]         base::withCallingHandlers({
[13:14:28.806]             ...future.value <- base::withVisible(base::local({
[13:14:28.806]                 ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[13:14:28.806]                 if (!identical(...future.globals.maxSize.org, 
[13:14:28.806]                   ...future.globals.maxSize)) {
[13:14:28.806]                   oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[13:14:28.806]                   on.exit(options(oopts), add = TRUE)
[13:14:28.806]                 }
[13:14:28.806]                 {
[13:14:28.806]                   args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[13:14:28.806]                     MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[13:14:28.806]                     USE.NAMES = FALSE)
[13:14:28.806]                   do.call(mapply, args = args)
[13:14:28.806]                 }
[13:14:28.806]             }))
[13:14:28.806]             future::FutureResult(value = ...future.value$value, 
[13:14:28.806]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[13:14:28.806]                   ...future.rng), globalenv = if (FALSE) 
[13:14:28.806]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[13:14:28.806]                     ...future.globalenv.names))
[13:14:28.806]                 else NULL, started = ...future.startTime, version = "1.8")
[13:14:28.806]         }, condition = base::local({
[13:14:28.806]             c <- base::c
[13:14:28.806]             inherits <- base::inherits
[13:14:28.806]             invokeRestart <- base::invokeRestart
[13:14:28.806]             length <- base::length
[13:14:28.806]             list <- base::list
[13:14:28.806]             seq.int <- base::seq.int
[13:14:28.806]             signalCondition <- base::signalCondition
[13:14:28.806]             sys.calls <- base::sys.calls
[13:14:28.806]             `[[` <- base::`[[`
[13:14:28.806]             `+` <- base::`+`
[13:14:28.806]             `<<-` <- base::`<<-`
[13:14:28.806]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[13:14:28.806]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[13:14:28.806]                   3L)]
[13:14:28.806]             }
[13:14:28.806]             function(cond) {
[13:14:28.806]                 is_error <- inherits(cond, "error")
[13:14:28.806]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[13:14:28.806]                   NULL)
[13:14:28.806]                 if (is_error) {
[13:14:28.806]                   sessionInformation <- function() {
[13:14:28.806]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[13:14:28.806]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[13:14:28.806]                       search = base::search(), system = base::Sys.info())
[13:14:28.806]                   }
[13:14:28.806]                   ...future.conditions[[length(...future.conditions) + 
[13:14:28.806]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[13:14:28.806]                     cond$call), session = sessionInformation(), 
[13:14:28.806]                     timestamp = base::Sys.time(), signaled = 0L)
[13:14:28.806]                   signalCondition(cond)
[13:14:28.806]                 }
[13:14:28.806]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[13:14:28.806]                 "immediateCondition"))) {
[13:14:28.806]                   signal <- TRUE && inherits(cond, "immediateCondition")
[13:14:28.806]                   ...future.conditions[[length(...future.conditions) + 
[13:14:28.806]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[13:14:28.806]                   if (TRUE && !signal) {
[13:14:28.806]                     muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:28.806]                     {
[13:14:28.806]                       inherits <- base::inherits
[13:14:28.806]                       invokeRestart <- base::invokeRestart
[13:14:28.806]                       is.null <- base::is.null
[13:14:28.806]                       muffled <- FALSE
[13:14:28.806]                       if (inherits(cond, "message")) {
[13:14:28.806]                         muffled <- grepl(pattern, "muffleMessage")
[13:14:28.806]                         if (muffled) 
[13:14:28.806]                           invokeRestart("muffleMessage")
[13:14:28.806]                       }
[13:14:28.806]                       else if (inherits(cond, "warning")) {
[13:14:28.806]                         muffled <- grepl(pattern, "muffleWarning")
[13:14:28.806]                         if (muffled) 
[13:14:28.806]                           invokeRestart("muffleWarning")
[13:14:28.806]                       }
[13:14:28.806]                       else if (inherits(cond, "condition")) {
[13:14:28.806]                         if (!is.null(pattern)) {
[13:14:28.806]                           computeRestarts <- base::computeRestarts
[13:14:28.806]                           grepl <- base::grepl
[13:14:28.806]                           restarts <- computeRestarts(cond)
[13:14:28.806]                           for (restart in restarts) {
[13:14:28.806]                             name <- restart$name
[13:14:28.806]                             if (is.null(name)) 
[13:14:28.806]                               next
[13:14:28.806]                             if (!grepl(pattern, name)) 
[13:14:28.806]                               next
[13:14:28.806]                             invokeRestart(restart)
[13:14:28.806]                             muffled <- TRUE
[13:14:28.806]                             break
[13:14:28.806]                           }
[13:14:28.806]                         }
[13:14:28.806]                       }
[13:14:28.806]                       invisible(muffled)
[13:14:28.806]                     }
[13:14:28.806]                     muffleCondition(cond, pattern = "^muffle")
[13:14:28.806]                   }
[13:14:28.806]                 }
[13:14:28.806]                 else {
[13:14:28.806]                   if (TRUE) {
[13:14:28.806]                     muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:28.806]                     {
[13:14:28.806]                       inherits <- base::inherits
[13:14:28.806]                       invokeRestart <- base::invokeRestart
[13:14:28.806]                       is.null <- base::is.null
[13:14:28.806]                       muffled <- FALSE
[13:14:28.806]                       if (inherits(cond, "message")) {
[13:14:28.806]                         muffled <- grepl(pattern, "muffleMessage")
[13:14:28.806]                         if (muffled) 
[13:14:28.806]                           invokeRestart("muffleMessage")
[13:14:28.806]                       }
[13:14:28.806]                       else if (inherits(cond, "warning")) {
[13:14:28.806]                         muffled <- grepl(pattern, "muffleWarning")
[13:14:28.806]                         if (muffled) 
[13:14:28.806]                           invokeRestart("muffleWarning")
[13:14:28.806]                       }
[13:14:28.806]                       else if (inherits(cond, "condition")) {
[13:14:28.806]                         if (!is.null(pattern)) {
[13:14:28.806]                           computeRestarts <- base::computeRestarts
[13:14:28.806]                           grepl <- base::grepl
[13:14:28.806]                           restarts <- computeRestarts(cond)
[13:14:28.806]                           for (restart in restarts) {
[13:14:28.806]                             name <- restart$name
[13:14:28.806]                             if (is.null(name)) 
[13:14:28.806]                               next
[13:14:28.806]                             if (!grepl(pattern, name)) 
[13:14:28.806]                               next
[13:14:28.806]                             invokeRestart(restart)
[13:14:28.806]                             muffled <- TRUE
[13:14:28.806]                             break
[13:14:28.806]                           }
[13:14:28.806]                         }
[13:14:28.806]                       }
[13:14:28.806]                       invisible(muffled)
[13:14:28.806]                     }
[13:14:28.806]                     muffleCondition(cond, pattern = "^muffle")
[13:14:28.806]                   }
[13:14:28.806]                 }
[13:14:28.806]             }
[13:14:28.806]         }))
[13:14:28.806]     }, error = function(ex) {
[13:14:28.806]         base::structure(base::list(value = NULL, visible = NULL, 
[13:14:28.806]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[13:14:28.806]                 ...future.rng), started = ...future.startTime, 
[13:14:28.806]             finished = Sys.time(), session_uuid = NA_character_, 
[13:14:28.806]             version = "1.8"), class = "FutureResult")
[13:14:28.806]     }, finally = {
[13:14:28.806]         if (!identical(...future.workdir, getwd())) 
[13:14:28.806]             setwd(...future.workdir)
[13:14:28.806]         {
[13:14:28.806]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[13:14:28.806]                 ...future.oldOptions$nwarnings <- NULL
[13:14:28.806]             }
[13:14:28.806]             base::options(...future.oldOptions)
[13:14:28.806]             if (.Platform$OS.type == "windows") {
[13:14:28.806]                 old_names <- names(...future.oldEnvVars)
[13:14:28.806]                 envs <- base::Sys.getenv()
[13:14:28.806]                 names <- names(envs)
[13:14:28.806]                 common <- intersect(names, old_names)
[13:14:28.806]                 added <- setdiff(names, old_names)
[13:14:28.806]                 removed <- setdiff(old_names, names)
[13:14:28.806]                 changed <- common[...future.oldEnvVars[common] != 
[13:14:28.806]                   envs[common]]
[13:14:28.806]                 NAMES <- toupper(changed)
[13:14:28.806]                 args <- list()
[13:14:28.806]                 for (kk in seq_along(NAMES)) {
[13:14:28.806]                   name <- changed[[kk]]
[13:14:28.806]                   NAME <- NAMES[[kk]]
[13:14:28.806]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:28.806]                     next
[13:14:28.806]                   args[[name]] <- ...future.oldEnvVars[[name]]
[13:14:28.806]                 }
[13:14:28.806]                 NAMES <- toupper(added)
[13:14:28.806]                 for (kk in seq_along(NAMES)) {
[13:14:28.806]                   name <- added[[kk]]
[13:14:28.806]                   NAME <- NAMES[[kk]]
[13:14:28.806]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:28.806]                     next
[13:14:28.806]                   args[[name]] <- ""
[13:14:28.806]                 }
[13:14:28.806]                 NAMES <- toupper(removed)
[13:14:28.806]                 for (kk in seq_along(NAMES)) {
[13:14:28.806]                   name <- removed[[kk]]
[13:14:28.806]                   NAME <- NAMES[[kk]]
[13:14:28.806]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:28.806]                     next
[13:14:28.806]                   args[[name]] <- ...future.oldEnvVars[[name]]
[13:14:28.806]                 }
[13:14:28.806]                 if (length(args) > 0) 
[13:14:28.806]                   base::do.call(base::Sys.setenv, args = args)
[13:14:28.806]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[13:14:28.806]             }
[13:14:28.806]             else {
[13:14:28.806]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[13:14:28.806]             }
[13:14:28.806]             {
[13:14:28.806]                 if (base::length(...future.futureOptionsAdded) > 
[13:14:28.806]                   0L) {
[13:14:28.806]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[13:14:28.806]                   base::names(opts) <- ...future.futureOptionsAdded
[13:14:28.806]                   base::options(opts)
[13:14:28.806]                 }
[13:14:28.806]                 {
[13:14:28.806]                   {
[13:14:28.806]                     NULL
[13:14:28.806]                     RNGkind("Mersenne-Twister")
[13:14:28.806]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[13:14:28.806]                       inherits = FALSE)
[13:14:28.806]                   }
[13:14:28.806]                   options(future.plan = NULL)
[13:14:28.806]                   if (is.na(NA_character_)) 
[13:14:28.806]                     Sys.unsetenv("R_FUTURE_PLAN")
[13:14:28.806]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[13:14:28.806]                   future::plan(list(function (..., workers = availableCores(), 
[13:14:28.806]                     lazy = FALSE, rscript_libs = .libPaths(), 
[13:14:28.806]                     envir = parent.frame()) 
[13:14:28.806]                   {
[13:14:28.806]                     if (is.function(workers)) 
[13:14:28.806]                       workers <- workers()
[13:14:28.806]                     workers <- structure(as.integer(workers), 
[13:14:28.806]                       class = class(workers))
[13:14:28.806]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[13:14:28.806]                       workers >= 1)
[13:14:28.806]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[13:14:28.806]                       return(sequential(..., lazy = TRUE, envir = envir))
[13:14:28.806]                     }
[13:14:28.806]                     future <- MultisessionFuture(..., workers = workers, 
[13:14:28.806]                       lazy = lazy, rscript_libs = rscript_libs, 
[13:14:28.806]                       envir = envir)
[13:14:28.806]                     if (!future$lazy) 
[13:14:28.806]                       future <- run(future)
[13:14:28.806]                     invisible(future)
[13:14:28.806]                   }), .cleanup = FALSE, .init = FALSE)
[13:14:28.806]                 }
[13:14:28.806]             }
[13:14:28.806]         }
[13:14:28.806]     })
[13:14:28.806]     if (TRUE) {
[13:14:28.806]         base::sink(type = "output", split = FALSE)
[13:14:28.806]         if (FALSE) {
[13:14:28.806]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[13:14:28.806]         }
[13:14:28.806]         else {
[13:14:28.806]             ...future.result["stdout"] <- base::list(NULL)
[13:14:28.806]         }
[13:14:28.806]         base::close(...future.stdout)
[13:14:28.806]         ...future.stdout <- NULL
[13:14:28.806]     }
[13:14:28.806]     ...future.result$conditions <- ...future.conditions
[13:14:28.806]     ...future.result$finished <- base::Sys.time()
[13:14:28.806]     ...future.result
[13:14:28.806] }
[13:14:28.811] assign_globals() ...
[13:14:28.811] List of 5
[13:14:28.811]  $ ...future.FUN            :function (x, y)  
[13:14:28.811]  $ MoreArgs                 : NULL
[13:14:28.811]  $ ...future.elements_ii    :List of 2
[13:14:28.811]   ..$ :List of 2
[13:14:28.811]   .. ..$ : int 1
[13:14:28.811]   .. ..$ : int 0
[13:14:28.811]   ..$ :List of 2
[13:14:28.811]   .. ..$ : int 0
[13:14:28.811]   .. ..$ : int 1
[13:14:28.811]  $ ...future.seeds_ii       : NULL
[13:14:28.811]  $ ...future.globals.maxSize: NULL
[13:14:28.811]  - attr(*, "where")=List of 5
[13:14:28.811]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[13:14:28.811]   ..$ MoreArgs                 :<environment: R_EmptyEnv> 
[13:14:28.811]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[13:14:28.811]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[13:14:28.811]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[13:14:28.811]  - attr(*, "resolved")= logi FALSE
[13:14:28.811]  - attr(*, "total_size")= num 6480
[13:14:28.811]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[13:14:28.811]  - attr(*, "already-done")= logi TRUE
[13:14:28.818] - reassign environment for '...future.FUN'
[13:14:28.818] - copied '...future.FUN' to environment
[13:14:28.819] - copied 'MoreArgs' to environment
[13:14:28.819] - copied '...future.elements_ii' to environment
[13:14:28.819] - copied '...future.seeds_ii' to environment
[13:14:28.819] - copied '...future.globals.maxSize' to environment
[13:14:28.819] assign_globals() ... done
[13:14:28.820] plan(): Setting new future strategy stack:
[13:14:28.820] List of future strategies:
[13:14:28.820] 1. sequential:
[13:14:28.820]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[13:14:28.820]    - tweaked: FALSE
[13:14:28.820]    - call: NULL
[13:14:28.820] plan(): nbrOfWorkers() = 1
[13:14:29.323] plan(): Setting new future strategy stack:
[13:14:29.323] List of future strategies:
[13:14:29.323] 1. multisession:
[13:14:29.323]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[13:14:29.323]    - tweaked: FALSE
[13:14:29.323]    - call: plan(strategy)
[13:14:29.325] plan(): nbrOfWorkers() = 1
[13:14:29.326] SequentialFuture started (and completed)
[13:14:29.326] - Launch lazy future ... done
[13:14:29.326] run() for 'SequentialFuture' ... done
[13:14:29.326] Created future:
[13:14:29.327] SequentialFuture:
[13:14:29.327] Label: 'future_mapply-1'
[13:14:29.327] Expression:
[13:14:29.327] {
[13:14:29.327]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[13:14:29.327]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[13:14:29.327]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[13:14:29.327]         on.exit(options(oopts), add = TRUE)
[13:14:29.327]     }
[13:14:29.327]     {
[13:14:29.327]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[13:14:29.327]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[13:14:29.327]         do.call(mapply, args = args)
[13:14:29.327]     }
[13:14:29.327] }
[13:14:29.327] Lazy evaluation: FALSE
[13:14:29.327] Asynchronous evaluation: FALSE
[13:14:29.327] Local evaluation: TRUE
[13:14:29.327] Environment: R_GlobalEnv
[13:14:29.327] Capture standard output: FALSE
[13:14:29.327] Capture condition classes: 'condition' (excluding 'nothing')
[13:14:29.327] Globals: 5 objects totaling 6.33 KiB (function '...future.FUN' of 6.11 KiB, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 224 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[13:14:29.327] Packages: <none>
[13:14:29.327] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[13:14:29.327] Resolved: TRUE
[13:14:29.327] Value: 224 bytes of class 'list'
[13:14:29.327] Early signaling: FALSE
[13:14:29.327] Owner process: 68097d82-3b31-293d-2920-9b7259f27083
[13:14:29.327] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[13:14:29.328] Chunk #1 of 1 ... DONE
[13:14:29.328] Launching 1 futures (chunks) ... DONE
[13:14:29.328] Resolving 1 futures (chunks) ...
[13:14:29.328] resolve() on list ...
[13:14:29.328]  recursive: 0
[13:14:29.329]  length: 1
[13:14:29.329] 
[13:14:29.329] resolved() for 'SequentialFuture' ...
[13:14:29.329] - state: 'finished'
[13:14:29.329] - run: TRUE
[13:14:29.329] - result: 'FutureResult'
[13:14:29.330] resolved() for 'SequentialFuture' ... done
[13:14:29.330] Future #1
[13:14:29.330] signalConditionsASAP(SequentialFuture, pos=1) ...
[13:14:29.330] - nx: 1
[13:14:29.330] - relay: TRUE
[13:14:29.331] - stdout: TRUE
[13:14:29.331] - signal: TRUE
[13:14:29.331] - resignal: FALSE
[13:14:29.331] - force: TRUE
[13:14:29.331] - relayed: [n=1] FALSE
[13:14:29.331] - queued futures: [n=1] FALSE
[13:14:29.331]  - until=1
[13:14:29.332]  - relaying element #1
[13:14:29.332] - relayed: [n=1] TRUE
[13:14:29.332] - queued futures: [n=1] TRUE
[13:14:29.332] signalConditionsASAP(SequentialFuture, pos=1) ... done
[13:14:29.332]  length: 0 (resolved future 1)
[13:14:29.333] Relaying remaining futures
[13:14:29.333] signalConditionsASAP(NULL, pos=0) ...
[13:14:29.333] - nx: 1
[13:14:29.333] - relay: TRUE
[13:14:29.333] - stdout: TRUE
[13:14:29.333] - signal: TRUE
[13:14:29.333] - resignal: FALSE
[13:14:29.334] - force: TRUE
[13:14:29.334] - relayed: [n=1] TRUE
[13:14:29.334] - queued futures: [n=1] TRUE
 - flush all
[13:14:29.334] - relayed: [n=1] TRUE
[13:14:29.334] - queued futures: [n=1] TRUE
[13:14:29.335] signalConditionsASAP(NULL, pos=0) ... done
[13:14:29.335] resolve() on list ... DONE
[13:14:29.335]  - Number of value chunks collected: 1
[13:14:29.335] Resolving 1 futures (chunks) ... DONE
[13:14:29.335] Reducing values from 1 chunks ...
[13:14:29.335]  - Number of values collected after concatenation: 2
[13:14:29.336]  - Number of values expected: 2
[13:14:29.336] Reducing values from 1 chunks ... DONE
[13:14:29.336] future_mapply() ... DONE
* future_mapply(x, ..., future.stdout = FALSE) ... DONE
* future_mapply(x, ..., future.stdout = TRUE) ...
[13:14:29.336] future_mapply() ...
[13:14:29.339] Number of chunks: 1
[13:14:29.339] getGlobalsAndPackagesXApply() ...
[13:14:29.339]  - future.globals: TRUE
[13:14:29.339] getGlobalsAndPackages() ...
[13:14:29.339] Searching for globals...
[13:14:29.341] - globals found: [6] 'FUN', '{', 'Sys.sleep', '/', 'print', 'list'
[13:14:29.341] Searching for globals ... DONE
[13:14:29.342] Resolving globals: FALSE
[13:14:29.342] The total size of the 1 globals is 6.11 KiB (6256 bytes)
[13:14:29.343] The total size of the 1 globals exported for future expression ('FUN()') is 6.11 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (6.11 KiB of class 'function')
[13:14:29.343] - globals: [1] 'FUN'
[13:14:29.343] 
[13:14:29.343] getGlobalsAndPackages() ... DONE
[13:14:29.343]  - globals found/used: [n=1] 'FUN'
[13:14:29.343]  - needed namespaces: [n=0] 
[13:14:29.344] Finding globals ... DONE
[13:14:29.344] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[13:14:29.344] List of 2
[13:14:29.344]  $ ...future.FUN:function (x, y)  
[13:14:29.344]  $ MoreArgs     : NULL
[13:14:29.344]  - attr(*, "where")=List of 2
[13:14:29.344]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[13:14:29.344]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[13:14:29.344]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[13:14:29.344]  - attr(*, "resolved")= logi FALSE
[13:14:29.344]  - attr(*, "total_size")= num NA
[13:14:29.348] Packages to be attached in all futures: [n=0] 
[13:14:29.348] getGlobalsAndPackagesXApply() ... DONE
[13:14:29.348] Number of futures (= number of chunks): 1
[13:14:29.348] Launching 1 futures (chunks) ...
[13:14:29.349] Chunk #1 of 1 ...
[13:14:29.349]  - Finding globals in '...' for chunk #1 ...
[13:14:29.349] getGlobalsAndPackages() ...
[13:14:29.349] Searching for globals...
[13:14:29.349] 
[13:14:29.350] Searching for globals ... DONE
[13:14:29.350] - globals: [0] <none>
[13:14:29.350] getGlobalsAndPackages() ... DONE
[13:14:29.350]    + additional globals found: [n=0] 
[13:14:29.350]    + additional namespaces needed: [n=0] 
[13:14:29.350]  - Finding globals in '...' for chunk #1 ... DONE
[13:14:29.351]  - seeds: <none>
[13:14:29.351]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:29.351] getGlobalsAndPackages() ...
[13:14:29.351] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:29.351] Resolving globals: FALSE
[13:14:29.352] The total size of the 5 globals is 6.33 KiB (6480 bytes)
[13:14:29.353] The total size of the 5 globals exported for future expression ('{; ...future.globals.maxSize.org <- getOption("future.globals.maxSize"); if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {; oopts <- options(future.globals.maxSize = ...future.globals.maxSize); on.exit(options(oopts), add = TRUE); }; ...; do.call(mapply, args = args); }; }') is 6.33 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (6.11 KiB of class 'function'), '...future.elements_ii' (224 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[13:14:29.353] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:29.353] 
[13:14:29.353] getGlobalsAndPackages() ... DONE
[13:14:29.353] run() for 'Future' ...
[13:14:29.354] - state: 'created'
[13:14:29.354] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[13:14:29.356] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[13:14:29.356] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[13:14:29.357]   - Field: 'label'
[13:14:29.357]   - Field: 'local'
[13:14:29.357]   - Field: 'owner'
[13:14:29.357]   - Field: 'envir'
[13:14:29.357]   - Field: 'packages'
[13:14:29.357]   - Field: 'gc'
[13:14:29.358]   - Field: 'conditions'
[13:14:29.358]   - Field: 'expr'
[13:14:29.358]   - Field: 'uuid'
[13:14:29.358]   - Field: 'seed'
[13:14:29.358]   - Field: 'version'
[13:14:29.358]   - Field: 'result'
[13:14:29.359]   - Field: 'asynchronous'
[13:14:29.359]   - Field: 'calls'
[13:14:29.359]   - Field: 'globals'
[13:14:29.359]   - Field: 'stdout'
[13:14:29.359]   - Field: 'earlySignal'
[13:14:29.359]   - Field: 'lazy'
[13:14:29.360]   - Field: 'state'
[13:14:29.360] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[13:14:29.360] - Launch lazy future ...
[13:14:29.360] Packages needed by the future expression (n = 0): <none>
[13:14:29.360] Packages needed by future strategies (n = 0): <none>
[13:14:29.361] {
[13:14:29.361]     {
[13:14:29.361]         {
[13:14:29.361]             ...future.startTime <- base::Sys.time()
[13:14:29.361]             {
[13:14:29.361]                 {
[13:14:29.361]                   {
[13:14:29.361]                     base::local({
[13:14:29.361]                       has_future <- base::requireNamespace("future", 
[13:14:29.361]                         quietly = TRUE)
[13:14:29.361]                       if (has_future) {
[13:14:29.361]                         ns <- base::getNamespace("future")
[13:14:29.361]                         version <- ns[[".package"]][["version"]]
[13:14:29.361]                         if (is.null(version)) 
[13:14:29.361]                           version <- utils::packageVersion("future")
[13:14:29.361]                       }
[13:14:29.361]                       else {
[13:14:29.361]                         version <- NULL
[13:14:29.361]                       }
[13:14:29.361]                       if (!has_future || version < "1.8.0") {
[13:14:29.361]                         info <- base::c(r_version = base::gsub("R version ", 
[13:14:29.361]                           "", base::R.version$version.string), 
[13:14:29.361]                           platform = base::sprintf("%s (%s-bit)", 
[13:14:29.361]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[13:14:29.361]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[13:14:29.361]                             "release", "version")], collapse = " "), 
[13:14:29.361]                           hostname = base::Sys.info()[["nodename"]])
[13:14:29.361]                         info <- base::sprintf("%s: %s", base::names(info), 
[13:14:29.361]                           info)
[13:14:29.361]                         info <- base::paste(info, collapse = "; ")
[13:14:29.361]                         if (!has_future) {
[13:14:29.361]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[13:14:29.361]                             info)
[13:14:29.361]                         }
[13:14:29.361]                         else {
[13:14:29.361]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[13:14:29.361]                             info, version)
[13:14:29.361]                         }
[13:14:29.361]                         base::stop(msg)
[13:14:29.361]                       }
[13:14:29.361]                     })
[13:14:29.361]                   }
[13:14:29.361]                   options(future.plan = NULL)
[13:14:29.361]                   Sys.unsetenv("R_FUTURE_PLAN")
[13:14:29.361]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[13:14:29.361]                 }
[13:14:29.361]                 ...future.workdir <- getwd()
[13:14:29.361]             }
[13:14:29.361]             ...future.oldOptions <- base::as.list(base::.Options)
[13:14:29.361]             ...future.oldEnvVars <- base::Sys.getenv()
[13:14:29.361]         }
[13:14:29.361]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[13:14:29.361]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[13:14:29.361]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[13:14:29.361]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[13:14:29.361]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[13:14:29.361]             future.stdout.windows.reencode = NULL, width = 80L)
[13:14:29.361]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[13:14:29.361]             base::names(...future.oldOptions))
[13:14:29.361]     }
[13:14:29.361]     if (FALSE) {
[13:14:29.361]     }
[13:14:29.361]     else {
[13:14:29.361]         if (TRUE) {
[13:14:29.361]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[13:14:29.361]                 open = "w")
[13:14:29.361]         }
[13:14:29.361]         else {
[13:14:29.361]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[13:14:29.361]                 windows = "NUL", "/dev/null"), open = "w")
[13:14:29.361]         }
[13:14:29.361]         base::sink(...future.stdout, type = "output", split = FALSE)
[13:14:29.361]         base::on.exit(if (!base::is.null(...future.stdout)) {
[13:14:29.361]             base::sink(type = "output", split = FALSE)
[13:14:29.361]             base::close(...future.stdout)
[13:14:29.361]         }, add = TRUE)
[13:14:29.361]     }
[13:14:29.361]     ...future.frame <- base::sys.nframe()
[13:14:29.361]     ...future.conditions <- base::list()
[13:14:29.361]     ...future.rng <- base::globalenv()$.Random.seed
[13:14:29.361]     if (FALSE) {
[13:14:29.361]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[13:14:29.361]             "...future.value", "...future.globalenv.names", ".Random.seed")
[13:14:29.361]     }
[13:14:29.361]     ...future.result <- base::tryCatch({
[13:14:29.361]         base::withCallingHandlers({
[13:14:29.361]             ...future.value <- base::withVisible(base::local({
[13:14:29.361]                 ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[13:14:29.361]                 if (!identical(...future.globals.maxSize.org, 
[13:14:29.361]                   ...future.globals.maxSize)) {
[13:14:29.361]                   oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[13:14:29.361]                   on.exit(options(oopts), add = TRUE)
[13:14:29.361]                 }
[13:14:29.361]                 {
[13:14:29.361]                   args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[13:14:29.361]                     MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[13:14:29.361]                     USE.NAMES = FALSE)
[13:14:29.361]                   do.call(mapply, args = args)
[13:14:29.361]                 }
[13:14:29.361]             }))
[13:14:29.361]             future::FutureResult(value = ...future.value$value, 
[13:14:29.361]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[13:14:29.361]                   ...future.rng), globalenv = if (FALSE) 
[13:14:29.361]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[13:14:29.361]                     ...future.globalenv.names))
[13:14:29.361]                 else NULL, started = ...future.startTime, version = "1.8")
[13:14:29.361]         }, condition = base::local({
[13:14:29.361]             c <- base::c
[13:14:29.361]             inherits <- base::inherits
[13:14:29.361]             invokeRestart <- base::invokeRestart
[13:14:29.361]             length <- base::length
[13:14:29.361]             list <- base::list
[13:14:29.361]             seq.int <- base::seq.int
[13:14:29.361]             signalCondition <- base::signalCondition
[13:14:29.361]             sys.calls <- base::sys.calls
[13:14:29.361]             `[[` <- base::`[[`
[13:14:29.361]             `+` <- base::`+`
[13:14:29.361]             `<<-` <- base::`<<-`
[13:14:29.361]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[13:14:29.361]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[13:14:29.361]                   3L)]
[13:14:29.361]             }
[13:14:29.361]             function(cond) {
[13:14:29.361]                 is_error <- inherits(cond, "error")
[13:14:29.361]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[13:14:29.361]                   NULL)
[13:14:29.361]                 if (is_error) {
[13:14:29.361]                   sessionInformation <- function() {
[13:14:29.361]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[13:14:29.361]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[13:14:29.361]                       search = base::search(), system = base::Sys.info())
[13:14:29.361]                   }
[13:14:29.361]                   ...future.conditions[[length(...future.conditions) + 
[13:14:29.361]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[13:14:29.361]                     cond$call), session = sessionInformation(), 
[13:14:29.361]                     timestamp = base::Sys.time(), signaled = 0L)
[13:14:29.361]                   signalCondition(cond)
[13:14:29.361]                 }
[13:14:29.361]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[13:14:29.361]                 "immediateCondition"))) {
[13:14:29.361]                   signal <- TRUE && inherits(cond, "immediateCondition")
[13:14:29.361]                   ...future.conditions[[length(...future.conditions) + 
[13:14:29.361]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[13:14:29.361]                   if (TRUE && !signal) {
[13:14:29.361]                     muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:29.361]                     {
[13:14:29.361]                       inherits <- base::inherits
[13:14:29.361]                       invokeRestart <- base::invokeRestart
[13:14:29.361]                       is.null <- base::is.null
[13:14:29.361]                       muffled <- FALSE
[13:14:29.361]                       if (inherits(cond, "message")) {
[13:14:29.361]                         muffled <- grepl(pattern, "muffleMessage")
[13:14:29.361]                         if (muffled) 
[13:14:29.361]                           invokeRestart("muffleMessage")
[13:14:29.361]                       }
[13:14:29.361]                       else if (inherits(cond, "warning")) {
[13:14:29.361]                         muffled <- grepl(pattern, "muffleWarning")
[13:14:29.361]                         if (muffled) 
[13:14:29.361]                           invokeRestart("muffleWarning")
[13:14:29.361]                       }
[13:14:29.361]                       else if (inherits(cond, "condition")) {
[13:14:29.361]                         if (!is.null(pattern)) {
[13:14:29.361]                           computeRestarts <- base::computeRestarts
[13:14:29.361]                           grepl <- base::grepl
[13:14:29.361]                           restarts <- computeRestarts(cond)
[13:14:29.361]                           for (restart in restarts) {
[13:14:29.361]                             name <- restart$name
[13:14:29.361]                             if (is.null(name)) 
[13:14:29.361]                               next
[13:14:29.361]                             if (!grepl(pattern, name)) 
[13:14:29.361]                               next
[13:14:29.361]                             invokeRestart(restart)
[13:14:29.361]                             muffled <- TRUE
[13:14:29.361]                             break
[13:14:29.361]                           }
[13:14:29.361]                         }
[13:14:29.361]                       }
[13:14:29.361]                       invisible(muffled)
[13:14:29.361]                     }
[13:14:29.361]                     muffleCondition(cond, pattern = "^muffle")
[13:14:29.361]                   }
[13:14:29.361]                 }
[13:14:29.361]                 else {
[13:14:29.361]                   if (TRUE) {
[13:14:29.361]                     muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:29.361]                     {
[13:14:29.361]                       inherits <- base::inherits
[13:14:29.361]                       invokeRestart <- base::invokeRestart
[13:14:29.361]                       is.null <- base::is.null
[13:14:29.361]                       muffled <- FALSE
[13:14:29.361]                       if (inherits(cond, "message")) {
[13:14:29.361]                         muffled <- grepl(pattern, "muffleMessage")
[13:14:29.361]                         if (muffled) 
[13:14:29.361]                           invokeRestart("muffleMessage")
[13:14:29.361]                       }
[13:14:29.361]                       else if (inherits(cond, "warning")) {
[13:14:29.361]                         muffled <- grepl(pattern, "muffleWarning")
[13:14:29.361]                         if (muffled) 
[13:14:29.361]                           invokeRestart("muffleWarning")
[13:14:29.361]                       }
[13:14:29.361]                       else if (inherits(cond, "condition")) {
[13:14:29.361]                         if (!is.null(pattern)) {
[13:14:29.361]                           computeRestarts <- base::computeRestarts
[13:14:29.361]                           grepl <- base::grepl
[13:14:29.361]                           restarts <- computeRestarts(cond)
[13:14:29.361]                           for (restart in restarts) {
[13:14:29.361]                             name <- restart$name
[13:14:29.361]                             if (is.null(name)) 
[13:14:29.361]                               next
[13:14:29.361]                             if (!grepl(pattern, name)) 
[13:14:29.361]                               next
[13:14:29.361]                             invokeRestart(restart)
[13:14:29.361]                             muffled <- TRUE
[13:14:29.361]                             break
[13:14:29.361]                           }
[13:14:29.361]                         }
[13:14:29.361]                       }
[13:14:29.361]                       invisible(muffled)
[13:14:29.361]                     }
[13:14:29.361]                     muffleCondition(cond, pattern = "^muffle")
[13:14:29.361]                   }
[13:14:29.361]                 }
[13:14:29.361]             }
[13:14:29.361]         }))
[13:14:29.361]     }, error = function(ex) {
[13:14:29.361]         base::structure(base::list(value = NULL, visible = NULL, 
[13:14:29.361]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[13:14:29.361]                 ...future.rng), started = ...future.startTime, 
[13:14:29.361]             finished = Sys.time(), session_uuid = NA_character_, 
[13:14:29.361]             version = "1.8"), class = "FutureResult")
[13:14:29.361]     }, finally = {
[13:14:29.361]         if (!identical(...future.workdir, getwd())) 
[13:14:29.361]             setwd(...future.workdir)
[13:14:29.361]         {
[13:14:29.361]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[13:14:29.361]                 ...future.oldOptions$nwarnings <- NULL
[13:14:29.361]             }
[13:14:29.361]             base::options(...future.oldOptions)
[13:14:29.361]             if (.Platform$OS.type == "windows") {
[13:14:29.361]                 old_names <- names(...future.oldEnvVars)
[13:14:29.361]                 envs <- base::Sys.getenv()
[13:14:29.361]                 names <- names(envs)
[13:14:29.361]                 common <- intersect(names, old_names)
[13:14:29.361]                 added <- setdiff(names, old_names)
[13:14:29.361]                 removed <- setdiff(old_names, names)
[13:14:29.361]                 changed <- common[...future.oldEnvVars[common] != 
[13:14:29.361]                   envs[common]]
[13:14:29.361]                 NAMES <- toupper(changed)
[13:14:29.361]                 args <- list()
[13:14:29.361]                 for (kk in seq_along(NAMES)) {
[13:14:29.361]                   name <- changed[[kk]]
[13:14:29.361]                   NAME <- NAMES[[kk]]
[13:14:29.361]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:29.361]                     next
[13:14:29.361]                   args[[name]] <- ...future.oldEnvVars[[name]]
[13:14:29.361]                 }
[13:14:29.361]                 NAMES <- toupper(added)
[13:14:29.361]                 for (kk in seq_along(NAMES)) {
[13:14:29.361]                   name <- added[[kk]]
[13:14:29.361]                   NAME <- NAMES[[kk]]
[13:14:29.361]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:29.361]                     next
[13:14:29.361]                   args[[name]] <- ""
[13:14:29.361]                 }
[13:14:29.361]                 NAMES <- toupper(removed)
[13:14:29.361]                 for (kk in seq_along(NAMES)) {
[13:14:29.361]                   name <- removed[[kk]]
[13:14:29.361]                   NAME <- NAMES[[kk]]
[13:14:29.361]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:29.361]                     next
[13:14:29.361]                   args[[name]] <- ...future.oldEnvVars[[name]]
[13:14:29.361]                 }
[13:14:29.361]                 if (length(args) > 0) 
[13:14:29.361]                   base::do.call(base::Sys.setenv, args = args)
[13:14:29.361]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[13:14:29.361]             }
[13:14:29.361]             else {
[13:14:29.361]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[13:14:29.361]             }
[13:14:29.361]             {
[13:14:29.361]                 if (base::length(...future.futureOptionsAdded) > 
[13:14:29.361]                   0L) {
[13:14:29.361]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[13:14:29.361]                   base::names(opts) <- ...future.futureOptionsAdded
[13:14:29.361]                   base::options(opts)
[13:14:29.361]                 }
[13:14:29.361]                 {
[13:14:29.361]                   {
[13:14:29.361]                     NULL
[13:14:29.361]                     RNGkind("Mersenne-Twister")
[13:14:29.361]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[13:14:29.361]                       inherits = FALSE)
[13:14:29.361]                   }
[13:14:29.361]                   options(future.plan = NULL)
[13:14:29.361]                   if (is.na(NA_character_)) 
[13:14:29.361]                     Sys.unsetenv("R_FUTURE_PLAN")
[13:14:29.361]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[13:14:29.361]                   future::plan(list(function (..., workers = availableCores(), 
[13:14:29.361]                     lazy = FALSE, rscript_libs = .libPaths(), 
[13:14:29.361]                     envir = parent.frame()) 
[13:14:29.361]                   {
[13:14:29.361]                     if (is.function(workers)) 
[13:14:29.361]                       workers <- workers()
[13:14:29.361]                     workers <- structure(as.integer(workers), 
[13:14:29.361]                       class = class(workers))
[13:14:29.361]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[13:14:29.361]                       workers >= 1)
[13:14:29.361]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[13:14:29.361]                       return(sequential(..., lazy = TRUE, envir = envir))
[13:14:29.361]                     }
[13:14:29.361]                     future <- MultisessionFuture(..., workers = workers, 
[13:14:29.361]                       lazy = lazy, rscript_libs = rscript_libs, 
[13:14:29.361]                       envir = envir)
[13:14:29.361]                     if (!future$lazy) 
[13:14:29.361]                       future <- run(future)
[13:14:29.361]                     invisible(future)
[13:14:29.361]                   }), .cleanup = FALSE, .init = FALSE)
[13:14:29.361]                 }
[13:14:29.361]             }
[13:14:29.361]         }
[13:14:29.361]     })
[13:14:29.361]     if (TRUE) {
[13:14:29.361]         base::sink(type = "output", split = FALSE)
[13:14:29.361]         if (TRUE) {
[13:14:29.361]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[13:14:29.361]         }
[13:14:29.361]         else {
[13:14:29.361]             ...future.result["stdout"] <- base::list(NULL)
[13:14:29.361]         }
[13:14:29.361]         base::close(...future.stdout)
[13:14:29.361]         ...future.stdout <- NULL
[13:14:29.361]     }
[13:14:29.361]     ...future.result$conditions <- ...future.conditions
[13:14:29.361]     ...future.result$finished <- base::Sys.time()
[13:14:29.361]     ...future.result
[13:14:29.361] }
[13:14:29.365] assign_globals() ...
[13:14:29.365] List of 5
[13:14:29.365]  $ ...future.FUN            :function (x, y)  
[13:14:29.365]  $ MoreArgs                 : NULL
[13:14:29.365]  $ ...future.elements_ii    :List of 2
[13:14:29.365]   ..$ :List of 2
[13:14:29.365]   .. ..$ : int 1
[13:14:29.365]   .. ..$ : int 0
[13:14:29.365]   ..$ :List of 2
[13:14:29.365]   .. ..$ : int 0
[13:14:29.365]   .. ..$ : int 1
[13:14:29.365]  $ ...future.seeds_ii       : NULL
[13:14:29.365]  $ ...future.globals.maxSize: NULL
[13:14:29.365]  - attr(*, "where")=List of 5
[13:14:29.365]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[13:14:29.365]   ..$ MoreArgs                 :<environment: R_EmptyEnv> 
[13:14:29.365]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[13:14:29.365]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[13:14:29.365]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[13:14:29.365]  - attr(*, "resolved")= logi FALSE
[13:14:29.365]  - attr(*, "total_size")= num 6480
[13:14:29.365]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[13:14:29.365]  - attr(*, "already-done")= logi TRUE
[13:14:29.372] - reassign environment for '...future.FUN'
[13:14:29.372] - copied '...future.FUN' to environment
[13:14:29.372] - copied 'MoreArgs' to environment
[13:14:29.372] - copied '...future.elements_ii' to environment
[13:14:29.372] - copied '...future.seeds_ii' to environment
[13:14:29.373] - copied '...future.globals.maxSize' to environment
[13:14:29.373] assign_globals() ... done
[13:14:29.373] plan(): Setting new future strategy stack:
[13:14:29.373] List of future strategies:
[13:14:29.373] 1. sequential:
[13:14:29.373]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[13:14:29.373]    - tweaked: FALSE
[13:14:29.373]    - call: NULL
[13:14:29.374] plan(): nbrOfWorkers() = 1
[13:14:29.882] plan(): Setting new future strategy stack:
[13:14:29.882] List of future strategies:
[13:14:29.882] 1. multisession:
[13:14:29.882]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[13:14:29.882]    - tweaked: FALSE
[13:14:29.882]    - call: plan(strategy)
[13:14:29.885] plan(): nbrOfWorkers() = 1
[13:14:29.885] SequentialFuture started (and completed)
[13:14:29.885] - Launch lazy future ... done
[13:14:29.885] run() for 'SequentialFuture' ... done
[13:14:29.886] Created future:
[13:14:29.886] SequentialFuture:
[13:14:29.886] Label: 'future_mapply-1'
[13:14:29.886] Expression:
[13:14:29.886] {
[13:14:29.886]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[13:14:29.886]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[13:14:29.886]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[13:14:29.886]         on.exit(options(oopts), add = TRUE)
[13:14:29.886]     }
[13:14:29.886]     {
[13:14:29.886]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[13:14:29.886]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[13:14:29.886]         do.call(mapply, args = args)
[13:14:29.886]     }
[13:14:29.886] }
[13:14:29.886] Lazy evaluation: FALSE
[13:14:29.886] Asynchronous evaluation: FALSE
[13:14:29.886] Local evaluation: TRUE
[13:14:29.886] Environment: R_GlobalEnv
[13:14:29.886] Capture standard output: TRUE
[13:14:29.886] Capture condition classes: 'condition' (excluding 'nothing')
[13:14:29.886] Globals: 5 objects totaling 6.33 KiB (function '...future.FUN' of 6.11 KiB, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 224 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[13:14:29.886] Packages: <none>
[13:14:29.886] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[13:14:29.886] Resolved: TRUE
[13:14:29.886] Value: 224 bytes of class 'list'
[13:14:29.886] Early signaling: FALSE
[13:14:29.886] Owner process: 68097d82-3b31-293d-2920-9b7259f27083
[13:14:29.886] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[13:14:29.887] Chunk #1 of 1 ... DONE
[13:14:29.888] Launching 1 futures (chunks) ... DONE
[13:14:29.888] Resolving 1 futures (chunks) ...
[13:14:29.888] resolve() on list ...
[13:14:29.888]  recursive: 0
[13:14:29.888]  length: 1
[13:14:29.889] 
[13:14:29.889] resolved() for 'SequentialFuture' ...
[13:14:29.889] - state: 'finished'
[13:14:29.889] - run: TRUE
[13:14:29.889] - result: 'FutureResult'
[13:14:29.890] resolved() for 'SequentialFuture' ... done
[13:14:29.890] Future #1
[13:14:29.890] signalConditionsASAP(SequentialFuture, pos=1) ...
[13:14:29.890] - nx: 1
[13:14:29.890] - relay: TRUE
[13:14:29.890] - stdout: TRUE
[13:14:29.891] - signal: TRUE
[13:14:29.891] - resignal: FALSE
[13:14:29.891] - force: TRUE
[13:14:29.891] - relayed: [n=1] FALSE
[13:14:29.891] - queued futures: [n=1] FALSE
[13:14:29.891]  - until=1
[13:14:29.891]  - relaying element #1
[13:14:29.892] - relayed: [n=1] TRUE
[13:14:29.892] - queued futures: [n=1] TRUE
[13:14:29.892] signalConditionsASAP(SequentialFuture, pos=1) ... done
[13:14:29.892]  length: 0 (resolved future 1)
[13:14:29.892] Relaying remaining futures
[13:14:29.893] signalConditionsASAP(NULL, pos=0) ...
[13:14:29.893] - nx: 1
[13:14:29.893] - relay: TRUE
[13:14:29.893] - stdout: TRUE
[13:14:29.893] - signal: TRUE
[13:14:29.893] - resignal: FALSE
[13:14:29.893] - force: TRUE
[13:14:29.894] - relayed: [n=1] TRUE
[13:14:29.894] - queued futures: [n=1] TRUE
 - flush all
[13:14:29.894] - relayed: [n=1] TRUE
[13:14:29.894] - queued futures: [n=1] TRUE
[13:14:29.894] signalConditionsASAP(NULL, pos=0) ... done
[13:14:29.894] resolve() on list ... DONE
[13:14:29.895]  - Number of value chunks collected: 1
[13:14:29.895] Resolving 1 futures (chunks) ... DONE
[13:14:29.895] Reducing values from 1 chunks ...
[13:14:29.895]  - Number of values collected after concatenation: 2
[13:14:29.895]  - Number of values expected: 2
[13:14:29.895] Reducing values from 1 chunks ... DONE
[13:14:29.896] future_mapply() ... DONE
* future_mapply(x, ..., future.stdout = TRUE) ... DONE
* future_mapply(x, ..., future.stdout = NA) ...
[13:14:29.896] future_mapply() ...
[13:14:29.898] Number of chunks: 1
[13:14:29.898] getGlobalsAndPackagesXApply() ...
[13:14:29.899]  - future.globals: TRUE
[13:14:29.899] getGlobalsAndPackages() ...
[13:14:29.899] Searching for globals...
[13:14:29.901] - globals found: [6] 'FUN', '{', 'Sys.sleep', '/', 'print', 'list'
[13:14:29.901] Searching for globals ... DONE
[13:14:29.901] Resolving globals: FALSE
[13:14:29.902] The total size of the 1 globals is 6.11 KiB (6256 bytes)
[13:14:29.902] The total size of the 1 globals exported for future expression ('FUN()') is 6.11 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (6.11 KiB of class 'function')
[13:14:29.902] - globals: [1] 'FUN'
[13:14:29.902] 
[13:14:29.903] getGlobalsAndPackages() ... DONE
[13:14:29.903]  - globals found/used: [n=1] 'FUN'
[13:14:29.903]  - needed namespaces: [n=0] 
[13:14:29.903] Finding globals ... DONE
[13:14:29.903] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[13:14:29.904] List of 2
[13:14:29.904]  $ ...future.FUN:function (x, y)  
[13:14:29.904]  $ MoreArgs     : NULL
[13:14:29.904]  - attr(*, "where")=List of 2
[13:14:29.904]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[13:14:29.904]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[13:14:29.904]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[13:14:29.904]  - attr(*, "resolved")= logi FALSE
[13:14:29.904]  - attr(*, "total_size")= num NA
[13:14:29.906] Packages to be attached in all futures: [n=0] 
[13:14:29.907] getGlobalsAndPackagesXApply() ... DONE
[13:14:29.907] Number of futures (= number of chunks): 1
[13:14:29.907] Launching 1 futures (chunks) ...
[13:14:29.907] Chunk #1 of 1 ...
[13:14:29.907]  - Finding globals in '...' for chunk #1 ...
[13:14:29.908] getGlobalsAndPackages() ...
[13:14:29.908] Searching for globals...
[13:14:29.908] 
[13:14:29.908] Searching for globals ... DONE
[13:14:29.908] - globals: [0] <none>
[13:14:29.909] getGlobalsAndPackages() ... DONE
[13:14:29.909]    + additional globals found: [n=0] 
[13:14:29.909]    + additional namespaces needed: [n=0] 
[13:14:29.909]  - Finding globals in '...' for chunk #1 ... DONE
[13:14:29.909]  - seeds: <none>
[13:14:29.909]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:29.910] getGlobalsAndPackages() ...
[13:14:29.910] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:29.910] Resolving globals: FALSE
[13:14:29.910] The total size of the 5 globals is 6.33 KiB (6480 bytes)
[13:14:29.911] The total size of the 5 globals exported for future expression ('{; ...future.globals.maxSize.org <- getOption("future.globals.maxSize"); if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {; oopts <- options(future.globals.maxSize = ...future.globals.maxSize); on.exit(options(oopts), add = TRUE); }; ...; do.call(mapply, args = args); }; }') is 6.33 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (6.11 KiB of class 'function'), '...future.elements_ii' (224 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[13:14:29.911] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:29.911] 
[13:14:29.912] getGlobalsAndPackages() ... DONE
[13:14:29.912] run() for 'Future' ...
[13:14:29.912] - state: 'created'
[13:14:29.912] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[13:14:29.915] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[13:14:29.915] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[13:14:29.915]   - Field: 'label'
[13:14:29.915]   - Field: 'local'
[13:14:29.915]   - Field: 'owner'
[13:14:29.916]   - Field: 'envir'
[13:14:29.916]   - Field: 'packages'
[13:14:29.916]   - Field: 'gc'
[13:14:29.916]   - Field: 'conditions'
[13:14:29.916]   - Field: 'expr'
[13:14:29.916]   - Field: 'uuid'
[13:14:29.917]   - Field: 'seed'
[13:14:29.917]   - Field: 'version'
[13:14:29.917]   - Field: 'result'
[13:14:29.918]   - Field: 'asynchronous'
[13:14:29.918]   - Field: 'calls'
[13:14:29.918]   - Field: 'globals'
[13:14:29.918]   - Field: 'stdout'
[13:14:29.919]   - Field: 'earlySignal'
[13:14:29.919]   - Field: 'lazy'
[13:14:29.919]   - Field: 'state'
[13:14:29.919] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[13:14:29.919] - Launch lazy future ...
[13:14:29.920] Packages needed by the future expression (n = 0): <none>
[13:14:29.920] Packages needed by future strategies (n = 0): <none>
[13:14:29.920] {
[13:14:29.920]     {
[13:14:29.920]         {
[13:14:29.920]             ...future.startTime <- base::Sys.time()
[13:14:29.920]             {
[13:14:29.920]                 {
[13:14:29.920]                   {
[13:14:29.920]                     base::local({
[13:14:29.920]                       has_future <- base::requireNamespace("future", 
[13:14:29.920]                         quietly = TRUE)
[13:14:29.920]                       if (has_future) {
[13:14:29.920]                         ns <- base::getNamespace("future")
[13:14:29.920]                         version <- ns[[".package"]][["version"]]
[13:14:29.920]                         if (is.null(version)) 
[13:14:29.920]                           version <- utils::packageVersion("future")
[13:14:29.920]                       }
[13:14:29.920]                       else {
[13:14:29.920]                         version <- NULL
[13:14:29.920]                       }
[13:14:29.920]                       if (!has_future || version < "1.8.0") {
[13:14:29.920]                         info <- base::c(r_version = base::gsub("R version ", 
[13:14:29.920]                           "", base::R.version$version.string), 
[13:14:29.920]                           platform = base::sprintf("%s (%s-bit)", 
[13:14:29.920]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[13:14:29.920]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[13:14:29.920]                             "release", "version")], collapse = " "), 
[13:14:29.920]                           hostname = base::Sys.info()[["nodename"]])
[13:14:29.920]                         info <- base::sprintf("%s: %s", base::names(info), 
[13:14:29.920]                           info)
[13:14:29.920]                         info <- base::paste(info, collapse = "; ")
[13:14:29.920]                         if (!has_future) {
[13:14:29.920]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[13:14:29.920]                             info)
[13:14:29.920]                         }
[13:14:29.920]                         else {
[13:14:29.920]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[13:14:29.920]                             info, version)
[13:14:29.920]                         }
[13:14:29.920]                         base::stop(msg)
[13:14:29.920]                       }
[13:14:29.920]                     })
[13:14:29.920]                   }
[13:14:29.920]                   options(future.plan = NULL)
[13:14:29.920]                   Sys.unsetenv("R_FUTURE_PLAN")
[13:14:29.920]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[13:14:29.920]                 }
[13:14:29.920]                 ...future.workdir <- getwd()
[13:14:29.920]             }
[13:14:29.920]             ...future.oldOptions <- base::as.list(base::.Options)
[13:14:29.920]             ...future.oldEnvVars <- base::Sys.getenv()
[13:14:29.920]         }
[13:14:29.920]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[13:14:29.920]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[13:14:29.920]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[13:14:29.920]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[13:14:29.920]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[13:14:29.920]             future.stdout.windows.reencode = NULL, width = 80L)
[13:14:29.920]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[13:14:29.920]             base::names(...future.oldOptions))
[13:14:29.920]     }
[13:14:29.920]     if (TRUE) {
[13:14:29.920]     }
[13:14:29.920]     else {
[13:14:29.920]         if (NA) {
[13:14:29.920]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[13:14:29.920]                 open = "w")
[13:14:29.920]         }
[13:14:29.920]         else {
[13:14:29.920]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[13:14:29.920]                 windows = "NUL", "/dev/null"), open = "w")
[13:14:29.920]         }
[13:14:29.920]         base::sink(...future.stdout, type = "output", split = FALSE)
[13:14:29.920]         base::on.exit(if (!base::is.null(...future.stdout)) {
[13:14:29.920]             base::sink(type = "output", split = FALSE)
[13:14:29.920]             base::close(...future.stdout)
[13:14:29.920]         }, add = TRUE)
[13:14:29.920]     }
[13:14:29.920]     ...future.frame <- base::sys.nframe()
[13:14:29.920]     ...future.conditions <- base::list()
[13:14:29.920]     ...future.rng <- base::globalenv()$.Random.seed
[13:14:29.920]     if (FALSE) {
[13:14:29.920]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[13:14:29.920]             "...future.value", "...future.globalenv.names", ".Random.seed")
[13:14:29.920]     }
[13:14:29.920]     ...future.result <- base::tryCatch({
[13:14:29.920]         base::withCallingHandlers({
[13:14:29.920]             ...future.value <- base::withVisible(base::local({
[13:14:29.920]                 ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[13:14:29.920]                 if (!identical(...future.globals.maxSize.org, 
[13:14:29.920]                   ...future.globals.maxSize)) {
[13:14:29.920]                   oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[13:14:29.920]                   on.exit(options(oopts), add = TRUE)
[13:14:29.920]                 }
[13:14:29.920]                 {
[13:14:29.920]                   args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[13:14:29.920]                     MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[13:14:29.920]                     USE.NAMES = FALSE)
[13:14:29.920]                   do.call(mapply, args = args)
[13:14:29.920]                 }
[13:14:29.920]             }))
[13:14:29.920]             future::FutureResult(value = ...future.value$value, 
[13:14:29.920]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[13:14:29.920]                   ...future.rng), globalenv = if (FALSE) 
[13:14:29.920]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[13:14:29.920]                     ...future.globalenv.names))
[13:14:29.920]                 else NULL, started = ...future.startTime, version = "1.8")
[13:14:29.920]         }, condition = base::local({
[13:14:29.920]             c <- base::c
[13:14:29.920]             inherits <- base::inherits
[13:14:29.920]             invokeRestart <- base::invokeRestart
[13:14:29.920]             length <- base::length
[13:14:29.920]             list <- base::list
[13:14:29.920]             seq.int <- base::seq.int
[13:14:29.920]             signalCondition <- base::signalCondition
[13:14:29.920]             sys.calls <- base::sys.calls
[13:14:29.920]             `[[` <- base::`[[`
[13:14:29.920]             `+` <- base::`+`
[13:14:29.920]             `<<-` <- base::`<<-`
[13:14:29.920]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[13:14:29.920]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[13:14:29.920]                   3L)]
[13:14:29.920]             }
[13:14:29.920]             function(cond) {
[13:14:29.920]                 is_error <- inherits(cond, "error")
[13:14:29.920]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[13:14:29.920]                   NULL)
[13:14:29.920]                 if (is_error) {
[13:14:29.920]                   sessionInformation <- function() {
[13:14:29.920]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[13:14:29.920]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[13:14:29.920]                       search = base::search(), system = base::Sys.info())
[13:14:29.920]                   }
[13:14:29.920]                   ...future.conditions[[length(...future.conditions) + 
[13:14:29.920]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[13:14:29.920]                     cond$call), session = sessionInformation(), 
[13:14:29.920]                     timestamp = base::Sys.time(), signaled = 0L)
[13:14:29.920]                   signalCondition(cond)
[13:14:29.920]                 }
[13:14:29.920]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[13:14:29.920]                 "immediateCondition"))) {
[13:14:29.920]                   signal <- TRUE && inherits(cond, "immediateCondition")
[13:14:29.920]                   ...future.conditions[[length(...future.conditions) + 
[13:14:29.920]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[13:14:29.920]                   if (TRUE && !signal) {
[13:14:29.920]                     muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:29.920]                     {
[13:14:29.920]                       inherits <- base::inherits
[13:14:29.920]                       invokeRestart <- base::invokeRestart
[13:14:29.920]                       is.null <- base::is.null
[13:14:29.920]                       muffled <- FALSE
[13:14:29.920]                       if (inherits(cond, "message")) {
[13:14:29.920]                         muffled <- grepl(pattern, "muffleMessage")
[13:14:29.920]                         if (muffled) 
[13:14:29.920]                           invokeRestart("muffleMessage")
[13:14:29.920]                       }
[13:14:29.920]                       else if (inherits(cond, "warning")) {
[13:14:29.920]                         muffled <- grepl(pattern, "muffleWarning")
[13:14:29.920]                         if (muffled) 
[13:14:29.920]                           invokeRestart("muffleWarning")
[13:14:29.920]                       }
[13:14:29.920]                       else if (inherits(cond, "condition")) {
[13:14:29.920]                         if (!is.null(pattern)) {
[13:14:29.920]                           computeRestarts <- base::computeRestarts
[13:14:29.920]                           grepl <- base::grepl
[13:14:29.920]                           restarts <- computeRestarts(cond)
[13:14:29.920]                           for (restart in restarts) {
[13:14:29.920]                             name <- restart$name
[13:14:29.920]                             if (is.null(name)) 
[13:14:29.920]                               next
[13:14:29.920]                             if (!grepl(pattern, name)) 
[13:14:29.920]                               next
[13:14:29.920]                             invokeRestart(restart)
[13:14:29.920]                             muffled <- TRUE
[13:14:29.920]                             break
[13:14:29.920]                           }
[13:14:29.920]                         }
[13:14:29.920]                       }
[13:14:29.920]                       invisible(muffled)
[13:14:29.920]                     }
[13:14:29.920]                     muffleCondition(cond, pattern = "^muffle")
[13:14:29.920]                   }
[13:14:29.920]                 }
[13:14:29.920]                 else {
[13:14:29.920]                   if (TRUE) {
[13:14:29.920]                     muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:29.920]                     {
[13:14:29.920]                       inherits <- base::inherits
[13:14:29.920]                       invokeRestart <- base::invokeRestart
[13:14:29.920]                       is.null <- base::is.null
[13:14:29.920]                       muffled <- FALSE
[13:14:29.920]                       if (inherits(cond, "message")) {
[13:14:29.920]                         muffled <- grepl(pattern, "muffleMessage")
[13:14:29.920]                         if (muffled) 
[13:14:29.920]                           invokeRestart("muffleMessage")
[13:14:29.920]                       }
[13:14:29.920]                       else if (inherits(cond, "warning")) {
[13:14:29.920]                         muffled <- grepl(pattern, "muffleWarning")
[13:14:29.920]                         if (muffled) 
[13:14:29.920]                           invokeRestart("muffleWarning")
[13:14:29.920]                       }
[13:14:29.920]                       else if (inherits(cond, "condition")) {
[13:14:29.920]                         if (!is.null(pattern)) {
[13:14:29.920]                           computeRestarts <- base::computeRestarts
[13:14:29.920]                           grepl <- base::grepl
[13:14:29.920]                           restarts <- computeRestarts(cond)
[13:14:29.920]                           for (restart in restarts) {
[13:14:29.920]                             name <- restart$name
[13:14:29.920]                             if (is.null(name)) 
[13:14:29.920]                               next
[13:14:29.920]                             if (!grepl(pattern, name)) 
[13:14:29.920]                               next
[13:14:29.920]                             invokeRestart(restart)
[13:14:29.920]                             muffled <- TRUE
[13:14:29.920]                             break
[13:14:29.920]                           }
[13:14:29.920]                         }
[13:14:29.920]                       }
[13:14:29.920]                       invisible(muffled)
[13:14:29.920]                     }
[13:14:29.920]                     muffleCondition(cond, pattern = "^muffle")
[13:14:29.920]                   }
[13:14:29.920]                 }
[13:14:29.920]             }
[13:14:29.920]         }))
[13:14:29.920]     }, error = function(ex) {
[13:14:29.920]         base::structure(base::list(value = NULL, visible = NULL, 
[13:14:29.920]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[13:14:29.920]                 ...future.rng), started = ...future.startTime, 
[13:14:29.920]             finished = Sys.time(), session_uuid = NA_character_, 
[13:14:29.920]             version = "1.8"), class = "FutureResult")
[13:14:29.920]     }, finally = {
[13:14:29.920]         if (!identical(...future.workdir, getwd())) 
[13:14:29.920]             setwd(...future.workdir)
[13:14:29.920]         {
[13:14:29.920]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[13:14:29.920]                 ...future.oldOptions$nwarnings <- NULL
[13:14:29.920]             }
[13:14:29.920]             base::options(...future.oldOptions)
[13:14:29.920]             if (.Platform$OS.type == "windows") {
[13:14:29.920]                 old_names <- names(...future.oldEnvVars)
[13:14:29.920]                 envs <- base::Sys.getenv()
[13:14:29.920]                 names <- names(envs)
[13:14:29.920]                 common <- intersect(names, old_names)
[13:14:29.920]                 added <- setdiff(names, old_names)
[13:14:29.920]                 removed <- setdiff(old_names, names)
[13:14:29.920]                 changed <- common[...future.oldEnvVars[common] != 
[13:14:29.920]                   envs[common]]
[13:14:29.920]                 NAMES <- toupper(changed)
[13:14:29.920]                 args <- list()
[13:14:29.920]                 for (kk in seq_along(NAMES)) {
[13:14:29.920]                   name <- changed[[kk]]
[13:14:29.920]                   NAME <- NAMES[[kk]]
[13:14:29.920]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:29.920]                     next
[13:14:29.920]                   args[[name]] <- ...future.oldEnvVars[[name]]
[13:14:29.920]                 }
[13:14:29.920]                 NAMES <- toupper(added)
[13:14:29.920]                 for (kk in seq_along(NAMES)) {
[13:14:29.920]                   name <- added[[kk]]
[13:14:29.920]                   NAME <- NAMES[[kk]]
[13:14:29.920]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:29.920]                     next
[13:14:29.920]                   args[[name]] <- ""
[13:14:29.920]                 }
[13:14:29.920]                 NAMES <- toupper(removed)
[13:14:29.920]                 for (kk in seq_along(NAMES)) {
[13:14:29.920]                   name <- removed[[kk]]
[13:14:29.920]                   NAME <- NAMES[[kk]]
[13:14:29.920]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:29.920]                     next
[13:14:29.920]                   args[[name]] <- ...future.oldEnvVars[[name]]
[13:14:29.920]                 }
[13:14:29.920]                 if (length(args) > 0) 
[13:14:29.920]                   base::do.call(base::Sys.setenv, args = args)
[13:14:29.920]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[13:14:29.920]             }
[13:14:29.920]             else {
[13:14:29.920]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[13:14:29.920]             }
[13:14:29.920]             {
[13:14:29.920]                 if (base::length(...future.futureOptionsAdded) > 
[13:14:29.920]                   0L) {
[13:14:29.920]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[13:14:29.920]                   base::names(opts) <- ...future.futureOptionsAdded
[13:14:29.920]                   base::options(opts)
[13:14:29.920]                 }
[13:14:29.920]                 {
[13:14:29.920]                   {
[13:14:29.920]                     NULL
[13:14:29.920]                     RNGkind("Mersenne-Twister")
[13:14:29.920]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[13:14:29.920]                       inherits = FALSE)
[13:14:29.920]                   }
[13:14:29.920]                   options(future.plan = NULL)
[13:14:29.920]                   if (is.na(NA_character_)) 
[13:14:29.920]                     Sys.unsetenv("R_FUTURE_PLAN")
[13:14:29.920]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[13:14:29.920]                   future::plan(list(function (..., workers = availableCores(), 
[13:14:29.920]                     lazy = FALSE, rscript_libs = .libPaths(), 
[13:14:29.920]                     envir = parent.frame()) 
[13:14:29.920]                   {
[13:14:29.920]                     if (is.function(workers)) 
[13:14:29.920]                       workers <- workers()
[13:14:29.920]                     workers <- structure(as.integer(workers), 
[13:14:29.920]                       class = class(workers))
[13:14:29.920]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[13:14:29.920]                       workers >= 1)
[13:14:29.920]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[13:14:29.920]                       return(sequential(..., lazy = TRUE, envir = envir))
[13:14:29.920]                     }
[13:14:29.920]                     future <- MultisessionFuture(..., workers = workers, 
[13:14:29.920]                       lazy = lazy, rscript_libs = rscript_libs, 
[13:14:29.920]                       envir = envir)
[13:14:29.920]                     if (!future$lazy) 
[13:14:29.920]                       future <- run(future)
[13:14:29.920]                     invisible(future)
[13:14:29.920]                   }), .cleanup = FALSE, .init = FALSE)
[13:14:29.920]                 }
[13:14:29.920]             }
[13:14:29.920]         }
[13:14:29.920]     })
[13:14:29.920]     if (FALSE) {
[13:14:29.920]         base::sink(type = "output", split = FALSE)
[13:14:29.920]         if (NA) {
[13:14:29.920]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[13:14:29.920]         }
[13:14:29.920]         else {
[13:14:29.920]             ...future.result["stdout"] <- base::list(NULL)
[13:14:29.920]         }
[13:14:29.920]         base::close(...future.stdout)
[13:14:29.920]         ...future.stdout <- NULL
[13:14:29.920]     }
[13:14:29.920]     ...future.result$conditions <- ...future.conditions
[13:14:29.920]     ...future.result$finished <- base::Sys.time()
[13:14:29.920]     ...future.result
[13:14:29.920] }
[13:14:29.924] assign_globals() ...
[13:14:29.924] List of 5
[13:14:29.924]  $ ...future.FUN            :function (x, y)  
[13:14:29.924]  $ MoreArgs                 : NULL
[13:14:29.924]  $ ...future.elements_ii    :List of 2
[13:14:29.924]   ..$ :List of 2
[13:14:29.924]   .. ..$ : int 1
[13:14:29.924]   .. ..$ : int 0
[13:14:29.924]   ..$ :List of 2
[13:14:29.924]   .. ..$ : int 0
[13:14:29.924]   .. ..$ : int 1
[13:14:29.924]  $ ...future.seeds_ii       : NULL
[13:14:29.924]  $ ...future.globals.maxSize: NULL
[13:14:29.924]  - attr(*, "where")=List of 5
[13:14:29.924]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[13:14:29.924]   ..$ MoreArgs                 :<environment: R_EmptyEnv> 
[13:14:29.924]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[13:14:29.924]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[13:14:29.924]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[13:14:29.924]  - attr(*, "resolved")= logi FALSE
[13:14:29.924]  - attr(*, "total_size")= num 6480
[13:14:29.924]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[13:14:29.924]  - attr(*, "already-done")= logi TRUE
[13:14:29.931] - reassign environment for '...future.FUN'
[13:14:29.931] - copied '...future.FUN' to environment
[13:14:29.932] - copied 'MoreArgs' to environment
[13:14:29.932] - copied '...future.elements_ii' to environment
[13:14:29.932] - copied '...future.seeds_ii' to environment
[13:14:29.932] - copied '...future.globals.maxSize' to environment
[13:14:29.932] assign_globals() ... done
[13:14:29.933] plan(): Setting new future strategy stack:
[13:14:29.933] List of future strategies:
[13:14:29.933] 1. sequential:
[13:14:29.933]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[13:14:29.933]    - tweaked: FALSE
[13:14:29.933]    - call: NULL
[13:14:29.933] plan(): nbrOfWorkers() = 1
[13:14:30.444] plan(): Setting new future strategy stack:
[13:14:30.445] List of future strategies:
[13:14:30.445] 1. multisession:
[13:14:30.445]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[13:14:30.445]    - tweaked: FALSE
[13:14:30.445]    - call: plan(strategy)
[13:14:30.447] plan(): nbrOfWorkers() = 1
[13:14:30.447] SequentialFuture started (and completed)
[13:14:30.447] - Launch lazy future ... done
[13:14:30.448] run() for 'SequentialFuture' ... done
[13:14:30.448] Created future:
[13:14:30.448] SequentialFuture:
[13:14:30.448] Label: 'future_mapply-1'
[13:14:30.448] Expression:
[13:14:30.448] {
[13:14:30.448]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[13:14:30.448]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[13:14:30.448]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[13:14:30.448]         on.exit(options(oopts), add = TRUE)
[13:14:30.448]     }
[13:14:30.448]     {
[13:14:30.448]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[13:14:30.448]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[13:14:30.448]         do.call(mapply, args = args)
[13:14:30.448]     }
[13:14:30.448] }
[13:14:30.448] Lazy evaluation: FALSE
[13:14:30.448] Asynchronous evaluation: FALSE
[13:14:30.448] Local evaluation: TRUE
[13:14:30.448] Environment: R_GlobalEnv
[13:14:30.448] Capture standard output: NA
[13:14:30.448] Capture condition classes: 'condition' (excluding 'nothing')
[13:14:30.448] Globals: 5 objects totaling 6.33 KiB (function '...future.FUN' of 6.11 KiB, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 224 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[13:14:30.448] Packages: <none>
[13:14:30.448] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[13:14:30.448] Resolved: TRUE
[13:14:30.448] Value: 224 bytes of class 'list'
[13:14:30.448] Early signaling: FALSE
[13:14:30.448] Owner process: 68097d82-3b31-293d-2920-9b7259f27083
[13:14:30.448] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[13:14:30.449] Chunk #1 of 1 ... DONE
[13:14:30.449] Launching 1 futures (chunks) ... DONE
[13:14:30.450] Resolving 1 futures (chunks) ...
[13:14:30.450] resolve() on list ...
[13:14:30.450]  recursive: 0
[13:14:30.450]  length: 1
[13:14:30.450] 
[13:14:30.450] resolved() for 'SequentialFuture' ...
[13:14:30.451] - state: 'finished'
[13:14:30.451] - run: TRUE
[13:14:30.451] - result: 'FutureResult'
[13:14:30.451] resolved() for 'SequentialFuture' ... done
[13:14:30.451] Future #1
[13:14:30.451] signalConditionsASAP(SequentialFuture, pos=1) ...
[13:14:30.452] - nx: 1
[13:14:30.452] - relay: TRUE
[13:14:30.452] - stdout: TRUE
[13:14:30.452] - signal: TRUE
[13:14:30.452] - resignal: FALSE
[13:14:30.452] - force: TRUE
[13:14:30.453] - relayed: [n=1] FALSE
[13:14:30.453] - queued futures: [n=1] FALSE
[13:14:30.453]  - until=1
[13:14:30.453]  - relaying element #1
[13:14:30.453] - relayed: [n=1] TRUE
[13:14:30.453] - queued futures: [n=1] TRUE
[13:14:30.454] signalConditionsASAP(SequentialFuture, pos=1) ... done
[13:14:30.454]  length: 0 (resolved future 1)
[13:14:30.454] Relaying remaining futures
[13:14:30.454] signalConditionsASAP(NULL, pos=0) ...
[13:14:30.454] - nx: 1
[13:14:30.454] - relay: TRUE
[13:14:30.455] - stdout: TRUE
[13:14:30.455] - signal: TRUE
[13:14:30.455] - resignal: FALSE
[13:14:30.455] - force: TRUE
[13:14:30.455] - relayed: [n=1] TRUE
[13:14:30.455] - queued futures: [n=1] TRUE
 - flush all
[13:14:30.455] - relayed: [n=1] TRUE
[13:14:30.456] - queued futures: [n=1] TRUE
[13:14:30.456] signalConditionsASAP(NULL, pos=0) ... done
[13:14:30.456] resolve() on list ... DONE
[13:14:30.456]  - Number of value chunks collected: 1
[13:14:30.456] Resolving 1 futures (chunks) ... DONE
[13:14:30.456] Reducing values from 1 chunks ...
[13:14:30.457]  - Number of values collected after concatenation: 2
[13:14:30.457]  - Number of values expected: 2
[13:14:30.457] Reducing values from 1 chunks ... DONE
[13:14:30.457] future_mapply() ... DONE
* future_mapply(x, ..., future.stdout = NA) ... DONE
* plan('multisession') ... DONE
  - Testing with 1 cores ... DONE
  - Testing with 2 cores ...
* plan('multisession') ...
[13:14:30.463] plan(): Setting new future strategy stack:
[13:14:30.463] List of future strategies:
[13:14:30.463] 1. multisession:
[13:14:30.463]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[13:14:30.463]    - tweaked: FALSE
[13:14:30.463]    - call: plan(strategy)
[13:14:30.463] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
[13:14:30.464] multisession:
[13:14:30.464] - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[13:14:30.464] - tweaked: FALSE
[13:14:30.464] - call: plan(strategy)
[13:14:30.468] getGlobalsAndPackages() ...
[13:14:30.468] Not searching for globals
[13:14:30.468] - globals: [0] <none>
[13:14:30.469] getGlobalsAndPackages() ... DONE
[13:14:30.469] [local output] makeClusterPSOCK() ...
[13:14:30.498] [local output] Workers: [n = 2] 'localhost', 'localhost'
[13:14:30.505] [local output] Base port: 20510
[13:14:30.505] [local output] Getting setup options for 2 cluster nodes ...
[13:14:30.505] [local output]  - Node 1 of 2 ...
[13:14:30.506] [local output] localMachine=TRUE => revtunnel=FALSE

[13:14:30.507] Testing if worker's PID can be inferred: '"D:/RCompile/recent/R/bin/x64/Rscript" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpKE7Jej/worker.rank=1.parallelly.parent=4892.131c1f547e7e.pid\")), silent = TRUE)" -e "file.exists(\"D:/temp/RtmpKE7Jej/worker.rank=1.parallelly.parent=4892.131c1f547e7e.pid\")"'
[13:14:30.944] - Possible to infer worker's PID: TRUE
[13:14:30.945] [local output] Rscript port: 20510

[13:14:30.945] [local output]  - Node 2 of 2 ...
[13:14:30.946] [local output] localMachine=TRUE => revtunnel=FALSE

[13:14:30.947] [local output] Rscript port: 20510

[13:14:30.948] [local output] Getting setup options for 2 cluster nodes ... done
[13:14:30.948] [local output]  - Parallel setup requested for some PSOCK nodes
[13:14:30.949] [local output] Setting up PSOCK nodes in parallel
[13:14:30.949] List of 36
[13:14:30.949]  $ worker          : chr "localhost"
[13:14:30.949]   ..- attr(*, "localhost")= logi TRUE
[13:14:30.949]  $ master          : chr "localhost"
[13:14:30.949]  $ port            : int 20510
[13:14:30.949]  $ connectTimeout  : num 120
[13:14:30.949]  $ timeout         : num 120
[13:14:30.949]  $ rscript         : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\""
[13:14:30.949]  $ homogeneous     : logi TRUE
[13:14:30.949]  $ rscript_args    : chr "--default-packages=datasets,utils,grDevices,graphics,stats,methods -e \"#label=stdout.R:4892:CRANWIN3:CRAN\" -e"| __truncated__
[13:14:30.949]  $ rscript_envs    : NULL
[13:14:30.949]  $ rscript_libs    : chr [1:2] "D:/temp/RtmpKkFYYg/RLIBS_20dc214b714b" "D:/RCompile/recent/R/library"
[13:14:30.949]  $ rscript_startup : NULL
[13:14:30.949]  $ rscript_sh      : chr "cmd"
[13:14:30.949]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[13:14:30.949]  $ methods         : logi TRUE
[13:14:30.949]  $ socketOptions   : chr "no-delay"
[13:14:30.949]  $ useXDR          : logi FALSE
[13:14:30.949]  $ outfile         : chr "/dev/null"
[13:14:30.949]  $ renice          : int NA
[13:14:30.949]  $ rshcmd          : NULL
[13:14:30.949]  $ user            : chr(0) 
[13:14:30.949]  $ revtunnel       : logi FALSE
[13:14:30.949]  $ rshlogfile      : NULL
[13:14:30.949]  $ rshopts         : chr(0) 
[13:14:30.949]  $ rank            : int 1
[13:14:30.949]  $ manual          : logi FALSE
[13:14:30.949]  $ dryrun          : logi FALSE
[13:14:30.949]  $ quiet           : logi FALSE
[13:14:30.949]  $ setup_strategy  : chr "parallel"
[13:14:30.949]  $ local_cmd       : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[13:14:30.949]  $ pidfile         : chr "D:/temp/RtmpKE7Jej/worker.rank=1.parallelly.parent=4892.131c1f547e7e.pid"
[13:14:30.949]  $ rshcmd_label    : NULL
[13:14:30.949]  $ rsh_call        : NULL
[13:14:30.949]  $ cmd             : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[13:14:30.949]  $ localMachine    : logi TRUE
[13:14:30.949]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[13:14:30.949]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[13:14:30.949]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[13:14:30.949]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[13:14:30.949]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[13:14:30.949]         "cmd", "sh"), default_packages = c("datasets", "utils", "grDevices", 
[13:14:30.949]         "graphics", "stats", if (methods) "methods"), methods = TRUE, socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[13:14:30.949]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[13:14:30.949]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[13:14:30.949]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[13:14:30.949]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[13:14:30.949]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[13:14:30.949]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[13:14:30.949]  $ arguments       :List of 28
[13:14:30.949]   ..$ worker          : chr "localhost"
[13:14:30.949]   ..$ master          : NULL
[13:14:30.949]   ..$ port            : int 20510
[13:14:30.949]   ..$ connectTimeout  : num 120
[13:14:30.949]   ..$ timeout         : num 120
[13:14:30.949]   ..$ rscript         : NULL
[13:14:30.949]   ..$ homogeneous     : NULL
[13:14:30.949]   ..$ rscript_args    : NULL
[13:14:30.949]   ..$ rscript_envs    : NULL
[13:14:30.949]   ..$ rscript_libs    : chr [1:2] "D:/temp/RtmpKkFYYg/RLIBS_20dc214b714b" "D:/RCompile/recent/R/library"
[13:14:30.949]   ..$ rscript_startup : NULL
[13:14:30.949]   ..$ rscript_sh      : chr [1:3] "auto" "cmd" "sh"
[13:14:30.949]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[13:14:30.949]   ..$ methods         : logi TRUE
[13:14:30.949]   ..$ socketOptions   : chr "no-delay"
[13:14:30.949]   ..$ useXDR          : logi FALSE
[13:14:30.949]   ..$ outfile         : chr "/dev/null"
[13:14:30.949]   ..$ renice          : int NA
[13:14:30.949]   ..$ rshcmd          : NULL
[13:14:30.949]   ..$ user            : NULL
[13:14:30.949]   ..$ revtunnel       : logi NA
[13:14:30.949]   ..$ rshlogfile      : NULL
[13:14:30.949]   ..$ rshopts         : NULL
[13:14:30.949]   ..$ rank            : int 1
[13:14:30.949]   ..$ manual          : logi FALSE
[13:14:30.949]   ..$ dryrun          : logi FALSE
[13:14:30.949]   ..$ quiet           : logi FALSE
[13:14:30.949]   ..$ setup_strategy  : chr "parallel"
[13:14:30.949]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[13:14:30.971] [local output] System call to launch all workers:
[13:14:30.971] [local output] "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=stdout.R:4892:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpKE7Jej/worker.rank=1.parallelly.parent=4892.131c1f547e7e.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e ".libPaths(c(\"D:/temp/RtmpKkFYYg/RLIBS_20dc214b714b\",\"D:/RCompile/recent/R/library\"))" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" MASTER=localhost PORT=20510 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[13:14:30.971] [local output] Starting PSOCK main server
[13:14:30.977] [local output] Workers launched
[13:14:30.978] [local output] Waiting for workers to connect back
[13:14:30.978]  - [local output] 0 workers out of 2 ready
[13:14:31.144]  - [local output] 0 workers out of 2 ready
[13:14:31.144]  - [local output] 1 workers out of 2 ready
[13:14:31.147]  - [local output] 1 workers out of 2 ready
[13:14:31.147]  - [local output] 2 workers out of 2 ready
[13:14:31.147] [local output] Launching of workers completed
[13:14:31.148] [local output] Collecting session information from workers
[13:14:31.149] [local output]  - Worker #1 of 2
[13:14:31.149] [local output]  - Worker #2 of 2
[13:14:31.150] [local output] makeClusterPSOCK() ... done
[13:14:31.163] Packages needed by the future expression (n = 0): <none>
[13:14:31.163] Packages needed by future strategies (n = 0): <none>
[13:14:31.164] {
[13:14:31.164]     {
[13:14:31.164]         {
[13:14:31.164]             ...future.startTime <- base::Sys.time()
[13:14:31.164]             {
[13:14:31.164]                 {
[13:14:31.164]                   {
[13:14:31.164]                     {
[13:14:31.164]                       base::local({
[13:14:31.164]                         has_future <- base::requireNamespace("future", 
[13:14:31.164]                           quietly = TRUE)
[13:14:31.164]                         if (has_future) {
[13:14:31.164]                           ns <- base::getNamespace("future")
[13:14:31.164]                           version <- ns[[".package"]][["version"]]
[13:14:31.164]                           if (is.null(version)) 
[13:14:31.164]                             version <- utils::packageVersion("future")
[13:14:31.164]                         }
[13:14:31.164]                         else {
[13:14:31.164]                           version <- NULL
[13:14:31.164]                         }
[13:14:31.164]                         if (!has_future || version < "1.8.0") {
[13:14:31.164]                           info <- base::c(r_version = base::gsub("R version ", 
[13:14:31.164]                             "", base::R.version$version.string), 
[13:14:31.164]                             platform = base::sprintf("%s (%s-bit)", 
[13:14:31.164]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[13:14:31.164]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[13:14:31.164]                               "release", "version")], collapse = " "), 
[13:14:31.164]                             hostname = base::Sys.info()[["nodename"]])
[13:14:31.164]                           info <- base::sprintf("%s: %s", base::names(info), 
[13:14:31.164]                             info)
[13:14:31.164]                           info <- base::paste(info, collapse = "; ")
[13:14:31.164]                           if (!has_future) {
[13:14:31.164]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[13:14:31.164]                               info)
[13:14:31.164]                           }
[13:14:31.164]                           else {
[13:14:31.164]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[13:14:31.164]                               info, version)
[13:14:31.164]                           }
[13:14:31.164]                           base::stop(msg)
[13:14:31.164]                         }
[13:14:31.164]                       })
[13:14:31.164]                     }
[13:14:31.164]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[13:14:31.164]                     base::options(mc.cores = 1L)
[13:14:31.164]                   }
[13:14:31.164]                   options(future.plan = NULL)
[13:14:31.164]                   Sys.unsetenv("R_FUTURE_PLAN")
[13:14:31.164]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[13:14:31.164]                 }
[13:14:31.164]                 ...future.workdir <- getwd()
[13:14:31.164]             }
[13:14:31.164]             ...future.oldOptions <- base::as.list(base::.Options)
[13:14:31.164]             ...future.oldEnvVars <- base::Sys.getenv()
[13:14:31.164]         }
[13:14:31.164]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[13:14:31.164]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[13:14:31.164]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[13:14:31.164]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[13:14:31.164]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[13:14:31.164]             future.stdout.windows.reencode = NULL, width = 80L)
[13:14:31.164]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[13:14:31.164]             base::names(...future.oldOptions))
[13:14:31.164]     }
[13:14:31.164]     if (FALSE) {
[13:14:31.164]     }
[13:14:31.164]     else {
[13:14:31.164]         if (TRUE) {
[13:14:31.164]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[13:14:31.164]                 open = "w")
[13:14:31.164]         }
[13:14:31.164]         else {
[13:14:31.164]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[13:14:31.164]                 windows = "NUL", "/dev/null"), open = "w")
[13:14:31.164]         }
[13:14:31.164]         base::sink(...future.stdout, type = "output", split = FALSE)
[13:14:31.164]         base::on.exit(if (!base::is.null(...future.stdout)) {
[13:14:31.164]             base::sink(type = "output", split = FALSE)
[13:14:31.164]             base::close(...future.stdout)
[13:14:31.164]         }, add = TRUE)
[13:14:31.164]     }
[13:14:31.164]     ...future.frame <- base::sys.nframe()
[13:14:31.164]     ...future.conditions <- base::list()
[13:14:31.164]     ...future.rng <- base::globalenv()$.Random.seed
[13:14:31.164]     if (FALSE) {
[13:14:31.164]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[13:14:31.164]             "...future.value", "...future.globalenv.names", ".Random.seed")
[13:14:31.164]     }
[13:14:31.164]     ...future.result <- base::tryCatch({
[13:14:31.164]         base::withCallingHandlers({
[13:14:31.164]             ...future.value <- base::withVisible(base::local({
[13:14:31.164]                 ...future.makeSendCondition <- local({
[13:14:31.164]                   sendCondition <- NULL
[13:14:31.164]                   function(frame = 1L) {
[13:14:31.164]                     if (is.function(sendCondition)) 
[13:14:31.164]                       return(sendCondition)
[13:14:31.164]                     ns <- getNamespace("parallel")
[13:14:31.164]                     if (exists("sendData", mode = "function", 
[13:14:31.164]                       envir = ns)) {
[13:14:31.164]                       parallel_sendData <- get("sendData", mode = "function", 
[13:14:31.164]                         envir = ns)
[13:14:31.164]                       envir <- sys.frame(frame)
[13:14:31.164]                       master <- NULL
[13:14:31.164]                       while (!identical(envir, .GlobalEnv) && 
[13:14:31.164]                         !identical(envir, emptyenv())) {
[13:14:31.164]                         if (exists("master", mode = "list", envir = envir, 
[13:14:31.164]                           inherits = FALSE)) {
[13:14:31.164]                           master <- get("master", mode = "list", 
[13:14:31.164]                             envir = envir, inherits = FALSE)
[13:14:31.164]                           if (inherits(master, c("SOCKnode", 
[13:14:31.164]                             "SOCK0node"))) {
[13:14:31.164]                             sendCondition <<- function(cond) {
[13:14:31.164]                               data <- list(type = "VALUE", value = cond, 
[13:14:31.164]                                 success = TRUE)
[13:14:31.164]                               parallel_sendData(master, data)
[13:14:31.164]                             }
[13:14:31.164]                             return(sendCondition)
[13:14:31.164]                           }
[13:14:31.164]                         }
[13:14:31.164]                         frame <- frame + 1L
[13:14:31.164]                         envir <- sys.frame(frame)
[13:14:31.164]                       }
[13:14:31.164]                     }
[13:14:31.164]                     sendCondition <<- function(cond) NULL
[13:14:31.164]                   }
[13:14:31.164]                 })
[13:14:31.164]                 withCallingHandlers({
[13:14:31.164]                   NA
[13:14:31.164]                 }, immediateCondition = function(cond) {
[13:14:31.164]                   sendCondition <- ...future.makeSendCondition()
[13:14:31.164]                   sendCondition(cond)
[13:14:31.164]                   muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:31.164]                   {
[13:14:31.164]                     inherits <- base::inherits
[13:14:31.164]                     invokeRestart <- base::invokeRestart
[13:14:31.164]                     is.null <- base::is.null
[13:14:31.164]                     muffled <- FALSE
[13:14:31.164]                     if (inherits(cond, "message")) {
[13:14:31.164]                       muffled <- grepl(pattern, "muffleMessage")
[13:14:31.164]                       if (muffled) 
[13:14:31.164]                         invokeRestart("muffleMessage")
[13:14:31.164]                     }
[13:14:31.164]                     else if (inherits(cond, "warning")) {
[13:14:31.164]                       muffled <- grepl(pattern, "muffleWarning")
[13:14:31.164]                       if (muffled) 
[13:14:31.164]                         invokeRestart("muffleWarning")
[13:14:31.164]                     }
[13:14:31.164]                     else if (inherits(cond, "condition")) {
[13:14:31.164]                       if (!is.null(pattern)) {
[13:14:31.164]                         computeRestarts <- base::computeRestarts
[13:14:31.164]                         grepl <- base::grepl
[13:14:31.164]                         restarts <- computeRestarts(cond)
[13:14:31.164]                         for (restart in restarts) {
[13:14:31.164]                           name <- restart$name
[13:14:31.164]                           if (is.null(name)) 
[13:14:31.164]                             next
[13:14:31.164]                           if (!grepl(pattern, name)) 
[13:14:31.164]                             next
[13:14:31.164]                           invokeRestart(restart)
[13:14:31.164]                           muffled <- TRUE
[13:14:31.164]                           break
[13:14:31.164]                         }
[13:14:31.164]                       }
[13:14:31.164]                     }
[13:14:31.164]                     invisible(muffled)
[13:14:31.164]                   }
[13:14:31.164]                   muffleCondition(cond)
[13:14:31.164]                 })
[13:14:31.164]             }))
[13:14:31.164]             future::FutureResult(value = ...future.value$value, 
[13:14:31.164]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[13:14:31.164]                   ...future.rng), globalenv = if (FALSE) 
[13:14:31.164]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[13:14:31.164]                     ...future.globalenv.names))
[13:14:31.164]                 else NULL, started = ...future.startTime, version = "1.8")
[13:14:31.164]         }, condition = base::local({
[13:14:31.164]             c <- base::c
[13:14:31.164]             inherits <- base::inherits
[13:14:31.164]             invokeRestart <- base::invokeRestart
[13:14:31.164]             length <- base::length
[13:14:31.164]             list <- base::list
[13:14:31.164]             seq.int <- base::seq.int
[13:14:31.164]             signalCondition <- base::signalCondition
[13:14:31.164]             sys.calls <- base::sys.calls
[13:14:31.164]             `[[` <- base::`[[`
[13:14:31.164]             `+` <- base::`+`
[13:14:31.164]             `<<-` <- base::`<<-`
[13:14:31.164]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[13:14:31.164]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[13:14:31.164]                   3L)]
[13:14:31.164]             }
[13:14:31.164]             function(cond) {
[13:14:31.164]                 is_error <- inherits(cond, "error")
[13:14:31.164]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[13:14:31.164]                   NULL)
[13:14:31.164]                 if (is_error) {
[13:14:31.164]                   sessionInformation <- function() {
[13:14:31.164]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[13:14:31.164]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[13:14:31.164]                       search = base::search(), system = base::Sys.info())
[13:14:31.164]                   }
[13:14:31.164]                   ...future.conditions[[length(...future.conditions) + 
[13:14:31.164]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[13:14:31.164]                     cond$call), session = sessionInformation(), 
[13:14:31.164]                     timestamp = base::Sys.time(), signaled = 0L)
[13:14:31.164]                   signalCondition(cond)
[13:14:31.164]                 }
[13:14:31.164]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[13:14:31.164]                 "immediateCondition"))) {
[13:14:31.164]                   signal <- TRUE && inherits(cond, "immediateCondition")
[13:14:31.164]                   ...future.conditions[[length(...future.conditions) + 
[13:14:31.164]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[13:14:31.164]                   if (TRUE && !signal) {
[13:14:31.164]                     muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:31.164]                     {
[13:14:31.164]                       inherits <- base::inherits
[13:14:31.164]                       invokeRestart <- base::invokeRestart
[13:14:31.164]                       is.null <- base::is.null
[13:14:31.164]                       muffled <- FALSE
[13:14:31.164]                       if (inherits(cond, "message")) {
[13:14:31.164]                         muffled <- grepl(pattern, "muffleMessage")
[13:14:31.164]                         if (muffled) 
[13:14:31.164]                           invokeRestart("muffleMessage")
[13:14:31.164]                       }
[13:14:31.164]                       else if (inherits(cond, "warning")) {
[13:14:31.164]                         muffled <- grepl(pattern, "muffleWarning")
[13:14:31.164]                         if (muffled) 
[13:14:31.164]                           invokeRestart("muffleWarning")
[13:14:31.164]                       }
[13:14:31.164]                       else if (inherits(cond, "condition")) {
[13:14:31.164]                         if (!is.null(pattern)) {
[13:14:31.164]                           computeRestarts <- base::computeRestarts
[13:14:31.164]                           grepl <- base::grepl
[13:14:31.164]                           restarts <- computeRestarts(cond)
[13:14:31.164]                           for (restart in restarts) {
[13:14:31.164]                             name <- restart$name
[13:14:31.164]                             if (is.null(name)) 
[13:14:31.164]                               next
[13:14:31.164]                             if (!grepl(pattern, name)) 
[13:14:31.164]                               next
[13:14:31.164]                             invokeRestart(restart)
[13:14:31.164]                             muffled <- TRUE
[13:14:31.164]                             break
[13:14:31.164]                           }
[13:14:31.164]                         }
[13:14:31.164]                       }
[13:14:31.164]                       invisible(muffled)
[13:14:31.164]                     }
[13:14:31.164]                     muffleCondition(cond, pattern = "^muffle")
[13:14:31.164]                   }
[13:14:31.164]                 }
[13:14:31.164]                 else {
[13:14:31.164]                   if (TRUE) {
[13:14:31.164]                     muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:31.164]                     {
[13:14:31.164]                       inherits <- base::inherits
[13:14:31.164]                       invokeRestart <- base::invokeRestart
[13:14:31.164]                       is.null <- base::is.null
[13:14:31.164]                       muffled <- FALSE
[13:14:31.164]                       if (inherits(cond, "message")) {
[13:14:31.164]                         muffled <- grepl(pattern, "muffleMessage")
[13:14:31.164]                         if (muffled) 
[13:14:31.164]                           invokeRestart("muffleMessage")
[13:14:31.164]                       }
[13:14:31.164]                       else if (inherits(cond, "warning")) {
[13:14:31.164]                         muffled <- grepl(pattern, "muffleWarning")
[13:14:31.164]                         if (muffled) 
[13:14:31.164]                           invokeRestart("muffleWarning")
[13:14:31.164]                       }
[13:14:31.164]                       else if (inherits(cond, "condition")) {
[13:14:31.164]                         if (!is.null(pattern)) {
[13:14:31.164]                           computeRestarts <- base::computeRestarts
[13:14:31.164]                           grepl <- base::grepl
[13:14:31.164]                           restarts <- computeRestarts(cond)
[13:14:31.164]                           for (restart in restarts) {
[13:14:31.164]                             name <- restart$name
[13:14:31.164]                             if (is.null(name)) 
[13:14:31.164]                               next
[13:14:31.164]                             if (!grepl(pattern, name)) 
[13:14:31.164]                               next
[13:14:31.164]                             invokeRestart(restart)
[13:14:31.164]                             muffled <- TRUE
[13:14:31.164]                             break
[13:14:31.164]                           }
[13:14:31.164]                         }
[13:14:31.164]                       }
[13:14:31.164]                       invisible(muffled)
[13:14:31.164]                     }
[13:14:31.164]                     muffleCondition(cond, pattern = "^muffle")
[13:14:31.164]                   }
[13:14:31.164]                 }
[13:14:31.164]             }
[13:14:31.164]         }))
[13:14:31.164]     }, error = function(ex) {
[13:14:31.164]         base::structure(base::list(value = NULL, visible = NULL, 
[13:14:31.164]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[13:14:31.164]                 ...future.rng), started = ...future.startTime, 
[13:14:31.164]             finished = Sys.time(), session_uuid = NA_character_, 
[13:14:31.164]             version = "1.8"), class = "FutureResult")
[13:14:31.164]     }, finally = {
[13:14:31.164]         if (!identical(...future.workdir, getwd())) 
[13:14:31.164]             setwd(...future.workdir)
[13:14:31.164]         {
[13:14:31.164]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[13:14:31.164]                 ...future.oldOptions$nwarnings <- NULL
[13:14:31.164]             }
[13:14:31.164]             base::options(...future.oldOptions)
[13:14:31.164]             if (.Platform$OS.type == "windows") {
[13:14:31.164]                 old_names <- names(...future.oldEnvVars)
[13:14:31.164]                 envs <- base::Sys.getenv()
[13:14:31.164]                 names <- names(envs)
[13:14:31.164]                 common <- intersect(names, old_names)
[13:14:31.164]                 added <- setdiff(names, old_names)
[13:14:31.164]                 removed <- setdiff(old_names, names)
[13:14:31.164]                 changed <- common[...future.oldEnvVars[common] != 
[13:14:31.164]                   envs[common]]
[13:14:31.164]                 NAMES <- toupper(changed)
[13:14:31.164]                 args <- list()
[13:14:31.164]                 for (kk in seq_along(NAMES)) {
[13:14:31.164]                   name <- changed[[kk]]
[13:14:31.164]                   NAME <- NAMES[[kk]]
[13:14:31.164]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:31.164]                     next
[13:14:31.164]                   args[[name]] <- ...future.oldEnvVars[[name]]
[13:14:31.164]                 }
[13:14:31.164]                 NAMES <- toupper(added)
[13:14:31.164]                 for (kk in seq_along(NAMES)) {
[13:14:31.164]                   name <- added[[kk]]
[13:14:31.164]                   NAME <- NAMES[[kk]]
[13:14:31.164]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:31.164]                     next
[13:14:31.164]                   args[[name]] <- ""
[13:14:31.164]                 }
[13:14:31.164]                 NAMES <- toupper(removed)
[13:14:31.164]                 for (kk in seq_along(NAMES)) {
[13:14:31.164]                   name <- removed[[kk]]
[13:14:31.164]                   NAME <- NAMES[[kk]]
[13:14:31.164]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:31.164]                     next
[13:14:31.164]                   args[[name]] <- ...future.oldEnvVars[[name]]
[13:14:31.164]                 }
[13:14:31.164]                 if (length(args) > 0) 
[13:14:31.164]                   base::do.call(base::Sys.setenv, args = args)
[13:14:31.164]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[13:14:31.164]             }
[13:14:31.164]             else {
[13:14:31.164]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[13:14:31.164]             }
[13:14:31.164]             {
[13:14:31.164]                 if (base::length(...future.futureOptionsAdded) > 
[13:14:31.164]                   0L) {
[13:14:31.164]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[13:14:31.164]                   base::names(opts) <- ...future.futureOptionsAdded
[13:14:31.164]                   base::options(opts)
[13:14:31.164]                 }
[13:14:31.164]                 {
[13:14:31.164]                   {
[13:14:31.164]                     base::options(mc.cores = ...future.mc.cores.old)
[13:14:31.164]                     NULL
[13:14:31.164]                   }
[13:14:31.164]                   options(future.plan = NULL)
[13:14:31.164]                   if (is.na(NA_character_)) 
[13:14:31.164]                     Sys.unsetenv("R_FUTURE_PLAN")
[13:14:31.164]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[13:14:31.164]                   future::plan(list(function (..., workers = availableCores(), 
[13:14:31.164]                     lazy = FALSE, rscript_libs = .libPaths(), 
[13:14:31.164]                     envir = parent.frame()) 
[13:14:31.164]                   {
[13:14:31.164]                     if (is.function(workers)) 
[13:14:31.164]                       workers <- workers()
[13:14:31.164]                     workers <- structure(as.integer(workers), 
[13:14:31.164]                       class = class(workers))
[13:14:31.164]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[13:14:31.164]                       workers >= 1)
[13:14:31.164]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[13:14:31.164]                       return(sequential(..., lazy = TRUE, envir = envir))
[13:14:31.164]                     }
[13:14:31.164]                     future <- MultisessionFuture(..., workers = workers, 
[13:14:31.164]                       lazy = lazy, rscript_libs = rscript_libs, 
[13:14:31.164]                       envir = envir)
[13:14:31.164]                     if (!future$lazy) 
[13:14:31.164]                       future <- run(future)
[13:14:31.164]                     invisible(future)
[13:14:31.164]                   }), .cleanup = FALSE, .init = FALSE)
[13:14:31.164]                 }
[13:14:31.164]             }
[13:14:31.164]         }
[13:14:31.164]     })
[13:14:31.164]     if (TRUE) {
[13:14:31.164]         base::sink(type = "output", split = FALSE)
[13:14:31.164]         if (TRUE) {
[13:14:31.164]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[13:14:31.164]         }
[13:14:31.164]         else {
[13:14:31.164]             ...future.result["stdout"] <- base::list(NULL)
[13:14:31.164]         }
[13:14:31.164]         base::close(...future.stdout)
[13:14:31.164]         ...future.stdout <- NULL
[13:14:31.164]     }
[13:14:31.164]     ...future.result$conditions <- ...future.conditions
[13:14:31.164]     ...future.result$finished <- base::Sys.time()
[13:14:31.164]     ...future.result
[13:14:31.164] }
[13:14:31.239] MultisessionFuture started
[13:14:31.240] result() for ClusterFuture ...
[13:14:31.240] receiveMessageFromWorker() for ClusterFuture ...
[13:14:31.240] - Validating connection of MultisessionFuture
[13:14:31.296] - received message: FutureResult
[13:14:31.297] - Received FutureResult
[13:14:31.300] - Erased future from FutureRegistry
[13:14:31.300] result() for ClusterFuture ...
[13:14:31.300] - result already collected: FutureResult
[13:14:31.301] result() for ClusterFuture ... done
[13:14:31.301] receiveMessageFromWorker() for ClusterFuture ... done
[13:14:31.301] result() for ClusterFuture ... done
[13:14:31.301] result() for ClusterFuture ...
[13:14:31.301] - result already collected: FutureResult
[13:14:31.302] result() for ClusterFuture ... done
[13:14:31.302] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
[13:14:31.304] plan(): nbrOfWorkers() = 2
* future_lapply(x, ..., future.stdout = FALSE) ...
[13:14:31.305] future_lapply() ...
[13:14:31.310] Number of chunks: 2
[13:14:31.310] getGlobalsAndPackagesXApply() ...
[13:14:31.311]  - future.globals: TRUE
[13:14:31.311] getGlobalsAndPackages() ...
[13:14:31.311] Searching for globals...
[13:14:31.313] - globals found: [5] 'FUN', '{', 'Sys.sleep', '/', 'print'
[13:14:31.313] Searching for globals ... DONE
[13:14:31.314] Resolving globals: FALSE
[13:14:31.314] The total size of the 1 globals is 4.61 KiB (4720 bytes)
[13:14:31.315] The total size of the 1 globals exported for future expression ('FUN()') is 4.61 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.61 KiB of class 'function')
[13:14:31.315] - globals: [1] 'FUN'
[13:14:31.315] 
[13:14:31.315] getGlobalsAndPackages() ... DONE
[13:14:31.315]  - globals found/used: [n=1] 'FUN'
[13:14:31.316]  - needed namespaces: [n=0] 
[13:14:31.316] Finding globals ... DONE
[13:14:31.316]  - use_args: TRUE
[13:14:31.316]  - Getting '...' globals ...
[13:14:31.317] resolve() on list ...
[13:14:31.317]  recursive: 0
[13:14:31.317]  length: 1
[13:14:31.317]  elements: '...'
[13:14:31.318]  length: 0 (resolved future 1)
[13:14:31.318] resolve() on list ... DONE
[13:14:31.318]    - '...' content: [n=0] 
[13:14:31.318] List of 1
[13:14:31.318]  $ ...: list()
[13:14:31.318]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[13:14:31.318]  - attr(*, "where")=List of 1
[13:14:31.318]   ..$ ...:<environment: 0x0000022a34714b00> 
[13:14:31.318]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[13:14:31.318]  - attr(*, "resolved")= logi TRUE
[13:14:31.318]  - attr(*, "total_size")= num NA
[13:14:31.322]  - Getting '...' globals ... DONE
[13:14:31.322] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[13:14:31.322] List of 2
[13:14:31.322]  $ ...future.FUN:function (x)  
[13:14:31.322]  $ ...          : list()
[13:14:31.322]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[13:14:31.322]  - attr(*, "where")=List of 2
[13:14:31.322]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[13:14:31.322]   ..$ ...          :<environment: 0x0000022a34714b00> 
[13:14:31.322]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[13:14:31.322]  - attr(*, "resolved")= logi FALSE
[13:14:31.322]  - attr(*, "total_size")= num 4720
[13:14:31.326] Packages to be attached in all futures: [n=0] 
[13:14:31.327] getGlobalsAndPackagesXApply() ... DONE
[13:14:31.327] Number of futures (= number of chunks): 2
[13:14:31.327] Launching 2 futures (chunks) ...
[13:14:31.327] Chunk #1 of 2 ...
[13:14:31.328]  - Finding globals in 'X' for chunk #1 ...
[13:14:31.328] getGlobalsAndPackages() ...
[13:14:31.328] Searching for globals...
[13:14:31.328] 
[13:14:31.329] Searching for globals ... DONE
[13:14:31.329] - globals: [0] <none>
[13:14:31.329] getGlobalsAndPackages() ... DONE
[13:14:31.329]    + additional globals found: [n=0] 
[13:14:31.329]    + additional namespaces needed: [n=0] 
[13:14:31.330]  - Finding globals in 'X' for chunk #1 ... DONE
[13:14:31.330]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[13:14:31.330]  - seeds: <none>
[13:14:31.330]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:31.331] getGlobalsAndPackages() ...
[13:14:31.331] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:31.331] Resolving globals: FALSE
[13:14:31.331] Tweak future expression to call with '...' arguments ...
[13:14:31.331] {
[13:14:31.331]     do.call(function(...) {
[13:14:31.331]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[13:14:31.331]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[13:14:31.331]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[13:14:31.331]             on.exit(options(oopts), add = TRUE)
[13:14:31.331]         }
[13:14:31.331]         {
[13:14:31.331]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[13:14:31.331]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[13:14:31.331]                 ...future.FUN(...future.X_jj, ...)
[13:14:31.331]             })
[13:14:31.331]         }
[13:14:31.331]     }, args = future.call.arguments)
[13:14:31.331] }
[13:14:31.332] Tweak future expression to call with '...' arguments ... DONE
[13:14:31.333] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:31.333] 
[13:14:31.333] getGlobalsAndPackages() ... DONE
[13:14:31.333] run() for 'Future' ...
[13:14:31.334] - state: 'created'
[13:14:31.334] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[13:14:31.349] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[13:14:31.349] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[13:14:31.349]   - Field: 'node'
[13:14:31.350]   - Field: 'label'
[13:14:31.350]   - Field: 'local'
[13:14:31.350]   - Field: 'owner'
[13:14:31.350]   - Field: 'envir'
[13:14:31.350]   - Field: 'workers'
[13:14:31.351]   - Field: 'packages'
[13:14:31.351]   - Field: 'gc'
[13:14:31.351]   - Field: 'conditions'
[13:14:31.351]   - Field: 'persistent'
[13:14:31.351]   - Field: 'expr'
[13:14:31.351]   - Field: 'uuid'
[13:14:31.352]   - Field: 'seed'
[13:14:31.352]   - Field: 'version'
[13:14:31.352]   - Field: 'result'
[13:14:31.352]   - Field: 'asynchronous'
[13:14:31.352]   - Field: 'calls'
[13:14:31.353]   - Field: 'globals'
[13:14:31.353]   - Field: 'stdout'
[13:14:31.353]   - Field: 'earlySignal'
[13:14:31.353]   - Field: 'lazy'
[13:14:31.353]   - Field: 'state'
[13:14:31.354] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[13:14:31.354] - Launch lazy future ...
[13:14:31.354] Packages needed by the future expression (n = 0): <none>
[13:14:31.354] Packages needed by future strategies (n = 0): <none>
[13:14:31.355] {
[13:14:31.355]     {
[13:14:31.355]         {
[13:14:31.355]             ...future.startTime <- base::Sys.time()
[13:14:31.355]             {
[13:14:31.355]                 {
[13:14:31.355]                   {
[13:14:31.355]                     {
[13:14:31.355]                       base::local({
[13:14:31.355]                         has_future <- base::requireNamespace("future", 
[13:14:31.355]                           quietly = TRUE)
[13:14:31.355]                         if (has_future) {
[13:14:31.355]                           ns <- base::getNamespace("future")
[13:14:31.355]                           version <- ns[[".package"]][["version"]]
[13:14:31.355]                           if (is.null(version)) 
[13:14:31.355]                             version <- utils::packageVersion("future")
[13:14:31.355]                         }
[13:14:31.355]                         else {
[13:14:31.355]                           version <- NULL
[13:14:31.355]                         }
[13:14:31.355]                         if (!has_future || version < "1.8.0") {
[13:14:31.355]                           info <- base::c(r_version = base::gsub("R version ", 
[13:14:31.355]                             "", base::R.version$version.string), 
[13:14:31.355]                             platform = base::sprintf("%s (%s-bit)", 
[13:14:31.355]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[13:14:31.355]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[13:14:31.355]                               "release", "version")], collapse = " "), 
[13:14:31.355]                             hostname = base::Sys.info()[["nodename"]])
[13:14:31.355]                           info <- base::sprintf("%s: %s", base::names(info), 
[13:14:31.355]                             info)
[13:14:31.355]                           info <- base::paste(info, collapse = "; ")
[13:14:31.355]                           if (!has_future) {
[13:14:31.355]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[13:14:31.355]                               info)
[13:14:31.355]                           }
[13:14:31.355]                           else {
[13:14:31.355]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[13:14:31.355]                               info, version)
[13:14:31.355]                           }
[13:14:31.355]                           base::stop(msg)
[13:14:31.355]                         }
[13:14:31.355]                       })
[13:14:31.355]                     }
[13:14:31.355]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[13:14:31.355]                     base::options(mc.cores = 1L)
[13:14:31.355]                   }
[13:14:31.355]                   options(future.plan = NULL)
[13:14:31.355]                   Sys.unsetenv("R_FUTURE_PLAN")
[13:14:31.355]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[13:14:31.355]                 }
[13:14:31.355]                 ...future.workdir <- getwd()
[13:14:31.355]             }
[13:14:31.355]             ...future.oldOptions <- base::as.list(base::.Options)
[13:14:31.355]             ...future.oldEnvVars <- base::Sys.getenv()
[13:14:31.355]         }
[13:14:31.355]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[13:14:31.355]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[13:14:31.355]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[13:14:31.355]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[13:14:31.355]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[13:14:31.355]             future.stdout.windows.reencode = NULL, width = 80L)
[13:14:31.355]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[13:14:31.355]             base::names(...future.oldOptions))
[13:14:31.355]     }
[13:14:31.355]     if (FALSE) {
[13:14:31.355]     }
[13:14:31.355]     else {
[13:14:31.355]         if (FALSE) {
[13:14:31.355]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[13:14:31.355]                 open = "w")
[13:14:31.355]         }
[13:14:31.355]         else {
[13:14:31.355]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[13:14:31.355]                 windows = "NUL", "/dev/null"), open = "w")
[13:14:31.355]         }
[13:14:31.355]         base::sink(...future.stdout, type = "output", split = FALSE)
[13:14:31.355]         base::on.exit(if (!base::is.null(...future.stdout)) {
[13:14:31.355]             base::sink(type = "output", split = FALSE)
[13:14:31.355]             base::close(...future.stdout)
[13:14:31.355]         }, add = TRUE)
[13:14:31.355]     }
[13:14:31.355]     ...future.frame <- base::sys.nframe()
[13:14:31.355]     ...future.conditions <- base::list()
[13:14:31.355]     ...future.rng <- base::globalenv()$.Random.seed
[13:14:31.355]     if (FALSE) {
[13:14:31.355]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[13:14:31.355]             "...future.value", "...future.globalenv.names", ".Random.seed")
[13:14:31.355]     }
[13:14:31.355]     ...future.result <- base::tryCatch({
[13:14:31.355]         base::withCallingHandlers({
[13:14:31.355]             ...future.value <- base::withVisible(base::local({
[13:14:31.355]                 ...future.makeSendCondition <- local({
[13:14:31.355]                   sendCondition <- NULL
[13:14:31.355]                   function(frame = 1L) {
[13:14:31.355]                     if (is.function(sendCondition)) 
[13:14:31.355]                       return(sendCondition)
[13:14:31.355]                     ns <- getNamespace("parallel")
[13:14:31.355]                     if (exists("sendData", mode = "function", 
[13:14:31.355]                       envir = ns)) {
[13:14:31.355]                       parallel_sendData <- get("sendData", mode = "function", 
[13:14:31.355]                         envir = ns)
[13:14:31.355]                       envir <- sys.frame(frame)
[13:14:31.355]                       master <- NULL
[13:14:31.355]                       while (!identical(envir, .GlobalEnv) && 
[13:14:31.355]                         !identical(envir, emptyenv())) {
[13:14:31.355]                         if (exists("master", mode = "list", envir = envir, 
[13:14:31.355]                           inherits = FALSE)) {
[13:14:31.355]                           master <- get("master", mode = "list", 
[13:14:31.355]                             envir = envir, inherits = FALSE)
[13:14:31.355]                           if (inherits(master, c("SOCKnode", 
[13:14:31.355]                             "SOCK0node"))) {
[13:14:31.355]                             sendCondition <<- function(cond) {
[13:14:31.355]                               data <- list(type = "VALUE", value = cond, 
[13:14:31.355]                                 success = TRUE)
[13:14:31.355]                               parallel_sendData(master, data)
[13:14:31.355]                             }
[13:14:31.355]                             return(sendCondition)
[13:14:31.355]                           }
[13:14:31.355]                         }
[13:14:31.355]                         frame <- frame + 1L
[13:14:31.355]                         envir <- sys.frame(frame)
[13:14:31.355]                       }
[13:14:31.355]                     }
[13:14:31.355]                     sendCondition <<- function(cond) NULL
[13:14:31.355]                   }
[13:14:31.355]                 })
[13:14:31.355]                 withCallingHandlers({
[13:14:31.355]                   {
[13:14:31.355]                     do.call(function(...) {
[13:14:31.355]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[13:14:31.355]                       if (!identical(...future.globals.maxSize.org, 
[13:14:31.355]                         ...future.globals.maxSize)) {
[13:14:31.355]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[13:14:31.355]                         on.exit(options(oopts), add = TRUE)
[13:14:31.355]                       }
[13:14:31.355]                       {
[13:14:31.355]                         lapply(seq_along(...future.elements_ii), 
[13:14:31.355]                           FUN = function(jj) {
[13:14:31.355]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[13:14:31.355]                             ...future.FUN(...future.X_jj, ...)
[13:14:31.355]                           })
[13:14:31.355]                       }
[13:14:31.355]                     }, args = future.call.arguments)
[13:14:31.355]                   }
[13:14:31.355]                 }, immediateCondition = function(cond) {
[13:14:31.355]                   sendCondition <- ...future.makeSendCondition()
[13:14:31.355]                   sendCondition(cond)
[13:14:31.355]                   muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:31.355]                   {
[13:14:31.355]                     inherits <- base::inherits
[13:14:31.355]                     invokeRestart <- base::invokeRestart
[13:14:31.355]                     is.null <- base::is.null
[13:14:31.355]                     muffled <- FALSE
[13:14:31.355]                     if (inherits(cond, "message")) {
[13:14:31.355]                       muffled <- grepl(pattern, "muffleMessage")
[13:14:31.355]                       if (muffled) 
[13:14:31.355]                         invokeRestart("muffleMessage")
[13:14:31.355]                     }
[13:14:31.355]                     else if (inherits(cond, "warning")) {
[13:14:31.355]                       muffled <- grepl(pattern, "muffleWarning")
[13:14:31.355]                       if (muffled) 
[13:14:31.355]                         invokeRestart("muffleWarning")
[13:14:31.355]                     }
[13:14:31.355]                     else if (inherits(cond, "condition")) {
[13:14:31.355]                       if (!is.null(pattern)) {
[13:14:31.355]                         computeRestarts <- base::computeRestarts
[13:14:31.355]                         grepl <- base::grepl
[13:14:31.355]                         restarts <- computeRestarts(cond)
[13:14:31.355]                         for (restart in restarts) {
[13:14:31.355]                           name <- restart$name
[13:14:31.355]                           if (is.null(name)) 
[13:14:31.355]                             next
[13:14:31.355]                           if (!grepl(pattern, name)) 
[13:14:31.355]                             next
[13:14:31.355]                           invokeRestart(restart)
[13:14:31.355]                           muffled <- TRUE
[13:14:31.355]                           break
[13:14:31.355]                         }
[13:14:31.355]                       }
[13:14:31.355]                     }
[13:14:31.355]                     invisible(muffled)
[13:14:31.355]                   }
[13:14:31.355]                   muffleCondition(cond)
[13:14:31.355]                 })
[13:14:31.355]             }))
[13:14:31.355]             future::FutureResult(value = ...future.value$value, 
[13:14:31.355]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[13:14:31.355]                   ...future.rng), globalenv = if (FALSE) 
[13:14:31.355]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[13:14:31.355]                     ...future.globalenv.names))
[13:14:31.355]                 else NULL, started = ...future.startTime, version = "1.8")
[13:14:31.355]         }, condition = base::local({
[13:14:31.355]             c <- base::c
[13:14:31.355]             inherits <- base::inherits
[13:14:31.355]             invokeRestart <- base::invokeRestart
[13:14:31.355]             length <- base::length
[13:14:31.355]             list <- base::list
[13:14:31.355]             seq.int <- base::seq.int
[13:14:31.355]             signalCondition <- base::signalCondition
[13:14:31.355]             sys.calls <- base::sys.calls
[13:14:31.355]             `[[` <- base::`[[`
[13:14:31.355]             `+` <- base::`+`
[13:14:31.355]             `<<-` <- base::`<<-`
[13:14:31.355]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[13:14:31.355]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[13:14:31.355]                   3L)]
[13:14:31.355]             }
[13:14:31.355]             function(cond) {
[13:14:31.355]                 is_error <- inherits(cond, "error")
[13:14:31.355]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[13:14:31.355]                   NULL)
[13:14:31.355]                 if (is_error) {
[13:14:31.355]                   sessionInformation <- function() {
[13:14:31.355]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[13:14:31.355]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[13:14:31.355]                       search = base::search(), system = base::Sys.info())
[13:14:31.355]                   }
[13:14:31.355]                   ...future.conditions[[length(...future.conditions) + 
[13:14:31.355]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[13:14:31.355]                     cond$call), session = sessionInformation(), 
[13:14:31.355]                     timestamp = base::Sys.time(), signaled = 0L)
[13:14:31.355]                   signalCondition(cond)
[13:14:31.355]                 }
[13:14:31.355]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[13:14:31.355]                 "immediateCondition"))) {
[13:14:31.355]                   signal <- TRUE && inherits(cond, "immediateCondition")
[13:14:31.355]                   ...future.conditions[[length(...future.conditions) + 
[13:14:31.355]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[13:14:31.355]                   if (TRUE && !signal) {
[13:14:31.355]                     muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:31.355]                     {
[13:14:31.355]                       inherits <- base::inherits
[13:14:31.355]                       invokeRestart <- base::invokeRestart
[13:14:31.355]                       is.null <- base::is.null
[13:14:31.355]                       muffled <- FALSE
[13:14:31.355]                       if (inherits(cond, "message")) {
[13:14:31.355]                         muffled <- grepl(pattern, "muffleMessage")
[13:14:31.355]                         if (muffled) 
[13:14:31.355]                           invokeRestart("muffleMessage")
[13:14:31.355]                       }
[13:14:31.355]                       else if (inherits(cond, "warning")) {
[13:14:31.355]                         muffled <- grepl(pattern, "muffleWarning")
[13:14:31.355]                         if (muffled) 
[13:14:31.355]                           invokeRestart("muffleWarning")
[13:14:31.355]                       }
[13:14:31.355]                       else if (inherits(cond, "condition")) {
[13:14:31.355]                         if (!is.null(pattern)) {
[13:14:31.355]                           computeRestarts <- base::computeRestarts
[13:14:31.355]                           grepl <- base::grepl
[13:14:31.355]                           restarts <- computeRestarts(cond)
[13:14:31.355]                           for (restart in restarts) {
[13:14:31.355]                             name <- restart$name
[13:14:31.355]                             if (is.null(name)) 
[13:14:31.355]                               next
[13:14:31.355]                             if (!grepl(pattern, name)) 
[13:14:31.355]                               next
[13:14:31.355]                             invokeRestart(restart)
[13:14:31.355]                             muffled <- TRUE
[13:14:31.355]                             break
[13:14:31.355]                           }
[13:14:31.355]                         }
[13:14:31.355]                       }
[13:14:31.355]                       invisible(muffled)
[13:14:31.355]                     }
[13:14:31.355]                     muffleCondition(cond, pattern = "^muffle")
[13:14:31.355]                   }
[13:14:31.355]                 }
[13:14:31.355]                 else {
[13:14:31.355]                   if (TRUE) {
[13:14:31.355]                     muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:31.355]                     {
[13:14:31.355]                       inherits <- base::inherits
[13:14:31.355]                       invokeRestart <- base::invokeRestart
[13:14:31.355]                       is.null <- base::is.null
[13:14:31.355]                       muffled <- FALSE
[13:14:31.355]                       if (inherits(cond, "message")) {
[13:14:31.355]                         muffled <- grepl(pattern, "muffleMessage")
[13:14:31.355]                         if (muffled) 
[13:14:31.355]                           invokeRestart("muffleMessage")
[13:14:31.355]                       }
[13:14:31.355]                       else if (inherits(cond, "warning")) {
[13:14:31.355]                         muffled <- grepl(pattern, "muffleWarning")
[13:14:31.355]                         if (muffled) 
[13:14:31.355]                           invokeRestart("muffleWarning")
[13:14:31.355]                       }
[13:14:31.355]                       else if (inherits(cond, "condition")) {
[13:14:31.355]                         if (!is.null(pattern)) {
[13:14:31.355]                           computeRestarts <- base::computeRestarts
[13:14:31.355]                           grepl <- base::grepl
[13:14:31.355]                           restarts <- computeRestarts(cond)
[13:14:31.355]                           for (restart in restarts) {
[13:14:31.355]                             name <- restart$name
[13:14:31.355]                             if (is.null(name)) 
[13:14:31.355]                               next
[13:14:31.355]                             if (!grepl(pattern, name)) 
[13:14:31.355]                               next
[13:14:31.355]                             invokeRestart(restart)
[13:14:31.355]                             muffled <- TRUE
[13:14:31.355]                             break
[13:14:31.355]                           }
[13:14:31.355]                         }
[13:14:31.355]                       }
[13:14:31.355]                       invisible(muffled)
[13:14:31.355]                     }
[13:14:31.355]                     muffleCondition(cond, pattern = "^muffle")
[13:14:31.355]                   }
[13:14:31.355]                 }
[13:14:31.355]             }
[13:14:31.355]         }))
[13:14:31.355]     }, error = function(ex) {
[13:14:31.355]         base::structure(base::list(value = NULL, visible = NULL, 
[13:14:31.355]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[13:14:31.355]                 ...future.rng), started = ...future.startTime, 
[13:14:31.355]             finished = Sys.time(), session_uuid = NA_character_, 
[13:14:31.355]             version = "1.8"), class = "FutureResult")
[13:14:31.355]     }, finally = {
[13:14:31.355]         if (!identical(...future.workdir, getwd())) 
[13:14:31.355]             setwd(...future.workdir)
[13:14:31.355]         {
[13:14:31.355]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[13:14:31.355]                 ...future.oldOptions$nwarnings <- NULL
[13:14:31.355]             }
[13:14:31.355]             base::options(...future.oldOptions)
[13:14:31.355]             if (.Platform$OS.type == "windows") {
[13:14:31.355]                 old_names <- names(...future.oldEnvVars)
[13:14:31.355]                 envs <- base::Sys.getenv()
[13:14:31.355]                 names <- names(envs)
[13:14:31.355]                 common <- intersect(names, old_names)
[13:14:31.355]                 added <- setdiff(names, old_names)
[13:14:31.355]                 removed <- setdiff(old_names, names)
[13:14:31.355]                 changed <- common[...future.oldEnvVars[common] != 
[13:14:31.355]                   envs[common]]
[13:14:31.355]                 NAMES <- toupper(changed)
[13:14:31.355]                 args <- list()
[13:14:31.355]                 for (kk in seq_along(NAMES)) {
[13:14:31.355]                   name <- changed[[kk]]
[13:14:31.355]                   NAME <- NAMES[[kk]]
[13:14:31.355]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:31.355]                     next
[13:14:31.355]                   args[[name]] <- ...future.oldEnvVars[[name]]
[13:14:31.355]                 }
[13:14:31.355]                 NAMES <- toupper(added)
[13:14:31.355]                 for (kk in seq_along(NAMES)) {
[13:14:31.355]                   name <- added[[kk]]
[13:14:31.355]                   NAME <- NAMES[[kk]]
[13:14:31.355]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:31.355]                     next
[13:14:31.355]                   args[[name]] <- ""
[13:14:31.355]                 }
[13:14:31.355]                 NAMES <- toupper(removed)
[13:14:31.355]                 for (kk in seq_along(NAMES)) {
[13:14:31.355]                   name <- removed[[kk]]
[13:14:31.355]                   NAME <- NAMES[[kk]]
[13:14:31.355]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:31.355]                     next
[13:14:31.355]                   args[[name]] <- ...future.oldEnvVars[[name]]
[13:14:31.355]                 }
[13:14:31.355]                 if (length(args) > 0) 
[13:14:31.355]                   base::do.call(base::Sys.setenv, args = args)
[13:14:31.355]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[13:14:31.355]             }
[13:14:31.355]             else {
[13:14:31.355]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[13:14:31.355]             }
[13:14:31.355]             {
[13:14:31.355]                 if (base::length(...future.futureOptionsAdded) > 
[13:14:31.355]                   0L) {
[13:14:31.355]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[13:14:31.355]                   base::names(opts) <- ...future.futureOptionsAdded
[13:14:31.355]                   base::options(opts)
[13:14:31.355]                 }
[13:14:31.355]                 {
[13:14:31.355]                   {
[13:14:31.355]                     base::options(mc.cores = ...future.mc.cores.old)
[13:14:31.355]                     NULL
[13:14:31.355]                   }
[13:14:31.355]                   options(future.plan = NULL)
[13:14:31.355]                   if (is.na(NA_character_)) 
[13:14:31.355]                     Sys.unsetenv("R_FUTURE_PLAN")
[13:14:31.355]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[13:14:31.355]                   future::plan(list(function (..., workers = availableCores(), 
[13:14:31.355]                     lazy = FALSE, rscript_libs = .libPaths(), 
[13:14:31.355]                     envir = parent.frame()) 
[13:14:31.355]                   {
[13:14:31.355]                     if (is.function(workers)) 
[13:14:31.355]                       workers <- workers()
[13:14:31.355]                     workers <- structure(as.integer(workers), 
[13:14:31.355]                       class = class(workers))
[13:14:31.355]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[13:14:31.355]                       workers >= 1)
[13:14:31.355]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[13:14:31.355]                       return(sequential(..., lazy = TRUE, envir = envir))
[13:14:31.355]                     }
[13:14:31.355]                     future <- MultisessionFuture(..., workers = workers, 
[13:14:31.355]                       lazy = lazy, rscript_libs = rscript_libs, 
[13:14:31.355]                       envir = envir)
[13:14:31.355]                     if (!future$lazy) 
[13:14:31.355]                       future <- run(future)
[13:14:31.355]                     invisible(future)
[13:14:31.355]                   }), .cleanup = FALSE, .init = FALSE)
[13:14:31.355]                 }
[13:14:31.355]             }
[13:14:31.355]         }
[13:14:31.355]     })
[13:14:31.355]     if (TRUE) {
[13:14:31.355]         base::sink(type = "output", split = FALSE)
[13:14:31.355]         if (FALSE) {
[13:14:31.355]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[13:14:31.355]         }
[13:14:31.355]         else {
[13:14:31.355]             ...future.result["stdout"] <- base::list(NULL)
[13:14:31.355]         }
[13:14:31.355]         base::close(...future.stdout)
[13:14:31.355]         ...future.stdout <- NULL
[13:14:31.355]     }
[13:14:31.355]     ...future.result$conditions <- ...future.conditions
[13:14:31.355]     ...future.result$finished <- base::Sys.time()
[13:14:31.355]     ...future.result
[13:14:31.355] }
[13:14:31.361] Exporting 5 global objects (4.61 KiB) to cluster node #1 ...
[13:14:31.361] Exporting '...future.FUN' (4.61 KiB) to cluster node #1 ...
[13:14:31.362] Exporting '...future.FUN' (4.61 KiB) to cluster node #1 ... DONE
[13:14:31.362] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[13:14:31.362] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[13:14:31.363] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ...
[13:14:31.363] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ... DONE
[13:14:31.363] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[13:14:31.364] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[13:14:31.364] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[13:14:31.365] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[13:14:31.365] Exporting 5 global objects (4.61 KiB) to cluster node #1 ... DONE
[13:14:31.366] MultisessionFuture started
[13:14:31.366] - Launch lazy future ... done
[13:14:31.366] run() for 'MultisessionFuture' ... done
[13:14:31.366] Created future:
[13:14:31.366] MultisessionFuture:
[13:14:31.366] Label: 'future_lapply-1'
[13:14:31.366] Expression:
[13:14:31.366] {
[13:14:31.366]     do.call(function(...) {
[13:14:31.366]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[13:14:31.366]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[13:14:31.366]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[13:14:31.366]             on.exit(options(oopts), add = TRUE)
[13:14:31.366]         }
[13:14:31.366]         {
[13:14:31.366]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[13:14:31.366]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[13:14:31.366]                 ...future.FUN(...future.X_jj, ...)
[13:14:31.366]             })
[13:14:31.366]         }
[13:14:31.366]     }, args = future.call.arguments)
[13:14:31.366] }
[13:14:31.366] Lazy evaluation: FALSE
[13:14:31.366] Asynchronous evaluation: TRUE
[13:14:31.366] Local evaluation: TRUE
[13:14:31.366] Environment: R_GlobalEnv
[13:14:31.366] Capture standard output: FALSE
[13:14:31.366] Capture condition classes: 'condition' (excluding 'nothing')
[13:14:31.366] Globals: 5 objects totaling 4.66 KiB (function '...future.FUN' of 4.61 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 56 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[13:14:31.366] Packages: <none>
[13:14:31.366] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[13:14:31.366] Resolved: FALSE
[13:14:31.366] Value: <not collected>
[13:14:31.366] Conditions captured: <none>
[13:14:31.366] Early signaling: FALSE
[13:14:31.366] Owner process: 68097d82-3b31-293d-2920-9b7259f27083
[13:14:31.366] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[13:14:31.570] Chunk #1 of 2 ... DONE
[13:14:31.570] Chunk #2 of 2 ...
[13:14:31.570]  - Finding globals in 'X' for chunk #2 ...
[13:14:31.570] getGlobalsAndPackages() ...
[13:14:31.571] Searching for globals...
[13:14:31.571] 
[13:14:31.571] Searching for globals ... DONE
[13:14:31.571] - globals: [0] <none>
[13:14:31.571] getGlobalsAndPackages() ... DONE
[13:14:31.572]    + additional globals found: [n=0] 
[13:14:31.572]    + additional namespaces needed: [n=0] 
[13:14:31.572]  - Finding globals in 'X' for chunk #2 ... DONE
[13:14:31.572]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[13:14:31.572]  - seeds: <none>
[13:14:31.573]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:31.573] getGlobalsAndPackages() ...
[13:14:31.573] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:31.573] Resolving globals: FALSE
[13:14:31.573] Tweak future expression to call with '...' arguments ...
[13:14:31.574] {
[13:14:31.574]     do.call(function(...) {
[13:14:31.574]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[13:14:31.574]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[13:14:31.574]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[13:14:31.574]             on.exit(options(oopts), add = TRUE)
[13:14:31.574]         }
[13:14:31.574]         {
[13:14:31.574]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[13:14:31.574]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[13:14:31.574]                 ...future.FUN(...future.X_jj, ...)
[13:14:31.574]             })
[13:14:31.574]         }
[13:14:31.574]     }, args = future.call.arguments)
[13:14:31.574] }
[13:14:31.574] Tweak future expression to call with '...' arguments ... DONE
[13:14:31.575] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:31.575] 
[13:14:31.575] getGlobalsAndPackages() ... DONE
[13:14:31.575] run() for 'Future' ...
[13:14:31.576] - state: 'created'
[13:14:31.576] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[13:14:31.591] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[13:14:31.591] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[13:14:31.591]   - Field: 'node'
[13:14:31.591]   - Field: 'label'
[13:14:31.591]   - Field: 'local'
[13:14:31.592]   - Field: 'owner'
[13:14:31.592]   - Field: 'envir'
[13:14:31.592]   - Field: 'workers'
[13:14:31.592]   - Field: 'packages'
[13:14:31.592]   - Field: 'gc'
[13:14:31.593]   - Field: 'conditions'
[13:14:31.593]   - Field: 'persistent'
[13:14:31.593]   - Field: 'expr'
[13:14:31.593]   - Field: 'uuid'
[13:14:31.593]   - Field: 'seed'
[13:14:31.594]   - Field: 'version'
[13:14:31.594]   - Field: 'result'
[13:14:31.594]   - Field: 'asynchronous'
[13:14:31.594]   - Field: 'calls'
[13:14:31.594]   - Field: 'globals'
[13:14:31.595]   - Field: 'stdout'
[13:14:31.595]   - Field: 'earlySignal'
[13:14:31.595]   - Field: 'lazy'
[13:14:31.595]   - Field: 'state'
[13:14:31.595] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[13:14:31.596] - Launch lazy future ...
[13:14:31.596] Packages needed by the future expression (n = 0): <none>
[13:14:31.596] Packages needed by future strategies (n = 0): <none>
[13:14:31.597] {
[13:14:31.597]     {
[13:14:31.597]         {
[13:14:31.597]             ...future.startTime <- base::Sys.time()
[13:14:31.597]             {
[13:14:31.597]                 {
[13:14:31.597]                   {
[13:14:31.597]                     {
[13:14:31.597]                       base::local({
[13:14:31.597]                         has_future <- base::requireNamespace("future", 
[13:14:31.597]                           quietly = TRUE)
[13:14:31.597]                         if (has_future) {
[13:14:31.597]                           ns <- base::getNamespace("future")
[13:14:31.597]                           version <- ns[[".package"]][["version"]]
[13:14:31.597]                           if (is.null(version)) 
[13:14:31.597]                             version <- utils::packageVersion("future")
[13:14:31.597]                         }
[13:14:31.597]                         else {
[13:14:31.597]                           version <- NULL
[13:14:31.597]                         }
[13:14:31.597]                         if (!has_future || version < "1.8.0") {
[13:14:31.597]                           info <- base::c(r_version = base::gsub("R version ", 
[13:14:31.597]                             "", base::R.version$version.string), 
[13:14:31.597]                             platform = base::sprintf("%s (%s-bit)", 
[13:14:31.597]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[13:14:31.597]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[13:14:31.597]                               "release", "version")], collapse = " "), 
[13:14:31.597]                             hostname = base::Sys.info()[["nodename"]])
[13:14:31.597]                           info <- base::sprintf("%s: %s", base::names(info), 
[13:14:31.597]                             info)
[13:14:31.597]                           info <- base::paste(info, collapse = "; ")
[13:14:31.597]                           if (!has_future) {
[13:14:31.597]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[13:14:31.597]                               info)
[13:14:31.597]                           }
[13:14:31.597]                           else {
[13:14:31.597]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[13:14:31.597]                               info, version)
[13:14:31.597]                           }
[13:14:31.597]                           base::stop(msg)
[13:14:31.597]                         }
[13:14:31.597]                       })
[13:14:31.597]                     }
[13:14:31.597]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[13:14:31.597]                     base::options(mc.cores = 1L)
[13:14:31.597]                   }
[13:14:31.597]                   options(future.plan = NULL)
[13:14:31.597]                   Sys.unsetenv("R_FUTURE_PLAN")
[13:14:31.597]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[13:14:31.597]                 }
[13:14:31.597]                 ...future.workdir <- getwd()
[13:14:31.597]             }
[13:14:31.597]             ...future.oldOptions <- base::as.list(base::.Options)
[13:14:31.597]             ...future.oldEnvVars <- base::Sys.getenv()
[13:14:31.597]         }
[13:14:31.597]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[13:14:31.597]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[13:14:31.597]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[13:14:31.597]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[13:14:31.597]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[13:14:31.597]             future.stdout.windows.reencode = NULL, width = 80L)
[13:14:31.597]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[13:14:31.597]             base::names(...future.oldOptions))
[13:14:31.597]     }
[13:14:31.597]     if (FALSE) {
[13:14:31.597]     }
[13:14:31.597]     else {
[13:14:31.597]         if (FALSE) {
[13:14:31.597]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[13:14:31.597]                 open = "w")
[13:14:31.597]         }
[13:14:31.597]         else {
[13:14:31.597]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[13:14:31.597]                 windows = "NUL", "/dev/null"), open = "w")
[13:14:31.597]         }
[13:14:31.597]         base::sink(...future.stdout, type = "output", split = FALSE)
[13:14:31.597]         base::on.exit(if (!base::is.null(...future.stdout)) {
[13:14:31.597]             base::sink(type = "output", split = FALSE)
[13:14:31.597]             base::close(...future.stdout)
[13:14:31.597]         }, add = TRUE)
[13:14:31.597]     }
[13:14:31.597]     ...future.frame <- base::sys.nframe()
[13:14:31.597]     ...future.conditions <- base::list()
[13:14:31.597]     ...future.rng <- base::globalenv()$.Random.seed
[13:14:31.597]     if (FALSE) {
[13:14:31.597]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[13:14:31.597]             "...future.value", "...future.globalenv.names", ".Random.seed")
[13:14:31.597]     }
[13:14:31.597]     ...future.result <- base::tryCatch({
[13:14:31.597]         base::withCallingHandlers({
[13:14:31.597]             ...future.value <- base::withVisible(base::local({
[13:14:31.597]                 ...future.makeSendCondition <- local({
[13:14:31.597]                   sendCondition <- NULL
[13:14:31.597]                   function(frame = 1L) {
[13:14:31.597]                     if (is.function(sendCondition)) 
[13:14:31.597]                       return(sendCondition)
[13:14:31.597]                     ns <- getNamespace("parallel")
[13:14:31.597]                     if (exists("sendData", mode = "function", 
[13:14:31.597]                       envir = ns)) {
[13:14:31.597]                       parallel_sendData <- get("sendData", mode = "function", 
[13:14:31.597]                         envir = ns)
[13:14:31.597]                       envir <- sys.frame(frame)
[13:14:31.597]                       master <- NULL
[13:14:31.597]                       while (!identical(envir, .GlobalEnv) && 
[13:14:31.597]                         !identical(envir, emptyenv())) {
[13:14:31.597]                         if (exists("master", mode = "list", envir = envir, 
[13:14:31.597]                           inherits = FALSE)) {
[13:14:31.597]                           master <- get("master", mode = "list", 
[13:14:31.597]                             envir = envir, inherits = FALSE)
[13:14:31.597]                           if (inherits(master, c("SOCKnode", 
[13:14:31.597]                             "SOCK0node"))) {
[13:14:31.597]                             sendCondition <<- function(cond) {
[13:14:31.597]                               data <- list(type = "VALUE", value = cond, 
[13:14:31.597]                                 success = TRUE)
[13:14:31.597]                               parallel_sendData(master, data)
[13:14:31.597]                             }
[13:14:31.597]                             return(sendCondition)
[13:14:31.597]                           }
[13:14:31.597]                         }
[13:14:31.597]                         frame <- frame + 1L
[13:14:31.597]                         envir <- sys.frame(frame)
[13:14:31.597]                       }
[13:14:31.597]                     }
[13:14:31.597]                     sendCondition <<- function(cond) NULL
[13:14:31.597]                   }
[13:14:31.597]                 })
[13:14:31.597]                 withCallingHandlers({
[13:14:31.597]                   {
[13:14:31.597]                     do.call(function(...) {
[13:14:31.597]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[13:14:31.597]                       if (!identical(...future.globals.maxSize.org, 
[13:14:31.597]                         ...future.globals.maxSize)) {
[13:14:31.597]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[13:14:31.597]                         on.exit(options(oopts), add = TRUE)
[13:14:31.597]                       }
[13:14:31.597]                       {
[13:14:31.597]                         lapply(seq_along(...future.elements_ii), 
[13:14:31.597]                           FUN = function(jj) {
[13:14:31.597]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[13:14:31.597]                             ...future.FUN(...future.X_jj, ...)
[13:14:31.597]                           })
[13:14:31.597]                       }
[13:14:31.597]                     }, args = future.call.arguments)
[13:14:31.597]                   }
[13:14:31.597]                 }, immediateCondition = function(cond) {
[13:14:31.597]                   sendCondition <- ...future.makeSendCondition()
[13:14:31.597]                   sendCondition(cond)
[13:14:31.597]                   muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:31.597]                   {
[13:14:31.597]                     inherits <- base::inherits
[13:14:31.597]                     invokeRestart <- base::invokeRestart
[13:14:31.597]                     is.null <- base::is.null
[13:14:31.597]                     muffled <- FALSE
[13:14:31.597]                     if (inherits(cond, "message")) {
[13:14:31.597]                       muffled <- grepl(pattern, "muffleMessage")
[13:14:31.597]                       if (muffled) 
[13:14:31.597]                         invokeRestart("muffleMessage")
[13:14:31.597]                     }
[13:14:31.597]                     else if (inherits(cond, "warning")) {
[13:14:31.597]                       muffled <- grepl(pattern, "muffleWarning")
[13:14:31.597]                       if (muffled) 
[13:14:31.597]                         invokeRestart("muffleWarning")
[13:14:31.597]                     }
[13:14:31.597]                     else if (inherits(cond, "condition")) {
[13:14:31.597]                       if (!is.null(pattern)) {
[13:14:31.597]                         computeRestarts <- base::computeRestarts
[13:14:31.597]                         grepl <- base::grepl
[13:14:31.597]                         restarts <- computeRestarts(cond)
[13:14:31.597]                         for (restart in restarts) {
[13:14:31.597]                           name <- restart$name
[13:14:31.597]                           if (is.null(name)) 
[13:14:31.597]                             next
[13:14:31.597]                           if (!grepl(pattern, name)) 
[13:14:31.597]                             next
[13:14:31.597]                           invokeRestart(restart)
[13:14:31.597]                           muffled <- TRUE
[13:14:31.597]                           break
[13:14:31.597]                         }
[13:14:31.597]                       }
[13:14:31.597]                     }
[13:14:31.597]                     invisible(muffled)
[13:14:31.597]                   }
[13:14:31.597]                   muffleCondition(cond)
[13:14:31.597]                 })
[13:14:31.597]             }))
[13:14:31.597]             future::FutureResult(value = ...future.value$value, 
[13:14:31.597]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[13:14:31.597]                   ...future.rng), globalenv = if (FALSE) 
[13:14:31.597]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[13:14:31.597]                     ...future.globalenv.names))
[13:14:31.597]                 else NULL, started = ...future.startTime, version = "1.8")
[13:14:31.597]         }, condition = base::local({
[13:14:31.597]             c <- base::c
[13:14:31.597]             inherits <- base::inherits
[13:14:31.597]             invokeRestart <- base::invokeRestart
[13:14:31.597]             length <- base::length
[13:14:31.597]             list <- base::list
[13:14:31.597]             seq.int <- base::seq.int
[13:14:31.597]             signalCondition <- base::signalCondition
[13:14:31.597]             sys.calls <- base::sys.calls
[13:14:31.597]             `[[` <- base::`[[`
[13:14:31.597]             `+` <- base::`+`
[13:14:31.597]             `<<-` <- base::`<<-`
[13:14:31.597]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[13:14:31.597]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[13:14:31.597]                   3L)]
[13:14:31.597]             }
[13:14:31.597]             function(cond) {
[13:14:31.597]                 is_error <- inherits(cond, "error")
[13:14:31.597]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[13:14:31.597]                   NULL)
[13:14:31.597]                 if (is_error) {
[13:14:31.597]                   sessionInformation <- function() {
[13:14:31.597]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[13:14:31.597]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[13:14:31.597]                       search = base::search(), system = base::Sys.info())
[13:14:31.597]                   }
[13:14:31.597]                   ...future.conditions[[length(...future.conditions) + 
[13:14:31.597]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[13:14:31.597]                     cond$call), session = sessionInformation(), 
[13:14:31.597]                     timestamp = base::Sys.time(), signaled = 0L)
[13:14:31.597]                   signalCondition(cond)
[13:14:31.597]                 }
[13:14:31.597]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[13:14:31.597]                 "immediateCondition"))) {
[13:14:31.597]                   signal <- TRUE && inherits(cond, "immediateCondition")
[13:14:31.597]                   ...future.conditions[[length(...future.conditions) + 
[13:14:31.597]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[13:14:31.597]                   if (TRUE && !signal) {
[13:14:31.597]                     muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:31.597]                     {
[13:14:31.597]                       inherits <- base::inherits
[13:14:31.597]                       invokeRestart <- base::invokeRestart
[13:14:31.597]                       is.null <- base::is.null
[13:14:31.597]                       muffled <- FALSE
[13:14:31.597]                       if (inherits(cond, "message")) {
[13:14:31.597]                         muffled <- grepl(pattern, "muffleMessage")
[13:14:31.597]                         if (muffled) 
[13:14:31.597]                           invokeRestart("muffleMessage")
[13:14:31.597]                       }
[13:14:31.597]                       else if (inherits(cond, "warning")) {
[13:14:31.597]                         muffled <- grepl(pattern, "muffleWarning")
[13:14:31.597]                         if (muffled) 
[13:14:31.597]                           invokeRestart("muffleWarning")
[13:14:31.597]                       }
[13:14:31.597]                       else if (inherits(cond, "condition")) {
[13:14:31.597]                         if (!is.null(pattern)) {
[13:14:31.597]                           computeRestarts <- base::computeRestarts
[13:14:31.597]                           grepl <- base::grepl
[13:14:31.597]                           restarts <- computeRestarts(cond)
[13:14:31.597]                           for (restart in restarts) {
[13:14:31.597]                             name <- restart$name
[13:14:31.597]                             if (is.null(name)) 
[13:14:31.597]                               next
[13:14:31.597]                             if (!grepl(pattern, name)) 
[13:14:31.597]                               next
[13:14:31.597]                             invokeRestart(restart)
[13:14:31.597]                             muffled <- TRUE
[13:14:31.597]                             break
[13:14:31.597]                           }
[13:14:31.597]                         }
[13:14:31.597]                       }
[13:14:31.597]                       invisible(muffled)
[13:14:31.597]                     }
[13:14:31.597]                     muffleCondition(cond, pattern = "^muffle")
[13:14:31.597]                   }
[13:14:31.597]                 }
[13:14:31.597]                 else {
[13:14:31.597]                   if (TRUE) {
[13:14:31.597]                     muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:31.597]                     {
[13:14:31.597]                       inherits <- base::inherits
[13:14:31.597]                       invokeRestart <- base::invokeRestart
[13:14:31.597]                       is.null <- base::is.null
[13:14:31.597]                       muffled <- FALSE
[13:14:31.597]                       if (inherits(cond, "message")) {
[13:14:31.597]                         muffled <- grepl(pattern, "muffleMessage")
[13:14:31.597]                         if (muffled) 
[13:14:31.597]                           invokeRestart("muffleMessage")
[13:14:31.597]                       }
[13:14:31.597]                       else if (inherits(cond, "warning")) {
[13:14:31.597]                         muffled <- grepl(pattern, "muffleWarning")
[13:14:31.597]                         if (muffled) 
[13:14:31.597]                           invokeRestart("muffleWarning")
[13:14:31.597]                       }
[13:14:31.597]                       else if (inherits(cond, "condition")) {
[13:14:31.597]                         if (!is.null(pattern)) {
[13:14:31.597]                           computeRestarts <- base::computeRestarts
[13:14:31.597]                           grepl <- base::grepl
[13:14:31.597]                           restarts <- computeRestarts(cond)
[13:14:31.597]                           for (restart in restarts) {
[13:14:31.597]                             name <- restart$name
[13:14:31.597]                             if (is.null(name)) 
[13:14:31.597]                               next
[13:14:31.597]                             if (!grepl(pattern, name)) 
[13:14:31.597]                               next
[13:14:31.597]                             invokeRestart(restart)
[13:14:31.597]                             muffled <- TRUE
[13:14:31.597]                             break
[13:14:31.597]                           }
[13:14:31.597]                         }
[13:14:31.597]                       }
[13:14:31.597]                       invisible(muffled)
[13:14:31.597]                     }
[13:14:31.597]                     muffleCondition(cond, pattern = "^muffle")
[13:14:31.597]                   }
[13:14:31.597]                 }
[13:14:31.597]             }
[13:14:31.597]         }))
[13:14:31.597]     }, error = function(ex) {
[13:14:31.597]         base::structure(base::list(value = NULL, visible = NULL, 
[13:14:31.597]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[13:14:31.597]                 ...future.rng), started = ...future.startTime, 
[13:14:31.597]             finished = Sys.time(), session_uuid = NA_character_, 
[13:14:31.597]             version = "1.8"), class = "FutureResult")
[13:14:31.597]     }, finally = {
[13:14:31.597]         if (!identical(...future.workdir, getwd())) 
[13:14:31.597]             setwd(...future.workdir)
[13:14:31.597]         {
[13:14:31.597]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[13:14:31.597]                 ...future.oldOptions$nwarnings <- NULL
[13:14:31.597]             }
[13:14:31.597]             base::options(...future.oldOptions)
[13:14:31.597]             if (.Platform$OS.type == "windows") {
[13:14:31.597]                 old_names <- names(...future.oldEnvVars)
[13:14:31.597]                 envs <- base::Sys.getenv()
[13:14:31.597]                 names <- names(envs)
[13:14:31.597]                 common <- intersect(names, old_names)
[13:14:31.597]                 added <- setdiff(names, old_names)
[13:14:31.597]                 removed <- setdiff(old_names, names)
[13:14:31.597]                 changed <- common[...future.oldEnvVars[common] != 
[13:14:31.597]                   envs[common]]
[13:14:31.597]                 NAMES <- toupper(changed)
[13:14:31.597]                 args <- list()
[13:14:31.597]                 for (kk in seq_along(NAMES)) {
[13:14:31.597]                   name <- changed[[kk]]
[13:14:31.597]                   NAME <- NAMES[[kk]]
[13:14:31.597]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:31.597]                     next
[13:14:31.597]                   args[[name]] <- ...future.oldEnvVars[[name]]
[13:14:31.597]                 }
[13:14:31.597]                 NAMES <- toupper(added)
[13:14:31.597]                 for (kk in seq_along(NAMES)) {
[13:14:31.597]                   name <- added[[kk]]
[13:14:31.597]                   NAME <- NAMES[[kk]]
[13:14:31.597]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:31.597]                     next
[13:14:31.597]                   args[[name]] <- ""
[13:14:31.597]                 }
[13:14:31.597]                 NAMES <- toupper(removed)
[13:14:31.597]                 for (kk in seq_along(NAMES)) {
[13:14:31.597]                   name <- removed[[kk]]
[13:14:31.597]                   NAME <- NAMES[[kk]]
[13:14:31.597]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:31.597]                     next
[13:14:31.597]                   args[[name]] <- ...future.oldEnvVars[[name]]
[13:14:31.597]                 }
[13:14:31.597]                 if (length(args) > 0) 
[13:14:31.597]                   base::do.call(base::Sys.setenv, args = args)
[13:14:31.597]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[13:14:31.597]             }
[13:14:31.597]             else {
[13:14:31.597]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[13:14:31.597]             }
[13:14:31.597]             {
[13:14:31.597]                 if (base::length(...future.futureOptionsAdded) > 
[13:14:31.597]                   0L) {
[13:14:31.597]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[13:14:31.597]                   base::names(opts) <- ...future.futureOptionsAdded
[13:14:31.597]                   base::options(opts)
[13:14:31.597]                 }
[13:14:31.597]                 {
[13:14:31.597]                   {
[13:14:31.597]                     base::options(mc.cores = ...future.mc.cores.old)
[13:14:31.597]                     NULL
[13:14:31.597]                   }
[13:14:31.597]                   options(future.plan = NULL)
[13:14:31.597]                   if (is.na(NA_character_)) 
[13:14:31.597]                     Sys.unsetenv("R_FUTURE_PLAN")
[13:14:31.597]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[13:14:31.597]                   future::plan(list(function (..., workers = availableCores(), 
[13:14:31.597]                     lazy = FALSE, rscript_libs = .libPaths(), 
[13:14:31.597]                     envir = parent.frame()) 
[13:14:31.597]                   {
[13:14:31.597]                     if (is.function(workers)) 
[13:14:31.597]                       workers <- workers()
[13:14:31.597]                     workers <- structure(as.integer(workers), 
[13:14:31.597]                       class = class(workers))
[13:14:31.597]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[13:14:31.597]                       workers >= 1)
[13:14:31.597]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[13:14:31.597]                       return(sequential(..., lazy = TRUE, envir = envir))
[13:14:31.597]                     }
[13:14:31.597]                     future <- MultisessionFuture(..., workers = workers, 
[13:14:31.597]                       lazy = lazy, rscript_libs = rscript_libs, 
[13:14:31.597]                       envir = envir)
[13:14:31.597]                     if (!future$lazy) 
[13:14:31.597]                       future <- run(future)
[13:14:31.597]                     invisible(future)
[13:14:31.597]                   }), .cleanup = FALSE, .init = FALSE)
[13:14:31.597]                 }
[13:14:31.597]             }
[13:14:31.597]         }
[13:14:31.597]     })
[13:14:31.597]     if (TRUE) {
[13:14:31.597]         base::sink(type = "output", split = FALSE)
[13:14:31.597]         if (FALSE) {
[13:14:31.597]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[13:14:31.597]         }
[13:14:31.597]         else {
[13:14:31.597]             ...future.result["stdout"] <- base::list(NULL)
[13:14:31.597]         }
[13:14:31.597]         base::close(...future.stdout)
[13:14:31.597]         ...future.stdout <- NULL
[13:14:31.597]     }
[13:14:31.597]     ...future.result$conditions <- ...future.conditions
[13:14:31.597]     ...future.result$finished <- base::Sys.time()
[13:14:31.597]     ...future.result
[13:14:31.597] }
[13:14:31.674] Exporting 5 global objects (4.61 KiB) to cluster node #2 ...
[13:14:31.675] Exporting '...future.FUN' (4.61 KiB) to cluster node #2 ...
[13:14:31.678] Exporting '...future.FUN' (4.61 KiB) to cluster node #2 ... DONE
[13:14:31.678] Exporting 'future.call.arguments' (0 bytes) to cluster node #2 ...
[13:14:31.679] Exporting 'future.call.arguments' (0 bytes) to cluster node #2 ... DONE
[13:14:31.679] Exporting '...future.elements_ii' (56 bytes) to cluster node #2 ...
[13:14:31.679] Exporting '...future.elements_ii' (56 bytes) to cluster node #2 ... DONE
[13:14:31.679] Exporting '...future.seeds_ii' (0 bytes) to cluster node #2 ...
[13:14:31.680] Exporting '...future.seeds_ii' (0 bytes) to cluster node #2 ... DONE
[13:14:31.680] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #2 ...
[13:14:31.680] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #2 ... DONE
[13:14:31.681] Exporting 5 global objects (4.61 KiB) to cluster node #2 ... DONE
[13:14:31.681] MultisessionFuture started
[13:14:31.681] - Launch lazy future ... done
[13:14:31.682] run() for 'MultisessionFuture' ... done
[13:14:31.682] Created future:
[13:14:31.739] receiveMessageFromWorker() for ClusterFuture ...
[13:14:31.739] - Validating connection of MultisessionFuture
[13:14:31.740] - received message: FutureResult
[13:14:31.740] - Received FutureResult
[13:14:31.740] - Erased future from FutureRegistry
[13:14:31.740] result() for ClusterFuture ...
[13:14:31.740] - result already collected: FutureResult
[13:14:31.741] result() for ClusterFuture ... done
[13:14:31.741] receiveMessageFromWorker() for ClusterFuture ... done
[13:14:31.682] MultisessionFuture:
[13:14:31.682] Label: 'future_lapply-2'
[13:14:31.682] Expression:
[13:14:31.682] {
[13:14:31.682]     do.call(function(...) {
[13:14:31.682]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[13:14:31.682]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[13:14:31.682]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[13:14:31.682]             on.exit(options(oopts), add = TRUE)
[13:14:31.682]         }
[13:14:31.682]         {
[13:14:31.682]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[13:14:31.682]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[13:14:31.682]                 ...future.FUN(...future.X_jj, ...)
[13:14:31.682]             })
[13:14:31.682]         }
[13:14:31.682]     }, args = future.call.arguments)
[13:14:31.682] }
[13:14:31.682] Lazy evaluation: FALSE
[13:14:31.682] Asynchronous evaluation: TRUE
[13:14:31.682] Local evaluation: TRUE
[13:14:31.682] Environment: R_GlobalEnv
[13:14:31.682] Capture standard output: FALSE
[13:14:31.682] Capture condition classes: 'condition' (excluding 'nothing')
[13:14:31.682] Globals: 5 objects totaling 4.66 KiB (function '...future.FUN' of 4.61 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 56 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[13:14:31.682] Packages: <none>
[13:14:31.682] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[13:14:31.682] Resolved: TRUE
[13:14:31.682] Value: <not collected>
[13:14:31.682] Conditions captured: <none>
[13:14:31.682] Early signaling: FALSE
[13:14:31.682] Owner process: 68097d82-3b31-293d-2920-9b7259f27083
[13:14:31.682] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[13:14:31.741] Chunk #2 of 2 ... DONE
[13:14:31.741] Launching 2 futures (chunks) ... DONE
[13:14:31.741] Resolving 2 futures (chunks) ...
[13:14:31.742] resolve() on list ...
[13:14:31.742]  recursive: 0
[13:14:31.742]  length: 2
[13:14:31.742] 
[13:14:31.898] receiveMessageFromWorker() for ClusterFuture ...
[13:14:31.898] - Validating connection of MultisessionFuture
[13:14:31.899] - received message: FutureResult
[13:14:31.899] - Received FutureResult
[13:14:31.899] - Erased future from FutureRegistry
[13:14:31.899] result() for ClusterFuture ...
[13:14:31.899] - result already collected: FutureResult
[13:14:31.899] result() for ClusterFuture ... done
[13:14:31.900] receiveMessageFromWorker() for ClusterFuture ... done
[13:14:31.900] Future #1
[13:14:31.900] result() for ClusterFuture ...
[13:14:31.900] - result already collected: FutureResult
[13:14:31.900] result() for ClusterFuture ... done
[13:14:31.900] result() for ClusterFuture ...
[13:14:31.901] - result already collected: FutureResult
[13:14:31.901] result() for ClusterFuture ... done
[13:14:31.901] signalConditionsASAP(MultisessionFuture, pos=1) ...
[13:14:31.901] - nx: 2
[13:14:31.901] - relay: TRUE
[13:14:31.901] - stdout: TRUE
[13:14:31.902] - signal: TRUE
[13:14:31.902] - resignal: FALSE
[13:14:31.902] - force: TRUE
[13:14:31.902] - relayed: [n=2] FALSE, FALSE
[13:14:31.902] - queued futures: [n=2] FALSE, FALSE
[13:14:31.902]  - until=1
[13:14:31.902]  - relaying element #1
[13:14:31.903] result() for ClusterFuture ...
[13:14:31.903] - result already collected: FutureResult
[13:14:31.903] result() for ClusterFuture ... done
[13:14:31.903] result() for ClusterFuture ...
[13:14:31.903] - result already collected: FutureResult
[13:14:31.903] result() for ClusterFuture ... done
[13:14:31.904] result() for ClusterFuture ...
[13:14:31.904] - result already collected: FutureResult
[13:14:31.904] result() for ClusterFuture ... done
[13:14:31.904] result() for ClusterFuture ...
[13:14:31.904] - result already collected: FutureResult
[13:14:31.904] result() for ClusterFuture ... done
[13:14:31.905] - relayed: [n=2] TRUE, FALSE
[13:14:31.905] - queued futures: [n=2] TRUE, FALSE
[13:14:31.905] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[13:14:31.905]  length: 1 (resolved future 1)
[13:14:31.905] Future #2
[13:14:31.905] result() for ClusterFuture ...
[13:14:31.906] - result already collected: FutureResult
[13:14:31.906] result() for ClusterFuture ... done
[13:14:31.906] result() for ClusterFuture ...
[13:14:31.906] - result already collected: FutureResult
[13:14:31.906] result() for ClusterFuture ... done
[13:14:31.906] signalConditionsASAP(MultisessionFuture, pos=2) ...
[13:14:31.906] - nx: 2
[13:14:31.907] - relay: TRUE
[13:14:31.907] - stdout: TRUE
[13:14:31.907] - signal: TRUE
[13:14:31.907] - resignal: FALSE
[13:14:31.907] - force: TRUE
[13:14:31.907] - relayed: [n=2] TRUE, FALSE
[13:14:31.908] - queued futures: [n=2] TRUE, FALSE
[13:14:31.908]  - until=2
[13:14:31.908]  - relaying element #2
[13:14:31.908] result() for ClusterFuture ...
[13:14:31.908] - result already collected: FutureResult
[13:14:31.908] result() for ClusterFuture ... done
[13:14:31.908] result() for ClusterFuture ...
[13:14:31.909] - result already collected: FutureResult
[13:14:31.909] result() for ClusterFuture ... done
[13:14:31.909] result() for ClusterFuture ...
[13:14:31.909] - result already collected: FutureResult
[13:14:31.909] result() for ClusterFuture ... done
[13:14:31.909] result() for ClusterFuture ...
[13:14:31.910] - result already collected: FutureResult
[13:14:31.910] result() for ClusterFuture ... done
[13:14:31.910] - relayed: [n=2] TRUE, TRUE
[13:14:31.910] - queued futures: [n=2] TRUE, TRUE
[13:14:31.910] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[13:14:31.910]  length: 0 (resolved future 2)
[13:14:31.911] Relaying remaining futures
[13:14:31.911] signalConditionsASAP(NULL, pos=0) ...
[13:14:31.911] - nx: 2
[13:14:31.911] - relay: TRUE
[13:14:31.911] - stdout: TRUE
[13:14:31.911] - signal: TRUE
[13:14:31.911] - resignal: FALSE
[13:14:31.912] - force: TRUE
[13:14:31.912] - relayed: [n=2] TRUE, TRUE
[13:14:31.912] - queued futures: [n=2] TRUE, TRUE
 - flush all
[13:14:31.912] - relayed: [n=2] TRUE, TRUE
[13:14:31.912] - queued futures: [n=2] TRUE, TRUE
[13:14:31.912] signalConditionsASAP(NULL, pos=0) ... done
[13:14:31.913] resolve() on list ... DONE
[13:14:31.913] result() for ClusterFuture ...
[13:14:31.913] - result already collected: FutureResult
[13:14:31.913] result() for ClusterFuture ... done
[13:14:31.913] result() for ClusterFuture ...
[13:14:31.913] - result already collected: FutureResult
[13:14:31.914] result() for ClusterFuture ... done
[13:14:31.914] result() for ClusterFuture ...
[13:14:31.914] - result already collected: FutureResult
[13:14:31.914] result() for ClusterFuture ... done
[13:14:31.914] result() for ClusterFuture ...
[13:14:31.914] - result already collected: FutureResult
[13:14:31.914] result() for ClusterFuture ... done
[13:14:31.915]  - Number of value chunks collected: 2
[13:14:31.915] Resolving 2 futures (chunks) ... DONE
[13:14:31.915] Reducing values from 2 chunks ...
[13:14:31.915]  - Number of values collected after concatenation: 2
[13:14:31.915]  - Number of values expected: 2
[13:14:31.915] Reducing values from 2 chunks ... DONE
[13:14:31.916] future_lapply() ... DONE
* future_lapply(x, ..., future.stdout = FALSE) ... DONE
* future_lapply(x, ..., future.stdout = TRUE) ...
[13:14:31.916] future_lapply() ...
[13:14:31.920] Number of chunks: 2
[13:14:31.920] getGlobalsAndPackagesXApply() ...
[13:14:31.920]  - future.globals: TRUE
[13:14:31.920] getGlobalsAndPackages() ...
[13:14:31.920] Searching for globals...
[13:14:31.922] - globals found: [5] 'FUN', '{', 'Sys.sleep', '/', 'print'
[13:14:31.922] Searching for globals ... DONE
[13:14:31.922] Resolving globals: FALSE
[13:14:31.923] The total size of the 1 globals is 4.61 KiB (4720 bytes)
[13:14:31.923] The total size of the 1 globals exported for future expression ('FUN()') is 4.61 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.61 KiB of class 'function')
[13:14:31.924] - globals: [1] 'FUN'
[13:14:31.924] 
[13:14:31.924] getGlobalsAndPackages() ... DONE
[13:14:31.924]  - globals found/used: [n=1] 'FUN'
[13:14:31.924]  - needed namespaces: [n=0] 
[13:14:31.924] Finding globals ... DONE
[13:14:31.925]  - use_args: TRUE
[13:14:31.925]  - Getting '...' globals ...
[13:14:31.925] resolve() on list ...
[13:14:31.925]  recursive: 0
[13:14:31.926]  length: 1
[13:14:31.926]  elements: '...'
[13:14:31.926]  length: 0 (resolved future 1)
[13:14:31.926] resolve() on list ... DONE
[13:14:31.926]    - '...' content: [n=0] 
[13:14:31.926] List of 1
[13:14:31.926]  $ ...: list()
[13:14:31.926]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[13:14:31.926]  - attr(*, "where")=List of 1
[13:14:31.926]   ..$ ...:<environment: 0x0000022a31754ae0> 
[13:14:31.926]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[13:14:31.926]  - attr(*, "resolved")= logi TRUE
[13:14:31.926]  - attr(*, "total_size")= num NA
[13:14:31.930]  - Getting '...' globals ... DONE
[13:14:31.930] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[13:14:31.930] List of 2
[13:14:31.930]  $ ...future.FUN:function (x)  
[13:14:31.930]  $ ...          : list()
[13:14:31.930]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[13:14:31.930]  - attr(*, "where")=List of 2
[13:14:31.930]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[13:14:31.930]   ..$ ...          :<environment: 0x0000022a31754ae0> 
[13:14:31.930]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[13:14:31.930]  - attr(*, "resolved")= logi FALSE
[13:14:31.930]  - attr(*, "total_size")= num 4720
[13:14:31.933] Packages to be attached in all futures: [n=0] 
[13:14:31.934] getGlobalsAndPackagesXApply() ... DONE
[13:14:31.934] Number of futures (= number of chunks): 2
[13:14:31.934] Launching 2 futures (chunks) ...
[13:14:31.934] Chunk #1 of 2 ...
[13:14:31.934]  - Finding globals in 'X' for chunk #1 ...
[13:14:31.935] getGlobalsAndPackages() ...
[13:14:31.935] Searching for globals...
[13:14:31.935] 
[13:14:31.935] Searching for globals ... DONE
[13:14:31.935] - globals: [0] <none>
[13:14:31.936] getGlobalsAndPackages() ... DONE
[13:14:31.936]    + additional globals found: [n=0] 
[13:14:31.936]    + additional namespaces needed: [n=0] 
[13:14:31.936]  - Finding globals in 'X' for chunk #1 ... DONE
[13:14:31.936]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[13:14:31.936]  - seeds: <none>
[13:14:31.937]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:31.937] getGlobalsAndPackages() ...
[13:14:31.937] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:31.937] Resolving globals: FALSE
[13:14:31.937] Tweak future expression to call with '...' arguments ...
[13:14:31.937] {
[13:14:31.937]     do.call(function(...) {
[13:14:31.937]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[13:14:31.937]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[13:14:31.937]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[13:14:31.937]             on.exit(options(oopts), add = TRUE)
[13:14:31.937]         }
[13:14:31.937]         {
[13:14:31.937]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[13:14:31.937]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[13:14:31.937]                 ...future.FUN(...future.X_jj, ...)
[13:14:31.937]             })
[13:14:31.937]         }
[13:14:31.937]     }, args = future.call.arguments)
[13:14:31.937] }
[13:14:31.938] Tweak future expression to call with '...' arguments ... DONE
[13:14:31.938] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:31.939] 
[13:14:31.939] getGlobalsAndPackages() ... DONE
[13:14:31.939] run() for 'Future' ...
[13:14:31.939] - state: 'created'
[13:14:31.940] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[13:14:31.954] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[13:14:31.954] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[13:14:31.954]   - Field: 'node'
[13:14:31.954]   - Field: 'label'
[13:14:31.955]   - Field: 'local'
[13:14:31.955]   - Field: 'owner'
[13:14:31.955]   - Field: 'envir'
[13:14:31.955]   - Field: 'workers'
[13:14:31.955]   - Field: 'packages'
[13:14:31.956]   - Field: 'gc'
[13:14:31.956]   - Field: 'conditions'
[13:14:31.956]   - Field: 'persistent'
[13:14:31.956]   - Field: 'expr'
[13:14:31.956]   - Field: 'uuid'
[13:14:31.956]   - Field: 'seed'
[13:14:31.957]   - Field: 'version'
[13:14:31.957]   - Field: 'result'
[13:14:31.957]   - Field: 'asynchronous'
[13:14:31.957]   - Field: 'calls'
[13:14:31.957]   - Field: 'globals'
[13:14:31.958]   - Field: 'stdout'
[13:14:31.958]   - Field: 'earlySignal'
[13:14:31.958]   - Field: 'lazy'
[13:14:31.958]   - Field: 'state'
[13:14:31.958] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[13:14:31.958] - Launch lazy future ...
[13:14:31.959] Packages needed by the future expression (n = 0): <none>
[13:14:31.959] Packages needed by future strategies (n = 0): <none>
[13:14:31.960] {
[13:14:31.960]     {
[13:14:31.960]         {
[13:14:31.960]             ...future.startTime <- base::Sys.time()
[13:14:31.960]             {
[13:14:31.960]                 {
[13:14:31.960]                   {
[13:14:31.960]                     {
[13:14:31.960]                       base::local({
[13:14:31.960]                         has_future <- base::requireNamespace("future", 
[13:14:31.960]                           quietly = TRUE)
[13:14:31.960]                         if (has_future) {
[13:14:31.960]                           ns <- base::getNamespace("future")
[13:14:31.960]                           version <- ns[[".package"]][["version"]]
[13:14:31.960]                           if (is.null(version)) 
[13:14:31.960]                             version <- utils::packageVersion("future")
[13:14:31.960]                         }
[13:14:31.960]                         else {
[13:14:31.960]                           version <- NULL
[13:14:31.960]                         }
[13:14:31.960]                         if (!has_future || version < "1.8.0") {
[13:14:31.960]                           info <- base::c(r_version = base::gsub("R version ", 
[13:14:31.960]                             "", base::R.version$version.string), 
[13:14:31.960]                             platform = base::sprintf("%s (%s-bit)", 
[13:14:31.960]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[13:14:31.960]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[13:14:31.960]                               "release", "version")], collapse = " "), 
[13:14:31.960]                             hostname = base::Sys.info()[["nodename"]])
[13:14:31.960]                           info <- base::sprintf("%s: %s", base::names(info), 
[13:14:31.960]                             info)
[13:14:31.960]                           info <- base::paste(info, collapse = "; ")
[13:14:31.960]                           if (!has_future) {
[13:14:31.960]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[13:14:31.960]                               info)
[13:14:31.960]                           }
[13:14:31.960]                           else {
[13:14:31.960]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[13:14:31.960]                               info, version)
[13:14:31.960]                           }
[13:14:31.960]                           base::stop(msg)
[13:14:31.960]                         }
[13:14:31.960]                       })
[13:14:31.960]                     }
[13:14:31.960]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[13:14:31.960]                     base::options(mc.cores = 1L)
[13:14:31.960]                   }
[13:14:31.960]                   options(future.plan = NULL)
[13:14:31.960]                   Sys.unsetenv("R_FUTURE_PLAN")
[13:14:31.960]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[13:14:31.960]                 }
[13:14:31.960]                 ...future.workdir <- getwd()
[13:14:31.960]             }
[13:14:31.960]             ...future.oldOptions <- base::as.list(base::.Options)
[13:14:31.960]             ...future.oldEnvVars <- base::Sys.getenv()
[13:14:31.960]         }
[13:14:31.960]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[13:14:31.960]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[13:14:31.960]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[13:14:31.960]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[13:14:31.960]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[13:14:31.960]             future.stdout.windows.reencode = NULL, width = 80L)
[13:14:31.960]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[13:14:31.960]             base::names(...future.oldOptions))
[13:14:31.960]     }
[13:14:31.960]     if (FALSE) {
[13:14:31.960]     }
[13:14:31.960]     else {
[13:14:31.960]         if (TRUE) {
[13:14:31.960]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[13:14:31.960]                 open = "w")
[13:14:31.960]         }
[13:14:31.960]         else {
[13:14:31.960]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[13:14:31.960]                 windows = "NUL", "/dev/null"), open = "w")
[13:14:31.960]         }
[13:14:31.960]         base::sink(...future.stdout, type = "output", split = FALSE)
[13:14:31.960]         base::on.exit(if (!base::is.null(...future.stdout)) {
[13:14:31.960]             base::sink(type = "output", split = FALSE)
[13:14:31.960]             base::close(...future.stdout)
[13:14:31.960]         }, add = TRUE)
[13:14:31.960]     }
[13:14:31.960]     ...future.frame <- base::sys.nframe()
[13:14:31.960]     ...future.conditions <- base::list()
[13:14:31.960]     ...future.rng <- base::globalenv()$.Random.seed
[13:14:31.960]     if (FALSE) {
[13:14:31.960]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[13:14:31.960]             "...future.value", "...future.globalenv.names", ".Random.seed")
[13:14:31.960]     }
[13:14:31.960]     ...future.result <- base::tryCatch({
[13:14:31.960]         base::withCallingHandlers({
[13:14:31.960]             ...future.value <- base::withVisible(base::local({
[13:14:31.960]                 ...future.makeSendCondition <- local({
[13:14:31.960]                   sendCondition <- NULL
[13:14:31.960]                   function(frame = 1L) {
[13:14:31.960]                     if (is.function(sendCondition)) 
[13:14:31.960]                       return(sendCondition)
[13:14:31.960]                     ns <- getNamespace("parallel")
[13:14:31.960]                     if (exists("sendData", mode = "function", 
[13:14:31.960]                       envir = ns)) {
[13:14:31.960]                       parallel_sendData <- get("sendData", mode = "function", 
[13:14:31.960]                         envir = ns)
[13:14:31.960]                       envir <- sys.frame(frame)
[13:14:31.960]                       master <- NULL
[13:14:31.960]                       while (!identical(envir, .GlobalEnv) && 
[13:14:31.960]                         !identical(envir, emptyenv())) {
[13:14:31.960]                         if (exists("master", mode = "list", envir = envir, 
[13:14:31.960]                           inherits = FALSE)) {
[13:14:31.960]                           master <- get("master", mode = "list", 
[13:14:31.960]                             envir = envir, inherits = FALSE)
[13:14:31.960]                           if (inherits(master, c("SOCKnode", 
[13:14:31.960]                             "SOCK0node"))) {
[13:14:31.960]                             sendCondition <<- function(cond) {
[13:14:31.960]                               data <- list(type = "VALUE", value = cond, 
[13:14:31.960]                                 success = TRUE)
[13:14:31.960]                               parallel_sendData(master, data)
[13:14:31.960]                             }
[13:14:31.960]                             return(sendCondition)
[13:14:31.960]                           }
[13:14:31.960]                         }
[13:14:31.960]                         frame <- frame + 1L
[13:14:31.960]                         envir <- sys.frame(frame)
[13:14:31.960]                       }
[13:14:31.960]                     }
[13:14:31.960]                     sendCondition <<- function(cond) NULL
[13:14:31.960]                   }
[13:14:31.960]                 })
[13:14:31.960]                 withCallingHandlers({
[13:14:31.960]                   {
[13:14:31.960]                     do.call(function(...) {
[13:14:31.960]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[13:14:31.960]                       if (!identical(...future.globals.maxSize.org, 
[13:14:31.960]                         ...future.globals.maxSize)) {
[13:14:31.960]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[13:14:31.960]                         on.exit(options(oopts), add = TRUE)
[13:14:31.960]                       }
[13:14:31.960]                       {
[13:14:31.960]                         lapply(seq_along(...future.elements_ii), 
[13:14:31.960]                           FUN = function(jj) {
[13:14:31.960]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[13:14:31.960]                             ...future.FUN(...future.X_jj, ...)
[13:14:31.960]                           })
[13:14:31.960]                       }
[13:14:31.960]                     }, args = future.call.arguments)
[13:14:31.960]                   }
[13:14:31.960]                 }, immediateCondition = function(cond) {
[13:14:31.960]                   sendCondition <- ...future.makeSendCondition()
[13:14:31.960]                   sendCondition(cond)
[13:14:31.960]                   muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:31.960]                   {
[13:14:31.960]                     inherits <- base::inherits
[13:14:31.960]                     invokeRestart <- base::invokeRestart
[13:14:31.960]                     is.null <- base::is.null
[13:14:31.960]                     muffled <- FALSE
[13:14:31.960]                     if (inherits(cond, "message")) {
[13:14:31.960]                       muffled <- grepl(pattern, "muffleMessage")
[13:14:31.960]                       if (muffled) 
[13:14:31.960]                         invokeRestart("muffleMessage")
[13:14:31.960]                     }
[13:14:31.960]                     else if (inherits(cond, "warning")) {
[13:14:31.960]                       muffled <- grepl(pattern, "muffleWarning")
[13:14:31.960]                       if (muffled) 
[13:14:31.960]                         invokeRestart("muffleWarning")
[13:14:31.960]                     }
[13:14:31.960]                     else if (inherits(cond, "condition")) {
[13:14:31.960]                       if (!is.null(pattern)) {
[13:14:31.960]                         computeRestarts <- base::computeRestarts
[13:14:31.960]                         grepl <- base::grepl
[13:14:31.960]                         restarts <- computeRestarts(cond)
[13:14:31.960]                         for (restart in restarts) {
[13:14:31.960]                           name <- restart$name
[13:14:31.960]                           if (is.null(name)) 
[13:14:31.960]                             next
[13:14:31.960]                           if (!grepl(pattern, name)) 
[13:14:31.960]                             next
[13:14:31.960]                           invokeRestart(restart)
[13:14:31.960]                           muffled <- TRUE
[13:14:31.960]                           break
[13:14:31.960]                         }
[13:14:31.960]                       }
[13:14:31.960]                     }
[13:14:31.960]                     invisible(muffled)
[13:14:31.960]                   }
[13:14:31.960]                   muffleCondition(cond)
[13:14:31.960]                 })
[13:14:31.960]             }))
[13:14:31.960]             future::FutureResult(value = ...future.value$value, 
[13:14:31.960]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[13:14:31.960]                   ...future.rng), globalenv = if (FALSE) 
[13:14:31.960]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[13:14:31.960]                     ...future.globalenv.names))
[13:14:31.960]                 else NULL, started = ...future.startTime, version = "1.8")
[13:14:31.960]         }, condition = base::local({
[13:14:31.960]             c <- base::c
[13:14:31.960]             inherits <- base::inherits
[13:14:31.960]             invokeRestart <- base::invokeRestart
[13:14:31.960]             length <- base::length
[13:14:31.960]             list <- base::list
[13:14:31.960]             seq.int <- base::seq.int
[13:14:31.960]             signalCondition <- base::signalCondition
[13:14:31.960]             sys.calls <- base::sys.calls
[13:14:31.960]             `[[` <- base::`[[`
[13:14:31.960]             `+` <- base::`+`
[13:14:31.960]             `<<-` <- base::`<<-`
[13:14:31.960]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[13:14:31.960]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[13:14:31.960]                   3L)]
[13:14:31.960]             }
[13:14:31.960]             function(cond) {
[13:14:31.960]                 is_error <- inherits(cond, "error")
[13:14:31.960]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[13:14:31.960]                   NULL)
[13:14:31.960]                 if (is_error) {
[13:14:31.960]                   sessionInformation <- function() {
[13:14:31.960]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[13:14:31.960]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[13:14:31.960]                       search = base::search(), system = base::Sys.info())
[13:14:31.960]                   }
[13:14:31.960]                   ...future.conditions[[length(...future.conditions) + 
[13:14:31.960]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[13:14:31.960]                     cond$call), session = sessionInformation(), 
[13:14:31.960]                     timestamp = base::Sys.time(), signaled = 0L)
[13:14:31.960]                   signalCondition(cond)
[13:14:31.960]                 }
[13:14:31.960]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[13:14:31.960]                 "immediateCondition"))) {
[13:14:31.960]                   signal <- TRUE && inherits(cond, "immediateCondition")
[13:14:31.960]                   ...future.conditions[[length(...future.conditions) + 
[13:14:31.960]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[13:14:31.960]                   if (TRUE && !signal) {
[13:14:31.960]                     muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:31.960]                     {
[13:14:31.960]                       inherits <- base::inherits
[13:14:31.960]                       invokeRestart <- base::invokeRestart
[13:14:31.960]                       is.null <- base::is.null
[13:14:31.960]                       muffled <- FALSE
[13:14:31.960]                       if (inherits(cond, "message")) {
[13:14:31.960]                         muffled <- grepl(pattern, "muffleMessage")
[13:14:31.960]                         if (muffled) 
[13:14:31.960]                           invokeRestart("muffleMessage")
[13:14:31.960]                       }
[13:14:31.960]                       else if (inherits(cond, "warning")) {
[13:14:31.960]                         muffled <- grepl(pattern, "muffleWarning")
[13:14:31.960]                         if (muffled) 
[13:14:31.960]                           invokeRestart("muffleWarning")
[13:14:31.960]                       }
[13:14:31.960]                       else if (inherits(cond, "condition")) {
[13:14:31.960]                         if (!is.null(pattern)) {
[13:14:31.960]                           computeRestarts <- base::computeRestarts
[13:14:31.960]                           grepl <- base::grepl
[13:14:31.960]                           restarts <- computeRestarts(cond)
[13:14:31.960]                           for (restart in restarts) {
[13:14:31.960]                             name <- restart$name
[13:14:31.960]                             if (is.null(name)) 
[13:14:31.960]                               next
[13:14:31.960]                             if (!grepl(pattern, name)) 
[13:14:31.960]                               next
[13:14:31.960]                             invokeRestart(restart)
[13:14:31.960]                             muffled <- TRUE
[13:14:31.960]                             break
[13:14:31.960]                           }
[13:14:31.960]                         }
[13:14:31.960]                       }
[13:14:31.960]                       invisible(muffled)
[13:14:31.960]                     }
[13:14:31.960]                     muffleCondition(cond, pattern = "^muffle")
[13:14:31.960]                   }
[13:14:31.960]                 }
[13:14:31.960]                 else {
[13:14:31.960]                   if (TRUE) {
[13:14:31.960]                     muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:31.960]                     {
[13:14:31.960]                       inherits <- base::inherits
[13:14:31.960]                       invokeRestart <- base::invokeRestart
[13:14:31.960]                       is.null <- base::is.null
[13:14:31.960]                       muffled <- FALSE
[13:14:31.960]                       if (inherits(cond, "message")) {
[13:14:31.960]                         muffled <- grepl(pattern, "muffleMessage")
[13:14:31.960]                         if (muffled) 
[13:14:31.960]                           invokeRestart("muffleMessage")
[13:14:31.960]                       }
[13:14:31.960]                       else if (inherits(cond, "warning")) {
[13:14:31.960]                         muffled <- grepl(pattern, "muffleWarning")
[13:14:31.960]                         if (muffled) 
[13:14:31.960]                           invokeRestart("muffleWarning")
[13:14:31.960]                       }
[13:14:31.960]                       else if (inherits(cond, "condition")) {
[13:14:31.960]                         if (!is.null(pattern)) {
[13:14:31.960]                           computeRestarts <- base::computeRestarts
[13:14:31.960]                           grepl <- base::grepl
[13:14:31.960]                           restarts <- computeRestarts(cond)
[13:14:31.960]                           for (restart in restarts) {
[13:14:31.960]                             name <- restart$name
[13:14:31.960]                             if (is.null(name)) 
[13:14:31.960]                               next
[13:14:31.960]                             if (!grepl(pattern, name)) 
[13:14:31.960]                               next
[13:14:31.960]                             invokeRestart(restart)
[13:14:31.960]                             muffled <- TRUE
[13:14:31.960]                             break
[13:14:31.960]                           }
[13:14:31.960]                         }
[13:14:31.960]                       }
[13:14:31.960]                       invisible(muffled)
[13:14:31.960]                     }
[13:14:31.960]                     muffleCondition(cond, pattern = "^muffle")
[13:14:31.960]                   }
[13:14:31.960]                 }
[13:14:31.960]             }
[13:14:31.960]         }))
[13:14:31.960]     }, error = function(ex) {
[13:14:31.960]         base::structure(base::list(value = NULL, visible = NULL, 
[13:14:31.960]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[13:14:31.960]                 ...future.rng), started = ...future.startTime, 
[13:14:31.960]             finished = Sys.time(), session_uuid = NA_character_, 
[13:14:31.960]             version = "1.8"), class = "FutureResult")
[13:14:31.960]     }, finally = {
[13:14:31.960]         if (!identical(...future.workdir, getwd())) 
[13:14:31.960]             setwd(...future.workdir)
[13:14:31.960]         {
[13:14:31.960]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[13:14:31.960]                 ...future.oldOptions$nwarnings <- NULL
[13:14:31.960]             }
[13:14:31.960]             base::options(...future.oldOptions)
[13:14:31.960]             if (.Platform$OS.type == "windows") {
[13:14:31.960]                 old_names <- names(...future.oldEnvVars)
[13:14:31.960]                 envs <- base::Sys.getenv()
[13:14:31.960]                 names <- names(envs)
[13:14:31.960]                 common <- intersect(names, old_names)
[13:14:31.960]                 added <- setdiff(names, old_names)
[13:14:31.960]                 removed <- setdiff(old_names, names)
[13:14:31.960]                 changed <- common[...future.oldEnvVars[common] != 
[13:14:31.960]                   envs[common]]
[13:14:31.960]                 NAMES <- toupper(changed)
[13:14:31.960]                 args <- list()
[13:14:31.960]                 for (kk in seq_along(NAMES)) {
[13:14:31.960]                   name <- changed[[kk]]
[13:14:31.960]                   NAME <- NAMES[[kk]]
[13:14:31.960]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:31.960]                     next
[13:14:31.960]                   args[[name]] <- ...future.oldEnvVars[[name]]
[13:14:31.960]                 }
[13:14:31.960]                 NAMES <- toupper(added)
[13:14:31.960]                 for (kk in seq_along(NAMES)) {
[13:14:31.960]                   name <- added[[kk]]
[13:14:31.960]                   NAME <- NAMES[[kk]]
[13:14:31.960]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:31.960]                     next
[13:14:31.960]                   args[[name]] <- ""
[13:14:31.960]                 }
[13:14:31.960]                 NAMES <- toupper(removed)
[13:14:31.960]                 for (kk in seq_along(NAMES)) {
[13:14:31.960]                   name <- removed[[kk]]
[13:14:31.960]                   NAME <- NAMES[[kk]]
[13:14:31.960]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:31.960]                     next
[13:14:31.960]                   args[[name]] <- ...future.oldEnvVars[[name]]
[13:14:31.960]                 }
[13:14:31.960]                 if (length(args) > 0) 
[13:14:31.960]                   base::do.call(base::Sys.setenv, args = args)
[13:14:31.960]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[13:14:31.960]             }
[13:14:31.960]             else {
[13:14:31.960]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[13:14:31.960]             }
[13:14:31.960]             {
[13:14:31.960]                 if (base::length(...future.futureOptionsAdded) > 
[13:14:31.960]                   0L) {
[13:14:31.960]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[13:14:31.960]                   base::names(opts) <- ...future.futureOptionsAdded
[13:14:31.960]                   base::options(opts)
[13:14:31.960]                 }
[13:14:31.960]                 {
[13:14:31.960]                   {
[13:14:31.960]                     base::options(mc.cores = ...future.mc.cores.old)
[13:14:31.960]                     NULL
[13:14:31.960]                   }
[13:14:31.960]                   options(future.plan = NULL)
[13:14:31.960]                   if (is.na(NA_character_)) 
[13:14:31.960]                     Sys.unsetenv("R_FUTURE_PLAN")
[13:14:31.960]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[13:14:31.960]                   future::plan(list(function (..., workers = availableCores(), 
[13:14:31.960]                     lazy = FALSE, rscript_libs = .libPaths(), 
[13:14:31.960]                     envir = parent.frame()) 
[13:14:31.960]                   {
[13:14:31.960]                     if (is.function(workers)) 
[13:14:31.960]                       workers <- workers()
[13:14:31.960]                     workers <- structure(as.integer(workers), 
[13:14:31.960]                       class = class(workers))
[13:14:31.960]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[13:14:31.960]                       workers >= 1)
[13:14:31.960]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[13:14:31.960]                       return(sequential(..., lazy = TRUE, envir = envir))
[13:14:31.960]                     }
[13:14:31.960]                     future <- MultisessionFuture(..., workers = workers, 
[13:14:31.960]                       lazy = lazy, rscript_libs = rscript_libs, 
[13:14:31.960]                       envir = envir)
[13:14:31.960]                     if (!future$lazy) 
[13:14:31.960]                       future <- run(future)
[13:14:31.960]                     invisible(future)
[13:14:31.960]                   }), .cleanup = FALSE, .init = FALSE)
[13:14:31.960]                 }
[13:14:31.960]             }
[13:14:31.960]         }
[13:14:31.960]     })
[13:14:31.960]     if (TRUE) {
[13:14:31.960]         base::sink(type = "output", split = FALSE)
[13:14:31.960]         if (TRUE) {
[13:14:31.960]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[13:14:31.960]         }
[13:14:31.960]         else {
[13:14:31.960]             ...future.result["stdout"] <- base::list(NULL)
[13:14:31.960]         }
[13:14:31.960]         base::close(...future.stdout)
[13:14:31.960]         ...future.stdout <- NULL
[13:14:31.960]     }
[13:14:31.960]     ...future.result$conditions <- ...future.conditions
[13:14:31.960]     ...future.result$finished <- base::Sys.time()
[13:14:31.960]     ...future.result
[13:14:31.960] }
[13:14:31.965] Exporting 5 global objects (4.61 KiB) to cluster node #1 ...
[13:14:31.965] Exporting '...future.FUN' (4.61 KiB) to cluster node #1 ...
[13:14:31.966] Exporting '...future.FUN' (4.61 KiB) to cluster node #1 ... DONE
[13:14:31.966] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[13:14:31.967] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[13:14:31.967] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ...
[13:14:31.967] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ... DONE
[13:14:31.968] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[13:14:31.968] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[13:14:31.968] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[13:14:31.969] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[13:14:31.969] Exporting 5 global objects (4.61 KiB) to cluster node #1 ... DONE
[13:14:31.970] MultisessionFuture started
[13:14:31.970] - Launch lazy future ... done
[13:14:31.970] run() for 'MultisessionFuture' ... done
[13:14:31.970] Created future:
[13:14:31.970] MultisessionFuture:
[13:14:31.970] Label: 'future_lapply-1'
[13:14:31.970] Expression:
[13:14:31.970] {
[13:14:31.970]     do.call(function(...) {
[13:14:31.970]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[13:14:31.970]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[13:14:31.970]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[13:14:31.970]             on.exit(options(oopts), add = TRUE)
[13:14:31.970]         }
[13:14:31.970]         {
[13:14:31.970]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[13:14:31.970]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[13:14:31.970]                 ...future.FUN(...future.X_jj, ...)
[13:14:31.970]             })
[13:14:31.970]         }
[13:14:31.970]     }, args = future.call.arguments)
[13:14:31.970] }
[13:14:31.970] Lazy evaluation: FALSE
[13:14:31.970] Asynchronous evaluation: TRUE
[13:14:31.970] Local evaluation: TRUE
[13:14:31.970] Environment: R_GlobalEnv
[13:14:31.970] Capture standard output: TRUE
[13:14:31.970] Capture condition classes: 'condition' (excluding 'nothing')
[13:14:31.970] Globals: 5 objects totaling 4.66 KiB (function '...future.FUN' of 4.61 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 56 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[13:14:31.970] Packages: <none>
[13:14:31.970] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[13:14:31.970] Resolved: FALSE
[13:14:31.970] Value: <not collected>
[13:14:31.970] Conditions captured: <none>
[13:14:31.970] Early signaling: FALSE
[13:14:31.970] Owner process: 68097d82-3b31-293d-2920-9b7259f27083
[13:14:31.970] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[13:14:32.163] Chunk #1 of 2 ... DONE
[13:14:32.163] Chunk #2 of 2 ...
[13:14:32.163]  - Finding globals in 'X' for chunk #2 ...
[13:14:32.164] getGlobalsAndPackages() ...
[13:14:32.164] Searching for globals...
[13:14:32.164] 
[13:14:32.164] Searching for globals ... DONE
[13:14:32.165] - globals: [0] <none>
[13:14:32.165] getGlobalsAndPackages() ... DONE
[13:14:32.165]    + additional globals found: [n=0] 
[13:14:32.165]    + additional namespaces needed: [n=0] 
[13:14:32.165]  - Finding globals in 'X' for chunk #2 ... DONE
[13:14:32.165]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[13:14:32.166]  - seeds: <none>
[13:14:32.166]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:32.166] getGlobalsAndPackages() ...
[13:14:32.166] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:32.166] Resolving globals: FALSE
[13:14:32.166] Tweak future expression to call with '...' arguments ...
[13:14:32.167] {
[13:14:32.167]     do.call(function(...) {
[13:14:32.167]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[13:14:32.167]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[13:14:32.167]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[13:14:32.167]             on.exit(options(oopts), add = TRUE)
[13:14:32.167]         }
[13:14:32.167]         {
[13:14:32.167]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[13:14:32.167]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[13:14:32.167]                 ...future.FUN(...future.X_jj, ...)
[13:14:32.167]             })
[13:14:32.167]         }
[13:14:32.167]     }, args = future.call.arguments)
[13:14:32.167] }
[13:14:32.167] Tweak future expression to call with '...' arguments ... DONE
[13:14:32.168] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:32.168] 
[13:14:32.168] getGlobalsAndPackages() ... DONE
[13:14:32.168] run() for 'Future' ...
[13:14:32.168] - state: 'created'
[13:14:32.169] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[13:14:32.183] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[13:14:32.183] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[13:14:32.183]   - Field: 'node'
[13:14:32.184]   - Field: 'label'
[13:14:32.184]   - Field: 'local'
[13:14:32.184]   - Field: 'owner'
[13:14:32.184]   - Field: 'envir'
[13:14:32.184]   - Field: 'workers'
[13:14:32.185]   - Field: 'packages'
[13:14:32.185]   - Field: 'gc'
[13:14:32.185]   - Field: 'conditions'
[13:14:32.185]   - Field: 'persistent'
[13:14:32.185]   - Field: 'expr'
[13:14:32.185]   - Field: 'uuid'
[13:14:32.186]   - Field: 'seed'
[13:14:32.186]   - Field: 'version'
[13:14:32.186]   - Field: 'result'
[13:14:32.186]   - Field: 'asynchronous'
[13:14:32.186]   - Field: 'calls'
[13:14:32.186]   - Field: 'globals'
[13:14:32.187]   - Field: 'stdout'
[13:14:32.187]   - Field: 'earlySignal'
[13:14:32.187]   - Field: 'lazy'
[13:14:32.187]   - Field: 'state'
[13:14:32.187] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[13:14:32.188] - Launch lazy future ...
[13:14:32.188] Packages needed by the future expression (n = 0): <none>
[13:14:32.188] Packages needed by future strategies (n = 0): <none>
[13:14:32.189] {
[13:14:32.189]     {
[13:14:32.189]         {
[13:14:32.189]             ...future.startTime <- base::Sys.time()
[13:14:32.189]             {
[13:14:32.189]                 {
[13:14:32.189]                   {
[13:14:32.189]                     {
[13:14:32.189]                       base::local({
[13:14:32.189]                         has_future <- base::requireNamespace("future", 
[13:14:32.189]                           quietly = TRUE)
[13:14:32.189]                         if (has_future) {
[13:14:32.189]                           ns <- base::getNamespace("future")
[13:14:32.189]                           version <- ns[[".package"]][["version"]]
[13:14:32.189]                           if (is.null(version)) 
[13:14:32.189]                             version <- utils::packageVersion("future")
[13:14:32.189]                         }
[13:14:32.189]                         else {
[13:14:32.189]                           version <- NULL
[13:14:32.189]                         }
[13:14:32.189]                         if (!has_future || version < "1.8.0") {
[13:14:32.189]                           info <- base::c(r_version = base::gsub("R version ", 
[13:14:32.189]                             "", base::R.version$version.string), 
[13:14:32.189]                             platform = base::sprintf("%s (%s-bit)", 
[13:14:32.189]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[13:14:32.189]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[13:14:32.189]                               "release", "version")], collapse = " "), 
[13:14:32.189]                             hostname = base::Sys.info()[["nodename"]])
[13:14:32.189]                           info <- base::sprintf("%s: %s", base::names(info), 
[13:14:32.189]                             info)
[13:14:32.189]                           info <- base::paste(info, collapse = "; ")
[13:14:32.189]                           if (!has_future) {
[13:14:32.189]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[13:14:32.189]                               info)
[13:14:32.189]                           }
[13:14:32.189]                           else {
[13:14:32.189]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[13:14:32.189]                               info, version)
[13:14:32.189]                           }
[13:14:32.189]                           base::stop(msg)
[13:14:32.189]                         }
[13:14:32.189]                       })
[13:14:32.189]                     }
[13:14:32.189]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[13:14:32.189]                     base::options(mc.cores = 1L)
[13:14:32.189]                   }
[13:14:32.189]                   options(future.plan = NULL)
[13:14:32.189]                   Sys.unsetenv("R_FUTURE_PLAN")
[13:14:32.189]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[13:14:32.189]                 }
[13:14:32.189]                 ...future.workdir <- getwd()
[13:14:32.189]             }
[13:14:32.189]             ...future.oldOptions <- base::as.list(base::.Options)
[13:14:32.189]             ...future.oldEnvVars <- base::Sys.getenv()
[13:14:32.189]         }
[13:14:32.189]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[13:14:32.189]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[13:14:32.189]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[13:14:32.189]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[13:14:32.189]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[13:14:32.189]             future.stdout.windows.reencode = NULL, width = 80L)
[13:14:32.189]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[13:14:32.189]             base::names(...future.oldOptions))
[13:14:32.189]     }
[13:14:32.189]     if (FALSE) {
[13:14:32.189]     }
[13:14:32.189]     else {
[13:14:32.189]         if (TRUE) {
[13:14:32.189]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[13:14:32.189]                 open = "w")
[13:14:32.189]         }
[13:14:32.189]         else {
[13:14:32.189]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[13:14:32.189]                 windows = "NUL", "/dev/null"), open = "w")
[13:14:32.189]         }
[13:14:32.189]         base::sink(...future.stdout, type = "output", split = FALSE)
[13:14:32.189]         base::on.exit(if (!base::is.null(...future.stdout)) {
[13:14:32.189]             base::sink(type = "output", split = FALSE)
[13:14:32.189]             base::close(...future.stdout)
[13:14:32.189]         }, add = TRUE)
[13:14:32.189]     }
[13:14:32.189]     ...future.frame <- base::sys.nframe()
[13:14:32.189]     ...future.conditions <- base::list()
[13:14:32.189]     ...future.rng <- base::globalenv()$.Random.seed
[13:14:32.189]     if (FALSE) {
[13:14:32.189]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[13:14:32.189]             "...future.value", "...future.globalenv.names", ".Random.seed")
[13:14:32.189]     }
[13:14:32.189]     ...future.result <- base::tryCatch({
[13:14:32.189]         base::withCallingHandlers({
[13:14:32.189]             ...future.value <- base::withVisible(base::local({
[13:14:32.189]                 ...future.makeSendCondition <- local({
[13:14:32.189]                   sendCondition <- NULL
[13:14:32.189]                   function(frame = 1L) {
[13:14:32.189]                     if (is.function(sendCondition)) 
[13:14:32.189]                       return(sendCondition)
[13:14:32.189]                     ns <- getNamespace("parallel")
[13:14:32.189]                     if (exists("sendData", mode = "function", 
[13:14:32.189]                       envir = ns)) {
[13:14:32.189]                       parallel_sendData <- get("sendData", mode = "function", 
[13:14:32.189]                         envir = ns)
[13:14:32.189]                       envir <- sys.frame(frame)
[13:14:32.189]                       master <- NULL
[13:14:32.189]                       while (!identical(envir, .GlobalEnv) && 
[13:14:32.189]                         !identical(envir, emptyenv())) {
[13:14:32.189]                         if (exists("master", mode = "list", envir = envir, 
[13:14:32.189]                           inherits = FALSE)) {
[13:14:32.189]                           master <- get("master", mode = "list", 
[13:14:32.189]                             envir = envir, inherits = FALSE)
[13:14:32.189]                           if (inherits(master, c("SOCKnode", 
[13:14:32.189]                             "SOCK0node"))) {
[13:14:32.189]                             sendCondition <<- function(cond) {
[13:14:32.189]                               data <- list(type = "VALUE", value = cond, 
[13:14:32.189]                                 success = TRUE)
[13:14:32.189]                               parallel_sendData(master, data)
[13:14:32.189]                             }
[13:14:32.189]                             return(sendCondition)
[13:14:32.189]                           }
[13:14:32.189]                         }
[13:14:32.189]                         frame <- frame + 1L
[13:14:32.189]                         envir <- sys.frame(frame)
[13:14:32.189]                       }
[13:14:32.189]                     }
[13:14:32.189]                     sendCondition <<- function(cond) NULL
[13:14:32.189]                   }
[13:14:32.189]                 })
[13:14:32.189]                 withCallingHandlers({
[13:14:32.189]                   {
[13:14:32.189]                     do.call(function(...) {
[13:14:32.189]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[13:14:32.189]                       if (!identical(...future.globals.maxSize.org, 
[13:14:32.189]                         ...future.globals.maxSize)) {
[13:14:32.189]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[13:14:32.189]                         on.exit(options(oopts), add = TRUE)
[13:14:32.189]                       }
[13:14:32.189]                       {
[13:14:32.189]                         lapply(seq_along(...future.elements_ii), 
[13:14:32.189]                           FUN = function(jj) {
[13:14:32.189]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[13:14:32.189]                             ...future.FUN(...future.X_jj, ...)
[13:14:32.189]                           })
[13:14:32.189]                       }
[13:14:32.189]                     }, args = future.call.arguments)
[13:14:32.189]                   }
[13:14:32.189]                 }, immediateCondition = function(cond) {
[13:14:32.189]                   sendCondition <- ...future.makeSendCondition()
[13:14:32.189]                   sendCondition(cond)
[13:14:32.189]                   muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:32.189]                   {
[13:14:32.189]                     inherits <- base::inherits
[13:14:32.189]                     invokeRestart <- base::invokeRestart
[13:14:32.189]                     is.null <- base::is.null
[13:14:32.189]                     muffled <- FALSE
[13:14:32.189]                     if (inherits(cond, "message")) {
[13:14:32.189]                       muffled <- grepl(pattern, "muffleMessage")
[13:14:32.189]                       if (muffled) 
[13:14:32.189]                         invokeRestart("muffleMessage")
[13:14:32.189]                     }
[13:14:32.189]                     else if (inherits(cond, "warning")) {
[13:14:32.189]                       muffled <- grepl(pattern, "muffleWarning")
[13:14:32.189]                       if (muffled) 
[13:14:32.189]                         invokeRestart("muffleWarning")
[13:14:32.189]                     }
[13:14:32.189]                     else if (inherits(cond, "condition")) {
[13:14:32.189]                       if (!is.null(pattern)) {
[13:14:32.189]                         computeRestarts <- base::computeRestarts
[13:14:32.189]                         grepl <- base::grepl
[13:14:32.189]                         restarts <- computeRestarts(cond)
[13:14:32.189]                         for (restart in restarts) {
[13:14:32.189]                           name <- restart$name
[13:14:32.189]                           if (is.null(name)) 
[13:14:32.189]                             next
[13:14:32.189]                           if (!grepl(pattern, name)) 
[13:14:32.189]                             next
[13:14:32.189]                           invokeRestart(restart)
[13:14:32.189]                           muffled <- TRUE
[13:14:32.189]                           break
[13:14:32.189]                         }
[13:14:32.189]                       }
[13:14:32.189]                     }
[13:14:32.189]                     invisible(muffled)
[13:14:32.189]                   }
[13:14:32.189]                   muffleCondition(cond)
[13:14:32.189]                 })
[13:14:32.189]             }))
[13:14:32.189]             future::FutureResult(value = ...future.value$value, 
[13:14:32.189]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[13:14:32.189]                   ...future.rng), globalenv = if (FALSE) 
[13:14:32.189]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[13:14:32.189]                     ...future.globalenv.names))
[13:14:32.189]                 else NULL, started = ...future.startTime, version = "1.8")
[13:14:32.189]         }, condition = base::local({
[13:14:32.189]             c <- base::c
[13:14:32.189]             inherits <- base::inherits
[13:14:32.189]             invokeRestart <- base::invokeRestart
[13:14:32.189]             length <- base::length
[13:14:32.189]             list <- base::list
[13:14:32.189]             seq.int <- base::seq.int
[13:14:32.189]             signalCondition <- base::signalCondition
[13:14:32.189]             sys.calls <- base::sys.calls
[13:14:32.189]             `[[` <- base::`[[`
[13:14:32.189]             `+` <- base::`+`
[13:14:32.189]             `<<-` <- base::`<<-`
[13:14:32.189]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[13:14:32.189]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[13:14:32.189]                   3L)]
[13:14:32.189]             }
[13:14:32.189]             function(cond) {
[13:14:32.189]                 is_error <- inherits(cond, "error")
[13:14:32.189]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[13:14:32.189]                   NULL)
[13:14:32.189]                 if (is_error) {
[13:14:32.189]                   sessionInformation <- function() {
[13:14:32.189]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[13:14:32.189]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[13:14:32.189]                       search = base::search(), system = base::Sys.info())
[13:14:32.189]                   }
[13:14:32.189]                   ...future.conditions[[length(...future.conditions) + 
[13:14:32.189]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[13:14:32.189]                     cond$call), session = sessionInformation(), 
[13:14:32.189]                     timestamp = base::Sys.time(), signaled = 0L)
[13:14:32.189]                   signalCondition(cond)
[13:14:32.189]                 }
[13:14:32.189]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[13:14:32.189]                 "immediateCondition"))) {
[13:14:32.189]                   signal <- TRUE && inherits(cond, "immediateCondition")
[13:14:32.189]                   ...future.conditions[[length(...future.conditions) + 
[13:14:32.189]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[13:14:32.189]                   if (TRUE && !signal) {
[13:14:32.189]                     muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:32.189]                     {
[13:14:32.189]                       inherits <- base::inherits
[13:14:32.189]                       invokeRestart <- base::invokeRestart
[13:14:32.189]                       is.null <- base::is.null
[13:14:32.189]                       muffled <- FALSE
[13:14:32.189]                       if (inherits(cond, "message")) {
[13:14:32.189]                         muffled <- grepl(pattern, "muffleMessage")
[13:14:32.189]                         if (muffled) 
[13:14:32.189]                           invokeRestart("muffleMessage")
[13:14:32.189]                       }
[13:14:32.189]                       else if (inherits(cond, "warning")) {
[13:14:32.189]                         muffled <- grepl(pattern, "muffleWarning")
[13:14:32.189]                         if (muffled) 
[13:14:32.189]                           invokeRestart("muffleWarning")
[13:14:32.189]                       }
[13:14:32.189]                       else if (inherits(cond, "condition")) {
[13:14:32.189]                         if (!is.null(pattern)) {
[13:14:32.189]                           computeRestarts <- base::computeRestarts
[13:14:32.189]                           grepl <- base::grepl
[13:14:32.189]                           restarts <- computeRestarts(cond)
[13:14:32.189]                           for (restart in restarts) {
[13:14:32.189]                             name <- restart$name
[13:14:32.189]                             if (is.null(name)) 
[13:14:32.189]                               next
[13:14:32.189]                             if (!grepl(pattern, name)) 
[13:14:32.189]                               next
[13:14:32.189]                             invokeRestart(restart)
[13:14:32.189]                             muffled <- TRUE
[13:14:32.189]                             break
[13:14:32.189]                           }
[13:14:32.189]                         }
[13:14:32.189]                       }
[13:14:32.189]                       invisible(muffled)
[13:14:32.189]                     }
[13:14:32.189]                     muffleCondition(cond, pattern = "^muffle")
[13:14:32.189]                   }
[13:14:32.189]                 }
[13:14:32.189]                 else {
[13:14:32.189]                   if (TRUE) {
[13:14:32.189]                     muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:32.189]                     {
[13:14:32.189]                       inherits <- base::inherits
[13:14:32.189]                       invokeRestart <- base::invokeRestart
[13:14:32.189]                       is.null <- base::is.null
[13:14:32.189]                       muffled <- FALSE
[13:14:32.189]                       if (inherits(cond, "message")) {
[13:14:32.189]                         muffled <- grepl(pattern, "muffleMessage")
[13:14:32.189]                         if (muffled) 
[13:14:32.189]                           invokeRestart("muffleMessage")
[13:14:32.189]                       }
[13:14:32.189]                       else if (inherits(cond, "warning")) {
[13:14:32.189]                         muffled <- grepl(pattern, "muffleWarning")
[13:14:32.189]                         if (muffled) 
[13:14:32.189]                           invokeRestart("muffleWarning")
[13:14:32.189]                       }
[13:14:32.189]                       else if (inherits(cond, "condition")) {
[13:14:32.189]                         if (!is.null(pattern)) {
[13:14:32.189]                           computeRestarts <- base::computeRestarts
[13:14:32.189]                           grepl <- base::grepl
[13:14:32.189]                           restarts <- computeRestarts(cond)
[13:14:32.189]                           for (restart in restarts) {
[13:14:32.189]                             name <- restart$name
[13:14:32.189]                             if (is.null(name)) 
[13:14:32.189]                               next
[13:14:32.189]                             if (!grepl(pattern, name)) 
[13:14:32.189]                               next
[13:14:32.189]                             invokeRestart(restart)
[13:14:32.189]                             muffled <- TRUE
[13:14:32.189]                             break
[13:14:32.189]                           }
[13:14:32.189]                         }
[13:14:32.189]                       }
[13:14:32.189]                       invisible(muffled)
[13:14:32.189]                     }
[13:14:32.189]                     muffleCondition(cond, pattern = "^muffle")
[13:14:32.189]                   }
[13:14:32.189]                 }
[13:14:32.189]             }
[13:14:32.189]         }))
[13:14:32.189]     }, error = function(ex) {
[13:14:32.189]         base::structure(base::list(value = NULL, visible = NULL, 
[13:14:32.189]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[13:14:32.189]                 ...future.rng), started = ...future.startTime, 
[13:14:32.189]             finished = Sys.time(), session_uuid = NA_character_, 
[13:14:32.189]             version = "1.8"), class = "FutureResult")
[13:14:32.189]     }, finally = {
[13:14:32.189]         if (!identical(...future.workdir, getwd())) 
[13:14:32.189]             setwd(...future.workdir)
[13:14:32.189]         {
[13:14:32.189]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[13:14:32.189]                 ...future.oldOptions$nwarnings <- NULL
[13:14:32.189]             }
[13:14:32.189]             base::options(...future.oldOptions)
[13:14:32.189]             if (.Platform$OS.type == "windows") {
[13:14:32.189]                 old_names <- names(...future.oldEnvVars)
[13:14:32.189]                 envs <- base::Sys.getenv()
[13:14:32.189]                 names <- names(envs)
[13:14:32.189]                 common <- intersect(names, old_names)
[13:14:32.189]                 added <- setdiff(names, old_names)
[13:14:32.189]                 removed <- setdiff(old_names, names)
[13:14:32.189]                 changed <- common[...future.oldEnvVars[common] != 
[13:14:32.189]                   envs[common]]
[13:14:32.189]                 NAMES <- toupper(changed)
[13:14:32.189]                 args <- list()
[13:14:32.189]                 for (kk in seq_along(NAMES)) {
[13:14:32.189]                   name <- changed[[kk]]
[13:14:32.189]                   NAME <- NAMES[[kk]]
[13:14:32.189]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:32.189]                     next
[13:14:32.189]                   args[[name]] <- ...future.oldEnvVars[[name]]
[13:14:32.189]                 }
[13:14:32.189]                 NAMES <- toupper(added)
[13:14:32.189]                 for (kk in seq_along(NAMES)) {
[13:14:32.189]                   name <- added[[kk]]
[13:14:32.189]                   NAME <- NAMES[[kk]]
[13:14:32.189]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:32.189]                     next
[13:14:32.189]                   args[[name]] <- ""
[13:14:32.189]                 }
[13:14:32.189]                 NAMES <- toupper(removed)
[13:14:32.189]                 for (kk in seq_along(NAMES)) {
[13:14:32.189]                   name <- removed[[kk]]
[13:14:32.189]                   NAME <- NAMES[[kk]]
[13:14:32.189]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:32.189]                     next
[13:14:32.189]                   args[[name]] <- ...future.oldEnvVars[[name]]
[13:14:32.189]                 }
[13:14:32.189]                 if (length(args) > 0) 
[13:14:32.189]                   base::do.call(base::Sys.setenv, args = args)
[13:14:32.189]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[13:14:32.189]             }
[13:14:32.189]             else {
[13:14:32.189]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[13:14:32.189]             }
[13:14:32.189]             {
[13:14:32.189]                 if (base::length(...future.futureOptionsAdded) > 
[13:14:32.189]                   0L) {
[13:14:32.189]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[13:14:32.189]                   base::names(opts) <- ...future.futureOptionsAdded
[13:14:32.189]                   base::options(opts)
[13:14:32.189]                 }
[13:14:32.189]                 {
[13:14:32.189]                   {
[13:14:32.189]                     base::options(mc.cores = ...future.mc.cores.old)
[13:14:32.189]                     NULL
[13:14:32.189]                   }
[13:14:32.189]                   options(future.plan = NULL)
[13:14:32.189]                   if (is.na(NA_character_)) 
[13:14:32.189]                     Sys.unsetenv("R_FUTURE_PLAN")
[13:14:32.189]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[13:14:32.189]                   future::plan(list(function (..., workers = availableCores(), 
[13:14:32.189]                     lazy = FALSE, rscript_libs = .libPaths(), 
[13:14:32.189]                     envir = parent.frame()) 
[13:14:32.189]                   {
[13:14:32.189]                     if (is.function(workers)) 
[13:14:32.189]                       workers <- workers()
[13:14:32.189]                     workers <- structure(as.integer(workers), 
[13:14:32.189]                       class = class(workers))
[13:14:32.189]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[13:14:32.189]                       workers >= 1)
[13:14:32.189]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[13:14:32.189]                       return(sequential(..., lazy = TRUE, envir = envir))
[13:14:32.189]                     }
[13:14:32.189]                     future <- MultisessionFuture(..., workers = workers, 
[13:14:32.189]                       lazy = lazy, rscript_libs = rscript_libs, 
[13:14:32.189]                       envir = envir)
[13:14:32.189]                     if (!future$lazy) 
[13:14:32.189]                       future <- run(future)
[13:14:32.189]                     invisible(future)
[13:14:32.189]                   }), .cleanup = FALSE, .init = FALSE)
[13:14:32.189]                 }
[13:14:32.189]             }
[13:14:32.189]         }
[13:14:32.189]     })
[13:14:32.189]     if (TRUE) {
[13:14:32.189]         base::sink(type = "output", split = FALSE)
[13:14:32.189]         if (TRUE) {
[13:14:32.189]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[13:14:32.189]         }
[13:14:32.189]         else {
[13:14:32.189]             ...future.result["stdout"] <- base::list(NULL)
[13:14:32.189]         }
[13:14:32.189]         base::close(...future.stdout)
[13:14:32.189]         ...future.stdout <- NULL
[13:14:32.189]     }
[13:14:32.189]     ...future.result$conditions <- ...future.conditions
[13:14:32.189]     ...future.result$finished <- base::Sys.time()
[13:14:32.189]     ...future.result
[13:14:32.189] }
[13:14:32.194] Exporting 5 global objects (4.61 KiB) to cluster node #2 ...
[13:14:32.194] Exporting '...future.FUN' (4.61 KiB) to cluster node #2 ...
[13:14:32.195] Exporting '...future.FUN' (4.61 KiB) to cluster node #2 ... DONE
[13:14:32.195] Exporting 'future.call.arguments' (0 bytes) to cluster node #2 ...
[13:14:32.196] Exporting 'future.call.arguments' (0 bytes) to cluster node #2 ... DONE
[13:14:32.196] Exporting '...future.elements_ii' (56 bytes) to cluster node #2 ...
[13:14:32.196] Exporting '...future.elements_ii' (56 bytes) to cluster node #2 ... DONE
[13:14:32.196] Exporting '...future.seeds_ii' (0 bytes) to cluster node #2 ...
[13:14:32.197] Exporting '...future.seeds_ii' (0 bytes) to cluster node #2 ... DONE
[13:14:32.197] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #2 ...
[13:14:32.198] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #2 ... DONE
[13:14:32.198] Exporting 5 global objects (4.61 KiB) to cluster node #2 ... DONE
[13:14:32.198] MultisessionFuture started
[13:14:32.199] - Launch lazy future ... done
[13:14:32.199] run() for 'MultisessionFuture' ... done
[13:14:32.199] Created future:
[13:14:32.217] receiveMessageFromWorker() for ClusterFuture ...
[13:14:32.217] - Validating connection of MultisessionFuture
[13:14:32.217] - received message: FutureResult
[13:14:32.217] - Received FutureResult
[13:14:32.218] - Erased future from FutureRegistry
[13:14:32.218] result() for ClusterFuture ...
[13:14:32.218] - result already collected: FutureResult
[13:14:32.218] result() for ClusterFuture ... done
[13:14:32.218] receiveMessageFromWorker() for ClusterFuture ... done
[13:14:32.199] MultisessionFuture:
[13:14:32.199] Label: 'future_lapply-2'
[13:14:32.199] Expression:
[13:14:32.199] {
[13:14:32.199]     do.call(function(...) {
[13:14:32.199]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[13:14:32.199]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[13:14:32.199]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[13:14:32.199]             on.exit(options(oopts), add = TRUE)
[13:14:32.199]         }
[13:14:32.199]         {
[13:14:32.199]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[13:14:32.199]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[13:14:32.199]                 ...future.FUN(...future.X_jj, ...)
[13:14:32.199]             })
[13:14:32.199]         }
[13:14:32.199]     }, args = future.call.arguments)
[13:14:32.199] }
[13:14:32.199] Lazy evaluation: FALSE
[13:14:32.199] Asynchronous evaluation: TRUE
[13:14:32.199] Local evaluation: TRUE
[13:14:32.199] Environment: R_GlobalEnv
[13:14:32.199] Capture standard output: TRUE
[13:14:32.199] Capture condition classes: 'condition' (excluding 'nothing')
[13:14:32.199] Globals: 5 objects totaling 4.66 KiB (function '...future.FUN' of 4.61 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 56 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[13:14:32.199] Packages: <none>
[13:14:32.199] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[13:14:32.199] Resolved: TRUE
[13:14:32.199] Value: <not collected>
[13:14:32.199] Conditions captured: <none>
[13:14:32.199] Early signaling: FALSE
[13:14:32.199] Owner process: 68097d82-3b31-293d-2920-9b7259f27083
[13:14:32.199] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[13:14:32.219] Chunk #2 of 2 ... DONE
[13:14:32.219] Launching 2 futures (chunks) ... DONE
[13:14:32.219] Resolving 2 futures (chunks) ...
[13:14:32.219] resolve() on list ...
[13:14:32.219]  recursive: 0
[13:14:32.220]  length: 2
[13:14:32.220] 
[13:14:32.413] Future #2
[13:14:32.413] result() for ClusterFuture ...
[13:14:32.413] - result already collected: FutureResult
[13:14:32.414] result() for ClusterFuture ... done
[13:14:32.414] result() for ClusterFuture ...
[13:14:32.414] - result already collected: FutureResult
[13:14:32.414] result() for ClusterFuture ... done
[13:14:32.414] signalConditionsASAP(MultisessionFuture, pos=2) ...
[13:14:32.414] - nx: 2
[13:14:32.415] - relay: TRUE
[13:14:32.415] - stdout: TRUE
[13:14:32.415] - signal: TRUE
[13:14:32.415] - resignal: FALSE
[13:14:32.415] - force: TRUE
[13:14:32.415] - relayed: [n=2] FALSE, FALSE
[13:14:32.416] - queued futures: [n=2] FALSE, FALSE
[13:14:32.416]  - until=1
[13:14:32.416]  - relaying element #1
[13:14:32.416] - relayed: [n=2] FALSE, FALSE
[13:14:32.416] - queued futures: [n=2] FALSE, TRUE
[13:14:32.416] signalConditionsASAP(NULL, pos=2) ... done
[13:14:32.417]  length: 1 (resolved future 2)
[13:14:32.492] receiveMessageFromWorker() for ClusterFuture ...
[13:14:32.492] - Validating connection of MultisessionFuture
[13:14:32.492] - received message: FutureResult
[13:14:32.492] - Received FutureResult
[13:14:32.492] - Erased future from FutureRegistry
[13:14:32.493] result() for ClusterFuture ...
[13:14:32.493] - result already collected: FutureResult
[13:14:32.493] result() for ClusterFuture ... done
[13:14:32.493] receiveMessageFromWorker() for ClusterFuture ... done
[13:14:32.493] Future #1
[13:14:32.493] result() for ClusterFuture ...
[13:14:32.494] - result already collected: FutureResult
[13:14:32.494] result() for ClusterFuture ... done
[13:14:32.494] result() for ClusterFuture ...
[13:14:32.494] - result already collected: FutureResult
[13:14:32.494] result() for ClusterFuture ... done
[13:14:32.494] signalConditionsASAP(MultisessionFuture, pos=1) ...
[13:14:32.495] - nx: 2
[13:14:32.495] - relay: TRUE
[13:14:32.495] - stdout: TRUE
[13:14:32.495] - signal: TRUE
[13:14:32.495] - resignal: FALSE
[13:14:32.495] - force: TRUE
[13:14:32.495] - relayed: [n=2] FALSE, FALSE
[13:14:32.496] - queued futures: [n=2] FALSE, TRUE
[13:14:32.496]  - until=1
[13:14:32.496]  - relaying element #1
[13:14:32.496] result() for ClusterFuture ...
[13:14:32.496] - result already collected: FutureResult
[13:14:32.496] result() for ClusterFuture ... done
[13:14:32.497] result() for ClusterFuture ...
[13:14:32.497] - result already collected: FutureResult
[13:14:32.497] result() for ClusterFuture ... done
[13:14:32.497] result() for ClusterFuture ...
[13:14:32.497] - result already collected: FutureResult
[13:14:32.497] result() for ClusterFuture ... done
[13:14:32.498] result() for ClusterFuture ...
[13:14:32.498] - result already collected: FutureResult
[13:14:32.498] result() for ClusterFuture ... done
[13:14:32.498] - relayed: [n=2] TRUE, FALSE
[13:14:32.498] - queued futures: [n=2] TRUE, TRUE
[13:14:32.498] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[13:14:32.499]  length: 0 (resolved future 1)
[13:14:32.499] Relaying remaining futures
[13:14:32.499] signalConditionsASAP(NULL, pos=0) ...
[13:14:32.499] - nx: 2
[13:14:32.499] - relay: TRUE
[13:14:32.499] - stdout: TRUE
[13:14:32.499] - signal: TRUE
[13:14:32.500] - resignal: FALSE
[13:14:32.500] - force: TRUE
[13:14:32.500] - relayed: [n=2] TRUE, FALSE
[13:14:32.500] - queued futures: [n=2] TRUE, TRUE
 - flush all
[13:14:32.500]  - relaying element #2
[13:14:32.500] result() for ClusterFuture ...
[13:14:32.501] - result already collected: FutureResult
[13:14:32.501] result() for ClusterFuture ... done
[13:14:32.501] result() for ClusterFuture ...
[13:14:32.501] - result already collected: FutureResult
[13:14:32.501] result() for ClusterFuture ... done
[13:14:32.501] result() for ClusterFuture ...
[13:14:32.502] - result already collected: FutureResult
[13:14:32.502] result() for ClusterFuture ... done
[13:14:32.502] result() for ClusterFuture ...
[13:14:32.502] - result already collected: FutureResult
[13:14:32.502] result() for ClusterFuture ... done
[13:14:32.502] - relayed: [n=2] TRUE, TRUE
[13:14:32.503] - queued futures: [n=2] TRUE, TRUE
[13:14:32.503] signalConditionsASAP(MultisessionFuture, pos=0) ... done
[13:14:32.503] resolve() on list ... DONE
[13:14:32.503] result() for ClusterFuture ...
[13:14:32.503] - result already collected: FutureResult
[13:14:32.503] result() for ClusterFuture ... done
[13:14:32.503] result() for ClusterFuture ...
[13:14:32.504] - result already collected: FutureResult
[13:14:32.504] result() for ClusterFuture ... done
[13:14:32.504] result() for ClusterFuture ...
[13:14:32.504] - result already collected: FutureResult
[13:14:32.504] result() for ClusterFuture ... done
[13:14:32.504] result() for ClusterFuture ...
[13:14:32.505] - result already collected: FutureResult
[13:14:32.505] result() for ClusterFuture ... done
[13:14:32.505]  - Number of value chunks collected: 2
[13:14:32.505] Resolving 2 futures (chunks) ... DONE
[13:14:32.505] Reducing values from 2 chunks ...
[13:14:32.505]  - Number of values collected after concatenation: 2
[13:14:32.506]  - Number of values expected: 2
[13:14:32.506] Reducing values from 2 chunks ... DONE
[13:14:32.506] future_lapply() ... DONE
* future_lapply(x, ..., future.stdout = TRUE) ... DONE
* future_lapply(x, ..., future.stdout = NA) ...
[13:14:32.506] future_lapply() ...
[13:14:32.510] Number of chunks: 2
[13:14:32.510] getGlobalsAndPackagesXApply() ...
[13:14:32.510]  - future.globals: TRUE
[13:14:32.510] getGlobalsAndPackages() ...
[13:14:32.510] Searching for globals...
[13:14:32.514] - globals found: [5] 'FUN', '{', 'Sys.sleep', '/', 'print'
[13:14:32.514] Searching for globals ... DONE
[13:14:32.514] Resolving globals: FALSE
[13:14:32.515] The total size of the 1 globals is 4.61 KiB (4720 bytes)
[13:14:32.515] The total size of the 1 globals exported for future expression ('FUN()') is 4.61 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.61 KiB of class 'function')
[13:14:32.515] - globals: [1] 'FUN'
[13:14:32.516] 
[13:14:32.516] getGlobalsAndPackages() ... DONE
[13:14:32.516]  - globals found/used: [n=1] 'FUN'
[13:14:32.516]  - needed namespaces: [n=0] 
[13:14:32.516] Finding globals ... DONE
[13:14:32.516]  - use_args: TRUE
[13:14:32.517]  - Getting '...' globals ...
[13:14:32.517] resolve() on list ...
[13:14:32.517]  recursive: 0
[13:14:32.517]  length: 1
[13:14:32.517]  elements: '...'
[13:14:32.518]  length: 0 (resolved future 1)
[13:14:32.518] resolve() on list ... DONE
[13:14:32.518]    - '...' content: [n=0] 
[13:14:32.518] List of 1
[13:14:32.518]  $ ...: list()
[13:14:32.518]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[13:14:32.518]  - attr(*, "where")=List of 1
[13:14:32.518]   ..$ ...:<environment: 0x0000022a35b56258> 
[13:14:32.518]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[13:14:32.518]  - attr(*, "resolved")= logi TRUE
[13:14:32.518]  - attr(*, "total_size")= num NA
[13:14:32.521]  - Getting '...' globals ... DONE
[13:14:32.521] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[13:14:32.522] List of 2
[13:14:32.522]  $ ...future.FUN:function (x)  
[13:14:32.522]  $ ...          : list()
[13:14:32.522]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[13:14:32.522]  - attr(*, "where")=List of 2
[13:14:32.522]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[13:14:32.522]   ..$ ...          :<environment: 0x0000022a35b56258> 
[13:14:32.522]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[13:14:32.522]  - attr(*, "resolved")= logi FALSE
[13:14:32.522]  - attr(*, "total_size")= num 4720
[13:14:32.525] Packages to be attached in all futures: [n=0] 
[13:14:32.525] getGlobalsAndPackagesXApply() ... DONE
[13:14:32.525] Number of futures (= number of chunks): 2
[13:14:32.526] Launching 2 futures (chunks) ...
[13:14:32.526] Chunk #1 of 2 ...
[13:14:32.526]  - Finding globals in 'X' for chunk #1 ...
[13:14:32.526] getGlobalsAndPackages() ...
[13:14:32.526] Searching for globals...
[13:14:32.527] 
[13:14:32.527] Searching for globals ... DONE
[13:14:32.527] - globals: [0] <none>
[13:14:32.527] getGlobalsAndPackages() ... DONE
[13:14:32.527]    + additional globals found: [n=0] 
[13:14:32.527]    + additional namespaces needed: [n=0] 
[13:14:32.528]  - Finding globals in 'X' for chunk #1 ... DONE
[13:14:32.528]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[13:14:32.528]  - seeds: <none>
[13:14:32.528]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:32.528] getGlobalsAndPackages() ...
[13:14:32.528] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:32.529] Resolving globals: FALSE
[13:14:32.529] Tweak future expression to call with '...' arguments ...
[13:14:32.529] {
[13:14:32.529]     do.call(function(...) {
[13:14:32.529]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[13:14:32.529]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[13:14:32.529]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[13:14:32.529]             on.exit(options(oopts), add = TRUE)
[13:14:32.529]         }
[13:14:32.529]         {
[13:14:32.529]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[13:14:32.529]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[13:14:32.529]                 ...future.FUN(...future.X_jj, ...)
[13:14:32.529]             })
[13:14:32.529]         }
[13:14:32.529]     }, args = future.call.arguments)
[13:14:32.529] }
[13:14:32.529] Tweak future expression to call with '...' arguments ... DONE
[13:14:32.530] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:32.530] 
[13:14:32.530] getGlobalsAndPackages() ... DONE
[13:14:32.530] run() for 'Future' ...
[13:14:32.531] - state: 'created'
[13:14:32.531] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[13:14:32.545] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[13:14:32.546] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[13:14:32.546]   - Field: 'node'
[13:14:32.546]   - Field: 'label'
[13:14:32.546]   - Field: 'local'
[13:14:32.546]   - Field: 'owner'
[13:14:32.547]   - Field: 'envir'
[13:14:32.547]   - Field: 'workers'
[13:14:32.547]   - Field: 'packages'
[13:14:32.547]   - Field: 'gc'
[13:14:32.547]   - Field: 'conditions'
[13:14:32.547]   - Field: 'persistent'
[13:14:32.548]   - Field: 'expr'
[13:14:32.548]   - Field: 'uuid'
[13:14:32.548]   - Field: 'seed'
[13:14:32.548]   - Field: 'version'
[13:14:32.548]   - Field: 'result'
[13:14:32.548]   - Field: 'asynchronous'
[13:14:32.549]   - Field: 'calls'
[13:14:32.549]   - Field: 'globals'
[13:14:32.549]   - Field: 'stdout'
[13:14:32.549]   - Field: 'earlySignal'
[13:14:32.549]   - Field: 'lazy'
[13:14:32.550]   - Field: 'state'
[13:14:32.550] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[13:14:32.550] - Launch lazy future ...
[13:14:32.550] Packages needed by the future expression (n = 0): <none>
[13:14:32.550] Packages needed by future strategies (n = 0): <none>
[13:14:32.551] {
[13:14:32.551]     {
[13:14:32.551]         {
[13:14:32.551]             ...future.startTime <- base::Sys.time()
[13:14:32.551]             {
[13:14:32.551]                 {
[13:14:32.551]                   {
[13:14:32.551]                     {
[13:14:32.551]                       base::local({
[13:14:32.551]                         has_future <- base::requireNamespace("future", 
[13:14:32.551]                           quietly = TRUE)
[13:14:32.551]                         if (has_future) {
[13:14:32.551]                           ns <- base::getNamespace("future")
[13:14:32.551]                           version <- ns[[".package"]][["version"]]
[13:14:32.551]                           if (is.null(version)) 
[13:14:32.551]                             version <- utils::packageVersion("future")
[13:14:32.551]                         }
[13:14:32.551]                         else {
[13:14:32.551]                           version <- NULL
[13:14:32.551]                         }
[13:14:32.551]                         if (!has_future || version < "1.8.0") {
[13:14:32.551]                           info <- base::c(r_version = base::gsub("R version ", 
[13:14:32.551]                             "", base::R.version$version.string), 
[13:14:32.551]                             platform = base::sprintf("%s (%s-bit)", 
[13:14:32.551]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[13:14:32.551]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[13:14:32.551]                               "release", "version")], collapse = " "), 
[13:14:32.551]                             hostname = base::Sys.info()[["nodename"]])
[13:14:32.551]                           info <- base::sprintf("%s: %s", base::names(info), 
[13:14:32.551]                             info)
[13:14:32.551]                           info <- base::paste(info, collapse = "; ")
[13:14:32.551]                           if (!has_future) {
[13:14:32.551]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[13:14:32.551]                               info)
[13:14:32.551]                           }
[13:14:32.551]                           else {
[13:14:32.551]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[13:14:32.551]                               info, version)
[13:14:32.551]                           }
[13:14:32.551]                           base::stop(msg)
[13:14:32.551]                         }
[13:14:32.551]                       })
[13:14:32.551]                     }
[13:14:32.551]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[13:14:32.551]                     base::options(mc.cores = 1L)
[13:14:32.551]                   }
[13:14:32.551]                   options(future.plan = NULL)
[13:14:32.551]                   Sys.unsetenv("R_FUTURE_PLAN")
[13:14:32.551]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[13:14:32.551]                 }
[13:14:32.551]                 ...future.workdir <- getwd()
[13:14:32.551]             }
[13:14:32.551]             ...future.oldOptions <- base::as.list(base::.Options)
[13:14:32.551]             ...future.oldEnvVars <- base::Sys.getenv()
[13:14:32.551]         }
[13:14:32.551]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[13:14:32.551]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[13:14:32.551]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[13:14:32.551]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[13:14:32.551]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[13:14:32.551]             future.stdout.windows.reencode = NULL, width = 80L)
[13:14:32.551]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[13:14:32.551]             base::names(...future.oldOptions))
[13:14:32.551]     }
[13:14:32.551]     if (TRUE) {
[13:14:32.551]     }
[13:14:32.551]     else {
[13:14:32.551]         if (NA) {
[13:14:32.551]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[13:14:32.551]                 open = "w")
[13:14:32.551]         }
[13:14:32.551]         else {
[13:14:32.551]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[13:14:32.551]                 windows = "NUL", "/dev/null"), open = "w")
[13:14:32.551]         }
[13:14:32.551]         base::sink(...future.stdout, type = "output", split = FALSE)
[13:14:32.551]         base::on.exit(if (!base::is.null(...future.stdout)) {
[13:14:32.551]             base::sink(type = "output", split = FALSE)
[13:14:32.551]             base::close(...future.stdout)
[13:14:32.551]         }, add = TRUE)
[13:14:32.551]     }
[13:14:32.551]     ...future.frame <- base::sys.nframe()
[13:14:32.551]     ...future.conditions <- base::list()
[13:14:32.551]     ...future.rng <- base::globalenv()$.Random.seed
[13:14:32.551]     if (FALSE) {
[13:14:32.551]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[13:14:32.551]             "...future.value", "...future.globalenv.names", ".Random.seed")
[13:14:32.551]     }
[13:14:32.551]     ...future.result <- base::tryCatch({
[13:14:32.551]         base::withCallingHandlers({
[13:14:32.551]             ...future.value <- base::withVisible(base::local({
[13:14:32.551]                 ...future.makeSendCondition <- local({
[13:14:32.551]                   sendCondition <- NULL
[13:14:32.551]                   function(frame = 1L) {
[13:14:32.551]                     if (is.function(sendCondition)) 
[13:14:32.551]                       return(sendCondition)
[13:14:32.551]                     ns <- getNamespace("parallel")
[13:14:32.551]                     if (exists("sendData", mode = "function", 
[13:14:32.551]                       envir = ns)) {
[13:14:32.551]                       parallel_sendData <- get("sendData", mode = "function", 
[13:14:32.551]                         envir = ns)
[13:14:32.551]                       envir <- sys.frame(frame)
[13:14:32.551]                       master <- NULL
[13:14:32.551]                       while (!identical(envir, .GlobalEnv) && 
[13:14:32.551]                         !identical(envir, emptyenv())) {
[13:14:32.551]                         if (exists("master", mode = "list", envir = envir, 
[13:14:32.551]                           inherits = FALSE)) {
[13:14:32.551]                           master <- get("master", mode = "list", 
[13:14:32.551]                             envir = envir, inherits = FALSE)
[13:14:32.551]                           if (inherits(master, c("SOCKnode", 
[13:14:32.551]                             "SOCK0node"))) {
[13:14:32.551]                             sendCondition <<- function(cond) {
[13:14:32.551]                               data <- list(type = "VALUE", value = cond, 
[13:14:32.551]                                 success = TRUE)
[13:14:32.551]                               parallel_sendData(master, data)
[13:14:32.551]                             }
[13:14:32.551]                             return(sendCondition)
[13:14:32.551]                           }
[13:14:32.551]                         }
[13:14:32.551]                         frame <- frame + 1L
[13:14:32.551]                         envir <- sys.frame(frame)
[13:14:32.551]                       }
[13:14:32.551]                     }
[13:14:32.551]                     sendCondition <<- function(cond) NULL
[13:14:32.551]                   }
[13:14:32.551]                 })
[13:14:32.551]                 withCallingHandlers({
[13:14:32.551]                   {
[13:14:32.551]                     do.call(function(...) {
[13:14:32.551]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[13:14:32.551]                       if (!identical(...future.globals.maxSize.org, 
[13:14:32.551]                         ...future.globals.maxSize)) {
[13:14:32.551]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[13:14:32.551]                         on.exit(options(oopts), add = TRUE)
[13:14:32.551]                       }
[13:14:32.551]                       {
[13:14:32.551]                         lapply(seq_along(...future.elements_ii), 
[13:14:32.551]                           FUN = function(jj) {
[13:14:32.551]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[13:14:32.551]                             ...future.FUN(...future.X_jj, ...)
[13:14:32.551]                           })
[13:14:32.551]                       }
[13:14:32.551]                     }, args = future.call.arguments)
[13:14:32.551]                   }
[13:14:32.551]                 }, immediateCondition = function(cond) {
[13:14:32.551]                   sendCondition <- ...future.makeSendCondition()
[13:14:32.551]                   sendCondition(cond)
[13:14:32.551]                   muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:32.551]                   {
[13:14:32.551]                     inherits <- base::inherits
[13:14:32.551]                     invokeRestart <- base::invokeRestart
[13:14:32.551]                     is.null <- base::is.null
[13:14:32.551]                     muffled <- FALSE
[13:14:32.551]                     if (inherits(cond, "message")) {
[13:14:32.551]                       muffled <- grepl(pattern, "muffleMessage")
[13:14:32.551]                       if (muffled) 
[13:14:32.551]                         invokeRestart("muffleMessage")
[13:14:32.551]                     }
[13:14:32.551]                     else if (inherits(cond, "warning")) {
[13:14:32.551]                       muffled <- grepl(pattern, "muffleWarning")
[13:14:32.551]                       if (muffled) 
[13:14:32.551]                         invokeRestart("muffleWarning")
[13:14:32.551]                     }
[13:14:32.551]                     else if (inherits(cond, "condition")) {
[13:14:32.551]                       if (!is.null(pattern)) {
[13:14:32.551]                         computeRestarts <- base::computeRestarts
[13:14:32.551]                         grepl <- base::grepl
[13:14:32.551]                         restarts <- computeRestarts(cond)
[13:14:32.551]                         for (restart in restarts) {
[13:14:32.551]                           name <- restart$name
[13:14:32.551]                           if (is.null(name)) 
[13:14:32.551]                             next
[13:14:32.551]                           if (!grepl(pattern, name)) 
[13:14:32.551]                             next
[13:14:32.551]                           invokeRestart(restart)
[13:14:32.551]                           muffled <- TRUE
[13:14:32.551]                           break
[13:14:32.551]                         }
[13:14:32.551]                       }
[13:14:32.551]                     }
[13:14:32.551]                     invisible(muffled)
[13:14:32.551]                   }
[13:14:32.551]                   muffleCondition(cond)
[13:14:32.551]                 })
[13:14:32.551]             }))
[13:14:32.551]             future::FutureResult(value = ...future.value$value, 
[13:14:32.551]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[13:14:32.551]                   ...future.rng), globalenv = if (FALSE) 
[13:14:32.551]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[13:14:32.551]                     ...future.globalenv.names))
[13:14:32.551]                 else NULL, started = ...future.startTime, version = "1.8")
[13:14:32.551]         }, condition = base::local({
[13:14:32.551]             c <- base::c
[13:14:32.551]             inherits <- base::inherits
[13:14:32.551]             invokeRestart <- base::invokeRestart
[13:14:32.551]             length <- base::length
[13:14:32.551]             list <- base::list
[13:14:32.551]             seq.int <- base::seq.int
[13:14:32.551]             signalCondition <- base::signalCondition
[13:14:32.551]             sys.calls <- base::sys.calls
[13:14:32.551]             `[[` <- base::`[[`
[13:14:32.551]             `+` <- base::`+`
[13:14:32.551]             `<<-` <- base::`<<-`
[13:14:32.551]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[13:14:32.551]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[13:14:32.551]                   3L)]
[13:14:32.551]             }
[13:14:32.551]             function(cond) {
[13:14:32.551]                 is_error <- inherits(cond, "error")
[13:14:32.551]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[13:14:32.551]                   NULL)
[13:14:32.551]                 if (is_error) {
[13:14:32.551]                   sessionInformation <- function() {
[13:14:32.551]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[13:14:32.551]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[13:14:32.551]                       search = base::search(), system = base::Sys.info())
[13:14:32.551]                   }
[13:14:32.551]                   ...future.conditions[[length(...future.conditions) + 
[13:14:32.551]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[13:14:32.551]                     cond$call), session = sessionInformation(), 
[13:14:32.551]                     timestamp = base::Sys.time(), signaled = 0L)
[13:14:32.551]                   signalCondition(cond)
[13:14:32.551]                 }
[13:14:32.551]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[13:14:32.551]                 "immediateCondition"))) {
[13:14:32.551]                   signal <- TRUE && inherits(cond, "immediateCondition")
[13:14:32.551]                   ...future.conditions[[length(...future.conditions) + 
[13:14:32.551]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[13:14:32.551]                   if (TRUE && !signal) {
[13:14:32.551]                     muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:32.551]                     {
[13:14:32.551]                       inherits <- base::inherits
[13:14:32.551]                       invokeRestart <- base::invokeRestart
[13:14:32.551]                       is.null <- base::is.null
[13:14:32.551]                       muffled <- FALSE
[13:14:32.551]                       if (inherits(cond, "message")) {
[13:14:32.551]                         muffled <- grepl(pattern, "muffleMessage")
[13:14:32.551]                         if (muffled) 
[13:14:32.551]                           invokeRestart("muffleMessage")
[13:14:32.551]                       }
[13:14:32.551]                       else if (inherits(cond, "warning")) {
[13:14:32.551]                         muffled <- grepl(pattern, "muffleWarning")
[13:14:32.551]                         if (muffled) 
[13:14:32.551]                           invokeRestart("muffleWarning")
[13:14:32.551]                       }
[13:14:32.551]                       else if (inherits(cond, "condition")) {
[13:14:32.551]                         if (!is.null(pattern)) {
[13:14:32.551]                           computeRestarts <- base::computeRestarts
[13:14:32.551]                           grepl <- base::grepl
[13:14:32.551]                           restarts <- computeRestarts(cond)
[13:14:32.551]                           for (restart in restarts) {
[13:14:32.551]                             name <- restart$name
[13:14:32.551]                             if (is.null(name)) 
[13:14:32.551]                               next
[13:14:32.551]                             if (!grepl(pattern, name)) 
[13:14:32.551]                               next
[13:14:32.551]                             invokeRestart(restart)
[13:14:32.551]                             muffled <- TRUE
[13:14:32.551]                             break
[13:14:32.551]                           }
[13:14:32.551]                         }
[13:14:32.551]                       }
[13:14:32.551]                       invisible(muffled)
[13:14:32.551]                     }
[13:14:32.551]                     muffleCondition(cond, pattern = "^muffle")
[13:14:32.551]                   }
[13:14:32.551]                 }
[13:14:32.551]                 else {
[13:14:32.551]                   if (TRUE) {
[13:14:32.551]                     muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:32.551]                     {
[13:14:32.551]                       inherits <- base::inherits
[13:14:32.551]                       invokeRestart <- base::invokeRestart
[13:14:32.551]                       is.null <- base::is.null
[13:14:32.551]                       muffled <- FALSE
[13:14:32.551]                       if (inherits(cond, "message")) {
[13:14:32.551]                         muffled <- grepl(pattern, "muffleMessage")
[13:14:32.551]                         if (muffled) 
[13:14:32.551]                           invokeRestart("muffleMessage")
[13:14:32.551]                       }
[13:14:32.551]                       else if (inherits(cond, "warning")) {
[13:14:32.551]                         muffled <- grepl(pattern, "muffleWarning")
[13:14:32.551]                         if (muffled) 
[13:14:32.551]                           invokeRestart("muffleWarning")
[13:14:32.551]                       }
[13:14:32.551]                       else if (inherits(cond, "condition")) {
[13:14:32.551]                         if (!is.null(pattern)) {
[13:14:32.551]                           computeRestarts <- base::computeRestarts
[13:14:32.551]                           grepl <- base::grepl
[13:14:32.551]                           restarts <- computeRestarts(cond)
[13:14:32.551]                           for (restart in restarts) {
[13:14:32.551]                             name <- restart$name
[13:14:32.551]                             if (is.null(name)) 
[13:14:32.551]                               next
[13:14:32.551]                             if (!grepl(pattern, name)) 
[13:14:32.551]                               next
[13:14:32.551]                             invokeRestart(restart)
[13:14:32.551]                             muffled <- TRUE
[13:14:32.551]                             break
[13:14:32.551]                           }
[13:14:32.551]                         }
[13:14:32.551]                       }
[13:14:32.551]                       invisible(muffled)
[13:14:32.551]                     }
[13:14:32.551]                     muffleCondition(cond, pattern = "^muffle")
[13:14:32.551]                   }
[13:14:32.551]                 }
[13:14:32.551]             }
[13:14:32.551]         }))
[13:14:32.551]     }, error = function(ex) {
[13:14:32.551]         base::structure(base::list(value = NULL, visible = NULL, 
[13:14:32.551]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[13:14:32.551]                 ...future.rng), started = ...future.startTime, 
[13:14:32.551]             finished = Sys.time(), session_uuid = NA_character_, 
[13:14:32.551]             version = "1.8"), class = "FutureResult")
[13:14:32.551]     }, finally = {
[13:14:32.551]         if (!identical(...future.workdir, getwd())) 
[13:14:32.551]             setwd(...future.workdir)
[13:14:32.551]         {
[13:14:32.551]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[13:14:32.551]                 ...future.oldOptions$nwarnings <- NULL
[13:14:32.551]             }
[13:14:32.551]             base::options(...future.oldOptions)
[13:14:32.551]             if (.Platform$OS.type == "windows") {
[13:14:32.551]                 old_names <- names(...future.oldEnvVars)
[13:14:32.551]                 envs <- base::Sys.getenv()
[13:14:32.551]                 names <- names(envs)
[13:14:32.551]                 common <- intersect(names, old_names)
[13:14:32.551]                 added <- setdiff(names, old_names)
[13:14:32.551]                 removed <- setdiff(old_names, names)
[13:14:32.551]                 changed <- common[...future.oldEnvVars[common] != 
[13:14:32.551]                   envs[common]]
[13:14:32.551]                 NAMES <- toupper(changed)
[13:14:32.551]                 args <- list()
[13:14:32.551]                 for (kk in seq_along(NAMES)) {
[13:14:32.551]                   name <- changed[[kk]]
[13:14:32.551]                   NAME <- NAMES[[kk]]
[13:14:32.551]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:32.551]                     next
[13:14:32.551]                   args[[name]] <- ...future.oldEnvVars[[name]]
[13:14:32.551]                 }
[13:14:32.551]                 NAMES <- toupper(added)
[13:14:32.551]                 for (kk in seq_along(NAMES)) {
[13:14:32.551]                   name <- added[[kk]]
[13:14:32.551]                   NAME <- NAMES[[kk]]
[13:14:32.551]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:32.551]                     next
[13:14:32.551]                   args[[name]] <- ""
[13:14:32.551]                 }
[13:14:32.551]                 NAMES <- toupper(removed)
[13:14:32.551]                 for (kk in seq_along(NAMES)) {
[13:14:32.551]                   name <- removed[[kk]]
[13:14:32.551]                   NAME <- NAMES[[kk]]
[13:14:32.551]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:32.551]                     next
[13:14:32.551]                   args[[name]] <- ...future.oldEnvVars[[name]]
[13:14:32.551]                 }
[13:14:32.551]                 if (length(args) > 0) 
[13:14:32.551]                   base::do.call(base::Sys.setenv, args = args)
[13:14:32.551]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[13:14:32.551]             }
[13:14:32.551]             else {
[13:14:32.551]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[13:14:32.551]             }
[13:14:32.551]             {
[13:14:32.551]                 if (base::length(...future.futureOptionsAdded) > 
[13:14:32.551]                   0L) {
[13:14:32.551]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[13:14:32.551]                   base::names(opts) <- ...future.futureOptionsAdded
[13:14:32.551]                   base::options(opts)
[13:14:32.551]                 }
[13:14:32.551]                 {
[13:14:32.551]                   {
[13:14:32.551]                     base::options(mc.cores = ...future.mc.cores.old)
[13:14:32.551]                     NULL
[13:14:32.551]                   }
[13:14:32.551]                   options(future.plan = NULL)
[13:14:32.551]                   if (is.na(NA_character_)) 
[13:14:32.551]                     Sys.unsetenv("R_FUTURE_PLAN")
[13:14:32.551]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[13:14:32.551]                   future::plan(list(function (..., workers = availableCores(), 
[13:14:32.551]                     lazy = FALSE, rscript_libs = .libPaths(), 
[13:14:32.551]                     envir = parent.frame()) 
[13:14:32.551]                   {
[13:14:32.551]                     if (is.function(workers)) 
[13:14:32.551]                       workers <- workers()
[13:14:32.551]                     workers <- structure(as.integer(workers), 
[13:14:32.551]                       class = class(workers))
[13:14:32.551]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[13:14:32.551]                       workers >= 1)
[13:14:32.551]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[13:14:32.551]                       return(sequential(..., lazy = TRUE, envir = envir))
[13:14:32.551]                     }
[13:14:32.551]                     future <- MultisessionFuture(..., workers = workers, 
[13:14:32.551]                       lazy = lazy, rscript_libs = rscript_libs, 
[13:14:32.551]                       envir = envir)
[13:14:32.551]                     if (!future$lazy) 
[13:14:32.551]                       future <- run(future)
[13:14:32.551]                     invisible(future)
[13:14:32.551]                   }), .cleanup = FALSE, .init = FALSE)
[13:14:32.551]                 }
[13:14:32.551]             }
[13:14:32.551]         }
[13:14:32.551]     })
[13:14:32.551]     if (FALSE) {
[13:14:32.551]         base::sink(type = "output", split = FALSE)
[13:14:32.551]         if (NA) {
[13:14:32.551]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[13:14:32.551]         }
[13:14:32.551]         else {
[13:14:32.551]             ...future.result["stdout"] <- base::list(NULL)
[13:14:32.551]         }
[13:14:32.551]         base::close(...future.stdout)
[13:14:32.551]         ...future.stdout <- NULL
[13:14:32.551]     }
[13:14:32.551]     ...future.result$conditions <- ...future.conditions
[13:14:32.551]     ...future.result$finished <- base::Sys.time()
[13:14:32.551]     ...future.result
[13:14:32.551] }
[13:14:32.556] Exporting 5 global objects (4.61 KiB) to cluster node #1 ...
[13:14:32.557] Exporting '...future.FUN' (4.61 KiB) to cluster node #1 ...
[13:14:32.557] Exporting '...future.FUN' (4.61 KiB) to cluster node #1 ... DONE
[13:14:32.557] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[13:14:32.558] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[13:14:32.558] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ...
[13:14:32.559] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ... DONE
[13:14:32.559] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[13:14:32.559] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[13:14:32.560] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[13:14:32.560] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[13:14:32.560] Exporting 5 global objects (4.61 KiB) to cluster node #1 ... DONE
[13:14:32.561] MultisessionFuture started
[13:14:32.561] - Launch lazy future ... done
[13:14:32.561] run() for 'MultisessionFuture' ... done
[13:14:32.561] Created future:
[13:14:32.562] MultisessionFuture:
[13:14:32.562] Label: 'future_lapply-1'
[13:14:32.562] Expression:
[13:14:32.562] {
[13:14:32.562]     do.call(function(...) {
[13:14:32.562]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[13:14:32.562]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[13:14:32.562]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[13:14:32.562]             on.exit(options(oopts), add = TRUE)
[13:14:32.562]         }
[13:14:32.562]         {
[13:14:32.562]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[13:14:32.562]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[13:14:32.562]                 ...future.FUN(...future.X_jj, ...)
[13:14:32.562]             })
[13:14:32.562]         }
[13:14:32.562]     }, args = future.call.arguments)
[13:14:32.562] }
[13:14:32.562] Lazy evaluation: FALSE
[13:14:32.562] Asynchronous evaluation: TRUE
[13:14:32.562] Local evaluation: TRUE
[13:14:32.562] Environment: R_GlobalEnv
[13:14:32.562] Capture standard output: NA
[13:14:32.562] Capture condition classes: 'condition' (excluding 'nothing')
[13:14:32.562] Globals: 5 objects totaling 4.66 KiB (function '...future.FUN' of 4.61 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 56 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[13:14:32.562] Packages: <none>
[13:14:32.562] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[13:14:32.562] Resolved: FALSE
[13:14:32.562] Value: <not collected>
[13:14:32.562] Conditions captured: <none>
[13:14:32.562] Early signaling: FALSE
[13:14:32.562] Owner process: 68097d82-3b31-293d-2920-9b7259f27083
[13:14:32.562] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[13:14:32.757] Chunk #1 of 2 ... DONE
[13:14:32.757] Chunk #2 of 2 ...
[13:14:32.758]  - Finding globals in 'X' for chunk #2 ...
[13:14:32.758] getGlobalsAndPackages() ...
[13:14:32.758] Searching for globals...
[13:14:32.758] 
[13:14:32.758] Searching for globals ... DONE
[13:14:32.759] - globals: [0] <none>
[13:14:32.759] getGlobalsAndPackages() ... DONE
[13:14:32.759]    + additional globals found: [n=0] 
[13:14:32.759]    + additional namespaces needed: [n=0] 
[13:14:32.759]  - Finding globals in 'X' for chunk #2 ... DONE
[13:14:32.759]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[13:14:32.760]  - seeds: <none>
[13:14:32.760]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:32.760] getGlobalsAndPackages() ...
[13:14:32.760] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:32.760] Resolving globals: FALSE
[13:14:32.760] Tweak future expression to call with '...' arguments ...
[13:14:32.761] {
[13:14:32.761]     do.call(function(...) {
[13:14:32.761]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[13:14:32.761]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[13:14:32.761]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[13:14:32.761]             on.exit(options(oopts), add = TRUE)
[13:14:32.761]         }
[13:14:32.761]         {
[13:14:32.761]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[13:14:32.761]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[13:14:32.761]                 ...future.FUN(...future.X_jj, ...)
[13:14:32.761]             })
[13:14:32.761]         }
[13:14:32.761]     }, args = future.call.arguments)
[13:14:32.761] }
[13:14:32.761] Tweak future expression to call with '...' arguments ... DONE
[13:14:32.762] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:32.762] 
[13:14:32.762] getGlobalsAndPackages() ... DONE
[13:14:32.762] run() for 'Future' ...
[13:14:32.762] - state: 'created'
[13:14:32.763] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[13:14:32.777] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[13:14:32.777] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[13:14:32.777]   - Field: 'node'
[13:14:32.777]   - Field: 'label'
[13:14:32.778]   - Field: 'local'
[13:14:32.778]   - Field: 'owner'
[13:14:32.778]   - Field: 'envir'
[13:14:32.778]   - Field: 'workers'
[13:14:32.778]   - Field: 'packages'
[13:14:32.778]   - Field: 'gc'
[13:14:32.779]   - Field: 'conditions'
[13:14:32.779]   - Field: 'persistent'
[13:14:32.779]   - Field: 'expr'
[13:14:32.779]   - Field: 'uuid'
[13:14:32.779]   - Field: 'seed'
[13:14:32.779]   - Field: 'version'
[13:14:32.780]   - Field: 'result'
[13:14:32.780]   - Field: 'asynchronous'
[13:14:32.780]   - Field: 'calls'
[13:14:32.780]   - Field: 'globals'
[13:14:32.780]   - Field: 'stdout'
[13:14:32.781]   - Field: 'earlySignal'
[13:14:32.781]   - Field: 'lazy'
[13:14:32.781]   - Field: 'state'
[13:14:32.781] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[13:14:32.781] - Launch lazy future ...
[13:14:32.782] Packages needed by the future expression (n = 0): <none>
[13:14:32.782] Packages needed by future strategies (n = 0): <none>
[13:14:32.782] {
[13:14:32.782]     {
[13:14:32.782]         {
[13:14:32.782]             ...future.startTime <- base::Sys.time()
[13:14:32.782]             {
[13:14:32.782]                 {
[13:14:32.782]                   {
[13:14:32.782]                     {
[13:14:32.782]                       base::local({
[13:14:32.782]                         has_future <- base::requireNamespace("future", 
[13:14:32.782]                           quietly = TRUE)
[13:14:32.782]                         if (has_future) {
[13:14:32.782]                           ns <- base::getNamespace("future")
[13:14:32.782]                           version <- ns[[".package"]][["version"]]
[13:14:32.782]                           if (is.null(version)) 
[13:14:32.782]                             version <- utils::packageVersion("future")
[13:14:32.782]                         }
[13:14:32.782]                         else {
[13:14:32.782]                           version <- NULL
[13:14:32.782]                         }
[13:14:32.782]                         if (!has_future || version < "1.8.0") {
[13:14:32.782]                           info <- base::c(r_version = base::gsub("R version ", 
[13:14:32.782]                             "", base::R.version$version.string), 
[13:14:32.782]                             platform = base::sprintf("%s (%s-bit)", 
[13:14:32.782]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[13:14:32.782]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[13:14:32.782]                               "release", "version")], collapse = " "), 
[13:14:32.782]                             hostname = base::Sys.info()[["nodename"]])
[13:14:32.782]                           info <- base::sprintf("%s: %s", base::names(info), 
[13:14:32.782]                             info)
[13:14:32.782]                           info <- base::paste(info, collapse = "; ")
[13:14:32.782]                           if (!has_future) {
[13:14:32.782]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[13:14:32.782]                               info)
[13:14:32.782]                           }
[13:14:32.782]                           else {
[13:14:32.782]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[13:14:32.782]                               info, version)
[13:14:32.782]                           }
[13:14:32.782]                           base::stop(msg)
[13:14:32.782]                         }
[13:14:32.782]                       })
[13:14:32.782]                     }
[13:14:32.782]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[13:14:32.782]                     base::options(mc.cores = 1L)
[13:14:32.782]                   }
[13:14:32.782]                   options(future.plan = NULL)
[13:14:32.782]                   Sys.unsetenv("R_FUTURE_PLAN")
[13:14:32.782]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[13:14:32.782]                 }
[13:14:32.782]                 ...future.workdir <- getwd()
[13:14:32.782]             }
[13:14:32.782]             ...future.oldOptions <- base::as.list(base::.Options)
[13:14:32.782]             ...future.oldEnvVars <- base::Sys.getenv()
[13:14:32.782]         }
[13:14:32.782]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[13:14:32.782]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[13:14:32.782]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[13:14:32.782]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[13:14:32.782]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[13:14:32.782]             future.stdout.windows.reencode = NULL, width = 80L)
[13:14:32.782]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[13:14:32.782]             base::names(...future.oldOptions))
[13:14:32.782]     }
[13:14:32.782]     if (TRUE) {
[13:14:32.782]     }
[13:14:32.782]     else {
[13:14:32.782]         if (NA) {
[13:14:32.782]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[13:14:32.782]                 open = "w")
[13:14:32.782]         }
[13:14:32.782]         else {
[13:14:32.782]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[13:14:32.782]                 windows = "NUL", "/dev/null"), open = "w")
[13:14:32.782]         }
[13:14:32.782]         base::sink(...future.stdout, type = "output", split = FALSE)
[13:14:32.782]         base::on.exit(if (!base::is.null(...future.stdout)) {
[13:14:32.782]             base::sink(type = "output", split = FALSE)
[13:14:32.782]             base::close(...future.stdout)
[13:14:32.782]         }, add = TRUE)
[13:14:32.782]     }
[13:14:32.782]     ...future.frame <- base::sys.nframe()
[13:14:32.782]     ...future.conditions <- base::list()
[13:14:32.782]     ...future.rng <- base::globalenv()$.Random.seed
[13:14:32.782]     if (FALSE) {
[13:14:32.782]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[13:14:32.782]             "...future.value", "...future.globalenv.names", ".Random.seed")
[13:14:32.782]     }
[13:14:32.782]     ...future.result <- base::tryCatch({
[13:14:32.782]         base::withCallingHandlers({
[13:14:32.782]             ...future.value <- base::withVisible(base::local({
[13:14:32.782]                 ...future.makeSendCondition <- local({
[13:14:32.782]                   sendCondition <- NULL
[13:14:32.782]                   function(frame = 1L) {
[13:14:32.782]                     if (is.function(sendCondition)) 
[13:14:32.782]                       return(sendCondition)
[13:14:32.782]                     ns <- getNamespace("parallel")
[13:14:32.782]                     if (exists("sendData", mode = "function", 
[13:14:32.782]                       envir = ns)) {
[13:14:32.782]                       parallel_sendData <- get("sendData", mode = "function", 
[13:14:32.782]                         envir = ns)
[13:14:32.782]                       envir <- sys.frame(frame)
[13:14:32.782]                       master <- NULL
[13:14:32.782]                       while (!identical(envir, .GlobalEnv) && 
[13:14:32.782]                         !identical(envir, emptyenv())) {
[13:14:32.782]                         if (exists("master", mode = "list", envir = envir, 
[13:14:32.782]                           inherits = FALSE)) {
[13:14:32.782]                           master <- get("master", mode = "list", 
[13:14:32.782]                             envir = envir, inherits = FALSE)
[13:14:32.782]                           if (inherits(master, c("SOCKnode", 
[13:14:32.782]                             "SOCK0node"))) {
[13:14:32.782]                             sendCondition <<- function(cond) {
[13:14:32.782]                               data <- list(type = "VALUE", value = cond, 
[13:14:32.782]                                 success = TRUE)
[13:14:32.782]                               parallel_sendData(master, data)
[13:14:32.782]                             }
[13:14:32.782]                             return(sendCondition)
[13:14:32.782]                           }
[13:14:32.782]                         }
[13:14:32.782]                         frame <- frame + 1L
[13:14:32.782]                         envir <- sys.frame(frame)
[13:14:32.782]                       }
[13:14:32.782]                     }
[13:14:32.782]                     sendCondition <<- function(cond) NULL
[13:14:32.782]                   }
[13:14:32.782]                 })
[13:14:32.782]                 withCallingHandlers({
[13:14:32.782]                   {
[13:14:32.782]                     do.call(function(...) {
[13:14:32.782]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[13:14:32.782]                       if (!identical(...future.globals.maxSize.org, 
[13:14:32.782]                         ...future.globals.maxSize)) {
[13:14:32.782]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[13:14:32.782]                         on.exit(options(oopts), add = TRUE)
[13:14:32.782]                       }
[13:14:32.782]                       {
[13:14:32.782]                         lapply(seq_along(...future.elements_ii), 
[13:14:32.782]                           FUN = function(jj) {
[13:14:32.782]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[13:14:32.782]                             ...future.FUN(...future.X_jj, ...)
[13:14:32.782]                           })
[13:14:32.782]                       }
[13:14:32.782]                     }, args = future.call.arguments)
[13:14:32.782]                   }
[13:14:32.782]                 }, immediateCondition = function(cond) {
[13:14:32.782]                   sendCondition <- ...future.makeSendCondition()
[13:14:32.782]                   sendCondition(cond)
[13:14:32.782]                   muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:32.782]                   {
[13:14:32.782]                     inherits <- base::inherits
[13:14:32.782]                     invokeRestart <- base::invokeRestart
[13:14:32.782]                     is.null <- base::is.null
[13:14:32.782]                     muffled <- FALSE
[13:14:32.782]                     if (inherits(cond, "message")) {
[13:14:32.782]                       muffled <- grepl(pattern, "muffleMessage")
[13:14:32.782]                       if (muffled) 
[13:14:32.782]                         invokeRestart("muffleMessage")
[13:14:32.782]                     }
[13:14:32.782]                     else if (inherits(cond, "warning")) {
[13:14:32.782]                       muffled <- grepl(pattern, "muffleWarning")
[13:14:32.782]                       if (muffled) 
[13:14:32.782]                         invokeRestart("muffleWarning")
[13:14:32.782]                     }
[13:14:32.782]                     else if (inherits(cond, "condition")) {
[13:14:32.782]                       if (!is.null(pattern)) {
[13:14:32.782]                         computeRestarts <- base::computeRestarts
[13:14:32.782]                         grepl <- base::grepl
[13:14:32.782]                         restarts <- computeRestarts(cond)
[13:14:32.782]                         for (restart in restarts) {
[13:14:32.782]                           name <- restart$name
[13:14:32.782]                           if (is.null(name)) 
[13:14:32.782]                             next
[13:14:32.782]                           if (!grepl(pattern, name)) 
[13:14:32.782]                             next
[13:14:32.782]                           invokeRestart(restart)
[13:14:32.782]                           muffled <- TRUE
[13:14:32.782]                           break
[13:14:32.782]                         }
[13:14:32.782]                       }
[13:14:32.782]                     }
[13:14:32.782]                     invisible(muffled)
[13:14:32.782]                   }
[13:14:32.782]                   muffleCondition(cond)
[13:14:32.782]                 })
[13:14:32.782]             }))
[13:14:32.782]             future::FutureResult(value = ...future.value$value, 
[13:14:32.782]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[13:14:32.782]                   ...future.rng), globalenv = if (FALSE) 
[13:14:32.782]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[13:14:32.782]                     ...future.globalenv.names))
[13:14:32.782]                 else NULL, started = ...future.startTime, version = "1.8")
[13:14:32.782]         }, condition = base::local({
[13:14:32.782]             c <- base::c
[13:14:32.782]             inherits <- base::inherits
[13:14:32.782]             invokeRestart <- base::invokeRestart
[13:14:32.782]             length <- base::length
[13:14:32.782]             list <- base::list
[13:14:32.782]             seq.int <- base::seq.int
[13:14:32.782]             signalCondition <- base::signalCondition
[13:14:32.782]             sys.calls <- base::sys.calls
[13:14:32.782]             `[[` <- base::`[[`
[13:14:32.782]             `+` <- base::`+`
[13:14:32.782]             `<<-` <- base::`<<-`
[13:14:32.782]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[13:14:32.782]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[13:14:32.782]                   3L)]
[13:14:32.782]             }
[13:14:32.782]             function(cond) {
[13:14:32.782]                 is_error <- inherits(cond, "error")
[13:14:32.782]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[13:14:32.782]                   NULL)
[13:14:32.782]                 if (is_error) {
[13:14:32.782]                   sessionInformation <- function() {
[13:14:32.782]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[13:14:32.782]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[13:14:32.782]                       search = base::search(), system = base::Sys.info())
[13:14:32.782]                   }
[13:14:32.782]                   ...future.conditions[[length(...future.conditions) + 
[13:14:32.782]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[13:14:32.782]                     cond$call), session = sessionInformation(), 
[13:14:32.782]                     timestamp = base::Sys.time(), signaled = 0L)
[13:14:32.782]                   signalCondition(cond)
[13:14:32.782]                 }
[13:14:32.782]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[13:14:32.782]                 "immediateCondition"))) {
[13:14:32.782]                   signal <- TRUE && inherits(cond, "immediateCondition")
[13:14:32.782]                   ...future.conditions[[length(...future.conditions) + 
[13:14:32.782]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[13:14:32.782]                   if (TRUE && !signal) {
[13:14:32.782]                     muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:32.782]                     {
[13:14:32.782]                       inherits <- base::inherits
[13:14:32.782]                       invokeRestart <- base::invokeRestart
[13:14:32.782]                       is.null <- base::is.null
[13:14:32.782]                       muffled <- FALSE
[13:14:32.782]                       if (inherits(cond, "message")) {
[13:14:32.782]                         muffled <- grepl(pattern, "muffleMessage")
[13:14:32.782]                         if (muffled) 
[13:14:32.782]                           invokeRestart("muffleMessage")
[13:14:32.782]                       }
[13:14:32.782]                       else if (inherits(cond, "warning")) {
[13:14:32.782]                         muffled <- grepl(pattern, "muffleWarning")
[13:14:32.782]                         if (muffled) 
[13:14:32.782]                           invokeRestart("muffleWarning")
[13:14:32.782]                       }
[13:14:32.782]                       else if (inherits(cond, "condition")) {
[13:14:32.782]                         if (!is.null(pattern)) {
[13:14:32.782]                           computeRestarts <- base::computeRestarts
[13:14:32.782]                           grepl <- base::grepl
[13:14:32.782]                           restarts <- computeRestarts(cond)
[13:14:32.782]                           for (restart in restarts) {
[13:14:32.782]                             name <- restart$name
[13:14:32.782]                             if (is.null(name)) 
[13:14:32.782]                               next
[13:14:32.782]                             if (!grepl(pattern, name)) 
[13:14:32.782]                               next
[13:14:32.782]                             invokeRestart(restart)
[13:14:32.782]                             muffled <- TRUE
[13:14:32.782]                             break
[13:14:32.782]                           }
[13:14:32.782]                         }
[13:14:32.782]                       }
[13:14:32.782]                       invisible(muffled)
[13:14:32.782]                     }
[13:14:32.782]                     muffleCondition(cond, pattern = "^muffle")
[13:14:32.782]                   }
[13:14:32.782]                 }
[13:14:32.782]                 else {
[13:14:32.782]                   if (TRUE) {
[13:14:32.782]                     muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:32.782]                     {
[13:14:32.782]                       inherits <- base::inherits
[13:14:32.782]                       invokeRestart <- base::invokeRestart
[13:14:32.782]                       is.null <- base::is.null
[13:14:32.782]                       muffled <- FALSE
[13:14:32.782]                       if (inherits(cond, "message")) {
[13:14:32.782]                         muffled <- grepl(pattern, "muffleMessage")
[13:14:32.782]                         if (muffled) 
[13:14:32.782]                           invokeRestart("muffleMessage")
[13:14:32.782]                       }
[13:14:32.782]                       else if (inherits(cond, "warning")) {
[13:14:32.782]                         muffled <- grepl(pattern, "muffleWarning")
[13:14:32.782]                         if (muffled) 
[13:14:32.782]                           invokeRestart("muffleWarning")
[13:14:32.782]                       }
[13:14:32.782]                       else if (inherits(cond, "condition")) {
[13:14:32.782]                         if (!is.null(pattern)) {
[13:14:32.782]                           computeRestarts <- base::computeRestarts
[13:14:32.782]                           grepl <- base::grepl
[13:14:32.782]                           restarts <- computeRestarts(cond)
[13:14:32.782]                           for (restart in restarts) {
[13:14:32.782]                             name <- restart$name
[13:14:32.782]                             if (is.null(name)) 
[13:14:32.782]                               next
[13:14:32.782]                             if (!grepl(pattern, name)) 
[13:14:32.782]                               next
[13:14:32.782]                             invokeRestart(restart)
[13:14:32.782]                             muffled <- TRUE
[13:14:32.782]                             break
[13:14:32.782]                           }
[13:14:32.782]                         }
[13:14:32.782]                       }
[13:14:32.782]                       invisible(muffled)
[13:14:32.782]                     }
[13:14:32.782]                     muffleCondition(cond, pattern = "^muffle")
[13:14:32.782]                   }
[13:14:32.782]                 }
[13:14:32.782]             }
[13:14:32.782]         }))
[13:14:32.782]     }, error = function(ex) {
[13:14:32.782]         base::structure(base::list(value = NULL, visible = NULL, 
[13:14:32.782]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[13:14:32.782]                 ...future.rng), started = ...future.startTime, 
[13:14:32.782]             finished = Sys.time(), session_uuid = NA_character_, 
[13:14:32.782]             version = "1.8"), class = "FutureResult")
[13:14:32.782]     }, finally = {
[13:14:32.782]         if (!identical(...future.workdir, getwd())) 
[13:14:32.782]             setwd(...future.workdir)
[13:14:32.782]         {
[13:14:32.782]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[13:14:32.782]                 ...future.oldOptions$nwarnings <- NULL
[13:14:32.782]             }
[13:14:32.782]             base::options(...future.oldOptions)
[13:14:32.782]             if (.Platform$OS.type == "windows") {
[13:14:32.782]                 old_names <- names(...future.oldEnvVars)
[13:14:32.782]                 envs <- base::Sys.getenv()
[13:14:32.782]                 names <- names(envs)
[13:14:32.782]                 common <- intersect(names, old_names)
[13:14:32.782]                 added <- setdiff(names, old_names)
[13:14:32.782]                 removed <- setdiff(old_names, names)
[13:14:32.782]                 changed <- common[...future.oldEnvVars[common] != 
[13:14:32.782]                   envs[common]]
[13:14:32.782]                 NAMES <- toupper(changed)
[13:14:32.782]                 args <- list()
[13:14:32.782]                 for (kk in seq_along(NAMES)) {
[13:14:32.782]                   name <- changed[[kk]]
[13:14:32.782]                   NAME <- NAMES[[kk]]
[13:14:32.782]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:32.782]                     next
[13:14:32.782]                   args[[name]] <- ...future.oldEnvVars[[name]]
[13:14:32.782]                 }
[13:14:32.782]                 NAMES <- toupper(added)
[13:14:32.782]                 for (kk in seq_along(NAMES)) {
[13:14:32.782]                   name <- added[[kk]]
[13:14:32.782]                   NAME <- NAMES[[kk]]
[13:14:32.782]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:32.782]                     next
[13:14:32.782]                   args[[name]] <- ""
[13:14:32.782]                 }
[13:14:32.782]                 NAMES <- toupper(removed)
[13:14:32.782]                 for (kk in seq_along(NAMES)) {
[13:14:32.782]                   name <- removed[[kk]]
[13:14:32.782]                   NAME <- NAMES[[kk]]
[13:14:32.782]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:32.782]                     next
[13:14:32.782]                   args[[name]] <- ...future.oldEnvVars[[name]]
[13:14:32.782]                 }
[13:14:32.782]                 if (length(args) > 0) 
[13:14:32.782]                   base::do.call(base::Sys.setenv, args = args)
[13:14:32.782]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[13:14:32.782]             }
[13:14:32.782]             else {
[13:14:32.782]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[13:14:32.782]             }
[13:14:32.782]             {
[13:14:32.782]                 if (base::length(...future.futureOptionsAdded) > 
[13:14:32.782]                   0L) {
[13:14:32.782]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[13:14:32.782]                   base::names(opts) <- ...future.futureOptionsAdded
[13:14:32.782]                   base::options(opts)
[13:14:32.782]                 }
[13:14:32.782]                 {
[13:14:32.782]                   {
[13:14:32.782]                     base::options(mc.cores = ...future.mc.cores.old)
[13:14:32.782]                     NULL
[13:14:32.782]                   }
[13:14:32.782]                   options(future.plan = NULL)
[13:14:32.782]                   if (is.na(NA_character_)) 
[13:14:32.782]                     Sys.unsetenv("R_FUTURE_PLAN")
[13:14:32.782]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[13:14:32.782]                   future::plan(list(function (..., workers = availableCores(), 
[13:14:32.782]                     lazy = FALSE, rscript_libs = .libPaths(), 
[13:14:32.782]                     envir = parent.frame()) 
[13:14:32.782]                   {
[13:14:32.782]                     if (is.function(workers)) 
[13:14:32.782]                       workers <- workers()
[13:14:32.782]                     workers <- structure(as.integer(workers), 
[13:14:32.782]                       class = class(workers))
[13:14:32.782]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[13:14:32.782]                       workers >= 1)
[13:14:32.782]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[13:14:32.782]                       return(sequential(..., lazy = TRUE, envir = envir))
[13:14:32.782]                     }
[13:14:32.782]                     future <- MultisessionFuture(..., workers = workers, 
[13:14:32.782]                       lazy = lazy, rscript_libs = rscript_libs, 
[13:14:32.782]                       envir = envir)
[13:14:32.782]                     if (!future$lazy) 
[13:14:32.782]                       future <- run(future)
[13:14:32.782]                     invisible(future)
[13:14:32.782]                   }), .cleanup = FALSE, .init = FALSE)
[13:14:32.782]                 }
[13:14:32.782]             }
[13:14:32.782]         }
[13:14:32.782]     })
[13:14:32.782]     if (FALSE) {
[13:14:32.782]         base::sink(type = "output", split = FALSE)
[13:14:32.782]         if (NA) {
[13:14:32.782]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[13:14:32.782]         }
[13:14:32.782]         else {
[13:14:32.782]             ...future.result["stdout"] <- base::list(NULL)
[13:14:32.782]         }
[13:14:32.782]         base::close(...future.stdout)
[13:14:32.782]         ...future.stdout <- NULL
[13:14:32.782]     }
[13:14:32.782]     ...future.result$conditions <- ...future.conditions
[13:14:32.782]     ...future.result$finished <- base::Sys.time()
[13:14:32.782]     ...future.result
[13:14:32.782] }
[13:14:32.788] Exporting 5 global objects (4.61 KiB) to cluster node #2 ...
[13:14:32.788] Exporting '...future.FUN' (4.61 KiB) to cluster node #2 ...
[13:14:32.789] Exporting '...future.FUN' (4.61 KiB) to cluster node #2 ... DONE
[13:14:32.789] Exporting 'future.call.arguments' (0 bytes) to cluster node #2 ...
[13:14:32.789] Exporting 'future.call.arguments' (0 bytes) to cluster node #2 ... DONE
[13:14:32.790] Exporting '...future.elements_ii' (56 bytes) to cluster node #2 ...
[13:14:32.790] Exporting '...future.elements_ii' (56 bytes) to cluster node #2 ... DONE
[13:14:32.790] Exporting '...future.seeds_ii' (0 bytes) to cluster node #2 ...
[13:14:32.791] Exporting '...future.seeds_ii' (0 bytes) to cluster node #2 ... DONE
[13:14:32.791] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #2 ...
[13:14:32.791] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #2 ... DONE
[13:14:32.792] Exporting 5 global objects (4.61 KiB) to cluster node #2 ... DONE
[13:14:32.792] MultisessionFuture started
[13:14:32.792] - Launch lazy future ... done
[13:14:32.792] run() for 'MultisessionFuture' ... done
[13:14:32.793] Created future:
[13:14:32.810] receiveMessageFromWorker() for ClusterFuture ...
[13:14:32.810] - Validating connection of MultisessionFuture
[13:14:32.810] - received message: FutureResult
[13:14:32.811] - Received FutureResult
[13:14:32.811] - Erased future from FutureRegistry
[13:14:32.811] result() for ClusterFuture ...
[13:14:32.811] - result already collected: FutureResult
[13:14:32.811] result() for ClusterFuture ... done
[13:14:32.811] receiveMessageFromWorker() for ClusterFuture ... done
[13:14:32.793] MultisessionFuture:
[13:14:32.793] Label: 'future_lapply-2'
[13:14:32.793] Expression:
[13:14:32.793] {
[13:14:32.793]     do.call(function(...) {
[13:14:32.793]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[13:14:32.793]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[13:14:32.793]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[13:14:32.793]             on.exit(options(oopts), add = TRUE)
[13:14:32.793]         }
[13:14:32.793]         {
[13:14:32.793]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[13:14:32.793]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[13:14:32.793]                 ...future.FUN(...future.X_jj, ...)
[13:14:32.793]             })
[13:14:32.793]         }
[13:14:32.793]     }, args = future.call.arguments)
[13:14:32.793] }
[13:14:32.793] Lazy evaluation: FALSE
[13:14:32.793] Asynchronous evaluation: TRUE
[13:14:32.793] Local evaluation: TRUE
[13:14:32.793] Environment: R_GlobalEnv
[13:14:32.793] Capture standard output: NA
[13:14:32.793] Capture condition classes: 'condition' (excluding 'nothing')
[13:14:32.793] Globals: 5 objects totaling 4.66 KiB (function '...future.FUN' of 4.61 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 56 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[13:14:32.793] Packages: <none>
[13:14:32.793] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[13:14:32.793] Resolved: TRUE
[13:14:32.793] Value: <not collected>
[13:14:32.793] Conditions captured: <none>
[13:14:32.793] Early signaling: FALSE
[13:14:32.793] Owner process: 68097d82-3b31-293d-2920-9b7259f27083
[13:14:32.793] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[13:14:32.812] Chunk #2 of 2 ... DONE
[13:14:32.812] Launching 2 futures (chunks) ... DONE
[13:14:32.812] Resolving 2 futures (chunks) ...
[13:14:32.812] resolve() on list ...
[13:14:32.812]  recursive: 0
[13:14:32.813]  length: 2
[13:14:32.813] 
[13:14:33.007] Future #2
[13:14:33.007] result() for ClusterFuture ...
[13:14:33.007] - result already collected: FutureResult
[13:14:33.007] result() for ClusterFuture ... done
[13:14:33.007] result() for ClusterFuture ...
[13:14:33.008] - result already collected: FutureResult
[13:14:33.008] result() for ClusterFuture ... done
[13:14:33.008] signalConditionsASAP(MultisessionFuture, pos=2) ...
[13:14:33.008] - nx: 2
[13:14:33.008] - relay: TRUE
[13:14:33.008] - stdout: TRUE
[13:14:33.009] - signal: TRUE
[13:14:33.009] - resignal: FALSE
[13:14:33.009] - force: TRUE
[13:14:33.009] - relayed: [n=2] FALSE, FALSE
[13:14:33.009] - queued futures: [n=2] FALSE, FALSE
[13:14:33.009]  - until=1
[13:14:33.009]  - relaying element #1
[13:14:33.010] - relayed: [n=2] FALSE, FALSE
[13:14:33.010] - queued futures: [n=2] FALSE, TRUE
[13:14:33.010] signalConditionsASAP(NULL, pos=2) ... done
[13:14:33.010]  length: 1 (resolved future 2)
[13:14:33.084] receiveMessageFromWorker() for ClusterFuture ...
[13:14:33.085] - Validating connection of MultisessionFuture
[13:14:33.085] - received message: FutureResult
[13:14:33.085] - Received FutureResult
[13:14:33.085] - Erased future from FutureRegistry
[13:14:33.086] result() for ClusterFuture ...
[13:14:33.086] - result already collected: FutureResult
[13:14:33.086] result() for ClusterFuture ... done
[13:14:33.086] receiveMessageFromWorker() for ClusterFuture ... done
[13:14:33.086] Future #1
[13:14:33.086] result() for ClusterFuture ...
[13:14:33.087] - result already collected: FutureResult
[13:14:33.087] result() for ClusterFuture ... done
[13:14:33.087] result() for ClusterFuture ...
[13:14:33.087] - result already collected: FutureResult
[13:14:33.087] result() for ClusterFuture ... done
[13:14:33.087] signalConditionsASAP(MultisessionFuture, pos=1) ...
[13:14:33.087] - nx: 2
[13:14:33.088] - relay: TRUE
[13:14:33.088] - stdout: TRUE
[13:14:33.088] - signal: TRUE
[13:14:33.088] - resignal: FALSE
[13:14:33.088] - force: TRUE
[13:14:33.088] - relayed: [n=2] FALSE, FALSE
[13:14:33.089] - queued futures: [n=2] FALSE, TRUE
[13:14:33.089]  - until=1
[13:14:33.089]  - relaying element #1
[13:14:33.089] result() for ClusterFuture ...
[13:14:33.089] - result already collected: FutureResult
[13:14:33.089] result() for ClusterFuture ... done
[13:14:33.089] result() for ClusterFuture ...
[13:14:33.090] - result already collected: FutureResult
[13:14:33.090] result() for ClusterFuture ... done
[13:14:33.090] result() for ClusterFuture ...
[13:14:33.090] - result already collected: FutureResult
[13:14:33.090] result() for ClusterFuture ... done
[13:14:33.090] result() for ClusterFuture ...
[13:14:33.091] - result already collected: FutureResult
[13:14:33.091] result() for ClusterFuture ... done
[13:14:33.091] - relayed: [n=2] TRUE, FALSE
[13:14:33.091] - queued futures: [n=2] TRUE, TRUE
[13:14:33.091] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[13:14:33.091]  length: 0 (resolved future 1)
[13:14:33.092] Relaying remaining futures
[13:14:33.092] signalConditionsASAP(NULL, pos=0) ...
[13:14:33.092] - nx: 2
[13:14:33.092] - relay: TRUE
[13:14:33.092] - stdout: TRUE
[13:14:33.092] - signal: TRUE
[13:14:33.092] - resignal: FALSE
[13:14:33.093] - force: TRUE
[13:14:33.093] - relayed: [n=2] TRUE, FALSE
[13:14:33.093] - queued futures: [n=2] TRUE, TRUE
 - flush all
[13:14:33.093]  - relaying element #2
[13:14:33.093] result() for ClusterFuture ...
[13:14:33.093] - result already collected: FutureResult
[13:14:33.094] result() for ClusterFuture ... done
[13:14:33.094] result() for ClusterFuture ...
[13:14:33.094] - result already collected: FutureResult
[13:14:33.094] result() for ClusterFuture ... done
[13:14:33.094] result() for ClusterFuture ...
[13:14:33.094] - result already collected: FutureResult
[13:14:33.095] result() for ClusterFuture ... done
[13:14:33.095] result() for ClusterFuture ...
[13:14:33.095] - result already collected: FutureResult
[13:14:33.095] result() for ClusterFuture ... done
[13:14:33.095] - relayed: [n=2] TRUE, TRUE
[13:14:33.095] - queued futures: [n=2] TRUE, TRUE
[13:14:33.096] signalConditionsASAP(MultisessionFuture, pos=0) ... done
[13:14:33.096] resolve() on list ... DONE
[13:14:33.096] result() for ClusterFuture ...
[13:14:33.096] - result already collected: FutureResult
[13:14:33.096] result() for ClusterFuture ... done
[13:14:33.096] result() for ClusterFuture ...
[13:14:33.096] - result already collected: FutureResult
[13:14:33.097] result() for ClusterFuture ... done
[13:14:33.097] result() for ClusterFuture ...
[13:14:33.097] - result already collected: FutureResult
[13:14:33.097] result() for ClusterFuture ... done
[13:14:33.097] result() for ClusterFuture ...
[13:14:33.097] - result already collected: FutureResult
[13:14:33.098] result() for ClusterFuture ... done
[13:14:33.098]  - Number of value chunks collected: 2
[13:14:33.098] Resolving 2 futures (chunks) ... DONE
[13:14:33.098] Reducing values from 2 chunks ...
[13:14:33.098]  - Number of values collected after concatenation: 2
[13:14:33.098]  - Number of values expected: 2
[13:14:33.099] Reducing values from 2 chunks ... DONE
[13:14:33.099] future_lapply() ... DONE
* future_lapply(x, ..., future.stdout = NA) ... DONE
* future_mapply(x, ..., future.stdout = FALSE) ...
[13:14:33.099] future_mapply() ...
[13:14:33.102] Number of chunks: 2
[13:14:33.102] getGlobalsAndPackagesXApply() ...
[13:14:33.102]  - future.globals: TRUE
[13:14:33.102] getGlobalsAndPackages() ...
[13:14:33.102] Searching for globals...
[13:14:33.104] - globals found: [6] 'FUN', '{', 'Sys.sleep', '/', 'print', 'list'
[13:14:33.105] Searching for globals ... DONE
[13:14:33.105] Resolving globals: FALSE
[13:14:33.105] The total size of the 1 globals is 6.11 KiB (6256 bytes)
[13:14:33.106] The total size of the 1 globals exported for future expression ('FUN()') is 6.11 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (6.11 KiB of class 'function')
[13:14:33.106] - globals: [1] 'FUN'
[13:14:33.106] 
[13:14:33.106] getGlobalsAndPackages() ... DONE
[13:14:33.106]  - globals found/used: [n=1] 'FUN'
[13:14:33.107]  - needed namespaces: [n=0] 
[13:14:33.107] Finding globals ... DONE
[13:14:33.107] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[13:14:33.107] List of 2
[13:14:33.107]  $ ...future.FUN:function (x, y)  
[13:14:33.107]  $ MoreArgs     : NULL
[13:14:33.107]  - attr(*, "where")=List of 2
[13:14:33.107]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[13:14:33.107]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[13:14:33.107]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[13:14:33.107]  - attr(*, "resolved")= logi FALSE
[13:14:33.107]  - attr(*, "total_size")= num NA
[13:14:33.110] Packages to be attached in all futures: [n=0] 
[13:14:33.110] getGlobalsAndPackagesXApply() ... DONE
[13:14:33.111] Number of futures (= number of chunks): 2
[13:14:33.111] Launching 2 futures (chunks) ...
[13:14:33.111] Chunk #1 of 2 ...
[13:14:33.111]  - Finding globals in '...' for chunk #1 ...
[13:14:33.111] getGlobalsAndPackages() ...
[13:14:33.112] Searching for globals...
[13:14:33.112] 
[13:14:33.112] Searching for globals ... DONE
[13:14:33.112] - globals: [0] <none>
[13:14:33.113] getGlobalsAndPackages() ... DONE
[13:14:33.113]    + additional globals found: [n=0] 
[13:14:33.113]    + additional namespaces needed: [n=0] 
[13:14:33.113]  - Finding globals in '...' for chunk #1 ... DONE
[13:14:33.113]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[13:14:33.113]  - seeds: <none>
[13:14:33.113]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:33.114] getGlobalsAndPackages() ...
[13:14:33.114] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:33.114] Resolving globals: FALSE
[13:14:33.115] The total size of the 5 globals is 6.22 KiB (6368 bytes)
[13:14:33.115] The total size of the 5 globals exported for future expression ('{; ...future.globals.maxSize.org <- getOption("future.globals.maxSize"); if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {; oopts <- options(future.globals.maxSize = ...future.globals.maxSize); on.exit(options(oopts), add = TRUE); }; ...; do.call(mapply, args = args); }; }') is 6.22 KiB.. This exceeds the maximum allowed size of 0.98 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (6.11 KiB of class 'function'), '...future.elements_ii' (112 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[13:14:33.115] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:33.116] 
[13:14:33.116] getGlobalsAndPackages() ... DONE
[13:14:33.116] run() for 'Future' ...
[13:14:33.116] - state: 'created'
[13:14:33.117] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[13:14:33.131] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[13:14:33.131] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[13:14:33.131]   - Field: 'node'
[13:14:33.131]   - Field: 'label'
[13:14:33.132]   - Field: 'local'
[13:14:33.132]   - Field: 'owner'
[13:14:33.132]   - Field: 'envir'
[13:14:33.132]   - Field: 'workers'
[13:14:33.132]   - Field: 'packages'
[13:14:33.133]   - Field: 'gc'
[13:14:33.133]   - Field: 'conditions'
[13:14:33.133]   - Field: 'persistent'
[13:14:33.133]   - Field: 'expr'
[13:14:33.133]   - Field: 'uuid'
[13:14:33.133]   - Field: 'seed'
[13:14:33.134]   - Field: 'version'
[13:14:33.134]   - Field: 'result'
[13:14:33.134]   - Field: 'asynchronous'
[13:14:33.134]   - Field: 'calls'
[13:14:33.134]   - Field: 'globals'
[13:14:33.135]   - Field: 'stdout'
[13:14:33.135]   - Field: 'earlySignal'
[13:14:33.135]   - Field: 'lazy'
[13:14:33.135]   - Field: 'state'
[13:14:33.135] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[13:14:33.135] - Launch lazy future ...
[13:14:33.136] Packages needed by the future expression (n = 0): <none>
[13:14:33.136] Packages needed by future strategies (n = 0): <none>
[13:14:33.137] {
[13:14:33.137]     {
[13:14:33.137]         {
[13:14:33.137]             ...future.startTime <- base::Sys.time()
[13:14:33.137]             {
[13:14:33.137]                 {
[13:14:33.137]                   {
[13:14:33.137]                     {
[13:14:33.137]                       base::local({
[13:14:33.137]                         has_future <- base::requireNamespace("future", 
[13:14:33.137]                           quietly = TRUE)
[13:14:33.137]                         if (has_future) {
[13:14:33.137]                           ns <- base::getNamespace("future")
[13:14:33.137]                           version <- ns[[".package"]][["version"]]
[13:14:33.137]                           if (is.null(version)) 
[13:14:33.137]                             version <- utils::packageVersion("future")
[13:14:33.137]                         }
[13:14:33.137]                         else {
[13:14:33.137]                           version <- NULL
[13:14:33.137]                         }
[13:14:33.137]                         if (!has_future || version < "1.8.0") {
[13:14:33.137]                           info <- base::c(r_version = base::gsub("R version ", 
[13:14:33.137]                             "", base::R.version$version.string), 
[13:14:33.137]                             platform = base::sprintf("%s (%s-bit)", 
[13:14:33.137]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[13:14:33.137]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[13:14:33.137]                               "release", "version")], collapse = " "), 
[13:14:33.137]                             hostname = base::Sys.info()[["nodename"]])
[13:14:33.137]                           info <- base::sprintf("%s: %s", base::names(info), 
[13:14:33.137]                             info)
[13:14:33.137]                           info <- base::paste(info, collapse = "; ")
[13:14:33.137]                           if (!has_future) {
[13:14:33.137]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[13:14:33.137]                               info)
[13:14:33.137]                           }
[13:14:33.137]                           else {
[13:14:33.137]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[13:14:33.137]                               info, version)
[13:14:33.137]                           }
[13:14:33.137]                           base::stop(msg)
[13:14:33.137]                         }
[13:14:33.137]                       })
[13:14:33.137]                     }
[13:14:33.137]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[13:14:33.137]                     base::options(mc.cores = 1L)
[13:14:33.137]                   }
[13:14:33.137]                   options(future.plan = NULL)
[13:14:33.137]                   Sys.unsetenv("R_FUTURE_PLAN")
[13:14:33.137]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[13:14:33.137]                 }
[13:14:33.137]                 ...future.workdir <- getwd()
[13:14:33.137]             }
[13:14:33.137]             ...future.oldOptions <- base::as.list(base::.Options)
[13:14:33.137]             ...future.oldEnvVars <- base::Sys.getenv()
[13:14:33.137]         }
[13:14:33.137]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[13:14:33.137]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[13:14:33.137]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[13:14:33.137]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[13:14:33.137]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[13:14:33.137]             future.stdout.windows.reencode = NULL, width = 80L)
[13:14:33.137]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[13:14:33.137]             base::names(...future.oldOptions))
[13:14:33.137]     }
[13:14:33.137]     if (FALSE) {
[13:14:33.137]     }
[13:14:33.137]     else {
[13:14:33.137]         if (FALSE) {
[13:14:33.137]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[13:14:33.137]                 open = "w")
[13:14:33.137]         }
[13:14:33.137]         else {
[13:14:33.137]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[13:14:33.137]                 windows = "NUL", "/dev/null"), open = "w")
[13:14:33.137]         }
[13:14:33.137]         base::sink(...future.stdout, type = "output", split = FALSE)
[13:14:33.137]         base::on.exit(if (!base::is.null(...future.stdout)) {
[13:14:33.137]             base::sink(type = "output", split = FALSE)
[13:14:33.137]             base::close(...future.stdout)
[13:14:33.137]         }, add = TRUE)
[13:14:33.137]     }
[13:14:33.137]     ...future.frame <- base::sys.nframe()
[13:14:33.137]     ...future.conditions <- base::list()
[13:14:33.137]     ...future.rng <- base::globalenv()$.Random.seed
[13:14:33.137]     if (FALSE) {
[13:14:33.137]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[13:14:33.137]             "...future.value", "...future.globalenv.names", ".Random.seed")
[13:14:33.137]     }
[13:14:33.137]     ...future.result <- base::tryCatch({
[13:14:33.137]         base::withCallingHandlers({
[13:14:33.137]             ...future.value <- base::withVisible(base::local({
[13:14:33.137]                 ...future.makeSendCondition <- local({
[13:14:33.137]                   sendCondition <- NULL
[13:14:33.137]                   function(frame = 1L) {
[13:14:33.137]                     if (is.function(sendCondition)) 
[13:14:33.137]                       return(sendCondition)
[13:14:33.137]                     ns <- getNamespace("parallel")
[13:14:33.137]                     if (exists("sendData", mode = "function", 
[13:14:33.137]                       envir = ns)) {
[13:14:33.137]                       parallel_sendData <- get("sendData", mode = "function", 
[13:14:33.137]                         envir = ns)
[13:14:33.137]                       envir <- sys.frame(frame)
[13:14:33.137]                       master <- NULL
[13:14:33.137]                       while (!identical(envir, .GlobalEnv) && 
[13:14:33.137]                         !identical(envir, emptyenv())) {
[13:14:33.137]                         if (exists("master", mode = "list", envir = envir, 
[13:14:33.137]                           inherits = FALSE)) {
[13:14:33.137]                           master <- get("master", mode = "list", 
[13:14:33.137]                             envir = envir, inherits = FALSE)
[13:14:33.137]                           if (inherits(master, c("SOCKnode", 
[13:14:33.137]                             "SOCK0node"))) {
[13:14:33.137]                             sendCondition <<- function(cond) {
[13:14:33.137]                               data <- list(type = "VALUE", value = cond, 
[13:14:33.137]                                 success = TRUE)
[13:14:33.137]                               parallel_sendData(master, data)
[13:14:33.137]                             }
[13:14:33.137]                             return(sendCondition)
[13:14:33.137]                           }
[13:14:33.137]                         }
[13:14:33.137]                         frame <- frame + 1L
[13:14:33.137]                         envir <- sys.frame(frame)
[13:14:33.137]                       }
[13:14:33.137]                     }
[13:14:33.137]                     sendCondition <<- function(cond) NULL
[13:14:33.137]                   }
[13:14:33.137]                 })
[13:14:33.137]                 withCallingHandlers({
[13:14:33.137]                   {
[13:14:33.137]                     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[13:14:33.137]                     if (!identical(...future.globals.maxSize.org, 
[13:14:33.137]                       ...future.globals.maxSize)) {
[13:14:33.137]                       oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[13:14:33.137]                       on.exit(options(oopts), add = TRUE)
[13:14:33.137]                     }
[13:14:33.137]                     {
[13:14:33.137]                       args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[13:14:33.137]                         MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[13:14:33.137]                         USE.NAMES = FALSE)
[13:14:33.137]                       do.call(mapply, args = args)
[13:14:33.137]                     }
[13:14:33.137]                   }
[13:14:33.137]                 }, immediateCondition = function(cond) {
[13:14:33.137]                   sendCondition <- ...future.makeSendCondition()
[13:14:33.137]                   sendCondition(cond)
[13:14:33.137]                   muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:33.137]                   {
[13:14:33.137]                     inherits <- base::inherits
[13:14:33.137]                     invokeRestart <- base::invokeRestart
[13:14:33.137]                     is.null <- base::is.null
[13:14:33.137]                     muffled <- FALSE
[13:14:33.137]                     if (inherits(cond, "message")) {
[13:14:33.137]                       muffled <- grepl(pattern, "muffleMessage")
[13:14:33.137]                       if (muffled) 
[13:14:33.137]                         invokeRestart("muffleMessage")
[13:14:33.137]                     }
[13:14:33.137]                     else if (inherits(cond, "warning")) {
[13:14:33.137]                       muffled <- grepl(pattern, "muffleWarning")
[13:14:33.137]                       if (muffled) 
[13:14:33.137]                         invokeRestart("muffleWarning")
[13:14:33.137]                     }
[13:14:33.137]                     else if (inherits(cond, "condition")) {
[13:14:33.137]                       if (!is.null(pattern)) {
[13:14:33.137]                         computeRestarts <- base::computeRestarts
[13:14:33.137]                         grepl <- base::grepl
[13:14:33.137]                         restarts <- computeRestarts(cond)
[13:14:33.137]                         for (restart in restarts) {
[13:14:33.137]                           name <- restart$name
[13:14:33.137]                           if (is.null(name)) 
[13:14:33.137]                             next
[13:14:33.137]                           if (!grepl(pattern, name)) 
[13:14:33.137]                             next
[13:14:33.137]                           invokeRestart(restart)
[13:14:33.137]                           muffled <- TRUE
[13:14:33.137]                           break
[13:14:33.137]                         }
[13:14:33.137]                       }
[13:14:33.137]                     }
[13:14:33.137]                     invisible(muffled)
[13:14:33.137]                   }
[13:14:33.137]                   muffleCondition(cond)
[13:14:33.137]                 })
[13:14:33.137]             }))
[13:14:33.137]             future::FutureResult(value = ...future.value$value, 
[13:14:33.137]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[13:14:33.137]                   ...future.rng), globalenv = if (FALSE) 
[13:14:33.137]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[13:14:33.137]                     ...future.globalenv.names))
[13:14:33.137]                 else NULL, started = ...future.startTime, version = "1.8")
[13:14:33.137]         }, condition = base::local({
[13:14:33.137]             c <- base::c
[13:14:33.137]             inherits <- base::inherits
[13:14:33.137]             invokeRestart <- base::invokeRestart
[13:14:33.137]             length <- base::length
[13:14:33.137]             list <- base::list
[13:14:33.137]             seq.int <- base::seq.int
[13:14:33.137]             signalCondition <- base::signalCondition
[13:14:33.137]             sys.calls <- base::sys.calls
[13:14:33.137]             `[[` <- base::`[[`
[13:14:33.137]             `+` <- base::`+`
[13:14:33.137]             `<<-` <- base::`<<-`
[13:14:33.137]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[13:14:33.137]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[13:14:33.137]                   3L)]
[13:14:33.137]             }
[13:14:33.137]             function(cond) {
[13:14:33.137]                 is_error <- inherits(cond, "error")
[13:14:33.137]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[13:14:33.137]                   NULL)
[13:14:33.137]                 if (is_error) {
[13:14:33.137]                   sessionInformation <- function() {
[13:14:33.137]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[13:14:33.137]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[13:14:33.137]                       search = base::search(), system = base::Sys.info())
[13:14:33.137]                   }
[13:14:33.137]                   ...future.conditions[[length(...future.conditions) + 
[13:14:33.137]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[13:14:33.137]                     cond$call), session = sessionInformation(), 
[13:14:33.137]                     timestamp = base::Sys.time(), signaled = 0L)
[13:14:33.137]                   signalCondition(cond)
[13:14:33.137]                 }
[13:14:33.137]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[13:14:33.137]                 "immediateCondition"))) {
[13:14:33.137]                   signal <- TRUE && inherits(cond, "immediateCondition")
[13:14:33.137]                   ...future.conditions[[length(...future.conditions) + 
[13:14:33.137]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[13:14:33.137]                   if (TRUE && !signal) {
[13:14:33.137]                     muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:33.137]                     {
[13:14:33.137]                       inherits <- base::inherits
[13:14:33.137]                       invokeRestart <- base::invokeRestart
[13:14:33.137]                       is.null <- base::is.null
[13:14:33.137]                       muffled <- FALSE
[13:14:33.137]                       if (inherits(cond, "message")) {
[13:14:33.137]                         muffled <- grepl(pattern, "muffleMessage")
[13:14:33.137]                         if (muffled) 
[13:14:33.137]                           invokeRestart("muffleMessage")
[13:14:33.137]                       }
[13:14:33.137]                       else if (inherits(cond, "warning")) {
[13:14:33.137]                         muffled <- grepl(pattern, "muffleWarning")
[13:14:33.137]                         if (muffled) 
[13:14:33.137]                           invokeRestart("muffleWarning")
[13:14:33.137]                       }
[13:14:33.137]                       else if (inherits(cond, "condition")) {
[13:14:33.137]                         if (!is.null(pattern)) {
[13:14:33.137]                           computeRestarts <- base::computeRestarts
[13:14:33.137]                           grepl <- base::grepl
[13:14:33.137]                           restarts <- computeRestarts(cond)
[13:14:33.137]                           for (restart in restarts) {
[13:14:33.137]                             name <- restart$name
[13:14:33.137]                             if (is.null(name)) 
[13:14:33.137]                               next
[13:14:33.137]                             if (!grepl(pattern, name)) 
[13:14:33.137]                               next
[13:14:33.137]                             invokeRestart(restart)
[13:14:33.137]                             muffled <- TRUE
[13:14:33.137]                             break
[13:14:33.137]                           }
[13:14:33.137]                         }
[13:14:33.137]                       }
[13:14:33.137]                       invisible(muffled)
[13:14:33.137]                     }
[13:14:33.137]                     muffleCondition(cond, pattern = "^muffle")
[13:14:33.137]                   }
[13:14:33.137]                 }
[13:14:33.137]                 else {
[13:14:33.137]                   if (TRUE) {
[13:14:33.137]                     muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:33.137]                     {
[13:14:33.137]                       inherits <- base::inherits
[13:14:33.137]                       invokeRestart <- base::invokeRestart
[13:14:33.137]                       is.null <- base::is.null
[13:14:33.137]                       muffled <- FALSE
[13:14:33.137]                       if (inherits(cond, "message")) {
[13:14:33.137]                         muffled <- grepl(pattern, "muffleMessage")
[13:14:33.137]                         if (muffled) 
[13:14:33.137]                           invokeRestart("muffleMessage")
[13:14:33.137]                       }
[13:14:33.137]                       else if (inherits(cond, "warning")) {
[13:14:33.137]                         muffled <- grepl(pattern, "muffleWarning")
[13:14:33.137]                         if (muffled) 
[13:14:33.137]                           invokeRestart("muffleWarning")
[13:14:33.137]                       }
[13:14:33.137]                       else if (inherits(cond, "condition")) {
[13:14:33.137]                         if (!is.null(pattern)) {
[13:14:33.137]                           computeRestarts <- base::computeRestarts
[13:14:33.137]                           grepl <- base::grepl
[13:14:33.137]                           restarts <- computeRestarts(cond)
[13:14:33.137]                           for (restart in restarts) {
[13:14:33.137]                             name <- restart$name
[13:14:33.137]                             if (is.null(name)) 
[13:14:33.137]                               next
[13:14:33.137]                             if (!grepl(pattern, name)) 
[13:14:33.137]                               next
[13:14:33.137]                             invokeRestart(restart)
[13:14:33.137]                             muffled <- TRUE
[13:14:33.137]                             break
[13:14:33.137]                           }
[13:14:33.137]                         }
[13:14:33.137]                       }
[13:14:33.137]                       invisible(muffled)
[13:14:33.137]                     }
[13:14:33.137]                     muffleCondition(cond, pattern = "^muffle")
[13:14:33.137]                   }
[13:14:33.137]                 }
[13:14:33.137]             }
[13:14:33.137]         }))
[13:14:33.137]     }, error = function(ex) {
[13:14:33.137]         base::structure(base::list(value = NULL, visible = NULL, 
[13:14:33.137]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[13:14:33.137]                 ...future.rng), started = ...future.startTime, 
[13:14:33.137]             finished = Sys.time(), session_uuid = NA_character_, 
[13:14:33.137]             version = "1.8"), class = "FutureResult")
[13:14:33.137]     }, finally = {
[13:14:33.137]         if (!identical(...future.workdir, getwd())) 
[13:14:33.137]             setwd(...future.workdir)
[13:14:33.137]         {
[13:14:33.137]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[13:14:33.137]                 ...future.oldOptions$nwarnings <- NULL
[13:14:33.137]             }
[13:14:33.137]             base::options(...future.oldOptions)
[13:14:33.137]             if (.Platform$OS.type == "windows") {
[13:14:33.137]                 old_names <- names(...future.oldEnvVars)
[13:14:33.137]                 envs <- base::Sys.getenv()
[13:14:33.137]                 names <- names(envs)
[13:14:33.137]                 common <- intersect(names, old_names)
[13:14:33.137]                 added <- setdiff(names, old_names)
[13:14:33.137]                 removed <- setdiff(old_names, names)
[13:14:33.137]                 changed <- common[...future.oldEnvVars[common] != 
[13:14:33.137]                   envs[common]]
[13:14:33.137]                 NAMES <- toupper(changed)
[13:14:33.137]                 args <- list()
[13:14:33.137]                 for (kk in seq_along(NAMES)) {
[13:14:33.137]                   name <- changed[[kk]]
[13:14:33.137]                   NAME <- NAMES[[kk]]
[13:14:33.137]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:33.137]                     next
[13:14:33.137]                   args[[name]] <- ...future.oldEnvVars[[name]]
[13:14:33.137]                 }
[13:14:33.137]                 NAMES <- toupper(added)
[13:14:33.137]                 for (kk in seq_along(NAMES)) {
[13:14:33.137]                   name <- added[[kk]]
[13:14:33.137]                   NAME <- NAMES[[kk]]
[13:14:33.137]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:33.137]                     next
[13:14:33.137]                   args[[name]] <- ""
[13:14:33.137]                 }
[13:14:33.137]                 NAMES <- toupper(removed)
[13:14:33.137]                 for (kk in seq_along(NAMES)) {
[13:14:33.137]                   name <- removed[[kk]]
[13:14:33.137]                   NAME <- NAMES[[kk]]
[13:14:33.137]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:33.137]                     next
[13:14:33.137]                   args[[name]] <- ...future.oldEnvVars[[name]]
[13:14:33.137]                 }
[13:14:33.137]                 if (length(args) > 0) 
[13:14:33.137]                   base::do.call(base::Sys.setenv, args = args)
[13:14:33.137]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[13:14:33.137]             }
[13:14:33.137]             else {
[13:14:33.137]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[13:14:33.137]             }
[13:14:33.137]             {
[13:14:33.137]                 if (base::length(...future.futureOptionsAdded) > 
[13:14:33.137]                   0L) {
[13:14:33.137]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[13:14:33.137]                   base::names(opts) <- ...future.futureOptionsAdded
[13:14:33.137]                   base::options(opts)
[13:14:33.137]                 }
[13:14:33.137]                 {
[13:14:33.137]                   {
[13:14:33.137]                     base::options(mc.cores = ...future.mc.cores.old)
[13:14:33.137]                     NULL
[13:14:33.137]                   }
[13:14:33.137]                   options(future.plan = NULL)
[13:14:33.137]                   if (is.na(NA_character_)) 
[13:14:33.137]                     Sys.unsetenv("R_FUTURE_PLAN")
[13:14:33.137]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[13:14:33.137]                   future::plan(list(function (..., workers = availableCores(), 
[13:14:33.137]                     lazy = FALSE, rscript_libs = .libPaths(), 
[13:14:33.137]                     envir = parent.frame()) 
[13:14:33.137]                   {
[13:14:33.137]                     if (is.function(workers)) 
[13:14:33.137]                       workers <- workers()
[13:14:33.137]                     workers <- structure(as.integer(workers), 
[13:14:33.137]                       class = class(workers))
[13:14:33.137]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[13:14:33.137]                       workers >= 1)
[13:14:33.137]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[13:14:33.137]                       return(sequential(..., lazy = TRUE, envir = envir))
[13:14:33.137]                     }
[13:14:33.137]                     future <- MultisessionFuture(..., workers = workers, 
[13:14:33.137]                       lazy = lazy, rscript_libs = rscript_libs, 
[13:14:33.137]                       envir = envir)
[13:14:33.137]                     if (!future$lazy) 
[13:14:33.137]                       future <- run(future)
[13:14:33.137]                     invisible(future)
[13:14:33.137]                   }), .cleanup = FALSE, .init = FALSE)
[13:14:33.137]                 }
[13:14:33.137]             }
[13:14:33.137]         }
[13:14:33.137]     })
[13:14:33.137]     if (TRUE) {
[13:14:33.137]         base::sink(type = "output", split = FALSE)
[13:14:33.137]         if (FALSE) {
[13:14:33.137]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[13:14:33.137]         }
[13:14:33.137]         else {
[13:14:33.137]             ...future.result["stdout"] <- base::list(NULL)
[13:14:33.137]         }
[13:14:33.137]         base::close(...future.stdout)
[13:14:33.137]         ...future.stdout <- NULL
[13:14:33.137]     }
[13:14:33.137]     ...future.result$conditions <- ...future.conditions
[13:14:33.137]     ...future.result$finished <- base::Sys.time()
[13:14:33.137]     ...future.result
[13:14:33.137] }
[13:14:33.142] Exporting 5 global objects (6.22 KiB) to cluster node #1 ...
[13:14:33.142] Exporting '...future.FUN' (6.11 KiB) to cluster node #1 ...
[13:14:33.143] Exporting '...future.FUN' (6.11 KiB) to cluster node #1 ... DONE
[13:14:33.143] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ...
[13:14:33.143] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ... DONE
[13:14:33.144] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[13:14:33.144] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[13:14:33.144] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[13:14:33.145] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[13:14:33.145] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[13:14:33.146] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[13:14:33.146] Exporting 5 global objects (6.22 KiB) to cluster node #1 ... DONE
[13:14:33.146] MultisessionFuture started
[13:14:33.147] - Launch lazy future ... done
[13:14:33.147] run() for 'MultisessionFuture' ... done
[13:14:33.147] Created future:
[13:14:33.147] MultisessionFuture:
[13:14:33.147] Label: 'future_mapply-1'
[13:14:33.147] Expression:
[13:14:33.147] {
[13:14:33.147]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[13:14:33.147]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[13:14:33.147]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[13:14:33.147]         on.exit(options(oopts), add = TRUE)
[13:14:33.147]     }
[13:14:33.147]     {
[13:14:33.147]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[13:14:33.147]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[13:14:33.147]         do.call(mapply, args = args)
[13:14:33.147]     }
[13:14:33.147] }
[13:14:33.147] Lazy evaluation: FALSE
[13:14:33.147] Asynchronous evaluation: TRUE
[13:14:33.147] Local evaluation: TRUE
[13:14:33.147] Environment: R_GlobalEnv
[13:14:33.147] Capture standard output: FALSE
[13:14:33.147] Capture condition classes: 'condition' (excluding 'nothing')
[13:14:33.147] Globals: 5 objects totaling 6.22 KiB (function '...future.FUN' of 6.11 KiB, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 112 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[13:14:33.147] Packages: <none>
[13:14:33.147] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[13:14:33.147] Resolved: FALSE
[13:14:33.147] Value: <not collected>
[13:14:33.147] Conditions captured: <none>
[13:14:33.147] Early signaling: FALSE
[13:14:33.147] Owner process: 68097d82-3b31-293d-2920-9b7259f27083
[13:14:33.147] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[13:14:33.351] Chunk #1 of 2 ... DONE
[13:14:33.351] Chunk #2 of 2 ...
[13:14:33.352]  - Finding globals in '...' for chunk #2 ...
[13:14:33.352] getGlobalsAndPackages() ...
[13:14:33.352] Searching for globals...
[13:14:33.352] 
[13:14:33.354] Searching for globals ... DONE
[13:14:33.354] - globals: [0] <none>
[13:14:33.355] getGlobalsAndPackages() ... DONE
[13:14:33.355]    + additional globals found: [n=0] 
[13:14:33.355]    + additional namespaces needed: [n=0] 
[13:14:33.355]  - Finding globals in '...' for chunk #2 ... DONE
[13:14:33.355]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[13:14:33.355]  - seeds: <none>
[13:14:33.356]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:33.356] getGlobalsAndPackages() ...
[13:14:33.356] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:33.356] Resolving globals: FALSE
[13:14:33.357] The total size of the 5 globals is 6.22 KiB (6368 bytes)
[13:14:33.357] The total size of the 5 globals exported for future expression ('{; ...future.globals.maxSize.org <- getOption("future.globals.maxSize"); if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {; oopts <- options(future.globals.maxSize = ...future.globals.maxSize); on.exit(options(oopts), add = TRUE); }; ...; do.call(mapply, args = args); }; }') is 6.22 KiB.. This exceeds the maximum allowed size of 0.98 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (6.11 KiB of class 'function'), '...future.elements_ii' (112 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[13:14:33.358] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:33.358] 
[13:14:33.358] getGlobalsAndPackages() ... DONE
[13:14:33.358] run() for 'Future' ...
[13:14:33.358] - state: 'created'
[13:14:33.359] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[13:14:33.372] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[13:14:33.372] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[13:14:33.373]   - Field: 'node'
[13:14:33.373]   - Field: 'label'
[13:14:33.373]   - Field: 'local'
[13:14:33.373]   - Field: 'owner'
[13:14:33.373]   - Field: 'envir'
[13:14:33.374]   - Field: 'workers'
[13:14:33.374]   - Field: 'packages'
[13:14:33.374]   - Field: 'gc'
[13:14:33.374]   - Field: 'conditions'
[13:14:33.374]   - Field: 'persistent'
[13:14:33.374]   - Field: 'expr'
[13:14:33.375]   - Field: 'uuid'
[13:14:33.375]   - Field: 'seed'
[13:14:33.375]   - Field: 'version'
[13:14:33.375]   - Field: 'result'
[13:14:33.375]   - Field: 'asynchronous'
[13:14:33.375]   - Field: 'calls'
[13:14:33.376]   - Field: 'globals'
[13:14:33.376]   - Field: 'stdout'
[13:14:33.376]   - Field: 'earlySignal'
[13:14:33.376]   - Field: 'lazy'
[13:14:33.376]   - Field: 'state'
[13:14:33.376] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[13:14:33.377] - Launch lazy future ...
[13:14:33.377] Packages needed by the future expression (n = 0): <none>
[13:14:33.377] Packages needed by future strategies (n = 0): <none>
[13:14:33.378] {
[13:14:33.378]     {
[13:14:33.378]         {
[13:14:33.378]             ...future.startTime <- base::Sys.time()
[13:14:33.378]             {
[13:14:33.378]                 {
[13:14:33.378]                   {
[13:14:33.378]                     {
[13:14:33.378]                       base::local({
[13:14:33.378]                         has_future <- base::requireNamespace("future", 
[13:14:33.378]                           quietly = TRUE)
[13:14:33.378]                         if (has_future) {
[13:14:33.378]                           ns <- base::getNamespace("future")
[13:14:33.378]                           version <- ns[[".package"]][["version"]]
[13:14:33.378]                           if (is.null(version)) 
[13:14:33.378]                             version <- utils::packageVersion("future")
[13:14:33.378]                         }
[13:14:33.378]                         else {
[13:14:33.378]                           version <- NULL
[13:14:33.378]                         }
[13:14:33.378]                         if (!has_future || version < "1.8.0") {
[13:14:33.378]                           info <- base::c(r_version = base::gsub("R version ", 
[13:14:33.378]                             "", base::R.version$version.string), 
[13:14:33.378]                             platform = base::sprintf("%s (%s-bit)", 
[13:14:33.378]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[13:14:33.378]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[13:14:33.378]                               "release", "version")], collapse = " "), 
[13:14:33.378]                             hostname = base::Sys.info()[["nodename"]])
[13:14:33.378]                           info <- base::sprintf("%s: %s", base::names(info), 
[13:14:33.378]                             info)
[13:14:33.378]                           info <- base::paste(info, collapse = "; ")
[13:14:33.378]                           if (!has_future) {
[13:14:33.378]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[13:14:33.378]                               info)
[13:14:33.378]                           }
[13:14:33.378]                           else {
[13:14:33.378]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[13:14:33.378]                               info, version)
[13:14:33.378]                           }
[13:14:33.378]                           base::stop(msg)
[13:14:33.378]                         }
[13:14:33.378]                       })
[13:14:33.378]                     }
[13:14:33.378]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[13:14:33.378]                     base::options(mc.cores = 1L)
[13:14:33.378]                   }
[13:14:33.378]                   options(future.plan = NULL)
[13:14:33.378]                   Sys.unsetenv("R_FUTURE_PLAN")
[13:14:33.378]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[13:14:33.378]                 }
[13:14:33.378]                 ...future.workdir <- getwd()
[13:14:33.378]             }
[13:14:33.378]             ...future.oldOptions <- base::as.list(base::.Options)
[13:14:33.378]             ...future.oldEnvVars <- base::Sys.getenv()
[13:14:33.378]         }
[13:14:33.378]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[13:14:33.378]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[13:14:33.378]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[13:14:33.378]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[13:14:33.378]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[13:14:33.378]             future.stdout.windows.reencode = NULL, width = 80L)
[13:14:33.378]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[13:14:33.378]             base::names(...future.oldOptions))
[13:14:33.378]     }
[13:14:33.378]     if (FALSE) {
[13:14:33.378]     }
[13:14:33.378]     else {
[13:14:33.378]         if (FALSE) {
[13:14:33.378]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[13:14:33.378]                 open = "w")
[13:14:33.378]         }
[13:14:33.378]         else {
[13:14:33.378]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[13:14:33.378]                 windows = "NUL", "/dev/null"), open = "w")
[13:14:33.378]         }
[13:14:33.378]         base::sink(...future.stdout, type = "output", split = FALSE)
[13:14:33.378]         base::on.exit(if (!base::is.null(...future.stdout)) {
[13:14:33.378]             base::sink(type = "output", split = FALSE)
[13:14:33.378]             base::close(...future.stdout)
[13:14:33.378]         }, add = TRUE)
[13:14:33.378]     }
[13:14:33.378]     ...future.frame <- base::sys.nframe()
[13:14:33.378]     ...future.conditions <- base::list()
[13:14:33.378]     ...future.rng <- base::globalenv()$.Random.seed
[13:14:33.378]     if (FALSE) {
[13:14:33.378]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[13:14:33.378]             "...future.value", "...future.globalenv.names", ".Random.seed")
[13:14:33.378]     }
[13:14:33.378]     ...future.result <- base::tryCatch({
[13:14:33.378]         base::withCallingHandlers({
[13:14:33.378]             ...future.value <- base::withVisible(base::local({
[13:14:33.378]                 ...future.makeSendCondition <- local({
[13:14:33.378]                   sendCondition <- NULL
[13:14:33.378]                   function(frame = 1L) {
[13:14:33.378]                     if (is.function(sendCondition)) 
[13:14:33.378]                       return(sendCondition)
[13:14:33.378]                     ns <- getNamespace("parallel")
[13:14:33.378]                     if (exists("sendData", mode = "function", 
[13:14:33.378]                       envir = ns)) {
[13:14:33.378]                       parallel_sendData <- get("sendData", mode = "function", 
[13:14:33.378]                         envir = ns)
[13:14:33.378]                       envir <- sys.frame(frame)
[13:14:33.378]                       master <- NULL
[13:14:33.378]                       while (!identical(envir, .GlobalEnv) && 
[13:14:33.378]                         !identical(envir, emptyenv())) {
[13:14:33.378]                         if (exists("master", mode = "list", envir = envir, 
[13:14:33.378]                           inherits = FALSE)) {
[13:14:33.378]                           master <- get("master", mode = "list", 
[13:14:33.378]                             envir = envir, inherits = FALSE)
[13:14:33.378]                           if (inherits(master, c("SOCKnode", 
[13:14:33.378]                             "SOCK0node"))) {
[13:14:33.378]                             sendCondition <<- function(cond) {
[13:14:33.378]                               data <- list(type = "VALUE", value = cond, 
[13:14:33.378]                                 success = TRUE)
[13:14:33.378]                               parallel_sendData(master, data)
[13:14:33.378]                             }
[13:14:33.378]                             return(sendCondition)
[13:14:33.378]                           }
[13:14:33.378]                         }
[13:14:33.378]                         frame <- frame + 1L
[13:14:33.378]                         envir <- sys.frame(frame)
[13:14:33.378]                       }
[13:14:33.378]                     }
[13:14:33.378]                     sendCondition <<- function(cond) NULL
[13:14:33.378]                   }
[13:14:33.378]                 })
[13:14:33.378]                 withCallingHandlers({
[13:14:33.378]                   {
[13:14:33.378]                     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[13:14:33.378]                     if (!identical(...future.globals.maxSize.org, 
[13:14:33.378]                       ...future.globals.maxSize)) {
[13:14:33.378]                       oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[13:14:33.378]                       on.exit(options(oopts), add = TRUE)
[13:14:33.378]                     }
[13:14:33.378]                     {
[13:14:33.378]                       args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[13:14:33.378]                         MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[13:14:33.378]                         USE.NAMES = FALSE)
[13:14:33.378]                       do.call(mapply, args = args)
[13:14:33.378]                     }
[13:14:33.378]                   }
[13:14:33.378]                 }, immediateCondition = function(cond) {
[13:14:33.378]                   sendCondition <- ...future.makeSendCondition()
[13:14:33.378]                   sendCondition(cond)
[13:14:33.378]                   muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:33.378]                   {
[13:14:33.378]                     inherits <- base::inherits
[13:14:33.378]                     invokeRestart <- base::invokeRestart
[13:14:33.378]                     is.null <- base::is.null
[13:14:33.378]                     muffled <- FALSE
[13:14:33.378]                     if (inherits(cond, "message")) {
[13:14:33.378]                       muffled <- grepl(pattern, "muffleMessage")
[13:14:33.378]                       if (muffled) 
[13:14:33.378]                         invokeRestart("muffleMessage")
[13:14:33.378]                     }
[13:14:33.378]                     else if (inherits(cond, "warning")) {
[13:14:33.378]                       muffled <- grepl(pattern, "muffleWarning")
[13:14:33.378]                       if (muffled) 
[13:14:33.378]                         invokeRestart("muffleWarning")
[13:14:33.378]                     }
[13:14:33.378]                     else if (inherits(cond, "condition")) {
[13:14:33.378]                       if (!is.null(pattern)) {
[13:14:33.378]                         computeRestarts <- base::computeRestarts
[13:14:33.378]                         grepl <- base::grepl
[13:14:33.378]                         restarts <- computeRestarts(cond)
[13:14:33.378]                         for (restart in restarts) {
[13:14:33.378]                           name <- restart$name
[13:14:33.378]                           if (is.null(name)) 
[13:14:33.378]                             next
[13:14:33.378]                           if (!grepl(pattern, name)) 
[13:14:33.378]                             next
[13:14:33.378]                           invokeRestart(restart)
[13:14:33.378]                           muffled <- TRUE
[13:14:33.378]                           break
[13:14:33.378]                         }
[13:14:33.378]                       }
[13:14:33.378]                     }
[13:14:33.378]                     invisible(muffled)
[13:14:33.378]                   }
[13:14:33.378]                   muffleCondition(cond)
[13:14:33.378]                 })
[13:14:33.378]             }))
[13:14:33.378]             future::FutureResult(value = ...future.value$value, 
[13:14:33.378]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[13:14:33.378]                   ...future.rng), globalenv = if (FALSE) 
[13:14:33.378]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[13:14:33.378]                     ...future.globalenv.names))
[13:14:33.378]                 else NULL, started = ...future.startTime, version = "1.8")
[13:14:33.378]         }, condition = base::local({
[13:14:33.378]             c <- base::c
[13:14:33.378]             inherits <- base::inherits
[13:14:33.378]             invokeRestart <- base::invokeRestart
[13:14:33.378]             length <- base::length
[13:14:33.378]             list <- base::list
[13:14:33.378]             seq.int <- base::seq.int
[13:14:33.378]             signalCondition <- base::signalCondition
[13:14:33.378]             sys.calls <- base::sys.calls
[13:14:33.378]             `[[` <- base::`[[`
[13:14:33.378]             `+` <- base::`+`
[13:14:33.378]             `<<-` <- base::`<<-`
[13:14:33.378]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[13:14:33.378]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[13:14:33.378]                   3L)]
[13:14:33.378]             }
[13:14:33.378]             function(cond) {
[13:14:33.378]                 is_error <- inherits(cond, "error")
[13:14:33.378]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[13:14:33.378]                   NULL)
[13:14:33.378]                 if (is_error) {
[13:14:33.378]                   sessionInformation <- function() {
[13:14:33.378]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[13:14:33.378]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[13:14:33.378]                       search = base::search(), system = base::Sys.info())
[13:14:33.378]                   }
[13:14:33.378]                   ...future.conditions[[length(...future.conditions) + 
[13:14:33.378]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[13:14:33.378]                     cond$call), session = sessionInformation(), 
[13:14:33.378]                     timestamp = base::Sys.time(), signaled = 0L)
[13:14:33.378]                   signalCondition(cond)
[13:14:33.378]                 }
[13:14:33.378]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[13:14:33.378]                 "immediateCondition"))) {
[13:14:33.378]                   signal <- TRUE && inherits(cond, "immediateCondition")
[13:14:33.378]                   ...future.conditions[[length(...future.conditions) + 
[13:14:33.378]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[13:14:33.378]                   if (TRUE && !signal) {
[13:14:33.378]                     muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:33.378]                     {
[13:14:33.378]                       inherits <- base::inherits
[13:14:33.378]                       invokeRestart <- base::invokeRestart
[13:14:33.378]                       is.null <- base::is.null
[13:14:33.378]                       muffled <- FALSE
[13:14:33.378]                       if (inherits(cond, "message")) {
[13:14:33.378]                         muffled <- grepl(pattern, "muffleMessage")
[13:14:33.378]                         if (muffled) 
[13:14:33.378]                           invokeRestart("muffleMessage")
[13:14:33.378]                       }
[13:14:33.378]                       else if (inherits(cond, "warning")) {
[13:14:33.378]                         muffled <- grepl(pattern, "muffleWarning")
[13:14:33.378]                         if (muffled) 
[13:14:33.378]                           invokeRestart("muffleWarning")
[13:14:33.378]                       }
[13:14:33.378]                       else if (inherits(cond, "condition")) {
[13:14:33.378]                         if (!is.null(pattern)) {
[13:14:33.378]                           computeRestarts <- base::computeRestarts
[13:14:33.378]                           grepl <- base::grepl
[13:14:33.378]                           restarts <- computeRestarts(cond)
[13:14:33.378]                           for (restart in restarts) {
[13:14:33.378]                             name <- restart$name
[13:14:33.378]                             if (is.null(name)) 
[13:14:33.378]                               next
[13:14:33.378]                             if (!grepl(pattern, name)) 
[13:14:33.378]                               next
[13:14:33.378]                             invokeRestart(restart)
[13:14:33.378]                             muffled <- TRUE
[13:14:33.378]                             break
[13:14:33.378]                           }
[13:14:33.378]                         }
[13:14:33.378]                       }
[13:14:33.378]                       invisible(muffled)
[13:14:33.378]                     }
[13:14:33.378]                     muffleCondition(cond, pattern = "^muffle")
[13:14:33.378]                   }
[13:14:33.378]                 }
[13:14:33.378]                 else {
[13:14:33.378]                   if (TRUE) {
[13:14:33.378]                     muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:33.378]                     {
[13:14:33.378]                       inherits <- base::inherits
[13:14:33.378]                       invokeRestart <- base::invokeRestart
[13:14:33.378]                       is.null <- base::is.null
[13:14:33.378]                       muffled <- FALSE
[13:14:33.378]                       if (inherits(cond, "message")) {
[13:14:33.378]                         muffled <- grepl(pattern, "muffleMessage")
[13:14:33.378]                         if (muffled) 
[13:14:33.378]                           invokeRestart("muffleMessage")
[13:14:33.378]                       }
[13:14:33.378]                       else if (inherits(cond, "warning")) {
[13:14:33.378]                         muffled <- grepl(pattern, "muffleWarning")
[13:14:33.378]                         if (muffled) 
[13:14:33.378]                           invokeRestart("muffleWarning")
[13:14:33.378]                       }
[13:14:33.378]                       else if (inherits(cond, "condition")) {
[13:14:33.378]                         if (!is.null(pattern)) {
[13:14:33.378]                           computeRestarts <- base::computeRestarts
[13:14:33.378]                           grepl <- base::grepl
[13:14:33.378]                           restarts <- computeRestarts(cond)
[13:14:33.378]                           for (restart in restarts) {
[13:14:33.378]                             name <- restart$name
[13:14:33.378]                             if (is.null(name)) 
[13:14:33.378]                               next
[13:14:33.378]                             if (!grepl(pattern, name)) 
[13:14:33.378]                               next
[13:14:33.378]                             invokeRestart(restart)
[13:14:33.378]                             muffled <- TRUE
[13:14:33.378]                             break
[13:14:33.378]                           }
[13:14:33.378]                         }
[13:14:33.378]                       }
[13:14:33.378]                       invisible(muffled)
[13:14:33.378]                     }
[13:14:33.378]                     muffleCondition(cond, pattern = "^muffle")
[13:14:33.378]                   }
[13:14:33.378]                 }
[13:14:33.378]             }
[13:14:33.378]         }))
[13:14:33.378]     }, error = function(ex) {
[13:14:33.378]         base::structure(base::list(value = NULL, visible = NULL, 
[13:14:33.378]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[13:14:33.378]                 ...future.rng), started = ...future.startTime, 
[13:14:33.378]             finished = Sys.time(), session_uuid = NA_character_, 
[13:14:33.378]             version = "1.8"), class = "FutureResult")
[13:14:33.378]     }, finally = {
[13:14:33.378]         if (!identical(...future.workdir, getwd())) 
[13:14:33.378]             setwd(...future.workdir)
[13:14:33.378]         {
[13:14:33.378]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[13:14:33.378]                 ...future.oldOptions$nwarnings <- NULL
[13:14:33.378]             }
[13:14:33.378]             base::options(...future.oldOptions)
[13:14:33.378]             if (.Platform$OS.type == "windows") {
[13:14:33.378]                 old_names <- names(...future.oldEnvVars)
[13:14:33.378]                 envs <- base::Sys.getenv()
[13:14:33.378]                 names <- names(envs)
[13:14:33.378]                 common <- intersect(names, old_names)
[13:14:33.378]                 added <- setdiff(names, old_names)
[13:14:33.378]                 removed <- setdiff(old_names, names)
[13:14:33.378]                 changed <- common[...future.oldEnvVars[common] != 
[13:14:33.378]                   envs[common]]
[13:14:33.378]                 NAMES <- toupper(changed)
[13:14:33.378]                 args <- list()
[13:14:33.378]                 for (kk in seq_along(NAMES)) {
[13:14:33.378]                   name <- changed[[kk]]
[13:14:33.378]                   NAME <- NAMES[[kk]]
[13:14:33.378]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:33.378]                     next
[13:14:33.378]                   args[[name]] <- ...future.oldEnvVars[[name]]
[13:14:33.378]                 }
[13:14:33.378]                 NAMES <- toupper(added)
[13:14:33.378]                 for (kk in seq_along(NAMES)) {
[13:14:33.378]                   name <- added[[kk]]
[13:14:33.378]                   NAME <- NAMES[[kk]]
[13:14:33.378]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:33.378]                     next
[13:14:33.378]                   args[[name]] <- ""
[13:14:33.378]                 }
[13:14:33.378]                 NAMES <- toupper(removed)
[13:14:33.378]                 for (kk in seq_along(NAMES)) {
[13:14:33.378]                   name <- removed[[kk]]
[13:14:33.378]                   NAME <- NAMES[[kk]]
[13:14:33.378]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:33.378]                     next
[13:14:33.378]                   args[[name]] <- ...future.oldEnvVars[[name]]
[13:14:33.378]                 }
[13:14:33.378]                 if (length(args) > 0) 
[13:14:33.378]                   base::do.call(base::Sys.setenv, args = args)
[13:14:33.378]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[13:14:33.378]             }
[13:14:33.378]             else {
[13:14:33.378]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[13:14:33.378]             }
[13:14:33.378]             {
[13:14:33.378]                 if (base::length(...future.futureOptionsAdded) > 
[13:14:33.378]                   0L) {
[13:14:33.378]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[13:14:33.378]                   base::names(opts) <- ...future.futureOptionsAdded
[13:14:33.378]                   base::options(opts)
[13:14:33.378]                 }
[13:14:33.378]                 {
[13:14:33.378]                   {
[13:14:33.378]                     base::options(mc.cores = ...future.mc.cores.old)
[13:14:33.378]                     NULL
[13:14:33.378]                   }
[13:14:33.378]                   options(future.plan = NULL)
[13:14:33.378]                   if (is.na(NA_character_)) 
[13:14:33.378]                     Sys.unsetenv("R_FUTURE_PLAN")
[13:14:33.378]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[13:14:33.378]                   future::plan(list(function (..., workers = availableCores(), 
[13:14:33.378]                     lazy = FALSE, rscript_libs = .libPaths(), 
[13:14:33.378]                     envir = parent.frame()) 
[13:14:33.378]                   {
[13:14:33.378]                     if (is.function(workers)) 
[13:14:33.378]                       workers <- workers()
[13:14:33.378]                     workers <- structure(as.integer(workers), 
[13:14:33.378]                       class = class(workers))
[13:14:33.378]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[13:14:33.378]                       workers >= 1)
[13:14:33.378]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[13:14:33.378]                       return(sequential(..., lazy = TRUE, envir = envir))
[13:14:33.378]                     }
[13:14:33.378]                     future <- MultisessionFuture(..., workers = workers, 
[13:14:33.378]                       lazy = lazy, rscript_libs = rscript_libs, 
[13:14:33.378]                       envir = envir)
[13:14:33.378]                     if (!future$lazy) 
[13:14:33.378]                       future <- run(future)
[13:14:33.378]                     invisible(future)
[13:14:33.378]                   }), .cleanup = FALSE, .init = FALSE)
[13:14:33.378]                 }
[13:14:33.378]             }
[13:14:33.378]         }
[13:14:33.378]     })
[13:14:33.378]     if (TRUE) {
[13:14:33.378]         base::sink(type = "output", split = FALSE)
[13:14:33.378]         if (FALSE) {
[13:14:33.378]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[13:14:33.378]         }
[13:14:33.378]         else {
[13:14:33.378]             ...future.result["stdout"] <- base::list(NULL)
[13:14:33.378]         }
[13:14:33.378]         base::close(...future.stdout)
[13:14:33.378]         ...future.stdout <- NULL
[13:14:33.378]     }
[13:14:33.378]     ...future.result$conditions <- ...future.conditions
[13:14:33.378]     ...future.result$finished <- base::Sys.time()
[13:14:33.378]     ...future.result
[13:14:33.378] }
[13:14:33.383] Exporting 5 global objects (6.22 KiB) to cluster node #2 ...
[13:14:33.384] Exporting '...future.FUN' (6.11 KiB) to cluster node #2 ...
[13:14:33.384] Exporting '...future.FUN' (6.11 KiB) to cluster node #2 ... DONE
[13:14:33.384] Exporting 'MoreArgs' (0 bytes) to cluster node #2 ...
[13:14:33.385] Exporting 'MoreArgs' (0 bytes) to cluster node #2 ... DONE
[13:14:33.385] Exporting '...future.elements_ii' (112 bytes) to cluster node #2 ...
[13:14:33.385] Exporting '...future.elements_ii' (112 bytes) to cluster node #2 ... DONE
[13:14:33.386] Exporting '...future.seeds_ii' (0 bytes) to cluster node #2 ...
[13:14:33.386] Exporting '...future.seeds_ii' (0 bytes) to cluster node #2 ... DONE
[13:14:33.386] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #2 ...
[13:14:33.387] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #2 ... DONE
[13:14:33.387] Exporting 5 global objects (6.22 KiB) to cluster node #2 ... DONE
[13:14:33.387] MultisessionFuture started
[13:14:33.388] - Launch lazy future ... done
[13:14:33.388] run() for 'MultisessionFuture' ... done
[13:14:33.388] Created future:
[13:14:33.404] receiveMessageFromWorker() for ClusterFuture ...
[13:14:33.404] - Validating connection of MultisessionFuture
[13:14:33.404] - received message: FutureResult
[13:14:33.405] - Received FutureResult
[13:14:33.405] - Erased future from FutureRegistry
[13:14:33.405] result() for ClusterFuture ...
[13:14:33.405] - result already collected: FutureResult
[13:14:33.405] result() for ClusterFuture ... done
[13:14:33.406] receiveMessageFromWorker() for ClusterFuture ... done
[13:14:33.388] MultisessionFuture:
[13:14:33.388] Label: 'future_mapply-2'
[13:14:33.388] Expression:
[13:14:33.388] {
[13:14:33.388]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[13:14:33.388]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[13:14:33.388]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[13:14:33.388]         on.exit(options(oopts), add = TRUE)
[13:14:33.388]     }
[13:14:33.388]     {
[13:14:33.388]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[13:14:33.388]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[13:14:33.388]         do.call(mapply, args = args)
[13:14:33.388]     }
[13:14:33.388] }
[13:14:33.388] Lazy evaluation: FALSE
[13:14:33.388] Asynchronous evaluation: TRUE
[13:14:33.388] Local evaluation: TRUE
[13:14:33.388] Environment: R_GlobalEnv
[13:14:33.388] Capture standard output: FALSE
[13:14:33.388] Capture condition classes: 'condition' (excluding 'nothing')
[13:14:33.388] Globals: 5 objects totaling 6.22 KiB (function '...future.FUN' of 6.11 KiB, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 112 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[13:14:33.388] Packages: <none>
[13:14:33.388] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[13:14:33.388] Resolved: TRUE
[13:14:33.388] Value: <not collected>
[13:14:33.388] Conditions captured: <none>
[13:14:33.388] Early signaling: FALSE
[13:14:33.388] Owner process: 68097d82-3b31-293d-2920-9b7259f27083
[13:14:33.388] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[13:14:33.406] Chunk #2 of 2 ... DONE
[13:14:33.406] Launching 2 futures (chunks) ... DONE
[13:14:33.406] Resolving 2 futures (chunks) ...
[13:14:33.406] resolve() on list ...
[13:14:33.407]  recursive: 0
[13:14:33.407]  length: 2
[13:14:33.407] 
[13:14:33.600] Future #2
[13:14:33.601] result() for ClusterFuture ...
[13:14:33.601] - result already collected: FutureResult
[13:14:33.601] result() for ClusterFuture ... done
[13:14:33.601] result() for ClusterFuture ...
[13:14:33.601] - result already collected: FutureResult
[13:14:33.601] result() for ClusterFuture ... done
[13:14:33.602] signalConditionsASAP(MultisessionFuture, pos=2) ...
[13:14:33.602] - nx: 2
[13:14:33.602] - relay: TRUE
[13:14:33.602] - stdout: TRUE
[13:14:33.602] - signal: TRUE
[13:14:33.602] - resignal: FALSE
[13:14:33.603] - force: TRUE
[13:14:33.603] - relayed: [n=2] FALSE, FALSE
[13:14:33.603] - queued futures: [n=2] FALSE, FALSE
[13:14:33.603]  - until=1
[13:14:33.603]  - relaying element #1
[13:14:33.603] - relayed: [n=2] FALSE, FALSE
[13:14:33.604] - queued futures: [n=2] FALSE, TRUE
[13:14:33.604] signalConditionsASAP(NULL, pos=2) ... done
[13:14:33.604]  length: 1 (resolved future 2)
[13:14:33.679] receiveMessageFromWorker() for ClusterFuture ...
[13:14:33.679] - Validating connection of MultisessionFuture
[13:14:33.680] - received message: FutureResult
[13:14:33.680] - Received FutureResult
[13:14:33.680] - Erased future from FutureRegistry
[13:14:33.680] result() for ClusterFuture ...
[13:14:33.680] - result already collected: FutureResult
[13:14:33.680] result() for ClusterFuture ... done
[13:14:33.681] receiveMessageFromWorker() for ClusterFuture ... done
[13:14:33.681] Future #1
[13:14:33.681] result() for ClusterFuture ...
[13:14:33.681] - result already collected: FutureResult
[13:14:33.681] result() for ClusterFuture ... done
[13:14:33.681] result() for ClusterFuture ...
[13:14:33.682] - result already collected: FutureResult
[13:14:33.682] result() for ClusterFuture ... done
[13:14:33.682] signalConditionsASAP(MultisessionFuture, pos=1) ...
[13:14:33.682] - nx: 2
[13:14:33.682] - relay: TRUE
[13:14:33.682] - stdout: TRUE
[13:14:33.682] - signal: TRUE
[13:14:33.683] - resignal: FALSE
[13:14:33.683] - force: TRUE
[13:14:33.683] - relayed: [n=2] FALSE, FALSE
[13:14:33.683] - queued futures: [n=2] FALSE, TRUE
[13:14:33.683]  - until=1
[13:14:33.683]  - relaying element #1
[13:14:33.684] result() for ClusterFuture ...
[13:14:33.684] - result already collected: FutureResult
[13:14:33.684] result() for ClusterFuture ... done
[13:14:33.684] result() for ClusterFuture ...
[13:14:33.684] - result already collected: FutureResult
[13:14:33.684] result() for ClusterFuture ... done
[13:14:33.685] result() for ClusterFuture ...
[13:14:33.685] - result already collected: FutureResult
[13:14:33.685] result() for ClusterFuture ... done
[13:14:33.685] result() for ClusterFuture ...
[13:14:33.685] - result already collected: FutureResult
[13:14:33.685] result() for ClusterFuture ... done
[13:14:33.685] - relayed: [n=2] TRUE, FALSE
[13:14:33.686] - queued futures: [n=2] TRUE, TRUE
[13:14:33.686] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[13:14:33.686]  length: 0 (resolved future 1)
[13:14:33.686] Relaying remaining futures
[13:14:33.686] signalConditionsASAP(NULL, pos=0) ...
[13:14:33.686] - nx: 2
[13:14:33.687] - relay: TRUE
[13:14:33.687] - stdout: TRUE
[13:14:33.687] - signal: TRUE
[13:14:33.687] - resignal: FALSE
[13:14:33.687] - force: TRUE
[13:14:33.687] - relayed: [n=2] TRUE, FALSE
[13:14:33.687] - queued futures: [n=2] TRUE, TRUE
 - flush all
[13:14:33.688]  - relaying element #2
[13:14:33.688] result() for ClusterFuture ...
[13:14:33.688] - result already collected: FutureResult
[13:14:33.688] result() for ClusterFuture ... done
[13:14:33.688] result() for ClusterFuture ...
[13:14:33.688] - result already collected: FutureResult
[13:14:33.689] result() for ClusterFuture ... done
[13:14:33.689] result() for ClusterFuture ...
[13:14:33.689] - result already collected: FutureResult
[13:14:33.689] result() for ClusterFuture ... done
[13:14:33.689] result() for ClusterFuture ...
[13:14:33.689] - result already collected: FutureResult
[13:14:33.690] result() for ClusterFuture ... done
[13:14:33.690] - relayed: [n=2] TRUE, TRUE
[13:14:33.690] - queued futures: [n=2] TRUE, TRUE
[13:14:33.690] signalConditionsASAP(MultisessionFuture, pos=0) ... done
[13:14:33.690] resolve() on list ... DONE
[13:14:33.690] result() for ClusterFuture ...
[13:14:33.691] - result already collected: FutureResult
[13:14:33.691] result() for ClusterFuture ... done
[13:14:33.691] result() for ClusterFuture ...
[13:14:33.691] - result already collected: FutureResult
[13:14:33.691] result() for ClusterFuture ... done
[13:14:33.691] result() for ClusterFuture ...
[13:14:33.692] - result already collected: FutureResult
[13:14:33.692] result() for ClusterFuture ... done
[13:14:33.692] result() for ClusterFuture ...
[13:14:33.692] - result already collected: FutureResult
[13:14:33.692] result() for ClusterFuture ... done
[13:14:33.692]  - Number of value chunks collected: 2
[13:14:33.692] Resolving 2 futures (chunks) ... DONE
[13:14:33.693] Reducing values from 2 chunks ...
[13:14:33.693]  - Number of values collected after concatenation: 2
[13:14:33.693]  - Number of values expected: 2
[13:14:33.693] Reducing values from 2 chunks ... DONE
[13:14:33.693] future_mapply() ... DONE
* future_mapply(x, ..., future.stdout = FALSE) ... DONE
* future_mapply(x, ..., future.stdout = TRUE) ...
[13:14:33.694] future_mapply() ...
[13:14:33.696] Number of chunks: 2
[13:14:33.696] getGlobalsAndPackagesXApply() ...
[13:14:33.697]  - future.globals: TRUE
[13:14:33.697] getGlobalsAndPackages() ...
[13:14:33.697] Searching for globals...
[13:14:33.699] - globals found: [6] 'FUN', '{', 'Sys.sleep', '/', 'print', 'list'
[13:14:33.699] Searching for globals ... DONE
[13:14:33.699] Resolving globals: FALSE
[13:14:33.700] The total size of the 1 globals is 6.11 KiB (6256 bytes)
[13:14:33.700] The total size of the 1 globals exported for future expression ('FUN()') is 6.11 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (6.11 KiB of class 'function')
[13:14:33.700] - globals: [1] 'FUN'
[13:14:33.701] 
[13:14:33.701] getGlobalsAndPackages() ... DONE
[13:14:33.701]  - globals found/used: [n=1] 'FUN'
[13:14:33.701]  - needed namespaces: [n=0] 
[13:14:33.701] Finding globals ... DONE
[13:14:33.702] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[13:14:33.702] List of 2
[13:14:33.702]  $ ...future.FUN:function (x, y)  
[13:14:33.702]  $ MoreArgs     : NULL
[13:14:33.702]  - attr(*, "where")=List of 2
[13:14:33.702]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[13:14:33.702]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[13:14:33.702]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[13:14:33.702]  - attr(*, "resolved")= logi FALSE
[13:14:33.702]  - attr(*, "total_size")= num NA
[13:14:33.705] Packages to be attached in all futures: [n=0] 
[13:14:33.705] getGlobalsAndPackagesXApply() ... DONE
[13:14:33.705] Number of futures (= number of chunks): 2
[13:14:33.706] Launching 2 futures (chunks) ...
[13:14:33.706] Chunk #1 of 2 ...
[13:14:33.706]  - Finding globals in '...' for chunk #1 ...
[13:14:33.706] getGlobalsAndPackages() ...
[13:14:33.706] Searching for globals...
[13:14:33.707] 
[13:14:33.707] Searching for globals ... DONE
[13:14:33.707] - globals: [0] <none>
[13:14:33.707] getGlobalsAndPackages() ... DONE
[13:14:33.707]    + additional globals found: [n=0] 
[13:14:33.707]    + additional namespaces needed: [n=0] 
[13:14:33.708]  - Finding globals in '...' for chunk #1 ... DONE
[13:14:33.708]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[13:14:33.708]  - seeds: <none>
[13:14:33.708]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:33.708] getGlobalsAndPackages() ...
[13:14:33.708] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:33.709] Resolving globals: FALSE
[13:14:33.709] The total size of the 5 globals is 6.22 KiB (6368 bytes)
[13:14:33.710] The total size of the 5 globals exported for future expression ('{; ...future.globals.maxSize.org <- getOption("future.globals.maxSize"); if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {; oopts <- options(future.globals.maxSize = ...future.globals.maxSize); on.exit(options(oopts), add = TRUE); }; ...; do.call(mapply, args = args); }; }') is 6.22 KiB.. This exceeds the maximum allowed size of 0.98 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (6.11 KiB of class 'function'), '...future.elements_ii' (112 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[13:14:33.710] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:33.710] 
[13:14:33.710] getGlobalsAndPackages() ... DONE
[13:14:33.711] run() for 'Future' ...
[13:14:33.711] - state: 'created'
[13:14:33.711] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[13:14:33.725] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[13:14:33.725] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[13:14:33.726]   - Field: 'node'
[13:14:33.726]   - Field: 'label'
[13:14:33.726]   - Field: 'local'
[13:14:33.726]   - Field: 'owner'
[13:14:33.726]   - Field: 'envir'
[13:14:33.727]   - Field: 'workers'
[13:14:33.727]   - Field: 'packages'
[13:14:33.727]   - Field: 'gc'
[13:14:33.727]   - Field: 'conditions'
[13:14:33.727]   - Field: 'persistent'
[13:14:33.727]   - Field: 'expr'
[13:14:33.728]   - Field: 'uuid'
[13:14:33.728]   - Field: 'seed'
[13:14:33.728]   - Field: 'version'
[13:14:33.728]   - Field: 'result'
[13:14:33.728]   - Field: 'asynchronous'
[13:14:33.728]   - Field: 'calls'
[13:14:33.729]   - Field: 'globals'
[13:14:33.729]   - Field: 'stdout'
[13:14:33.729]   - Field: 'earlySignal'
[13:14:33.729]   - Field: 'lazy'
[13:14:33.729]   - Field: 'state'
[13:14:33.730] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[13:14:33.730] - Launch lazy future ...
[13:14:33.730] Packages needed by the future expression (n = 0): <none>
[13:14:33.730] Packages needed by future strategies (n = 0): <none>
[13:14:33.731] {
[13:14:33.731]     {
[13:14:33.731]         {
[13:14:33.731]             ...future.startTime <- base::Sys.time()
[13:14:33.731]             {
[13:14:33.731]                 {
[13:14:33.731]                   {
[13:14:33.731]                     {
[13:14:33.731]                       base::local({
[13:14:33.731]                         has_future <- base::requireNamespace("future", 
[13:14:33.731]                           quietly = TRUE)
[13:14:33.731]                         if (has_future) {
[13:14:33.731]                           ns <- base::getNamespace("future")
[13:14:33.731]                           version <- ns[[".package"]][["version"]]
[13:14:33.731]                           if (is.null(version)) 
[13:14:33.731]                             version <- utils::packageVersion("future")
[13:14:33.731]                         }
[13:14:33.731]                         else {
[13:14:33.731]                           version <- NULL
[13:14:33.731]                         }
[13:14:33.731]                         if (!has_future || version < "1.8.0") {
[13:14:33.731]                           info <- base::c(r_version = base::gsub("R version ", 
[13:14:33.731]                             "", base::R.version$version.string), 
[13:14:33.731]                             platform = base::sprintf("%s (%s-bit)", 
[13:14:33.731]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[13:14:33.731]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[13:14:33.731]                               "release", "version")], collapse = " "), 
[13:14:33.731]                             hostname = base::Sys.info()[["nodename"]])
[13:14:33.731]                           info <- base::sprintf("%s: %s", base::names(info), 
[13:14:33.731]                             info)
[13:14:33.731]                           info <- base::paste(info, collapse = "; ")
[13:14:33.731]                           if (!has_future) {
[13:14:33.731]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[13:14:33.731]                               info)
[13:14:33.731]                           }
[13:14:33.731]                           else {
[13:14:33.731]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[13:14:33.731]                               info, version)
[13:14:33.731]                           }
[13:14:33.731]                           base::stop(msg)
[13:14:33.731]                         }
[13:14:33.731]                       })
[13:14:33.731]                     }
[13:14:33.731]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[13:14:33.731]                     base::options(mc.cores = 1L)
[13:14:33.731]                   }
[13:14:33.731]                   options(future.plan = NULL)
[13:14:33.731]                   Sys.unsetenv("R_FUTURE_PLAN")
[13:14:33.731]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[13:14:33.731]                 }
[13:14:33.731]                 ...future.workdir <- getwd()
[13:14:33.731]             }
[13:14:33.731]             ...future.oldOptions <- base::as.list(base::.Options)
[13:14:33.731]             ...future.oldEnvVars <- base::Sys.getenv()
[13:14:33.731]         }
[13:14:33.731]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[13:14:33.731]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[13:14:33.731]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[13:14:33.731]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[13:14:33.731]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[13:14:33.731]             future.stdout.windows.reencode = NULL, width = 80L)
[13:14:33.731]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[13:14:33.731]             base::names(...future.oldOptions))
[13:14:33.731]     }
[13:14:33.731]     if (FALSE) {
[13:14:33.731]     }
[13:14:33.731]     else {
[13:14:33.731]         if (TRUE) {
[13:14:33.731]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[13:14:33.731]                 open = "w")
[13:14:33.731]         }
[13:14:33.731]         else {
[13:14:33.731]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[13:14:33.731]                 windows = "NUL", "/dev/null"), open = "w")
[13:14:33.731]         }
[13:14:33.731]         base::sink(...future.stdout, type = "output", split = FALSE)
[13:14:33.731]         base::on.exit(if (!base::is.null(...future.stdout)) {
[13:14:33.731]             base::sink(type = "output", split = FALSE)
[13:14:33.731]             base::close(...future.stdout)
[13:14:33.731]         }, add = TRUE)
[13:14:33.731]     }
[13:14:33.731]     ...future.frame <- base::sys.nframe()
[13:14:33.731]     ...future.conditions <- base::list()
[13:14:33.731]     ...future.rng <- base::globalenv()$.Random.seed
[13:14:33.731]     if (FALSE) {
[13:14:33.731]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[13:14:33.731]             "...future.value", "...future.globalenv.names", ".Random.seed")
[13:14:33.731]     }
[13:14:33.731]     ...future.result <- base::tryCatch({
[13:14:33.731]         base::withCallingHandlers({
[13:14:33.731]             ...future.value <- base::withVisible(base::local({
[13:14:33.731]                 ...future.makeSendCondition <- local({
[13:14:33.731]                   sendCondition <- NULL
[13:14:33.731]                   function(frame = 1L) {
[13:14:33.731]                     if (is.function(sendCondition)) 
[13:14:33.731]                       return(sendCondition)
[13:14:33.731]                     ns <- getNamespace("parallel")
[13:14:33.731]                     if (exists("sendData", mode = "function", 
[13:14:33.731]                       envir = ns)) {
[13:14:33.731]                       parallel_sendData <- get("sendData", mode = "function", 
[13:14:33.731]                         envir = ns)
[13:14:33.731]                       envir <- sys.frame(frame)
[13:14:33.731]                       master <- NULL
[13:14:33.731]                       while (!identical(envir, .GlobalEnv) && 
[13:14:33.731]                         !identical(envir, emptyenv())) {
[13:14:33.731]                         if (exists("master", mode = "list", envir = envir, 
[13:14:33.731]                           inherits = FALSE)) {
[13:14:33.731]                           master <- get("master", mode = "list", 
[13:14:33.731]                             envir = envir, inherits = FALSE)
[13:14:33.731]                           if (inherits(master, c("SOCKnode", 
[13:14:33.731]                             "SOCK0node"))) {
[13:14:33.731]                             sendCondition <<- function(cond) {
[13:14:33.731]                               data <- list(type = "VALUE", value = cond, 
[13:14:33.731]                                 success = TRUE)
[13:14:33.731]                               parallel_sendData(master, data)
[13:14:33.731]                             }
[13:14:33.731]                             return(sendCondition)
[13:14:33.731]                           }
[13:14:33.731]                         }
[13:14:33.731]                         frame <- frame + 1L
[13:14:33.731]                         envir <- sys.frame(frame)
[13:14:33.731]                       }
[13:14:33.731]                     }
[13:14:33.731]                     sendCondition <<- function(cond) NULL
[13:14:33.731]                   }
[13:14:33.731]                 })
[13:14:33.731]                 withCallingHandlers({
[13:14:33.731]                   {
[13:14:33.731]                     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[13:14:33.731]                     if (!identical(...future.globals.maxSize.org, 
[13:14:33.731]                       ...future.globals.maxSize)) {
[13:14:33.731]                       oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[13:14:33.731]                       on.exit(options(oopts), add = TRUE)
[13:14:33.731]                     }
[13:14:33.731]                     {
[13:14:33.731]                       args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[13:14:33.731]                         MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[13:14:33.731]                         USE.NAMES = FALSE)
[13:14:33.731]                       do.call(mapply, args = args)
[13:14:33.731]                     }
[13:14:33.731]                   }
[13:14:33.731]                 }, immediateCondition = function(cond) {
[13:14:33.731]                   sendCondition <- ...future.makeSendCondition()
[13:14:33.731]                   sendCondition(cond)
[13:14:33.731]                   muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:33.731]                   {
[13:14:33.731]                     inherits <- base::inherits
[13:14:33.731]                     invokeRestart <- base::invokeRestart
[13:14:33.731]                     is.null <- base::is.null
[13:14:33.731]                     muffled <- FALSE
[13:14:33.731]                     if (inherits(cond, "message")) {
[13:14:33.731]                       muffled <- grepl(pattern, "muffleMessage")
[13:14:33.731]                       if (muffled) 
[13:14:33.731]                         invokeRestart("muffleMessage")
[13:14:33.731]                     }
[13:14:33.731]                     else if (inherits(cond, "warning")) {
[13:14:33.731]                       muffled <- grepl(pattern, "muffleWarning")
[13:14:33.731]                       if (muffled) 
[13:14:33.731]                         invokeRestart("muffleWarning")
[13:14:33.731]                     }
[13:14:33.731]                     else if (inherits(cond, "condition")) {
[13:14:33.731]                       if (!is.null(pattern)) {
[13:14:33.731]                         computeRestarts <- base::computeRestarts
[13:14:33.731]                         grepl <- base::grepl
[13:14:33.731]                         restarts <- computeRestarts(cond)
[13:14:33.731]                         for (restart in restarts) {
[13:14:33.731]                           name <- restart$name
[13:14:33.731]                           if (is.null(name)) 
[13:14:33.731]                             next
[13:14:33.731]                           if (!grepl(pattern, name)) 
[13:14:33.731]                             next
[13:14:33.731]                           invokeRestart(restart)
[13:14:33.731]                           muffled <- TRUE
[13:14:33.731]                           break
[13:14:33.731]                         }
[13:14:33.731]                       }
[13:14:33.731]                     }
[13:14:33.731]                     invisible(muffled)
[13:14:33.731]                   }
[13:14:33.731]                   muffleCondition(cond)
[13:14:33.731]                 })
[13:14:33.731]             }))
[13:14:33.731]             future::FutureResult(value = ...future.value$value, 
[13:14:33.731]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[13:14:33.731]                   ...future.rng), globalenv = if (FALSE) 
[13:14:33.731]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[13:14:33.731]                     ...future.globalenv.names))
[13:14:33.731]                 else NULL, started = ...future.startTime, version = "1.8")
[13:14:33.731]         }, condition = base::local({
[13:14:33.731]             c <- base::c
[13:14:33.731]             inherits <- base::inherits
[13:14:33.731]             invokeRestart <- base::invokeRestart
[13:14:33.731]             length <- base::length
[13:14:33.731]             list <- base::list
[13:14:33.731]             seq.int <- base::seq.int
[13:14:33.731]             signalCondition <- base::signalCondition
[13:14:33.731]             sys.calls <- base::sys.calls
[13:14:33.731]             `[[` <- base::`[[`
[13:14:33.731]             `+` <- base::`+`
[13:14:33.731]             `<<-` <- base::`<<-`
[13:14:33.731]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[13:14:33.731]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[13:14:33.731]                   3L)]
[13:14:33.731]             }
[13:14:33.731]             function(cond) {
[13:14:33.731]                 is_error <- inherits(cond, "error")
[13:14:33.731]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[13:14:33.731]                   NULL)
[13:14:33.731]                 if (is_error) {
[13:14:33.731]                   sessionInformation <- function() {
[13:14:33.731]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[13:14:33.731]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[13:14:33.731]                       search = base::search(), system = base::Sys.info())
[13:14:33.731]                   }
[13:14:33.731]                   ...future.conditions[[length(...future.conditions) + 
[13:14:33.731]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[13:14:33.731]                     cond$call), session = sessionInformation(), 
[13:14:33.731]                     timestamp = base::Sys.time(), signaled = 0L)
[13:14:33.731]                   signalCondition(cond)
[13:14:33.731]                 }
[13:14:33.731]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[13:14:33.731]                 "immediateCondition"))) {
[13:14:33.731]                   signal <- TRUE && inherits(cond, "immediateCondition")
[13:14:33.731]                   ...future.conditions[[length(...future.conditions) + 
[13:14:33.731]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[13:14:33.731]                   if (TRUE && !signal) {
[13:14:33.731]                     muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:33.731]                     {
[13:14:33.731]                       inherits <- base::inherits
[13:14:33.731]                       invokeRestart <- base::invokeRestart
[13:14:33.731]                       is.null <- base::is.null
[13:14:33.731]                       muffled <- FALSE
[13:14:33.731]                       if (inherits(cond, "message")) {
[13:14:33.731]                         muffled <- grepl(pattern, "muffleMessage")
[13:14:33.731]                         if (muffled) 
[13:14:33.731]                           invokeRestart("muffleMessage")
[13:14:33.731]                       }
[13:14:33.731]                       else if (inherits(cond, "warning")) {
[13:14:33.731]                         muffled <- grepl(pattern, "muffleWarning")
[13:14:33.731]                         if (muffled) 
[13:14:33.731]                           invokeRestart("muffleWarning")
[13:14:33.731]                       }
[13:14:33.731]                       else if (inherits(cond, "condition")) {
[13:14:33.731]                         if (!is.null(pattern)) {
[13:14:33.731]                           computeRestarts <- base::computeRestarts
[13:14:33.731]                           grepl <- base::grepl
[13:14:33.731]                           restarts <- computeRestarts(cond)
[13:14:33.731]                           for (restart in restarts) {
[13:14:33.731]                             name <- restart$name
[13:14:33.731]                             if (is.null(name)) 
[13:14:33.731]                               next
[13:14:33.731]                             if (!grepl(pattern, name)) 
[13:14:33.731]                               next
[13:14:33.731]                             invokeRestart(restart)
[13:14:33.731]                             muffled <- TRUE
[13:14:33.731]                             break
[13:14:33.731]                           }
[13:14:33.731]                         }
[13:14:33.731]                       }
[13:14:33.731]                       invisible(muffled)
[13:14:33.731]                     }
[13:14:33.731]                     muffleCondition(cond, pattern = "^muffle")
[13:14:33.731]                   }
[13:14:33.731]                 }
[13:14:33.731]                 else {
[13:14:33.731]                   if (TRUE) {
[13:14:33.731]                     muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:33.731]                     {
[13:14:33.731]                       inherits <- base::inherits
[13:14:33.731]                       invokeRestart <- base::invokeRestart
[13:14:33.731]                       is.null <- base::is.null
[13:14:33.731]                       muffled <- FALSE
[13:14:33.731]                       if (inherits(cond, "message")) {
[13:14:33.731]                         muffled <- grepl(pattern, "muffleMessage")
[13:14:33.731]                         if (muffled) 
[13:14:33.731]                           invokeRestart("muffleMessage")
[13:14:33.731]                       }
[13:14:33.731]                       else if (inherits(cond, "warning")) {
[13:14:33.731]                         muffled <- grepl(pattern, "muffleWarning")
[13:14:33.731]                         if (muffled) 
[13:14:33.731]                           invokeRestart("muffleWarning")
[13:14:33.731]                       }
[13:14:33.731]                       else if (inherits(cond, "condition")) {
[13:14:33.731]                         if (!is.null(pattern)) {
[13:14:33.731]                           computeRestarts <- base::computeRestarts
[13:14:33.731]                           grepl <- base::grepl
[13:14:33.731]                           restarts <- computeRestarts(cond)
[13:14:33.731]                           for (restart in restarts) {
[13:14:33.731]                             name <- restart$name
[13:14:33.731]                             if (is.null(name)) 
[13:14:33.731]                               next
[13:14:33.731]                             if (!grepl(pattern, name)) 
[13:14:33.731]                               next
[13:14:33.731]                             invokeRestart(restart)
[13:14:33.731]                             muffled <- TRUE
[13:14:33.731]                             break
[13:14:33.731]                           }
[13:14:33.731]                         }
[13:14:33.731]                       }
[13:14:33.731]                       invisible(muffled)
[13:14:33.731]                     }
[13:14:33.731]                     muffleCondition(cond, pattern = "^muffle")
[13:14:33.731]                   }
[13:14:33.731]                 }
[13:14:33.731]             }
[13:14:33.731]         }))
[13:14:33.731]     }, error = function(ex) {
[13:14:33.731]         base::structure(base::list(value = NULL, visible = NULL, 
[13:14:33.731]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[13:14:33.731]                 ...future.rng), started = ...future.startTime, 
[13:14:33.731]             finished = Sys.time(), session_uuid = NA_character_, 
[13:14:33.731]             version = "1.8"), class = "FutureResult")
[13:14:33.731]     }, finally = {
[13:14:33.731]         if (!identical(...future.workdir, getwd())) 
[13:14:33.731]             setwd(...future.workdir)
[13:14:33.731]         {
[13:14:33.731]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[13:14:33.731]                 ...future.oldOptions$nwarnings <- NULL
[13:14:33.731]             }
[13:14:33.731]             base::options(...future.oldOptions)
[13:14:33.731]             if (.Platform$OS.type == "windows") {
[13:14:33.731]                 old_names <- names(...future.oldEnvVars)
[13:14:33.731]                 envs <- base::Sys.getenv()
[13:14:33.731]                 names <- names(envs)
[13:14:33.731]                 common <- intersect(names, old_names)
[13:14:33.731]                 added <- setdiff(names, old_names)
[13:14:33.731]                 removed <- setdiff(old_names, names)
[13:14:33.731]                 changed <- common[...future.oldEnvVars[common] != 
[13:14:33.731]                   envs[common]]
[13:14:33.731]                 NAMES <- toupper(changed)
[13:14:33.731]                 args <- list()
[13:14:33.731]                 for (kk in seq_along(NAMES)) {
[13:14:33.731]                   name <- changed[[kk]]
[13:14:33.731]                   NAME <- NAMES[[kk]]
[13:14:33.731]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:33.731]                     next
[13:14:33.731]                   args[[name]] <- ...future.oldEnvVars[[name]]
[13:14:33.731]                 }
[13:14:33.731]                 NAMES <- toupper(added)
[13:14:33.731]                 for (kk in seq_along(NAMES)) {
[13:14:33.731]                   name <- added[[kk]]
[13:14:33.731]                   NAME <- NAMES[[kk]]
[13:14:33.731]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:33.731]                     next
[13:14:33.731]                   args[[name]] <- ""
[13:14:33.731]                 }
[13:14:33.731]                 NAMES <- toupper(removed)
[13:14:33.731]                 for (kk in seq_along(NAMES)) {
[13:14:33.731]                   name <- removed[[kk]]
[13:14:33.731]                   NAME <- NAMES[[kk]]
[13:14:33.731]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:33.731]                     next
[13:14:33.731]                   args[[name]] <- ...future.oldEnvVars[[name]]
[13:14:33.731]                 }
[13:14:33.731]                 if (length(args) > 0) 
[13:14:33.731]                   base::do.call(base::Sys.setenv, args = args)
[13:14:33.731]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[13:14:33.731]             }
[13:14:33.731]             else {
[13:14:33.731]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[13:14:33.731]             }
[13:14:33.731]             {
[13:14:33.731]                 if (base::length(...future.futureOptionsAdded) > 
[13:14:33.731]                   0L) {
[13:14:33.731]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[13:14:33.731]                   base::names(opts) <- ...future.futureOptionsAdded
[13:14:33.731]                   base::options(opts)
[13:14:33.731]                 }
[13:14:33.731]                 {
[13:14:33.731]                   {
[13:14:33.731]                     base::options(mc.cores = ...future.mc.cores.old)
[13:14:33.731]                     NULL
[13:14:33.731]                   }
[13:14:33.731]                   options(future.plan = NULL)
[13:14:33.731]                   if (is.na(NA_character_)) 
[13:14:33.731]                     Sys.unsetenv("R_FUTURE_PLAN")
[13:14:33.731]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[13:14:33.731]                   future::plan(list(function (..., workers = availableCores(), 
[13:14:33.731]                     lazy = FALSE, rscript_libs = .libPaths(), 
[13:14:33.731]                     envir = parent.frame()) 
[13:14:33.731]                   {
[13:14:33.731]                     if (is.function(workers)) 
[13:14:33.731]                       workers <- workers()
[13:14:33.731]                     workers <- structure(as.integer(workers), 
[13:14:33.731]                       class = class(workers))
[13:14:33.731]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[13:14:33.731]                       workers >= 1)
[13:14:33.731]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[13:14:33.731]                       return(sequential(..., lazy = TRUE, envir = envir))
[13:14:33.731]                     }
[13:14:33.731]                     future <- MultisessionFuture(..., workers = workers, 
[13:14:33.731]                       lazy = lazy, rscript_libs = rscript_libs, 
[13:14:33.731]                       envir = envir)
[13:14:33.731]                     if (!future$lazy) 
[13:14:33.731]                       future <- run(future)
[13:14:33.731]                     invisible(future)
[13:14:33.731]                   }), .cleanup = FALSE, .init = FALSE)
[13:14:33.731]                 }
[13:14:33.731]             }
[13:14:33.731]         }
[13:14:33.731]     })
[13:14:33.731]     if (TRUE) {
[13:14:33.731]         base::sink(type = "output", split = FALSE)
[13:14:33.731]         if (TRUE) {
[13:14:33.731]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[13:14:33.731]         }
[13:14:33.731]         else {
[13:14:33.731]             ...future.result["stdout"] <- base::list(NULL)
[13:14:33.731]         }
[13:14:33.731]         base::close(...future.stdout)
[13:14:33.731]         ...future.stdout <- NULL
[13:14:33.731]     }
[13:14:33.731]     ...future.result$conditions <- ...future.conditions
[13:14:33.731]     ...future.result$finished <- base::Sys.time()
[13:14:33.731]     ...future.result
[13:14:33.731] }
[13:14:33.736] Exporting 5 global objects (6.22 KiB) to cluster node #1 ...
[13:14:33.736] Exporting '...future.FUN' (6.11 KiB) to cluster node #1 ...
[13:14:33.737] Exporting '...future.FUN' (6.11 KiB) to cluster node #1 ... DONE
[13:14:33.737] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ...
[13:14:33.738] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ... DONE
[13:14:33.738] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[13:14:33.738] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[13:14:33.739] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[13:14:33.739] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[13:14:33.739] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[13:14:33.740] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[13:14:33.740] Exporting 5 global objects (6.22 KiB) to cluster node #1 ... DONE
[13:14:33.741] MultisessionFuture started
[13:14:33.741] - Launch lazy future ... done
[13:14:33.741] run() for 'MultisessionFuture' ... done
[13:14:33.741] Created future:
[13:14:33.741] MultisessionFuture:
[13:14:33.741] Label: 'future_mapply-1'
[13:14:33.741] Expression:
[13:14:33.741] {
[13:14:33.741]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[13:14:33.741]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[13:14:33.741]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[13:14:33.741]         on.exit(options(oopts), add = TRUE)
[13:14:33.741]     }
[13:14:33.741]     {
[13:14:33.741]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[13:14:33.741]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[13:14:33.741]         do.call(mapply, args = args)
[13:14:33.741]     }
[13:14:33.741] }
[13:14:33.741] Lazy evaluation: FALSE
[13:14:33.741] Asynchronous evaluation: TRUE
[13:14:33.741] Local evaluation: TRUE
[13:14:33.741] Environment: R_GlobalEnv
[13:14:33.741] Capture standard output: TRUE
[13:14:33.741] Capture condition classes: 'condition' (excluding 'nothing')
[13:14:33.741] Globals: 5 objects totaling 6.22 KiB (function '...future.FUN' of 6.11 KiB, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 112 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[13:14:33.741] Packages: <none>
[13:14:33.741] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[13:14:33.741] Resolved: FALSE
[13:14:33.741] Value: <not collected>
[13:14:33.741] Conditions captured: <none>
[13:14:33.741] Early signaling: FALSE
[13:14:33.741] Owner process: 68097d82-3b31-293d-2920-9b7259f27083
[13:14:33.741] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[13:14:33.951] Chunk #1 of 2 ... DONE
[13:14:33.952] Chunk #2 of 2 ...
[13:14:33.952]  - Finding globals in '...' for chunk #2 ...
[13:14:33.952] getGlobalsAndPackages() ...
[13:14:33.952] Searching for globals...
[13:14:33.953] 
[13:14:33.953] Searching for globals ... DONE
[13:14:33.953] - globals: [0] <none>
[13:14:33.953] getGlobalsAndPackages() ... DONE
[13:14:33.953]    + additional globals found: [n=0] 
[13:14:33.953]    + additional namespaces needed: [n=0] 
[13:14:33.954]  - Finding globals in '...' for chunk #2 ... DONE
[13:14:33.954]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[13:14:33.954]  - seeds: <none>
[13:14:33.954]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:33.954] getGlobalsAndPackages() ...
[13:14:33.955] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:33.955] Resolving globals: FALSE
[13:14:33.955] The total size of the 5 globals is 6.22 KiB (6368 bytes)
[13:14:33.956] The total size of the 5 globals exported for future expression ('{; ...future.globals.maxSize.org <- getOption("future.globals.maxSize"); if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {; oopts <- options(future.globals.maxSize = ...future.globals.maxSize); on.exit(options(oopts), add = TRUE); }; ...; do.call(mapply, args = args); }; }') is 6.22 KiB.. This exceeds the maximum allowed size of 0.98 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (6.11 KiB of class 'function'), '...future.elements_ii' (112 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[13:14:33.956] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:33.956] 
[13:14:33.957] getGlobalsAndPackages() ... DONE
[13:14:33.957] run() for 'Future' ...
[13:14:33.957] - state: 'created'
[13:14:33.957] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[13:14:33.971] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[13:14:33.972] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[13:14:33.972]   - Field: 'node'
[13:14:33.972]   - Field: 'label'
[13:14:33.972]   - Field: 'local'
[13:14:33.972]   - Field: 'owner'
[13:14:33.973]   - Field: 'envir'
[13:14:33.973]   - Field: 'workers'
[13:14:33.973]   - Field: 'packages'
[13:14:33.973]   - Field: 'gc'
[13:14:33.973]   - Field: 'conditions'
[13:14:33.973]   - Field: 'persistent'
[13:14:33.974]   - Field: 'expr'
[13:14:33.974]   - Field: 'uuid'
[13:14:33.974]   - Field: 'seed'
[13:14:33.974]   - Field: 'version'
[13:14:33.974]   - Field: 'result'
[13:14:33.974]   - Field: 'asynchronous'
[13:14:33.975]   - Field: 'calls'
[13:14:33.975]   - Field: 'globals'
[13:14:33.975]   - Field: 'stdout'
[13:14:33.975]   - Field: 'earlySignal'
[13:14:33.975]   - Field: 'lazy'
[13:14:33.976]   - Field: 'state'
[13:14:33.976] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[13:14:33.976] - Launch lazy future ...
[13:14:33.976] Packages needed by the future expression (n = 0): <none>
[13:14:33.976] Packages needed by future strategies (n = 0): <none>
[13:14:33.977] {
[13:14:33.977]     {
[13:14:33.977]         {
[13:14:33.977]             ...future.startTime <- base::Sys.time()
[13:14:33.977]             {
[13:14:33.977]                 {
[13:14:33.977]                   {
[13:14:33.977]                     {
[13:14:33.977]                       base::local({
[13:14:33.977]                         has_future <- base::requireNamespace("future", 
[13:14:33.977]                           quietly = TRUE)
[13:14:33.977]                         if (has_future) {
[13:14:33.977]                           ns <- base::getNamespace("future")
[13:14:33.977]                           version <- ns[[".package"]][["version"]]
[13:14:33.977]                           if (is.null(version)) 
[13:14:33.977]                             version <- utils::packageVersion("future")
[13:14:33.977]                         }
[13:14:33.977]                         else {
[13:14:33.977]                           version <- NULL
[13:14:33.977]                         }
[13:14:33.977]                         if (!has_future || version < "1.8.0") {
[13:14:33.977]                           info <- base::c(r_version = base::gsub("R version ", 
[13:14:33.977]                             "", base::R.version$version.string), 
[13:14:33.977]                             platform = base::sprintf("%s (%s-bit)", 
[13:14:33.977]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[13:14:33.977]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[13:14:33.977]                               "release", "version")], collapse = " "), 
[13:14:33.977]                             hostname = base::Sys.info()[["nodename"]])
[13:14:33.977]                           info <- base::sprintf("%s: %s", base::names(info), 
[13:14:33.977]                             info)
[13:14:33.977]                           info <- base::paste(info, collapse = "; ")
[13:14:33.977]                           if (!has_future) {
[13:14:33.977]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[13:14:33.977]                               info)
[13:14:33.977]                           }
[13:14:33.977]                           else {
[13:14:33.977]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[13:14:33.977]                               info, version)
[13:14:33.977]                           }
[13:14:33.977]                           base::stop(msg)
[13:14:33.977]                         }
[13:14:33.977]                       })
[13:14:33.977]                     }
[13:14:33.977]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[13:14:33.977]                     base::options(mc.cores = 1L)
[13:14:33.977]                   }
[13:14:33.977]                   options(future.plan = NULL)
[13:14:33.977]                   Sys.unsetenv("R_FUTURE_PLAN")
[13:14:33.977]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[13:14:33.977]                 }
[13:14:33.977]                 ...future.workdir <- getwd()
[13:14:33.977]             }
[13:14:33.977]             ...future.oldOptions <- base::as.list(base::.Options)
[13:14:33.977]             ...future.oldEnvVars <- base::Sys.getenv()
[13:14:33.977]         }
[13:14:33.977]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[13:14:33.977]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[13:14:33.977]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[13:14:33.977]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[13:14:33.977]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[13:14:33.977]             future.stdout.windows.reencode = NULL, width = 80L)
[13:14:33.977]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[13:14:33.977]             base::names(...future.oldOptions))
[13:14:33.977]     }
[13:14:33.977]     if (FALSE) {
[13:14:33.977]     }
[13:14:33.977]     else {
[13:14:33.977]         if (TRUE) {
[13:14:33.977]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[13:14:33.977]                 open = "w")
[13:14:33.977]         }
[13:14:33.977]         else {
[13:14:33.977]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[13:14:33.977]                 windows = "NUL", "/dev/null"), open = "w")
[13:14:33.977]         }
[13:14:33.977]         base::sink(...future.stdout, type = "output", split = FALSE)
[13:14:33.977]         base::on.exit(if (!base::is.null(...future.stdout)) {
[13:14:33.977]             base::sink(type = "output", split = FALSE)
[13:14:33.977]             base::close(...future.stdout)
[13:14:33.977]         }, add = TRUE)
[13:14:33.977]     }
[13:14:33.977]     ...future.frame <- base::sys.nframe()
[13:14:33.977]     ...future.conditions <- base::list()
[13:14:33.977]     ...future.rng <- base::globalenv()$.Random.seed
[13:14:33.977]     if (FALSE) {
[13:14:33.977]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[13:14:33.977]             "...future.value", "...future.globalenv.names", ".Random.seed")
[13:14:33.977]     }
[13:14:33.977]     ...future.result <- base::tryCatch({
[13:14:33.977]         base::withCallingHandlers({
[13:14:33.977]             ...future.value <- base::withVisible(base::local({
[13:14:33.977]                 ...future.makeSendCondition <- local({
[13:14:33.977]                   sendCondition <- NULL
[13:14:33.977]                   function(frame = 1L) {
[13:14:33.977]                     if (is.function(sendCondition)) 
[13:14:33.977]                       return(sendCondition)
[13:14:33.977]                     ns <- getNamespace("parallel")
[13:14:33.977]                     if (exists("sendData", mode = "function", 
[13:14:33.977]                       envir = ns)) {
[13:14:33.977]                       parallel_sendData <- get("sendData", mode = "function", 
[13:14:33.977]                         envir = ns)
[13:14:33.977]                       envir <- sys.frame(frame)
[13:14:33.977]                       master <- NULL
[13:14:33.977]                       while (!identical(envir, .GlobalEnv) && 
[13:14:33.977]                         !identical(envir, emptyenv())) {
[13:14:33.977]                         if (exists("master", mode = "list", envir = envir, 
[13:14:33.977]                           inherits = FALSE)) {
[13:14:33.977]                           master <- get("master", mode = "list", 
[13:14:33.977]                             envir = envir, inherits = FALSE)
[13:14:33.977]                           if (inherits(master, c("SOCKnode", 
[13:14:33.977]                             "SOCK0node"))) {
[13:14:33.977]                             sendCondition <<- function(cond) {
[13:14:33.977]                               data <- list(type = "VALUE", value = cond, 
[13:14:33.977]                                 success = TRUE)
[13:14:33.977]                               parallel_sendData(master, data)
[13:14:33.977]                             }
[13:14:33.977]                             return(sendCondition)
[13:14:33.977]                           }
[13:14:33.977]                         }
[13:14:33.977]                         frame <- frame + 1L
[13:14:33.977]                         envir <- sys.frame(frame)
[13:14:33.977]                       }
[13:14:33.977]                     }
[13:14:33.977]                     sendCondition <<- function(cond) NULL
[13:14:33.977]                   }
[13:14:33.977]                 })
[13:14:33.977]                 withCallingHandlers({
[13:14:33.977]                   {
[13:14:33.977]                     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[13:14:33.977]                     if (!identical(...future.globals.maxSize.org, 
[13:14:33.977]                       ...future.globals.maxSize)) {
[13:14:33.977]                       oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[13:14:33.977]                       on.exit(options(oopts), add = TRUE)
[13:14:33.977]                     }
[13:14:33.977]                     {
[13:14:33.977]                       args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[13:14:33.977]                         MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[13:14:33.977]                         USE.NAMES = FALSE)
[13:14:33.977]                       do.call(mapply, args = args)
[13:14:33.977]                     }
[13:14:33.977]                   }
[13:14:33.977]                 }, immediateCondition = function(cond) {
[13:14:33.977]                   sendCondition <- ...future.makeSendCondition()
[13:14:33.977]                   sendCondition(cond)
[13:14:33.977]                   muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:33.977]                   {
[13:14:33.977]                     inherits <- base::inherits
[13:14:33.977]                     invokeRestart <- base::invokeRestart
[13:14:33.977]                     is.null <- base::is.null
[13:14:33.977]                     muffled <- FALSE
[13:14:33.977]                     if (inherits(cond, "message")) {
[13:14:33.977]                       muffled <- grepl(pattern, "muffleMessage")
[13:14:33.977]                       if (muffled) 
[13:14:33.977]                         invokeRestart("muffleMessage")
[13:14:33.977]                     }
[13:14:33.977]                     else if (inherits(cond, "warning")) {
[13:14:33.977]                       muffled <- grepl(pattern, "muffleWarning")
[13:14:33.977]                       if (muffled) 
[13:14:33.977]                         invokeRestart("muffleWarning")
[13:14:33.977]                     }
[13:14:33.977]                     else if (inherits(cond, "condition")) {
[13:14:33.977]                       if (!is.null(pattern)) {
[13:14:33.977]                         computeRestarts <- base::computeRestarts
[13:14:33.977]                         grepl <- base::grepl
[13:14:33.977]                         restarts <- computeRestarts(cond)
[13:14:33.977]                         for (restart in restarts) {
[13:14:33.977]                           name <- restart$name
[13:14:33.977]                           if (is.null(name)) 
[13:14:33.977]                             next
[13:14:33.977]                           if (!grepl(pattern, name)) 
[13:14:33.977]                             next
[13:14:33.977]                           invokeRestart(restart)
[13:14:33.977]                           muffled <- TRUE
[13:14:33.977]                           break
[13:14:33.977]                         }
[13:14:33.977]                       }
[13:14:33.977]                     }
[13:14:33.977]                     invisible(muffled)
[13:14:33.977]                   }
[13:14:33.977]                   muffleCondition(cond)
[13:14:33.977]                 })
[13:14:33.977]             }))
[13:14:33.977]             future::FutureResult(value = ...future.value$value, 
[13:14:33.977]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[13:14:33.977]                   ...future.rng), globalenv = if (FALSE) 
[13:14:33.977]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[13:14:33.977]                     ...future.globalenv.names))
[13:14:33.977]                 else NULL, started = ...future.startTime, version = "1.8")
[13:14:33.977]         }, condition = base::local({
[13:14:33.977]             c <- base::c
[13:14:33.977]             inherits <- base::inherits
[13:14:33.977]             invokeRestart <- base::invokeRestart
[13:14:33.977]             length <- base::length
[13:14:33.977]             list <- base::list
[13:14:33.977]             seq.int <- base::seq.int
[13:14:33.977]             signalCondition <- base::signalCondition
[13:14:33.977]             sys.calls <- base::sys.calls
[13:14:33.977]             `[[` <- base::`[[`
[13:14:33.977]             `+` <- base::`+`
[13:14:33.977]             `<<-` <- base::`<<-`
[13:14:33.977]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[13:14:33.977]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[13:14:33.977]                   3L)]
[13:14:33.977]             }
[13:14:33.977]             function(cond) {
[13:14:33.977]                 is_error <- inherits(cond, "error")
[13:14:33.977]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[13:14:33.977]                   NULL)
[13:14:33.977]                 if (is_error) {
[13:14:33.977]                   sessionInformation <- function() {
[13:14:33.977]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[13:14:33.977]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[13:14:33.977]                       search = base::search(), system = base::Sys.info())
[13:14:33.977]                   }
[13:14:33.977]                   ...future.conditions[[length(...future.conditions) + 
[13:14:33.977]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[13:14:33.977]                     cond$call), session = sessionInformation(), 
[13:14:33.977]                     timestamp = base::Sys.time(), signaled = 0L)
[13:14:33.977]                   signalCondition(cond)
[13:14:33.977]                 }
[13:14:33.977]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[13:14:33.977]                 "immediateCondition"))) {
[13:14:33.977]                   signal <- TRUE && inherits(cond, "immediateCondition")
[13:14:33.977]                   ...future.conditions[[length(...future.conditions) + 
[13:14:33.977]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[13:14:33.977]                   if (TRUE && !signal) {
[13:14:33.977]                     muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:33.977]                     {
[13:14:33.977]                       inherits <- base::inherits
[13:14:33.977]                       invokeRestart <- base::invokeRestart
[13:14:33.977]                       is.null <- base::is.null
[13:14:33.977]                       muffled <- FALSE
[13:14:33.977]                       if (inherits(cond, "message")) {
[13:14:33.977]                         muffled <- grepl(pattern, "muffleMessage")
[13:14:33.977]                         if (muffled) 
[13:14:33.977]                           invokeRestart("muffleMessage")
[13:14:33.977]                       }
[13:14:33.977]                       else if (inherits(cond, "warning")) {
[13:14:33.977]                         muffled <- grepl(pattern, "muffleWarning")
[13:14:33.977]                         if (muffled) 
[13:14:33.977]                           invokeRestart("muffleWarning")
[13:14:33.977]                       }
[13:14:33.977]                       else if (inherits(cond, "condition")) {
[13:14:33.977]                         if (!is.null(pattern)) {
[13:14:33.977]                           computeRestarts <- base::computeRestarts
[13:14:33.977]                           grepl <- base::grepl
[13:14:33.977]                           restarts <- computeRestarts(cond)
[13:14:33.977]                           for (restart in restarts) {
[13:14:33.977]                             name <- restart$name
[13:14:33.977]                             if (is.null(name)) 
[13:14:33.977]                               next
[13:14:33.977]                             if (!grepl(pattern, name)) 
[13:14:33.977]                               next
[13:14:33.977]                             invokeRestart(restart)
[13:14:33.977]                             muffled <- TRUE
[13:14:33.977]                             break
[13:14:33.977]                           }
[13:14:33.977]                         }
[13:14:33.977]                       }
[13:14:33.977]                       invisible(muffled)
[13:14:33.977]                     }
[13:14:33.977]                     muffleCondition(cond, pattern = "^muffle")
[13:14:33.977]                   }
[13:14:33.977]                 }
[13:14:33.977]                 else {
[13:14:33.977]                   if (TRUE) {
[13:14:33.977]                     muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:33.977]                     {
[13:14:33.977]                       inherits <- base::inherits
[13:14:33.977]                       invokeRestart <- base::invokeRestart
[13:14:33.977]                       is.null <- base::is.null
[13:14:33.977]                       muffled <- FALSE
[13:14:33.977]                       if (inherits(cond, "message")) {
[13:14:33.977]                         muffled <- grepl(pattern, "muffleMessage")
[13:14:33.977]                         if (muffled) 
[13:14:33.977]                           invokeRestart("muffleMessage")
[13:14:33.977]                       }
[13:14:33.977]                       else if (inherits(cond, "warning")) {
[13:14:33.977]                         muffled <- grepl(pattern, "muffleWarning")
[13:14:33.977]                         if (muffled) 
[13:14:33.977]                           invokeRestart("muffleWarning")
[13:14:33.977]                       }
[13:14:33.977]                       else if (inherits(cond, "condition")) {
[13:14:33.977]                         if (!is.null(pattern)) {
[13:14:33.977]                           computeRestarts <- base::computeRestarts
[13:14:33.977]                           grepl <- base::grepl
[13:14:33.977]                           restarts <- computeRestarts(cond)
[13:14:33.977]                           for (restart in restarts) {
[13:14:33.977]                             name <- restart$name
[13:14:33.977]                             if (is.null(name)) 
[13:14:33.977]                               next
[13:14:33.977]                             if (!grepl(pattern, name)) 
[13:14:33.977]                               next
[13:14:33.977]                             invokeRestart(restart)
[13:14:33.977]                             muffled <- TRUE
[13:14:33.977]                             break
[13:14:33.977]                           }
[13:14:33.977]                         }
[13:14:33.977]                       }
[13:14:33.977]                       invisible(muffled)
[13:14:33.977]                     }
[13:14:33.977]                     muffleCondition(cond, pattern = "^muffle")
[13:14:33.977]                   }
[13:14:33.977]                 }
[13:14:33.977]             }
[13:14:33.977]         }))
[13:14:33.977]     }, error = function(ex) {
[13:14:33.977]         base::structure(base::list(value = NULL, visible = NULL, 
[13:14:33.977]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[13:14:33.977]                 ...future.rng), started = ...future.startTime, 
[13:14:33.977]             finished = Sys.time(), session_uuid = NA_character_, 
[13:14:33.977]             version = "1.8"), class = "FutureResult")
[13:14:33.977]     }, finally = {
[13:14:33.977]         if (!identical(...future.workdir, getwd())) 
[13:14:33.977]             setwd(...future.workdir)
[13:14:33.977]         {
[13:14:33.977]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[13:14:33.977]                 ...future.oldOptions$nwarnings <- NULL
[13:14:33.977]             }
[13:14:33.977]             base::options(...future.oldOptions)
[13:14:33.977]             if (.Platform$OS.type == "windows") {
[13:14:33.977]                 old_names <- names(...future.oldEnvVars)
[13:14:33.977]                 envs <- base::Sys.getenv()
[13:14:33.977]                 names <- names(envs)
[13:14:33.977]                 common <- intersect(names, old_names)
[13:14:33.977]                 added <- setdiff(names, old_names)
[13:14:33.977]                 removed <- setdiff(old_names, names)
[13:14:33.977]                 changed <- common[...future.oldEnvVars[common] != 
[13:14:33.977]                   envs[common]]
[13:14:33.977]                 NAMES <- toupper(changed)
[13:14:33.977]                 args <- list()
[13:14:33.977]                 for (kk in seq_along(NAMES)) {
[13:14:33.977]                   name <- changed[[kk]]
[13:14:33.977]                   NAME <- NAMES[[kk]]
[13:14:33.977]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:33.977]                     next
[13:14:33.977]                   args[[name]] <- ...future.oldEnvVars[[name]]
[13:14:33.977]                 }
[13:14:33.977]                 NAMES <- toupper(added)
[13:14:33.977]                 for (kk in seq_along(NAMES)) {
[13:14:33.977]                   name <- added[[kk]]
[13:14:33.977]                   NAME <- NAMES[[kk]]
[13:14:33.977]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:33.977]                     next
[13:14:33.977]                   args[[name]] <- ""
[13:14:33.977]                 }
[13:14:33.977]                 NAMES <- toupper(removed)
[13:14:33.977]                 for (kk in seq_along(NAMES)) {
[13:14:33.977]                   name <- removed[[kk]]
[13:14:33.977]                   NAME <- NAMES[[kk]]
[13:14:33.977]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:33.977]                     next
[13:14:33.977]                   args[[name]] <- ...future.oldEnvVars[[name]]
[13:14:33.977]                 }
[13:14:33.977]                 if (length(args) > 0) 
[13:14:33.977]                   base::do.call(base::Sys.setenv, args = args)
[13:14:33.977]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[13:14:33.977]             }
[13:14:33.977]             else {
[13:14:33.977]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[13:14:33.977]             }
[13:14:33.977]             {
[13:14:33.977]                 if (base::length(...future.futureOptionsAdded) > 
[13:14:33.977]                   0L) {
[13:14:33.977]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[13:14:33.977]                   base::names(opts) <- ...future.futureOptionsAdded
[13:14:33.977]                   base::options(opts)
[13:14:33.977]                 }
[13:14:33.977]                 {
[13:14:33.977]                   {
[13:14:33.977]                     base::options(mc.cores = ...future.mc.cores.old)
[13:14:33.977]                     NULL
[13:14:33.977]                   }
[13:14:33.977]                   options(future.plan = NULL)
[13:14:33.977]                   if (is.na(NA_character_)) 
[13:14:33.977]                     Sys.unsetenv("R_FUTURE_PLAN")
[13:14:33.977]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[13:14:33.977]                   future::plan(list(function (..., workers = availableCores(), 
[13:14:33.977]                     lazy = FALSE, rscript_libs = .libPaths(), 
[13:14:33.977]                     envir = parent.frame()) 
[13:14:33.977]                   {
[13:14:33.977]                     if (is.function(workers)) 
[13:14:33.977]                       workers <- workers()
[13:14:33.977]                     workers <- structure(as.integer(workers), 
[13:14:33.977]                       class = class(workers))
[13:14:33.977]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[13:14:33.977]                       workers >= 1)
[13:14:33.977]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[13:14:33.977]                       return(sequential(..., lazy = TRUE, envir = envir))
[13:14:33.977]                     }
[13:14:33.977]                     future <- MultisessionFuture(..., workers = workers, 
[13:14:33.977]                       lazy = lazy, rscript_libs = rscript_libs, 
[13:14:33.977]                       envir = envir)
[13:14:33.977]                     if (!future$lazy) 
[13:14:33.977]                       future <- run(future)
[13:14:33.977]                     invisible(future)
[13:14:33.977]                   }), .cleanup = FALSE, .init = FALSE)
[13:14:33.977]                 }
[13:14:33.977]             }
[13:14:33.977]         }
[13:14:33.977]     })
[13:14:33.977]     if (TRUE) {
[13:14:33.977]         base::sink(type = "output", split = FALSE)
[13:14:33.977]         if (TRUE) {
[13:14:33.977]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[13:14:33.977]         }
[13:14:33.977]         else {
[13:14:33.977]             ...future.result["stdout"] <- base::list(NULL)
[13:14:33.977]         }
[13:14:33.977]         base::close(...future.stdout)
[13:14:33.977]         ...future.stdout <- NULL
[13:14:33.977]     }
[13:14:33.977]     ...future.result$conditions <- ...future.conditions
[13:14:33.977]     ...future.result$finished <- base::Sys.time()
[13:14:33.977]     ...future.result
[13:14:33.977] }
[13:14:33.983] Exporting 5 global objects (6.22 KiB) to cluster node #2 ...
[13:14:33.983] Exporting '...future.FUN' (6.11 KiB) to cluster node #2 ...
[13:14:33.983] Exporting '...future.FUN' (6.11 KiB) to cluster node #2 ... DONE
[13:14:33.984] Exporting 'MoreArgs' (0 bytes) to cluster node #2 ...
[13:14:33.984] Exporting 'MoreArgs' (0 bytes) to cluster node #2 ... DONE
[13:14:33.984] Exporting '...future.elements_ii' (112 bytes) to cluster node #2 ...
[13:14:33.985] Exporting '...future.elements_ii' (112 bytes) to cluster node #2 ... DONE
[13:14:33.985] Exporting '...future.seeds_ii' (0 bytes) to cluster node #2 ...
[13:14:33.985] Exporting '...future.seeds_ii' (0 bytes) to cluster node #2 ... DONE
[13:14:33.986] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #2 ...
[13:14:33.986] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #2 ... DONE
[13:14:33.986] Exporting 5 global objects (6.22 KiB) to cluster node #2 ... DONE
[13:14:33.987] MultisessionFuture started
[13:14:33.987] - Launch lazy future ... done
[13:14:33.987] run() for 'MultisessionFuture' ... done
[13:14:33.987] Created future:
[13:14:34.005] receiveMessageFromWorker() for ClusterFuture ...
[13:14:34.005] - Validating connection of MultisessionFuture
[13:14:34.005] - received message: FutureResult
[13:14:34.005] - Received FutureResult
[13:14:34.006] - Erased future from FutureRegistry
[13:14:34.006] result() for ClusterFuture ...
[13:14:34.006] - result already collected: FutureResult
[13:14:34.006] result() for ClusterFuture ... done
[13:14:34.006] receiveMessageFromWorker() for ClusterFuture ... done
[13:14:33.988] MultisessionFuture:
[13:14:33.988] Label: 'future_mapply-2'
[13:14:33.988] Expression:
[13:14:33.988] {
[13:14:33.988]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[13:14:33.988]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[13:14:33.988]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[13:14:33.988]         on.exit(options(oopts), add = TRUE)
[13:14:33.988]     }
[13:14:33.988]     {
[13:14:33.988]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[13:14:33.988]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[13:14:33.988]         do.call(mapply, args = args)
[13:14:33.988]     }
[13:14:33.988] }
[13:14:33.988] Lazy evaluation: FALSE
[13:14:33.988] Asynchronous evaluation: TRUE
[13:14:33.988] Local evaluation: TRUE
[13:14:33.988] Environment: R_GlobalEnv
[13:14:33.988] Capture standard output: TRUE
[13:14:33.988] Capture condition classes: 'condition' (excluding 'nothing')
[13:14:33.988] Globals: 5 objects totaling 6.22 KiB (function '...future.FUN' of 6.11 KiB, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 112 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[13:14:33.988] Packages: <none>
[13:14:33.988] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[13:14:33.988] Resolved: TRUE
[13:14:33.988] Value: <not collected>
[13:14:33.988] Conditions captured: <none>
[13:14:33.988] Early signaling: FALSE
[13:14:33.988] Owner process: 68097d82-3b31-293d-2920-9b7259f27083
[13:14:33.988] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[13:14:34.007] Chunk #2 of 2 ... DONE
[13:14:34.007] Launching 2 futures (chunks) ... DONE
[13:14:34.007] Resolving 2 futures (chunks) ...
[13:14:34.007] resolve() on list ...
[13:14:34.007]  recursive: 0
[13:14:34.008]  length: 2
[13:14:34.008] 
[13:14:34.201] Future #2
[13:14:34.201] result() for ClusterFuture ...
[13:14:34.202] - result already collected: FutureResult
[13:14:34.202] result() for ClusterFuture ... done
[13:14:34.202] result() for ClusterFuture ...
[13:14:34.202] - result already collected: FutureResult
[13:14:34.202] result() for ClusterFuture ... done
[13:14:34.203] signalConditionsASAP(MultisessionFuture, pos=2) ...
[13:14:34.203] - nx: 2
[13:14:34.203] - relay: TRUE
[13:14:34.203] - stdout: TRUE
[13:14:34.203] - signal: TRUE
[13:14:34.203] - resignal: FALSE
[13:14:34.203] - force: TRUE
[13:14:34.204] - relayed: [n=2] FALSE, FALSE
[13:14:34.204] - queued futures: [n=2] FALSE, FALSE
[13:14:34.204]  - until=1
[13:14:34.204]  - relaying element #1
[13:14:34.204] - relayed: [n=2] FALSE, FALSE
[13:14:34.204] - queued futures: [n=2] FALSE, TRUE
[13:14:34.205] signalConditionsASAP(NULL, pos=2) ... done
[13:14:34.205]  length: 1 (resolved future 2)
[13:14:34.266] receiveMessageFromWorker() for ClusterFuture ...
[13:14:34.266] - Validating connection of MultisessionFuture
[13:14:34.266] - received message: FutureResult
[13:14:34.267] - Received FutureResult
[13:14:34.267] - Erased future from FutureRegistry
[13:14:34.267] result() for ClusterFuture ...
[13:14:34.267] - result already collected: FutureResult
[13:14:34.267] result() for ClusterFuture ... done
[13:14:34.267] receiveMessageFromWorker() for ClusterFuture ... done
[13:14:34.268] Future #1
[13:14:34.268] result() for ClusterFuture ...
[13:14:34.268] - result already collected: FutureResult
[13:14:34.268] result() for ClusterFuture ... done
[13:14:34.268] result() for ClusterFuture ...
[13:14:34.268] - result already collected: FutureResult
[13:14:34.268] result() for ClusterFuture ... done
[13:14:34.269] signalConditionsASAP(MultisessionFuture, pos=1) ...
[13:14:34.269] - nx: 2
[13:14:34.269] - relay: TRUE
[13:14:34.269] - stdout: TRUE
[13:14:34.269] - signal: TRUE
[13:14:34.269] - resignal: FALSE
[13:14:34.270] - force: TRUE
[13:14:34.270] - relayed: [n=2] FALSE, FALSE
[13:14:34.270] - queued futures: [n=2] FALSE, TRUE
[13:14:34.270]  - until=1
[13:14:34.270]  - relaying element #1
[13:14:34.270] result() for ClusterFuture ...
[13:14:34.271] - result already collected: FutureResult
[13:14:34.271] result() for ClusterFuture ... done
[13:14:34.271] result() for ClusterFuture ...
[13:14:34.271] - result already collected: FutureResult
[13:14:34.271] result() for ClusterFuture ... done
[13:14:34.271] result() for ClusterFuture ...
[13:14:34.272] - result already collected: FutureResult
[13:14:34.272] result() for ClusterFuture ... done
[13:14:34.272] result() for ClusterFuture ...
[13:14:34.272] - result already collected: FutureResult
[13:14:34.272] result() for ClusterFuture ... done
[13:14:34.272] - relayed: [n=2] TRUE, FALSE
[13:14:34.272] - queued futures: [n=2] TRUE, TRUE
[13:14:34.273] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[13:14:34.273]  length: 0 (resolved future 1)
[13:14:34.273] Relaying remaining futures
[13:14:34.273] signalConditionsASAP(NULL, pos=0) ...
[13:14:34.273] - nx: 2
[13:14:34.273] - relay: TRUE
[13:14:34.274] - stdout: TRUE
[13:14:34.274] - signal: TRUE
[13:14:34.274] - resignal: FALSE
[13:14:34.274] - force: TRUE
[13:14:34.274] - relayed: [n=2] TRUE, FALSE
[13:14:34.274] - queued futures: [n=2] TRUE, TRUE
 - flush all
[13:14:34.275]  - relaying element #2
[13:14:34.275] result() for ClusterFuture ...
[13:14:34.275] - result already collected: FutureResult
[13:14:34.275] result() for ClusterFuture ... done
[13:14:34.275] result() for ClusterFuture ...
[13:14:34.275] - result already collected: FutureResult
[13:14:34.276] result() for ClusterFuture ... done
[13:14:34.276] result() for ClusterFuture ...
[13:14:34.276] - result already collected: FutureResult
[13:14:34.276] result() for ClusterFuture ... done
[13:14:34.276] result() for ClusterFuture ...
[13:14:34.276] - result already collected: FutureResult
[13:14:34.277] result() for ClusterFuture ... done
[13:14:34.279] - relayed: [n=2] TRUE, TRUE
[13:14:34.279] - queued futures: [n=2] TRUE, TRUE
[13:14:34.279] signalConditionsASAP(MultisessionFuture, pos=0) ... done
[13:14:34.279] resolve() on list ... DONE
[13:14:34.279] result() for ClusterFuture ...
[13:14:34.279] - result already collected: FutureResult
[13:14:34.280] result() for ClusterFuture ... done
[13:14:34.280] result() for ClusterFuture ...
[13:14:34.280] - result already collected: FutureResult
[13:14:34.280] result() for ClusterFuture ... done
[13:14:34.280] result() for ClusterFuture ...
[13:14:34.280] - result already collected: FutureResult
[13:14:34.280] result() for ClusterFuture ... done
[13:14:34.281] result() for ClusterFuture ...
[13:14:34.281] - result already collected: FutureResult
[13:14:34.281] result() for ClusterFuture ... done
[13:14:34.281]  - Number of value chunks collected: 2
[13:14:34.281] Resolving 2 futures (chunks) ... DONE
[13:14:34.282] Reducing values from 2 chunks ...
[13:14:34.282]  - Number of values collected after concatenation: 2
[13:14:34.282]  - Number of values expected: 2
[13:14:34.282] Reducing values from 2 chunks ... DONE
[13:14:34.282] future_mapply() ... DONE
* future_mapply(x, ..., future.stdout = TRUE) ... DONE
* future_mapply(x, ..., future.stdout = NA) ...
[13:14:34.283] future_mapply() ...
[13:14:34.285] Number of chunks: 2
[13:14:34.285] getGlobalsAndPackagesXApply() ...
[13:14:34.286]  - future.globals: TRUE
[13:14:34.286] getGlobalsAndPackages() ...
[13:14:34.286] Searching for globals...
[13:14:34.288] - globals found: [6] 'FUN', '{', 'Sys.sleep', '/', 'print', 'list'
[13:14:34.288] Searching for globals ... DONE
[13:14:34.288] Resolving globals: FALSE
[13:14:34.289] The total size of the 1 globals is 6.11 KiB (6256 bytes)
[13:14:34.289] The total size of the 1 globals exported for future expression ('FUN()') is 6.11 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (6.11 KiB of class 'function')
[13:14:34.289] - globals: [1] 'FUN'
[13:14:34.289] 
[13:14:34.290] getGlobalsAndPackages() ... DONE
[13:14:34.290]  - globals found/used: [n=1] 'FUN'
[13:14:34.290]  - needed namespaces: [n=0] 
[13:14:34.290] Finding globals ... DONE
[13:14:34.290] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[13:14:34.291] List of 2
[13:14:34.291]  $ ...future.FUN:function (x, y)  
[13:14:34.291]  $ MoreArgs     : NULL
[13:14:34.291]  - attr(*, "where")=List of 2
[13:14:34.291]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[13:14:34.291]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[13:14:34.291]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[13:14:34.291]  - attr(*, "resolved")= logi FALSE
[13:14:34.291]  - attr(*, "total_size")= num NA
[13:14:34.294] Packages to be attached in all futures: [n=0] 
[13:14:34.294] getGlobalsAndPackagesXApply() ... DONE
[13:14:34.294] Number of futures (= number of chunks): 2
[13:14:34.294] Launching 2 futures (chunks) ...
[13:14:34.294] Chunk #1 of 2 ...
[13:14:34.295]  - Finding globals in '...' for chunk #1 ...
[13:14:34.295] getGlobalsAndPackages() ...
[13:14:34.295] Searching for globals...
[13:14:34.295] 
[13:14:34.295] Searching for globals ... DONE
[13:14:34.296] - globals: [0] <none>
[13:14:34.296] getGlobalsAndPackages() ... DONE
[13:14:34.296]    + additional globals found: [n=0] 
[13:14:34.296]    + additional namespaces needed: [n=0] 
[13:14:34.296]  - Finding globals in '...' for chunk #1 ... DONE
[13:14:34.296]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[13:14:34.297]  - seeds: <none>
[13:14:34.297]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:34.297] getGlobalsAndPackages() ...
[13:14:34.297] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:34.297] Resolving globals: FALSE
[13:14:34.298] The total size of the 5 globals is 6.22 KiB (6368 bytes)
[13:14:34.298] The total size of the 5 globals exported for future expression ('{; ...future.globals.maxSize.org <- getOption("future.globals.maxSize"); if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {; oopts <- options(future.globals.maxSize = ...future.globals.maxSize); on.exit(options(oopts), add = TRUE); }; ...; do.call(mapply, args = args); }; }') is 6.22 KiB.. This exceeds the maximum allowed size of 0.98 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (6.11 KiB of class 'function'), '...future.elements_ii' (112 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[13:14:34.299] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:34.299] 
[13:14:34.299] getGlobalsAndPackages() ... DONE
[13:14:34.299] run() for 'Future' ...
[13:14:34.300] - state: 'created'
[13:14:34.300] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[13:14:34.315] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[13:14:34.315] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[13:14:34.315]   - Field: 'node'
[13:14:34.315]   - Field: 'label'
[13:14:34.315]   - Field: 'local'
[13:14:34.316]   - Field: 'owner'
[13:14:34.316]   - Field: 'envir'
[13:14:34.316]   - Field: 'workers'
[13:14:34.316]   - Field: 'packages'
[13:14:34.316]   - Field: 'gc'
[13:14:34.316]   - Field: 'conditions'
[13:14:34.317]   - Field: 'persistent'
[13:14:34.317]   - Field: 'expr'
[13:14:34.317]   - Field: 'uuid'
[13:14:34.317]   - Field: 'seed'
[13:14:34.317]   - Field: 'version'
[13:14:34.318]   - Field: 'result'
[13:14:34.318]   - Field: 'asynchronous'
[13:14:34.318]   - Field: 'calls'
[13:14:34.318]   - Field: 'globals'
[13:14:34.318]   - Field: 'stdout'
[13:14:34.318]   - Field: 'earlySignal'
[13:14:34.319]   - Field: 'lazy'
[13:14:34.319]   - Field: 'state'
[13:14:34.319] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[13:14:34.319] - Launch lazy future ...
[13:14:34.319] Packages needed by the future expression (n = 0): <none>
[13:14:34.320] Packages needed by future strategies (n = 0): <none>
[13:14:34.320] {
[13:14:34.320]     {
[13:14:34.320]         {
[13:14:34.320]             ...future.startTime <- base::Sys.time()
[13:14:34.320]             {
[13:14:34.320]                 {
[13:14:34.320]                   {
[13:14:34.320]                     {
[13:14:34.320]                       base::local({
[13:14:34.320]                         has_future <- base::requireNamespace("future", 
[13:14:34.320]                           quietly = TRUE)
[13:14:34.320]                         if (has_future) {
[13:14:34.320]                           ns <- base::getNamespace("future")
[13:14:34.320]                           version <- ns[[".package"]][["version"]]
[13:14:34.320]                           if (is.null(version)) 
[13:14:34.320]                             version <- utils::packageVersion("future")
[13:14:34.320]                         }
[13:14:34.320]                         else {
[13:14:34.320]                           version <- NULL
[13:14:34.320]                         }
[13:14:34.320]                         if (!has_future || version < "1.8.0") {
[13:14:34.320]                           info <- base::c(r_version = base::gsub("R version ", 
[13:14:34.320]                             "", base::R.version$version.string), 
[13:14:34.320]                             platform = base::sprintf("%s (%s-bit)", 
[13:14:34.320]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[13:14:34.320]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[13:14:34.320]                               "release", "version")], collapse = " "), 
[13:14:34.320]                             hostname = base::Sys.info()[["nodename"]])
[13:14:34.320]                           info <- base::sprintf("%s: %s", base::names(info), 
[13:14:34.320]                             info)
[13:14:34.320]                           info <- base::paste(info, collapse = "; ")
[13:14:34.320]                           if (!has_future) {
[13:14:34.320]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[13:14:34.320]                               info)
[13:14:34.320]                           }
[13:14:34.320]                           else {
[13:14:34.320]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[13:14:34.320]                               info, version)
[13:14:34.320]                           }
[13:14:34.320]                           base::stop(msg)
[13:14:34.320]                         }
[13:14:34.320]                       })
[13:14:34.320]                     }
[13:14:34.320]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[13:14:34.320]                     base::options(mc.cores = 1L)
[13:14:34.320]                   }
[13:14:34.320]                   options(future.plan = NULL)
[13:14:34.320]                   Sys.unsetenv("R_FUTURE_PLAN")
[13:14:34.320]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[13:14:34.320]                 }
[13:14:34.320]                 ...future.workdir <- getwd()
[13:14:34.320]             }
[13:14:34.320]             ...future.oldOptions <- base::as.list(base::.Options)
[13:14:34.320]             ...future.oldEnvVars <- base::Sys.getenv()
[13:14:34.320]         }
[13:14:34.320]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[13:14:34.320]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[13:14:34.320]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[13:14:34.320]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[13:14:34.320]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[13:14:34.320]             future.stdout.windows.reencode = NULL, width = 80L)
[13:14:34.320]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[13:14:34.320]             base::names(...future.oldOptions))
[13:14:34.320]     }
[13:14:34.320]     if (TRUE) {
[13:14:34.320]     }
[13:14:34.320]     else {
[13:14:34.320]         if (NA) {
[13:14:34.320]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[13:14:34.320]                 open = "w")
[13:14:34.320]         }
[13:14:34.320]         else {
[13:14:34.320]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[13:14:34.320]                 windows = "NUL", "/dev/null"), open = "w")
[13:14:34.320]         }
[13:14:34.320]         base::sink(...future.stdout, type = "output", split = FALSE)
[13:14:34.320]         base::on.exit(if (!base::is.null(...future.stdout)) {
[13:14:34.320]             base::sink(type = "output", split = FALSE)
[13:14:34.320]             base::close(...future.stdout)
[13:14:34.320]         }, add = TRUE)
[13:14:34.320]     }
[13:14:34.320]     ...future.frame <- base::sys.nframe()
[13:14:34.320]     ...future.conditions <- base::list()
[13:14:34.320]     ...future.rng <- base::globalenv()$.Random.seed
[13:14:34.320]     if (FALSE) {
[13:14:34.320]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[13:14:34.320]             "...future.value", "...future.globalenv.names", ".Random.seed")
[13:14:34.320]     }
[13:14:34.320]     ...future.result <- base::tryCatch({
[13:14:34.320]         base::withCallingHandlers({
[13:14:34.320]             ...future.value <- base::withVisible(base::local({
[13:14:34.320]                 ...future.makeSendCondition <- local({
[13:14:34.320]                   sendCondition <- NULL
[13:14:34.320]                   function(frame = 1L) {
[13:14:34.320]                     if (is.function(sendCondition)) 
[13:14:34.320]                       return(sendCondition)
[13:14:34.320]                     ns <- getNamespace("parallel")
[13:14:34.320]                     if (exists("sendData", mode = "function", 
[13:14:34.320]                       envir = ns)) {
[13:14:34.320]                       parallel_sendData <- get("sendData", mode = "function", 
[13:14:34.320]                         envir = ns)
[13:14:34.320]                       envir <- sys.frame(frame)
[13:14:34.320]                       master <- NULL
[13:14:34.320]                       while (!identical(envir, .GlobalEnv) && 
[13:14:34.320]                         !identical(envir, emptyenv())) {
[13:14:34.320]                         if (exists("master", mode = "list", envir = envir, 
[13:14:34.320]                           inherits = FALSE)) {
[13:14:34.320]                           master <- get("master", mode = "list", 
[13:14:34.320]                             envir = envir, inherits = FALSE)
[13:14:34.320]                           if (inherits(master, c("SOCKnode", 
[13:14:34.320]                             "SOCK0node"))) {
[13:14:34.320]                             sendCondition <<- function(cond) {
[13:14:34.320]                               data <- list(type = "VALUE", value = cond, 
[13:14:34.320]                                 success = TRUE)
[13:14:34.320]                               parallel_sendData(master, data)
[13:14:34.320]                             }
[13:14:34.320]                             return(sendCondition)
[13:14:34.320]                           }
[13:14:34.320]                         }
[13:14:34.320]                         frame <- frame + 1L
[13:14:34.320]                         envir <- sys.frame(frame)
[13:14:34.320]                       }
[13:14:34.320]                     }
[13:14:34.320]                     sendCondition <<- function(cond) NULL
[13:14:34.320]                   }
[13:14:34.320]                 })
[13:14:34.320]                 withCallingHandlers({
[13:14:34.320]                   {
[13:14:34.320]                     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[13:14:34.320]                     if (!identical(...future.globals.maxSize.org, 
[13:14:34.320]                       ...future.globals.maxSize)) {
[13:14:34.320]                       oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[13:14:34.320]                       on.exit(options(oopts), add = TRUE)
[13:14:34.320]                     }
[13:14:34.320]                     {
[13:14:34.320]                       args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[13:14:34.320]                         MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[13:14:34.320]                         USE.NAMES = FALSE)
[13:14:34.320]                       do.call(mapply, args = args)
[13:14:34.320]                     }
[13:14:34.320]                   }
[13:14:34.320]                 }, immediateCondition = function(cond) {
[13:14:34.320]                   sendCondition <- ...future.makeSendCondition()
[13:14:34.320]                   sendCondition(cond)
[13:14:34.320]                   muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:34.320]                   {
[13:14:34.320]                     inherits <- base::inherits
[13:14:34.320]                     invokeRestart <- base::invokeRestart
[13:14:34.320]                     is.null <- base::is.null
[13:14:34.320]                     muffled <- FALSE
[13:14:34.320]                     if (inherits(cond, "message")) {
[13:14:34.320]                       muffled <- grepl(pattern, "muffleMessage")
[13:14:34.320]                       if (muffled) 
[13:14:34.320]                         invokeRestart("muffleMessage")
[13:14:34.320]                     }
[13:14:34.320]                     else if (inherits(cond, "warning")) {
[13:14:34.320]                       muffled <- grepl(pattern, "muffleWarning")
[13:14:34.320]                       if (muffled) 
[13:14:34.320]                         invokeRestart("muffleWarning")
[13:14:34.320]                     }
[13:14:34.320]                     else if (inherits(cond, "condition")) {
[13:14:34.320]                       if (!is.null(pattern)) {
[13:14:34.320]                         computeRestarts <- base::computeRestarts
[13:14:34.320]                         grepl <- base::grepl
[13:14:34.320]                         restarts <- computeRestarts(cond)
[13:14:34.320]                         for (restart in restarts) {
[13:14:34.320]                           name <- restart$name
[13:14:34.320]                           if (is.null(name)) 
[13:14:34.320]                             next
[13:14:34.320]                           if (!grepl(pattern, name)) 
[13:14:34.320]                             next
[13:14:34.320]                           invokeRestart(restart)
[13:14:34.320]                           muffled <- TRUE
[13:14:34.320]                           break
[13:14:34.320]                         }
[13:14:34.320]                       }
[13:14:34.320]                     }
[13:14:34.320]                     invisible(muffled)
[13:14:34.320]                   }
[13:14:34.320]                   muffleCondition(cond)
[13:14:34.320]                 })
[13:14:34.320]             }))
[13:14:34.320]             future::FutureResult(value = ...future.value$value, 
[13:14:34.320]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[13:14:34.320]                   ...future.rng), globalenv = if (FALSE) 
[13:14:34.320]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[13:14:34.320]                     ...future.globalenv.names))
[13:14:34.320]                 else NULL, started = ...future.startTime, version = "1.8")
[13:14:34.320]         }, condition = base::local({
[13:14:34.320]             c <- base::c
[13:14:34.320]             inherits <- base::inherits
[13:14:34.320]             invokeRestart <- base::invokeRestart
[13:14:34.320]             length <- base::length
[13:14:34.320]             list <- base::list
[13:14:34.320]             seq.int <- base::seq.int
[13:14:34.320]             signalCondition <- base::signalCondition
[13:14:34.320]             sys.calls <- base::sys.calls
[13:14:34.320]             `[[` <- base::`[[`
[13:14:34.320]             `+` <- base::`+`
[13:14:34.320]             `<<-` <- base::`<<-`
[13:14:34.320]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[13:14:34.320]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[13:14:34.320]                   3L)]
[13:14:34.320]             }
[13:14:34.320]             function(cond) {
[13:14:34.320]                 is_error <- inherits(cond, "error")
[13:14:34.320]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[13:14:34.320]                   NULL)
[13:14:34.320]                 if (is_error) {
[13:14:34.320]                   sessionInformation <- function() {
[13:14:34.320]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[13:14:34.320]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[13:14:34.320]                       search = base::search(), system = base::Sys.info())
[13:14:34.320]                   }
[13:14:34.320]                   ...future.conditions[[length(...future.conditions) + 
[13:14:34.320]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[13:14:34.320]                     cond$call), session = sessionInformation(), 
[13:14:34.320]                     timestamp = base::Sys.time(), signaled = 0L)
[13:14:34.320]                   signalCondition(cond)
[13:14:34.320]                 }
[13:14:34.320]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[13:14:34.320]                 "immediateCondition"))) {
[13:14:34.320]                   signal <- TRUE && inherits(cond, "immediateCondition")
[13:14:34.320]                   ...future.conditions[[length(...future.conditions) + 
[13:14:34.320]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[13:14:34.320]                   if (TRUE && !signal) {
[13:14:34.320]                     muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:34.320]                     {
[13:14:34.320]                       inherits <- base::inherits
[13:14:34.320]                       invokeRestart <- base::invokeRestart
[13:14:34.320]                       is.null <- base::is.null
[13:14:34.320]                       muffled <- FALSE
[13:14:34.320]                       if (inherits(cond, "message")) {
[13:14:34.320]                         muffled <- grepl(pattern, "muffleMessage")
[13:14:34.320]                         if (muffled) 
[13:14:34.320]                           invokeRestart("muffleMessage")
[13:14:34.320]                       }
[13:14:34.320]                       else if (inherits(cond, "warning")) {
[13:14:34.320]                         muffled <- grepl(pattern, "muffleWarning")
[13:14:34.320]                         if (muffled) 
[13:14:34.320]                           invokeRestart("muffleWarning")
[13:14:34.320]                       }
[13:14:34.320]                       else if (inherits(cond, "condition")) {
[13:14:34.320]                         if (!is.null(pattern)) {
[13:14:34.320]                           computeRestarts <- base::computeRestarts
[13:14:34.320]                           grepl <- base::grepl
[13:14:34.320]                           restarts <- computeRestarts(cond)
[13:14:34.320]                           for (restart in restarts) {
[13:14:34.320]                             name <- restart$name
[13:14:34.320]                             if (is.null(name)) 
[13:14:34.320]                               next
[13:14:34.320]                             if (!grepl(pattern, name)) 
[13:14:34.320]                               next
[13:14:34.320]                             invokeRestart(restart)
[13:14:34.320]                             muffled <- TRUE
[13:14:34.320]                             break
[13:14:34.320]                           }
[13:14:34.320]                         }
[13:14:34.320]                       }
[13:14:34.320]                       invisible(muffled)
[13:14:34.320]                     }
[13:14:34.320]                     muffleCondition(cond, pattern = "^muffle")
[13:14:34.320]                   }
[13:14:34.320]                 }
[13:14:34.320]                 else {
[13:14:34.320]                   if (TRUE) {
[13:14:34.320]                     muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:34.320]                     {
[13:14:34.320]                       inherits <- base::inherits
[13:14:34.320]                       invokeRestart <- base::invokeRestart
[13:14:34.320]                       is.null <- base::is.null
[13:14:34.320]                       muffled <- FALSE
[13:14:34.320]                       if (inherits(cond, "message")) {
[13:14:34.320]                         muffled <- grepl(pattern, "muffleMessage")
[13:14:34.320]                         if (muffled) 
[13:14:34.320]                           invokeRestart("muffleMessage")
[13:14:34.320]                       }
[13:14:34.320]                       else if (inherits(cond, "warning")) {
[13:14:34.320]                         muffled <- grepl(pattern, "muffleWarning")
[13:14:34.320]                         if (muffled) 
[13:14:34.320]                           invokeRestart("muffleWarning")
[13:14:34.320]                       }
[13:14:34.320]                       else if (inherits(cond, "condition")) {
[13:14:34.320]                         if (!is.null(pattern)) {
[13:14:34.320]                           computeRestarts <- base::computeRestarts
[13:14:34.320]                           grepl <- base::grepl
[13:14:34.320]                           restarts <- computeRestarts(cond)
[13:14:34.320]                           for (restart in restarts) {
[13:14:34.320]                             name <- restart$name
[13:14:34.320]                             if (is.null(name)) 
[13:14:34.320]                               next
[13:14:34.320]                             if (!grepl(pattern, name)) 
[13:14:34.320]                               next
[13:14:34.320]                             invokeRestart(restart)
[13:14:34.320]                             muffled <- TRUE
[13:14:34.320]                             break
[13:14:34.320]                           }
[13:14:34.320]                         }
[13:14:34.320]                       }
[13:14:34.320]                       invisible(muffled)
[13:14:34.320]                     }
[13:14:34.320]                     muffleCondition(cond, pattern = "^muffle")
[13:14:34.320]                   }
[13:14:34.320]                 }
[13:14:34.320]             }
[13:14:34.320]         }))
[13:14:34.320]     }, error = function(ex) {
[13:14:34.320]         base::structure(base::list(value = NULL, visible = NULL, 
[13:14:34.320]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[13:14:34.320]                 ...future.rng), started = ...future.startTime, 
[13:14:34.320]             finished = Sys.time(), session_uuid = NA_character_, 
[13:14:34.320]             version = "1.8"), class = "FutureResult")
[13:14:34.320]     }, finally = {
[13:14:34.320]         if (!identical(...future.workdir, getwd())) 
[13:14:34.320]             setwd(...future.workdir)
[13:14:34.320]         {
[13:14:34.320]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[13:14:34.320]                 ...future.oldOptions$nwarnings <- NULL
[13:14:34.320]             }
[13:14:34.320]             base::options(...future.oldOptions)
[13:14:34.320]             if (.Platform$OS.type == "windows") {
[13:14:34.320]                 old_names <- names(...future.oldEnvVars)
[13:14:34.320]                 envs <- base::Sys.getenv()
[13:14:34.320]                 names <- names(envs)
[13:14:34.320]                 common <- intersect(names, old_names)
[13:14:34.320]                 added <- setdiff(names, old_names)
[13:14:34.320]                 removed <- setdiff(old_names, names)
[13:14:34.320]                 changed <- common[...future.oldEnvVars[common] != 
[13:14:34.320]                   envs[common]]
[13:14:34.320]                 NAMES <- toupper(changed)
[13:14:34.320]                 args <- list()
[13:14:34.320]                 for (kk in seq_along(NAMES)) {
[13:14:34.320]                   name <- changed[[kk]]
[13:14:34.320]                   NAME <- NAMES[[kk]]
[13:14:34.320]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:34.320]                     next
[13:14:34.320]                   args[[name]] <- ...future.oldEnvVars[[name]]
[13:14:34.320]                 }
[13:14:34.320]                 NAMES <- toupper(added)
[13:14:34.320]                 for (kk in seq_along(NAMES)) {
[13:14:34.320]                   name <- added[[kk]]
[13:14:34.320]                   NAME <- NAMES[[kk]]
[13:14:34.320]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:34.320]                     next
[13:14:34.320]                   args[[name]] <- ""
[13:14:34.320]                 }
[13:14:34.320]                 NAMES <- toupper(removed)
[13:14:34.320]                 for (kk in seq_along(NAMES)) {
[13:14:34.320]                   name <- removed[[kk]]
[13:14:34.320]                   NAME <- NAMES[[kk]]
[13:14:34.320]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:34.320]                     next
[13:14:34.320]                   args[[name]] <- ...future.oldEnvVars[[name]]
[13:14:34.320]                 }
[13:14:34.320]                 if (length(args) > 0) 
[13:14:34.320]                   base::do.call(base::Sys.setenv, args = args)
[13:14:34.320]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[13:14:34.320]             }
[13:14:34.320]             else {
[13:14:34.320]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[13:14:34.320]             }
[13:14:34.320]             {
[13:14:34.320]                 if (base::length(...future.futureOptionsAdded) > 
[13:14:34.320]                   0L) {
[13:14:34.320]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[13:14:34.320]                   base::names(opts) <- ...future.futureOptionsAdded
[13:14:34.320]                   base::options(opts)
[13:14:34.320]                 }
[13:14:34.320]                 {
[13:14:34.320]                   {
[13:14:34.320]                     base::options(mc.cores = ...future.mc.cores.old)
[13:14:34.320]                     NULL
[13:14:34.320]                   }
[13:14:34.320]                   options(future.plan = NULL)
[13:14:34.320]                   if (is.na(NA_character_)) 
[13:14:34.320]                     Sys.unsetenv("R_FUTURE_PLAN")
[13:14:34.320]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[13:14:34.320]                   future::plan(list(function (..., workers = availableCores(), 
[13:14:34.320]                     lazy = FALSE, rscript_libs = .libPaths(), 
[13:14:34.320]                     envir = parent.frame()) 
[13:14:34.320]                   {
[13:14:34.320]                     if (is.function(workers)) 
[13:14:34.320]                       workers <- workers()
[13:14:34.320]                     workers <- structure(as.integer(workers), 
[13:14:34.320]                       class = class(workers))
[13:14:34.320]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[13:14:34.320]                       workers >= 1)
[13:14:34.320]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[13:14:34.320]                       return(sequential(..., lazy = TRUE, envir = envir))
[13:14:34.320]                     }
[13:14:34.320]                     future <- MultisessionFuture(..., workers = workers, 
[13:14:34.320]                       lazy = lazy, rscript_libs = rscript_libs, 
[13:14:34.320]                       envir = envir)
[13:14:34.320]                     if (!future$lazy) 
[13:14:34.320]                       future <- run(future)
[13:14:34.320]                     invisible(future)
[13:14:34.320]                   }), .cleanup = FALSE, .init = FALSE)
[13:14:34.320]                 }
[13:14:34.320]             }
[13:14:34.320]         }
[13:14:34.320]     })
[13:14:34.320]     if (FALSE) {
[13:14:34.320]         base::sink(type = "output", split = FALSE)
[13:14:34.320]         if (NA) {
[13:14:34.320]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[13:14:34.320]         }
[13:14:34.320]         else {
[13:14:34.320]             ...future.result["stdout"] <- base::list(NULL)
[13:14:34.320]         }
[13:14:34.320]         base::close(...future.stdout)
[13:14:34.320]         ...future.stdout <- NULL
[13:14:34.320]     }
[13:14:34.320]     ...future.result$conditions <- ...future.conditions
[13:14:34.320]     ...future.result$finished <- base::Sys.time()
[13:14:34.320]     ...future.result
[13:14:34.320] }
[13:14:34.326] Exporting 5 global objects (6.22 KiB) to cluster node #1 ...
[13:14:34.326] Exporting '...future.FUN' (6.11 KiB) to cluster node #1 ...
[13:14:34.326] Exporting '...future.FUN' (6.11 KiB) to cluster node #1 ... DONE
[13:14:34.327] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ...
[13:14:34.327] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ... DONE
[13:14:34.327] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[13:14:34.328] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[13:14:34.328] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[13:14:34.329] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[13:14:34.329] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[13:14:34.329] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[13:14:34.330] Exporting 5 global objects (6.22 KiB) to cluster node #1 ... DONE
[13:14:34.330] MultisessionFuture started
[13:14:34.330] - Launch lazy future ... done
[13:14:34.331] run() for 'MultisessionFuture' ... done
[13:14:34.331] Created future:
[13:14:34.331] MultisessionFuture:
[13:14:34.331] Label: 'future_mapply-1'
[13:14:34.331] Expression:
[13:14:34.331] {
[13:14:34.331]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[13:14:34.331]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[13:14:34.331]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[13:14:34.331]         on.exit(options(oopts), add = TRUE)
[13:14:34.331]     }
[13:14:34.331]     {
[13:14:34.331]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[13:14:34.331]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[13:14:34.331]         do.call(mapply, args = args)
[13:14:34.331]     }
[13:14:34.331] }
[13:14:34.331] Lazy evaluation: FALSE
[13:14:34.331] Asynchronous evaluation: TRUE
[13:14:34.331] Local evaluation: TRUE
[13:14:34.331] Environment: R_GlobalEnv
[13:14:34.331] Capture standard output: NA
[13:14:34.331] Capture condition classes: 'condition' (excluding 'nothing')
[13:14:34.331] Globals: 5 objects totaling 6.22 KiB (function '...future.FUN' of 6.11 KiB, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 112 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[13:14:34.331] Packages: <none>
[13:14:34.331] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[13:14:34.331] Resolved: FALSE
[13:14:34.331] Value: <not collected>
[13:14:34.331] Conditions captured: <none>
[13:14:34.331] Early signaling: FALSE
[13:14:34.331] Owner process: 68097d82-3b31-293d-2920-9b7259f27083
[13:14:34.331] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[13:14:34.544] Chunk #1 of 2 ... DONE
[13:14:34.544] Chunk #2 of 2 ...
[13:14:34.544]  - Finding globals in '...' for chunk #2 ...
[13:14:34.544] getGlobalsAndPackages() ...
[13:14:34.545] Searching for globals...
[13:14:34.545] 
[13:14:34.545] Searching for globals ... DONE
[13:14:34.545] - globals: [0] <none>
[13:14:34.546] getGlobalsAndPackages() ... DONE
[13:14:34.546]    + additional globals found: [n=0] 
[13:14:34.546]    + additional namespaces needed: [n=0] 
[13:14:34.546]  - Finding globals in '...' for chunk #2 ... DONE
[13:14:34.546]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[13:14:34.546]  - seeds: <none>
[13:14:34.547]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:34.547] getGlobalsAndPackages() ...
[13:14:34.547] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:34.547] Resolving globals: FALSE
[13:14:34.548] The total size of the 5 globals is 6.22 KiB (6368 bytes)
[13:14:34.548] The total size of the 5 globals exported for future expression ('{; ...future.globals.maxSize.org <- getOption("future.globals.maxSize"); if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {; oopts <- options(future.globals.maxSize = ...future.globals.maxSize); on.exit(options(oopts), add = TRUE); }; ...; do.call(mapply, args = args); }; }') is 6.22 KiB.. This exceeds the maximum allowed size of 0.98 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (6.11 KiB of class 'function'), '...future.elements_ii' (112 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[13:14:34.549] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[13:14:34.549] 
[13:14:34.549] getGlobalsAndPackages() ... DONE
[13:14:34.549] run() for 'Future' ...
[13:14:34.549] - state: 'created'
[13:14:34.550] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[13:14:34.564] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[13:14:34.564] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[13:14:34.564]   - Field: 'node'
[13:14:34.565]   - Field: 'label'
[13:14:34.565]   - Field: 'local'
[13:14:34.565]   - Field: 'owner'
[13:14:34.565]   - Field: 'envir'
[13:14:34.565]   - Field: 'workers'
[13:14:34.566]   - Field: 'packages'
[13:14:34.566]   - Field: 'gc'
[13:14:34.566]   - Field: 'conditions'
[13:14:34.566]   - Field: 'persistent'
[13:14:34.566]   - Field: 'expr'
[13:14:34.566]   - Field: 'uuid'
[13:14:34.567]   - Field: 'seed'
[13:14:34.567]   - Field: 'version'
[13:14:34.567]   - Field: 'result'
[13:14:34.567]   - Field: 'asynchronous'
[13:14:34.567]   - Field: 'calls'
[13:14:34.567]   - Field: 'globals'
[13:14:34.568]   - Field: 'stdout'
[13:14:34.568]   - Field: 'earlySignal'
[13:14:34.568]   - Field: 'lazy'
[13:14:34.568]   - Field: 'state'
[13:14:34.568] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[13:14:34.569] - Launch lazy future ...
[13:14:34.569] Packages needed by the future expression (n = 0): <none>
[13:14:34.569] Packages needed by future strategies (n = 0): <none>
[13:14:34.570] {
[13:14:34.570]     {
[13:14:34.570]         {
[13:14:34.570]             ...future.startTime <- base::Sys.time()
[13:14:34.570]             {
[13:14:34.570]                 {
[13:14:34.570]                   {
[13:14:34.570]                     {
[13:14:34.570]                       base::local({
[13:14:34.570]                         has_future <- base::requireNamespace("future", 
[13:14:34.570]                           quietly = TRUE)
[13:14:34.570]                         if (has_future) {
[13:14:34.570]                           ns <- base::getNamespace("future")
[13:14:34.570]                           version <- ns[[".package"]][["version"]]
[13:14:34.570]                           if (is.null(version)) 
[13:14:34.570]                             version <- utils::packageVersion("future")
[13:14:34.570]                         }
[13:14:34.570]                         else {
[13:14:34.570]                           version <- NULL
[13:14:34.570]                         }
[13:14:34.570]                         if (!has_future || version < "1.8.0") {
[13:14:34.570]                           info <- base::c(r_version = base::gsub("R version ", 
[13:14:34.570]                             "", base::R.version$version.string), 
[13:14:34.570]                             platform = base::sprintf("%s (%s-bit)", 
[13:14:34.570]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[13:14:34.570]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[13:14:34.570]                               "release", "version")], collapse = " "), 
[13:14:34.570]                             hostname = base::Sys.info()[["nodename"]])
[13:14:34.570]                           info <- base::sprintf("%s: %s", base::names(info), 
[13:14:34.570]                             info)
[13:14:34.570]                           info <- base::paste(info, collapse = "; ")
[13:14:34.570]                           if (!has_future) {
[13:14:34.570]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[13:14:34.570]                               info)
[13:14:34.570]                           }
[13:14:34.570]                           else {
[13:14:34.570]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[13:14:34.570]                               info, version)
[13:14:34.570]                           }
[13:14:34.570]                           base::stop(msg)
[13:14:34.570]                         }
[13:14:34.570]                       })
[13:14:34.570]                     }
[13:14:34.570]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[13:14:34.570]                     base::options(mc.cores = 1L)
[13:14:34.570]                   }
[13:14:34.570]                   options(future.plan = NULL)
[13:14:34.570]                   Sys.unsetenv("R_FUTURE_PLAN")
[13:14:34.570]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[13:14:34.570]                 }
[13:14:34.570]                 ...future.workdir <- getwd()
[13:14:34.570]             }
[13:14:34.570]             ...future.oldOptions <- base::as.list(base::.Options)
[13:14:34.570]             ...future.oldEnvVars <- base::Sys.getenv()
[13:14:34.570]         }
[13:14:34.570]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[13:14:34.570]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[13:14:34.570]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[13:14:34.570]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[13:14:34.570]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[13:14:34.570]             future.stdout.windows.reencode = NULL, width = 80L)
[13:14:34.570]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[13:14:34.570]             base::names(...future.oldOptions))
[13:14:34.570]     }
[13:14:34.570]     if (TRUE) {
[13:14:34.570]     }
[13:14:34.570]     else {
[13:14:34.570]         if (NA) {
[13:14:34.570]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[13:14:34.570]                 open = "w")
[13:14:34.570]         }
[13:14:34.570]         else {
[13:14:34.570]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[13:14:34.570]                 windows = "NUL", "/dev/null"), open = "w")
[13:14:34.570]         }
[13:14:34.570]         base::sink(...future.stdout, type = "output", split = FALSE)
[13:14:34.570]         base::on.exit(if (!base::is.null(...future.stdout)) {
[13:14:34.570]             base::sink(type = "output", split = FALSE)
[13:14:34.570]             base::close(...future.stdout)
[13:14:34.570]         }, add = TRUE)
[13:14:34.570]     }
[13:14:34.570]     ...future.frame <- base::sys.nframe()
[13:14:34.570]     ...future.conditions <- base::list()
[13:14:34.570]     ...future.rng <- base::globalenv()$.Random.seed
[13:14:34.570]     if (FALSE) {
[13:14:34.570]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[13:14:34.570]             "...future.value", "...future.globalenv.names", ".Random.seed")
[13:14:34.570]     }
[13:14:34.570]     ...future.result <- base::tryCatch({
[13:14:34.570]         base::withCallingHandlers({
[13:14:34.570]             ...future.value <- base::withVisible(base::local({
[13:14:34.570]                 ...future.makeSendCondition <- local({
[13:14:34.570]                   sendCondition <- NULL
[13:14:34.570]                   function(frame = 1L) {
[13:14:34.570]                     if (is.function(sendCondition)) 
[13:14:34.570]                       return(sendCondition)
[13:14:34.570]                     ns <- getNamespace("parallel")
[13:14:34.570]                     if (exists("sendData", mode = "function", 
[13:14:34.570]                       envir = ns)) {
[13:14:34.570]                       parallel_sendData <- get("sendData", mode = "function", 
[13:14:34.570]                         envir = ns)
[13:14:34.570]                       envir <- sys.frame(frame)
[13:14:34.570]                       master <- NULL
[13:14:34.570]                       while (!identical(envir, .GlobalEnv) && 
[13:14:34.570]                         !identical(envir, emptyenv())) {
[13:14:34.570]                         if (exists("master", mode = "list", envir = envir, 
[13:14:34.570]                           inherits = FALSE)) {
[13:14:34.570]                           master <- get("master", mode = "list", 
[13:14:34.570]                             envir = envir, inherits = FALSE)
[13:14:34.570]                           if (inherits(master, c("SOCKnode", 
[13:14:34.570]                             "SOCK0node"))) {
[13:14:34.570]                             sendCondition <<- function(cond) {
[13:14:34.570]                               data <- list(type = "VALUE", value = cond, 
[13:14:34.570]                                 success = TRUE)
[13:14:34.570]                               parallel_sendData(master, data)
[13:14:34.570]                             }
[13:14:34.570]                             return(sendCondition)
[13:14:34.570]                           }
[13:14:34.570]                         }
[13:14:34.570]                         frame <- frame + 1L
[13:14:34.570]                         envir <- sys.frame(frame)
[13:14:34.570]                       }
[13:14:34.570]                     }
[13:14:34.570]                     sendCondition <<- function(cond) NULL
[13:14:34.570]                   }
[13:14:34.570]                 })
[13:14:34.570]                 withCallingHandlers({
[13:14:34.570]                   {
[13:14:34.570]                     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[13:14:34.570]                     if (!identical(...future.globals.maxSize.org, 
[13:14:34.570]                       ...future.globals.maxSize)) {
[13:14:34.570]                       oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[13:14:34.570]                       on.exit(options(oopts), add = TRUE)
[13:14:34.570]                     }
[13:14:34.570]                     {
[13:14:34.570]                       args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[13:14:34.570]                         MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[13:14:34.570]                         USE.NAMES = FALSE)
[13:14:34.570]                       do.call(mapply, args = args)
[13:14:34.570]                     }
[13:14:34.570]                   }
[13:14:34.570]                 }, immediateCondition = function(cond) {
[13:14:34.570]                   sendCondition <- ...future.makeSendCondition()
[13:14:34.570]                   sendCondition(cond)
[13:14:34.570]                   muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:34.570]                   {
[13:14:34.570]                     inherits <- base::inherits
[13:14:34.570]                     invokeRestart <- base::invokeRestart
[13:14:34.570]                     is.null <- base::is.null
[13:14:34.570]                     muffled <- FALSE
[13:14:34.570]                     if (inherits(cond, "message")) {
[13:14:34.570]                       muffled <- grepl(pattern, "muffleMessage")
[13:14:34.570]                       if (muffled) 
[13:14:34.570]                         invokeRestart("muffleMessage")
[13:14:34.570]                     }
[13:14:34.570]                     else if (inherits(cond, "warning")) {
[13:14:34.570]                       muffled <- grepl(pattern, "muffleWarning")
[13:14:34.570]                       if (muffled) 
[13:14:34.570]                         invokeRestart("muffleWarning")
[13:14:34.570]                     }
[13:14:34.570]                     else if (inherits(cond, "condition")) {
[13:14:34.570]                       if (!is.null(pattern)) {
[13:14:34.570]                         computeRestarts <- base::computeRestarts
[13:14:34.570]                         grepl <- base::grepl
[13:14:34.570]                         restarts <- computeRestarts(cond)
[13:14:34.570]                         for (restart in restarts) {
[13:14:34.570]                           name <- restart$name
[13:14:34.570]                           if (is.null(name)) 
[13:14:34.570]                             next
[13:14:34.570]                           if (!grepl(pattern, name)) 
[13:14:34.570]                             next
[13:14:34.570]                           invokeRestart(restart)
[13:14:34.570]                           muffled <- TRUE
[13:14:34.570]                           break
[13:14:34.570]                         }
[13:14:34.570]                       }
[13:14:34.570]                     }
[13:14:34.570]                     invisible(muffled)
[13:14:34.570]                   }
[13:14:34.570]                   muffleCondition(cond)
[13:14:34.570]                 })
[13:14:34.570]             }))
[13:14:34.570]             future::FutureResult(value = ...future.value$value, 
[13:14:34.570]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[13:14:34.570]                   ...future.rng), globalenv = if (FALSE) 
[13:14:34.570]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[13:14:34.570]                     ...future.globalenv.names))
[13:14:34.570]                 else NULL, started = ...future.startTime, version = "1.8")
[13:14:34.570]         }, condition = base::local({
[13:14:34.570]             c <- base::c
[13:14:34.570]             inherits <- base::inherits
[13:14:34.570]             invokeRestart <- base::invokeRestart
[13:14:34.570]             length <- base::length
[13:14:34.570]             list <- base::list
[13:14:34.570]             seq.int <- base::seq.int
[13:14:34.570]             signalCondition <- base::signalCondition
[13:14:34.570]             sys.calls <- base::sys.calls
[13:14:34.570]             `[[` <- base::`[[`
[13:14:34.570]             `+` <- base::`+`
[13:14:34.570]             `<<-` <- base::`<<-`
[13:14:34.570]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[13:14:34.570]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[13:14:34.570]                   3L)]
[13:14:34.570]             }
[13:14:34.570]             function(cond) {
[13:14:34.570]                 is_error <- inherits(cond, "error")
[13:14:34.570]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[13:14:34.570]                   NULL)
[13:14:34.570]                 if (is_error) {
[13:14:34.570]                   sessionInformation <- function() {
[13:14:34.570]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[13:14:34.570]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[13:14:34.570]                       search = base::search(), system = base::Sys.info())
[13:14:34.570]                   }
[13:14:34.570]                   ...future.conditions[[length(...future.conditions) + 
[13:14:34.570]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[13:14:34.570]                     cond$call), session = sessionInformation(), 
[13:14:34.570]                     timestamp = base::Sys.time(), signaled = 0L)
[13:14:34.570]                   signalCondition(cond)
[13:14:34.570]                 }
[13:14:34.570]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[13:14:34.570]                 "immediateCondition"))) {
[13:14:34.570]                   signal <- TRUE && inherits(cond, "immediateCondition")
[13:14:34.570]                   ...future.conditions[[length(...future.conditions) + 
[13:14:34.570]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[13:14:34.570]                   if (TRUE && !signal) {
[13:14:34.570]                     muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:34.570]                     {
[13:14:34.570]                       inherits <- base::inherits
[13:14:34.570]                       invokeRestart <- base::invokeRestart
[13:14:34.570]                       is.null <- base::is.null
[13:14:34.570]                       muffled <- FALSE
[13:14:34.570]                       if (inherits(cond, "message")) {
[13:14:34.570]                         muffled <- grepl(pattern, "muffleMessage")
[13:14:34.570]                         if (muffled) 
[13:14:34.570]                           invokeRestart("muffleMessage")
[13:14:34.570]                       }
[13:14:34.570]                       else if (inherits(cond, "warning")) {
[13:14:34.570]                         muffled <- grepl(pattern, "muffleWarning")
[13:14:34.570]                         if (muffled) 
[13:14:34.570]                           invokeRestart("muffleWarning")
[13:14:34.570]                       }
[13:14:34.570]                       else if (inherits(cond, "condition")) {
[13:14:34.570]                         if (!is.null(pattern)) {
[13:14:34.570]                           computeRestarts <- base::computeRestarts
[13:14:34.570]                           grepl <- base::grepl
[13:14:34.570]                           restarts <- computeRestarts(cond)
[13:14:34.570]                           for (restart in restarts) {
[13:14:34.570]                             name <- restart$name
[13:14:34.570]                             if (is.null(name)) 
[13:14:34.570]                               next
[13:14:34.570]                             if (!grepl(pattern, name)) 
[13:14:34.570]                               next
[13:14:34.570]                             invokeRestart(restart)
[13:14:34.570]                             muffled <- TRUE
[13:14:34.570]                             break
[13:14:34.570]                           }
[13:14:34.570]                         }
[13:14:34.570]                       }
[13:14:34.570]                       invisible(muffled)
[13:14:34.570]                     }
[13:14:34.570]                     muffleCondition(cond, pattern = "^muffle")
[13:14:34.570]                   }
[13:14:34.570]                 }
[13:14:34.570]                 else {
[13:14:34.570]                   if (TRUE) {
[13:14:34.570]                     muffleCondition <- function (cond, pattern = "^muffle") 
[13:14:34.570]                     {
[13:14:34.570]                       inherits <- base::inherits
[13:14:34.570]                       invokeRestart <- base::invokeRestart
[13:14:34.570]                       is.null <- base::is.null
[13:14:34.570]                       muffled <- FALSE
[13:14:34.570]                       if (inherits(cond, "message")) {
[13:14:34.570]                         muffled <- grepl(pattern, "muffleMessage")
[13:14:34.570]                         if (muffled) 
[13:14:34.570]                           invokeRestart("muffleMessage")
[13:14:34.570]                       }
[13:14:34.570]                       else if (inherits(cond, "warning")) {
[13:14:34.570]                         muffled <- grepl(pattern, "muffleWarning")
[13:14:34.570]                         if (muffled) 
[13:14:34.570]                           invokeRestart("muffleWarning")
[13:14:34.570]                       }
[13:14:34.570]                       else if (inherits(cond, "condition")) {
[13:14:34.570]                         if (!is.null(pattern)) {
[13:14:34.570]                           computeRestarts <- base::computeRestarts
[13:14:34.570]                           grepl <- base::grepl
[13:14:34.570]                           restarts <- computeRestarts(cond)
[13:14:34.570]                           for (restart in restarts) {
[13:14:34.570]                             name <- restart$name
[13:14:34.570]                             if (is.null(name)) 
[13:14:34.570]                               next
[13:14:34.570]                             if (!grepl(pattern, name)) 
[13:14:34.570]                               next
[13:14:34.570]                             invokeRestart(restart)
[13:14:34.570]                             muffled <- TRUE
[13:14:34.570]                             break
[13:14:34.570]                           }
[13:14:34.570]                         }
[13:14:34.570]                       }
[13:14:34.570]                       invisible(muffled)
[13:14:34.570]                     }
[13:14:34.570]                     muffleCondition(cond, pattern = "^muffle")
[13:14:34.570]                   }
[13:14:34.570]                 }
[13:14:34.570]             }
[13:14:34.570]         }))
[13:14:34.570]     }, error = function(ex) {
[13:14:34.570]         base::structure(base::list(value = NULL, visible = NULL, 
[13:14:34.570]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[13:14:34.570]                 ...future.rng), started = ...future.startTime, 
[13:14:34.570]             finished = Sys.time(), session_uuid = NA_character_, 
[13:14:34.570]             version = "1.8"), class = "FutureResult")
[13:14:34.570]     }, finally = {
[13:14:34.570]         if (!identical(...future.workdir, getwd())) 
[13:14:34.570]             setwd(...future.workdir)
[13:14:34.570]         {
[13:14:34.570]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[13:14:34.570]                 ...future.oldOptions$nwarnings <- NULL
[13:14:34.570]             }
[13:14:34.570]             base::options(...future.oldOptions)
[13:14:34.570]             if (.Platform$OS.type == "windows") {
[13:14:34.570]                 old_names <- names(...future.oldEnvVars)
[13:14:34.570]                 envs <- base::Sys.getenv()
[13:14:34.570]                 names <- names(envs)
[13:14:34.570]                 common <- intersect(names, old_names)
[13:14:34.570]                 added <- setdiff(names, old_names)
[13:14:34.570]                 removed <- setdiff(old_names, names)
[13:14:34.570]                 changed <- common[...future.oldEnvVars[common] != 
[13:14:34.570]                   envs[common]]
[13:14:34.570]                 NAMES <- toupper(changed)
[13:14:34.570]                 args <- list()
[13:14:34.570]                 for (kk in seq_along(NAMES)) {
[13:14:34.570]                   name <- changed[[kk]]
[13:14:34.570]                   NAME <- NAMES[[kk]]
[13:14:34.570]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:34.570]                     next
[13:14:34.570]                   args[[name]] <- ...future.oldEnvVars[[name]]
[13:14:34.570]                 }
[13:14:34.570]                 NAMES <- toupper(added)
[13:14:34.570]                 for (kk in seq_along(NAMES)) {
[13:14:34.570]                   name <- added[[kk]]
[13:14:34.570]                   NAME <- NAMES[[kk]]
[13:14:34.570]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:34.570]                     next
[13:14:34.570]                   args[[name]] <- ""
[13:14:34.570]                 }
[13:14:34.570]                 NAMES <- toupper(removed)
[13:14:34.570]                 for (kk in seq_along(NAMES)) {
[13:14:34.570]                   name <- removed[[kk]]
[13:14:34.570]                   NAME <- NAMES[[kk]]
[13:14:34.570]                   if (name != NAME && is.element(NAME, old_names)) 
[13:14:34.570]                     next
[13:14:34.570]                   args[[name]] <- ...future.oldEnvVars[[name]]
[13:14:34.570]                 }
[13:14:34.570]                 if (length(args) > 0) 
[13:14:34.570]                   base::do.call(base::Sys.setenv, args = args)
[13:14:34.570]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[13:14:34.570]             }
[13:14:34.570]             else {
[13:14:34.570]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[13:14:34.570]             }
[13:14:34.570]             {
[13:14:34.570]                 if (base::length(...future.futureOptionsAdded) > 
[13:14:34.570]                   0L) {
[13:14:34.570]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[13:14:34.570]                   base::names(opts) <- ...future.futureOptionsAdded
[13:14:34.570]                   base::options(opts)
[13:14:34.570]                 }
[13:14:34.570]                 {
[13:14:34.570]                   {
[13:14:34.570]                     base::options(mc.cores = ...future.mc.cores.old)
[13:14:34.570]                     NULL
[13:14:34.570]                   }
[13:14:34.570]                   options(future.plan = NULL)
[13:14:34.570]                   if (is.na(NA_character_)) 
[13:14:34.570]                     Sys.unsetenv("R_FUTURE_PLAN")
[13:14:34.570]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[13:14:34.570]                   future::plan(list(function (..., workers = availableCores(), 
[13:14:34.570]                     lazy = FALSE, rscript_libs = .libPaths(), 
[13:14:34.570]                     envir = parent.frame()) 
[13:14:34.570]                   {
[13:14:34.570]                     if (is.function(workers)) 
[13:14:34.570]                       workers <- workers()
[13:14:34.570]                     workers <- structure(as.integer(workers), 
[13:14:34.570]                       class = class(workers))
[13:14:34.570]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[13:14:34.570]                       workers >= 1)
[13:14:34.570]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[13:14:34.570]                       return(sequential(..., lazy = TRUE, envir = envir))
[13:14:34.570]                     }
[13:14:34.570]                     future <- MultisessionFuture(..., workers = workers, 
[13:14:34.570]                       lazy = lazy, rscript_libs = rscript_libs, 
[13:14:34.570]                       envir = envir)
[13:14:34.570]                     if (!future$lazy) 
[13:14:34.570]                       future <- run(future)
[13:14:34.570]                     invisible(future)
[13:14:34.570]                   }), .cleanup = FALSE, .init = FALSE)
[13:14:34.570]                 }
[13:14:34.570]             }
[13:14:34.570]         }
[13:14:34.570]     })
[13:14:34.570]     if (FALSE) {
[13:14:34.570]         base::sink(type = "output", split = FALSE)
[13:14:34.570]         if (NA) {
[13:14:34.570]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[13:14:34.570]         }
[13:14:34.570]         else {
[13:14:34.570]             ...future.result["stdout"] <- base::list(NULL)
[13:14:34.570]         }
[13:14:34.570]         base::close(...future.stdout)
[13:14:34.570]         ...future.stdout <- NULL
[13:14:34.570]     }
[13:14:34.570]     ...future.result$conditions <- ...future.conditions
[13:14:34.570]     ...future.result$finished <- base::Sys.time()
[13:14:34.570]     ...future.result
[13:14:34.570] }
[13:14:34.575] Exporting 5 global objects (6.22 KiB) to cluster node #2 ...
[13:14:34.575] Exporting '...future.FUN' (6.11 KiB) to cluster node #2 ...
[13:14:34.576] Exporting '...future.FUN' (6.11 KiB) to cluster node #2 ... DONE
[13:14:34.576] Exporting 'MoreArgs' (0 bytes) to cluster node #2 ...
[13:14:34.577] Exporting 'MoreArgs' (0 bytes) to cluster node #2 ... DONE
[13:14:34.577] Exporting '...future.elements_ii' (112 bytes) to cluster node #2 ...
[13:14:34.577] Exporting '...future.elements_ii' (112 bytes) to cluster node #2 ... DONE
[13:14:34.577] Exporting '...future.seeds_ii' (0 bytes) to cluster node #2 ...
[13:14:34.578] Exporting '...future.seeds_ii' (0 bytes) to cluster node #2 ... DONE
[13:14:34.578] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #2 ...
[13:14:34.579] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #2 ... DONE
[13:14:34.579] Exporting 5 global objects (6.22 KiB) to cluster node #2 ... DONE
[13:14:34.579] MultisessionFuture started
[13:14:34.580] - Launch lazy future ... done
[13:14:34.580] run() for 'MultisessionFuture' ... done
[13:14:34.580] Created future:
[13:14:34.597] receiveMessageFromWorker() for ClusterFuture ...
[13:14:34.597] - Validating connection of MultisessionFuture
[13:14:34.598] - received message: FutureResult
[13:14:34.598] - Received FutureResult
[13:14:34.598] - Erased future from FutureRegistry
[13:14:34.598] result() for ClusterFuture ...
[13:14:34.598] - result already collected: FutureResult
[13:14:34.599] result() for ClusterFuture ... done
[13:14:34.599] receiveMessageFromWorker() for ClusterFuture ... done
[13:14:34.580] MultisessionFuture:
[13:14:34.580] Label: 'future_mapply-2'
[13:14:34.580] Expression:
[13:14:34.580] {
[13:14:34.580]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[13:14:34.580]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[13:14:34.580]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[13:14:34.580]         on.exit(options(oopts), add = TRUE)
[13:14:34.580]     }
[13:14:34.580]     {
[13:14:34.580]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[13:14:34.580]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[13:14:34.580]         do.call(mapply, args = args)
[13:14:34.580]     }
[13:14:34.580] }
[13:14:34.580] Lazy evaluation: FALSE
[13:14:34.580] Asynchronous evaluation: TRUE
[13:14:34.580] Local evaluation: TRUE
[13:14:34.580] Environment: R_GlobalEnv
[13:14:34.580] Capture standard output: NA
[13:14:34.580] Capture condition classes: 'condition' (excluding 'nothing')
[13:14:34.580] Globals: 5 objects totaling 6.22 KiB (function '...future.FUN' of 6.11 KiB, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 112 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[13:14:34.580] Packages: <none>
[13:14:34.580] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[13:14:34.580] Resolved: TRUE
[13:14:34.580] Value: <not collected>
[13:14:34.580] Conditions captured: <none>
[13:14:34.580] Early signaling: FALSE
[13:14:34.580] Owner process: 68097d82-3b31-293d-2920-9b7259f27083
[13:14:34.580] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[13:14:34.599] Chunk #2 of 2 ... DONE
[13:14:34.599] Launching 2 futures (chunks) ... DONE
[13:14:34.599] Resolving 2 futures (chunks) ...
[13:14:34.600] resolve() on list ...
[13:14:34.600]  recursive: 0
[13:14:34.600]  length: 2
[13:14:34.600] 
[13:14:34.794] Future #2
[13:14:34.794] result() for ClusterFuture ...
[13:14:34.794] - result already collected: FutureResult
[13:14:34.794] result() for ClusterFuture ... done
[13:14:34.794] result() for ClusterFuture ...
[13:14:34.794] - result already collected: FutureResult
[13:14:34.795] result() for ClusterFuture ... done
[13:14:34.795] signalConditionsASAP(MultisessionFuture, pos=2) ...
[13:14:34.795] - nx: 2
[13:14:34.795] - relay: TRUE
[13:14:34.795] - stdout: TRUE
[13:14:34.795] - signal: TRUE
[13:14:34.796] - resignal: FALSE
[13:14:34.796] - force: TRUE
[13:14:34.796] - relayed: [n=2] FALSE, FALSE
[13:14:34.796] - queued futures: [n=2] FALSE, FALSE
[13:14:34.796]  - until=1
[13:14:34.796]  - relaying element #1
[13:14:34.797] - relayed: [n=2] FALSE, FALSE
[13:14:34.797] - queued futures: [n=2] FALSE, TRUE
[13:14:34.797] signalConditionsASAP(NULL, pos=2) ... done
[13:14:34.797]  length: 1 (resolved future 2)
[13:14:34.858] receiveMessageFromWorker() for ClusterFuture ...
[13:14:34.858] - Validating connection of MultisessionFuture
[13:14:34.858] - received message: FutureResult
[13:14:34.858] - Received FutureResult
[13:14:34.859] - Erased future from FutureRegistry
[13:14:34.859] result() for ClusterFuture ...
[13:14:34.859] - result already collected: FutureResult
[13:14:34.859] result() for ClusterFuture ... done
[13:14:34.859] receiveMessageFromWorker() for ClusterFuture ... done
[13:14:34.859] Future #1
[13:14:34.860] result() for ClusterFuture ...
[13:14:34.860] - result already collected: FutureResult
[13:14:34.860] result() for ClusterFuture ... done
[13:14:34.860] result() for ClusterFuture ...
[13:14:34.860] - result already collected: FutureResult
[13:14:34.860] result() for ClusterFuture ... done
[13:14:34.860] signalConditionsASAP(MultisessionFuture, pos=1) ...
[13:14:34.861] - nx: 2
[13:14:34.861] - relay: TRUE
[13:14:34.861] - stdout: TRUE
[13:14:34.861] - signal: TRUE
[13:14:34.861] - resignal: FALSE
[13:14:34.861] - force: TRUE
[13:14:34.862] - relayed: [n=2] FALSE, FALSE
[13:14:34.862] - queued futures: [n=2] FALSE, TRUE
[13:14:34.862]  - until=1
[13:14:34.862]  - relaying element #1
[13:14:34.862] result() for ClusterFuture ...
[13:14:34.862] - result already collected: FutureResult
[13:14:34.862] result() for ClusterFuture ... done
[13:14:34.863] result() for ClusterFuture ...
[13:14:34.863] - result already collected: FutureResult
[13:14:34.863] result() for ClusterFuture ... done
[13:14:34.863] result() for ClusterFuture ...
[13:14:34.863] - result already collected: FutureResult
[13:14:34.863] result() for ClusterFuture ... done
[13:14:34.864] result() for ClusterFuture ...
[13:14:34.864] - result already collected: FutureResult
[13:14:34.864] result() for ClusterFuture ... done
[13:14:34.864] - relayed: [n=2] TRUE, FALSE
[13:14:34.864] - queued futures: [n=2] TRUE, TRUE
[13:14:34.864] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[13:14:34.865]  length: 0 (resolved future 1)
[13:14:34.865] Relaying remaining futures
[13:14:34.865] signalConditionsASAP(NULL, pos=0) ...
[13:14:34.865] - nx: 2
[13:14:34.865] - relay: TRUE
[13:14:34.865] - stdout: TRUE
[13:14:34.865] - signal: TRUE
[13:14:34.866] - resignal: FALSE
[13:14:34.866] - force: TRUE
[13:14:34.866] - relayed: [n=2] TRUE, FALSE
[13:14:34.866] - queued futures: [n=2] TRUE, TRUE
 - flush all
[13:14:34.866]  - relaying element #2
[13:14:34.866] result() for ClusterFuture ...
[13:14:34.867] - result already collected: FutureResult
[13:14:34.867] result() for ClusterFuture ... done
[13:14:34.867] result() for ClusterFuture ...
[13:14:34.867] - result already collected: FutureResult
[13:14:34.867] result() for ClusterFuture ... done
[13:14:34.867] result() for ClusterFuture ...
[13:14:34.868] - result already collected: FutureResult
[13:14:34.868] result() for ClusterFuture ... done
[13:14:34.868] result() for ClusterFuture ...
[13:14:34.868] - result already collected: FutureResult
[13:14:34.868] result() for ClusterFuture ... done
[13:14:34.868] - relayed: [n=2] TRUE, TRUE
[13:14:34.869] - queued futures: [n=2] TRUE, TRUE
[13:14:34.869] signalConditionsASAP(MultisessionFuture, pos=0) ... done
[13:14:34.869] resolve() on list ... DONE
[13:14:34.869] result() for ClusterFuture ...
[13:14:34.869] - result already collected: FutureResult
[13:14:34.869] result() for ClusterFuture ... done
[13:14:34.869] result() for ClusterFuture ...
[13:14:34.870] - result already collected: FutureResult
[13:14:34.870] result() for ClusterFuture ... done
[13:14:34.870] result() for ClusterFuture ...
[13:14:34.870] - result already collected: FutureResult
[13:14:34.870] result() for ClusterFuture ... done
[13:14:34.870] result() for ClusterFuture ...
[13:14:34.871] - result already collected: FutureResult
[13:14:34.871] result() for ClusterFuture ... done
[13:14:34.871]  - Number of value chunks collected: 2
[13:14:34.871] Resolving 2 futures (chunks) ... DONE
[13:14:34.871] Reducing values from 2 chunks ...
[13:14:34.871]  - Number of values collected after concatenation: 2
[13:14:34.872]  - Number of values expected: 2
[13:14:34.872] Reducing values from 2 chunks ... DONE
[13:14:34.872] future_mapply() ... DONE
* future_mapply(x, ..., future.stdout = NA) ... DONE
* plan('multisession') ... DONE
  - Testing with 2 cores ... DONE
> 
> message("*** future_*apply() and 'future.stdout' ... DONE")
*** future_*apply() and 'future.stdout' ... DONE
> 
> source("incl/end.R")
[13:14:34.873] plan(): Setting new future strategy stack:
[13:14:34.873] List of future strategies:
[13:14:34.873] 1. FutureStrategy:
[13:14:34.873]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[13:14:34.873]    - tweaked: FALSE
[13:14:34.873]    - call: future::plan(oplan)
[13:14:34.875] plan(): nbrOfWorkers() = 1
> 
> proc.time()
   user  system elapsed 
   1.56    0.10   11.53