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

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

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

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

> source("incl/start.R")
Loading required package: future
[15:32:19.026] plan(): Setting new future strategy stack:
[15:32:19.028] List of future strategies:
[15:32:19.028] 1. sequential:
[15:32:19.028]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:19.028]    - tweaked: FALSE
[15:32:19.028]    - call: future::plan("sequential")
[15:32:19.054] plan(): nbrOfWorkers() = 1
> 
> message("*** future_sapply() ...")
*** future_sapply() ...
> 
> xs <- list(
+   A = c(a = 1, b = 2, c = 3),
+   B = c(a = 1:2, b = 2:3, c = 3:4),
+   C = letters[1:3],
+   D = structure(10 * 5:8, names = LETTERS[1:4])
+ )
> 
> FUNS <- list(
+   a = identity,
+   b = as.matrix,
+   c = function(x, y = 2 * 1:5) outer(rep(x, length.out = 3L), y)
+ )
> 
> for (strategy in supportedStrategies()) {
+   message(sprintf("*** strategy = %s ...", sQuote(strategy)))
+   plan(strategy)
+   
+   for (x in xs) {
+     FUNS_x <- FUNS
+     if (!is.numeric(x)) FUNS_x[["c"]] <- NULL
+     
+     for (USE.NAMES in list(FALSE, TRUE)) {
+       for (simplify in list(FALSE, TRUE, "array")) {
+         for (FUN in FUNS_x) {
+           y0 <-        sapply(x, FUN = FUN,
+                               USE.NAMES = USE.NAMES, simplify = simplify)
+           y1 <- future_sapply(x, FUN = FUN,
+                               USE.NAMES = USE.NAMES, simplify = simplify)
+           str(list(y0 = y0, y1 = y1))
+           stopifnot(identical(y1, y0))
+           if (identical(simplify, FALSE)) {
+              y2 <- lapply(x, FUN = FUN)
+              str(list(y0 = y0, y2 = y2))
+              stopifnot(identical(unname(y2), unname(y0)))
+           }
+         }
+       }
+     }
+   }
+ 
+   y0 <- sapply(1:3, FUN = "sqrt")
+   y1 <- future_sapply(1:3, FUN = "sqrt")
+   stopifnot(identical(y1, y0))
+   
+   ## https://github.com/HenrikBengtsson/future.apply/issues/61
+   compute <- function(a, x_vec) a + x_vec
+   call_compute <- function(..., x_vec = 1:2){
+     compute_with_dots <- function(x) compute(..., x_vec = x)
+     future_sapply(x_vec, FUN = compute_with_dots)
+   }
+   y <- call_compute(0L)
+   print(y)
+   stopifnot(identical(y, 1:2))
+   
+   plan(sequential)
+   message(sprintf("*** strategy = %s ... done", sQuote(strategy)))
+ } ## for (strategy in ...) 
*** strategy = 'sequential' ...
[15:32:19.111] plan(): Setting new future strategy stack:
[15:32:19.111] List of future strategies:
[15:32:19.111] 1. sequential:
[15:32:19.111]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:19.111]    - tweaked: FALSE
[15:32:19.111]    - call: plan(strategy)
[15:32:19.132] plan(): nbrOfWorkers() = 1
[15:32:19.133] future_lapply() ...
[15:32:19.138] Number of chunks: 1
[15:32:19.139] getGlobalsAndPackagesXApply() ...
[15:32:19.139]  - future.globals: TRUE
[15:32:19.140] getGlobalsAndPackages() ...
[15:32:19.140] Searching for globals...
[15:32:19.145] - globals found: [1] 'FUN'
[15:32:19.146] Searching for globals ... DONE
[15:32:19.146] Resolving globals: FALSE
[15:32:19.147] The total size of the 1 globals is 848 bytes (848 bytes)
[15:32:19.148] The total size of the 1 globals exported for future expression ('FUN()') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:32:19.148] - globals: [1] 'FUN'
[15:32:19.149] 
[15:32:19.149] getGlobalsAndPackages() ... DONE
[15:32:19.149]  - globals found/used: [n=1] 'FUN'
[15:32:19.150]  - needed namespaces: [n=0] 
[15:32:19.150] Finding globals ... DONE
[15:32:19.150]  - use_args: TRUE
[15:32:19.150]  - Getting '...' globals ...
[15:32:19.152] resolve() on list ...
[15:32:19.152]  recursive: 0
[15:32:19.153]  length: 1
[15:32:19.153]  elements: '...'
[15:32:19.153]  length: 0 (resolved future 1)
[15:32:19.153] resolve() on list ... DONE
[15:32:19.154]    - '...' content: [n=0] 
[15:32:19.154] List of 1
[15:32:19.154]  $ ...: list()
[15:32:19.154]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:19.154]  - attr(*, "where")=List of 1
[15:32:19.154]   ..$ ...:<environment: 0x00000276e017fe28> 
[15:32:19.154]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:19.154]  - attr(*, "resolved")= logi TRUE
[15:32:19.154]  - attr(*, "total_size")= num NA
[15:32:19.163]  - Getting '...' globals ... DONE
[15:32:19.164] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:19.164] List of 2
[15:32:19.164]  $ ...future.FUN:function (x)  
[15:32:19.164]  $ ...          : list()
[15:32:19.164]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:19.164]  - attr(*, "where")=List of 2
[15:32:19.164]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:19.164]   ..$ ...          :<environment: 0x00000276e017fe28> 
[15:32:19.164]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:19.164]  - attr(*, "resolved")= logi FALSE
[15:32:19.164]  - attr(*, "total_size")= num 848
[15:32:19.170] Packages to be attached in all futures: [n=0] 
[15:32:19.171] getGlobalsAndPackagesXApply() ... DONE
[15:32:19.171] Number of futures (= number of chunks): 1
[15:32:19.172] Launching 1 futures (chunks) ...
[15:32:19.172] Chunk #1 of 1 ...
[15:32:19.173]  - Finding globals in 'X' for chunk #1 ...
[15:32:19.173] getGlobalsAndPackages() ...
[15:32:19.173] Searching for globals...
[15:32:19.174] 
[15:32:19.174] Searching for globals ... DONE
[15:32:19.175] - globals: [0] <none>
[15:32:19.175] getGlobalsAndPackages() ... DONE
[15:32:19.175]    + additional globals found: [n=0] 
[15:32:19.175]    + additional namespaces needed: [n=0] 
[15:32:19.176]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:19.176]  - seeds: <none>
[15:32:19.176]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:19.177] getGlobalsAndPackages() ...
[15:32:19.177] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:19.177] Resolving globals: FALSE
[15:32:19.178] Tweak future expression to call with '...' arguments ...
[15:32:19.178] {
[15:32:19.178]     do.call(function(...) {
[15:32:19.178]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:19.178]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:19.178]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:19.178]             on.exit(options(oopts), add = TRUE)
[15:32:19.178]         }
[15:32:19.178]         {
[15:32:19.178]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:19.178]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:19.178]                 ...future.FUN(...future.X_jj, ...)
[15:32:19.178]             })
[15:32:19.178]         }
[15:32:19.178]     }, args = future.call.arguments)
[15:32:19.178] }
[15:32:19.179] Tweak future expression to call with '...' arguments ... DONE
[15:32:19.180] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:19.180] 
[15:32:19.181] getGlobalsAndPackages() ... DONE
[15:32:19.182] run() for 'Future' ...
[15:32:19.182] - state: 'created'
[15:32:19.183] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:19.184] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:19.184] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:19.185]   - Field: 'label'
[15:32:19.185]   - Field: 'local'
[15:32:19.185]   - Field: 'owner'
[15:32:19.186]   - Field: 'envir'
[15:32:19.186]   - Field: 'packages'
[15:32:19.186]   - Field: 'gc'
[15:32:19.187]   - Field: 'conditions'
[15:32:19.187]   - Field: 'expr'
[15:32:19.187]   - Field: 'uuid'
[15:32:19.187]   - Field: 'seed'
[15:32:19.188]   - Field: 'version'
[15:32:19.188]   - Field: 'result'
[15:32:19.188]   - Field: 'asynchronous'
[15:32:19.189]   - Field: 'calls'
[15:32:19.189]   - Field: 'globals'
[15:32:19.189]   - Field: 'stdout'
[15:32:19.190]   - Field: 'earlySignal'
[15:32:19.190]   - Field: 'lazy'
[15:32:19.190]   - Field: 'state'
[15:32:19.191] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:19.191] - Launch lazy future ...
[15:32:19.193] Packages needed by the future expression (n = 0): <none>
[15:32:19.193] Packages needed by future strategies (n = 0): <none>
[15:32:19.200] {
[15:32:19.200]     {
[15:32:19.200]         {
[15:32:19.200]             ...future.startTime <- base::Sys.time()
[15:32:19.200]             {
[15:32:19.200]                 {
[15:32:19.200]                   {
[15:32:19.200]                     base::local({
[15:32:19.200]                       has_future <- base::requireNamespace("future", 
[15:32:19.200]                         quietly = TRUE)
[15:32:19.200]                       if (has_future) {
[15:32:19.200]                         ns <- base::getNamespace("future")
[15:32:19.200]                         version <- ns[[".package"]][["version"]]
[15:32:19.200]                         if (is.null(version)) 
[15:32:19.200]                           version <- utils::packageVersion("future")
[15:32:19.200]                       }
[15:32:19.200]                       else {
[15:32:19.200]                         version <- NULL
[15:32:19.200]                       }
[15:32:19.200]                       if (!has_future || version < "1.8.0") {
[15:32:19.200]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:19.200]                           "", base::R.version$version.string), 
[15:32:19.200]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:19.200]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:19.200]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:19.200]                             "release", "version")], collapse = " "), 
[15:32:19.200]                           hostname = base::Sys.info()[["nodename"]])
[15:32:19.200]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:19.200]                           info)
[15:32:19.200]                         info <- base::paste(info, collapse = "; ")
[15:32:19.200]                         if (!has_future) {
[15:32:19.200]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:19.200]                             info)
[15:32:19.200]                         }
[15:32:19.200]                         else {
[15:32:19.200]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:19.200]                             info, version)
[15:32:19.200]                         }
[15:32:19.200]                         base::stop(msg)
[15:32:19.200]                       }
[15:32:19.200]                     })
[15:32:19.200]                   }
[15:32:19.200]                   ...future.strategy.old <- future::plan("list")
[15:32:19.200]                   options(future.plan = NULL)
[15:32:19.200]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:19.200]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:19.200]                 }
[15:32:19.200]                 ...future.workdir <- getwd()
[15:32:19.200]             }
[15:32:19.200]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:19.200]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:19.200]         }
[15:32:19.200]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:19.200]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:19.200]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:19.200]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:19.200]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:19.200]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:19.200]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:19.200]             base::names(...future.oldOptions))
[15:32:19.200]     }
[15:32:19.200]     if (FALSE) {
[15:32:19.200]     }
[15:32:19.200]     else {
[15:32:19.200]         if (TRUE) {
[15:32:19.200]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:19.200]                 open = "w")
[15:32:19.200]         }
[15:32:19.200]         else {
[15:32:19.200]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:19.200]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:19.200]         }
[15:32:19.200]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:19.200]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:19.200]             base::sink(type = "output", split = FALSE)
[15:32:19.200]             base::close(...future.stdout)
[15:32:19.200]         }, add = TRUE)
[15:32:19.200]     }
[15:32:19.200]     ...future.frame <- base::sys.nframe()
[15:32:19.200]     ...future.conditions <- base::list()
[15:32:19.200]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:19.200]     if (FALSE) {
[15:32:19.200]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:19.200]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:19.200]     }
[15:32:19.200]     ...future.result <- base::tryCatch({
[15:32:19.200]         base::withCallingHandlers({
[15:32:19.200]             ...future.value <- base::withVisible(base::local({
[15:32:19.200]                 do.call(function(...) {
[15:32:19.200]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:19.200]                   if (!identical(...future.globals.maxSize.org, 
[15:32:19.200]                     ...future.globals.maxSize)) {
[15:32:19.200]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:19.200]                     on.exit(options(oopts), add = TRUE)
[15:32:19.200]                   }
[15:32:19.200]                   {
[15:32:19.200]                     lapply(seq_along(...future.elements_ii), 
[15:32:19.200]                       FUN = function(jj) {
[15:32:19.200]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:19.200]                         ...future.FUN(...future.X_jj, ...)
[15:32:19.200]                       })
[15:32:19.200]                   }
[15:32:19.200]                 }, args = future.call.arguments)
[15:32:19.200]             }))
[15:32:19.200]             future::FutureResult(value = ...future.value$value, 
[15:32:19.200]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:19.200]                   ...future.rng), globalenv = if (FALSE) 
[15:32:19.200]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:19.200]                     ...future.globalenv.names))
[15:32:19.200]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:19.200]         }, condition = base::local({
[15:32:19.200]             c <- base::c
[15:32:19.200]             inherits <- base::inherits
[15:32:19.200]             invokeRestart <- base::invokeRestart
[15:32:19.200]             length <- base::length
[15:32:19.200]             list <- base::list
[15:32:19.200]             seq.int <- base::seq.int
[15:32:19.200]             signalCondition <- base::signalCondition
[15:32:19.200]             sys.calls <- base::sys.calls
[15:32:19.200]             `[[` <- base::`[[`
[15:32:19.200]             `+` <- base::`+`
[15:32:19.200]             `<<-` <- base::`<<-`
[15:32:19.200]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:19.200]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:19.200]                   3L)]
[15:32:19.200]             }
[15:32:19.200]             function(cond) {
[15:32:19.200]                 is_error <- inherits(cond, "error")
[15:32:19.200]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:19.200]                   NULL)
[15:32:19.200]                 if (is_error) {
[15:32:19.200]                   sessionInformation <- function() {
[15:32:19.200]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:19.200]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:19.200]                       search = base::search(), system = base::Sys.info())
[15:32:19.200]                   }
[15:32:19.200]                   ...future.conditions[[length(...future.conditions) + 
[15:32:19.200]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:19.200]                     cond$call), session = sessionInformation(), 
[15:32:19.200]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:19.200]                   signalCondition(cond)
[15:32:19.200]                 }
[15:32:19.200]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:19.200]                 "immediateCondition"))) {
[15:32:19.200]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:19.200]                   ...future.conditions[[length(...future.conditions) + 
[15:32:19.200]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:19.200]                   if (TRUE && !signal) {
[15:32:19.200]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:19.200]                     {
[15:32:19.200]                       inherits <- base::inherits
[15:32:19.200]                       invokeRestart <- base::invokeRestart
[15:32:19.200]                       is.null <- base::is.null
[15:32:19.200]                       muffled <- FALSE
[15:32:19.200]                       if (inherits(cond, "message")) {
[15:32:19.200]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:19.200]                         if (muffled) 
[15:32:19.200]                           invokeRestart("muffleMessage")
[15:32:19.200]                       }
[15:32:19.200]                       else if (inherits(cond, "warning")) {
[15:32:19.200]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:19.200]                         if (muffled) 
[15:32:19.200]                           invokeRestart("muffleWarning")
[15:32:19.200]                       }
[15:32:19.200]                       else if (inherits(cond, "condition")) {
[15:32:19.200]                         if (!is.null(pattern)) {
[15:32:19.200]                           computeRestarts <- base::computeRestarts
[15:32:19.200]                           grepl <- base::grepl
[15:32:19.200]                           restarts <- computeRestarts(cond)
[15:32:19.200]                           for (restart in restarts) {
[15:32:19.200]                             name <- restart$name
[15:32:19.200]                             if (is.null(name)) 
[15:32:19.200]                               next
[15:32:19.200]                             if (!grepl(pattern, name)) 
[15:32:19.200]                               next
[15:32:19.200]                             invokeRestart(restart)
[15:32:19.200]                             muffled <- TRUE
[15:32:19.200]                             break
[15:32:19.200]                           }
[15:32:19.200]                         }
[15:32:19.200]                       }
[15:32:19.200]                       invisible(muffled)
[15:32:19.200]                     }
[15:32:19.200]                     muffleCondition(cond, pattern = "^muffle")
[15:32:19.200]                   }
[15:32:19.200]                 }
[15:32:19.200]                 else {
[15:32:19.200]                   if (TRUE) {
[15:32:19.200]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:19.200]                     {
[15:32:19.200]                       inherits <- base::inherits
[15:32:19.200]                       invokeRestart <- base::invokeRestart
[15:32:19.200]                       is.null <- base::is.null
[15:32:19.200]                       muffled <- FALSE
[15:32:19.200]                       if (inherits(cond, "message")) {
[15:32:19.200]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:19.200]                         if (muffled) 
[15:32:19.200]                           invokeRestart("muffleMessage")
[15:32:19.200]                       }
[15:32:19.200]                       else if (inherits(cond, "warning")) {
[15:32:19.200]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:19.200]                         if (muffled) 
[15:32:19.200]                           invokeRestart("muffleWarning")
[15:32:19.200]                       }
[15:32:19.200]                       else if (inherits(cond, "condition")) {
[15:32:19.200]                         if (!is.null(pattern)) {
[15:32:19.200]                           computeRestarts <- base::computeRestarts
[15:32:19.200]                           grepl <- base::grepl
[15:32:19.200]                           restarts <- computeRestarts(cond)
[15:32:19.200]                           for (restart in restarts) {
[15:32:19.200]                             name <- restart$name
[15:32:19.200]                             if (is.null(name)) 
[15:32:19.200]                               next
[15:32:19.200]                             if (!grepl(pattern, name)) 
[15:32:19.200]                               next
[15:32:19.200]                             invokeRestart(restart)
[15:32:19.200]                             muffled <- TRUE
[15:32:19.200]                             break
[15:32:19.200]                           }
[15:32:19.200]                         }
[15:32:19.200]                       }
[15:32:19.200]                       invisible(muffled)
[15:32:19.200]                     }
[15:32:19.200]                     muffleCondition(cond, pattern = "^muffle")
[15:32:19.200]                   }
[15:32:19.200]                 }
[15:32:19.200]             }
[15:32:19.200]         }))
[15:32:19.200]     }, error = function(ex) {
[15:32:19.200]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:19.200]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:19.200]                 ...future.rng), started = ...future.startTime, 
[15:32:19.200]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:19.200]             version = "1.8"), class = "FutureResult")
[15:32:19.200]     }, finally = {
[15:32:19.200]         if (!identical(...future.workdir, getwd())) 
[15:32:19.200]             setwd(...future.workdir)
[15:32:19.200]         {
[15:32:19.200]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:19.200]                 ...future.oldOptions$nwarnings <- NULL
[15:32:19.200]             }
[15:32:19.200]             base::options(...future.oldOptions)
[15:32:19.200]             if (.Platform$OS.type == "windows") {
[15:32:19.200]                 old_names <- names(...future.oldEnvVars)
[15:32:19.200]                 envs <- base::Sys.getenv()
[15:32:19.200]                 names <- names(envs)
[15:32:19.200]                 common <- intersect(names, old_names)
[15:32:19.200]                 added <- setdiff(names, old_names)
[15:32:19.200]                 removed <- setdiff(old_names, names)
[15:32:19.200]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:19.200]                   envs[common]]
[15:32:19.200]                 NAMES <- toupper(changed)
[15:32:19.200]                 args <- list()
[15:32:19.200]                 for (kk in seq_along(NAMES)) {
[15:32:19.200]                   name <- changed[[kk]]
[15:32:19.200]                   NAME <- NAMES[[kk]]
[15:32:19.200]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:19.200]                     next
[15:32:19.200]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:19.200]                 }
[15:32:19.200]                 NAMES <- toupper(added)
[15:32:19.200]                 for (kk in seq_along(NAMES)) {
[15:32:19.200]                   name <- added[[kk]]
[15:32:19.200]                   NAME <- NAMES[[kk]]
[15:32:19.200]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:19.200]                     next
[15:32:19.200]                   args[[name]] <- ""
[15:32:19.200]                 }
[15:32:19.200]                 NAMES <- toupper(removed)
[15:32:19.200]                 for (kk in seq_along(NAMES)) {
[15:32:19.200]                   name <- removed[[kk]]
[15:32:19.200]                   NAME <- NAMES[[kk]]
[15:32:19.200]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:19.200]                     next
[15:32:19.200]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:19.200]                 }
[15:32:19.200]                 if (length(args) > 0) 
[15:32:19.200]                   base::do.call(base::Sys.setenv, args = args)
[15:32:19.200]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:19.200]             }
[15:32:19.200]             else {
[15:32:19.200]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:19.200]             }
[15:32:19.200]             {
[15:32:19.200]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:19.200]                   0L) {
[15:32:19.200]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:19.200]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:19.200]                   base::options(opts)
[15:32:19.200]                 }
[15:32:19.200]                 {
[15:32:19.200]                   {
[15:32:19.200]                     NULL
[15:32:19.200]                     RNGkind("Mersenne-Twister")
[15:32:19.200]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:19.200]                       inherits = FALSE)
[15:32:19.200]                   }
[15:32:19.200]                   options(future.plan = NULL)
[15:32:19.200]                   if (is.na(NA_character_)) 
[15:32:19.200]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:19.200]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:19.200]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:19.200]                     .init = FALSE)
[15:32:19.200]                 }
[15:32:19.200]             }
[15:32:19.200]         }
[15:32:19.200]     })
[15:32:19.200]     if (TRUE) {
[15:32:19.200]         base::sink(type = "output", split = FALSE)
[15:32:19.200]         if (TRUE) {
[15:32:19.200]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:19.200]         }
[15:32:19.200]         else {
[15:32:19.200]             ...future.result["stdout"] <- base::list(NULL)
[15:32:19.200]         }
[15:32:19.200]         base::close(...future.stdout)
[15:32:19.200]         ...future.stdout <- NULL
[15:32:19.200]     }
[15:32:19.200]     ...future.result$conditions <- ...future.conditions
[15:32:19.200]     ...future.result$finished <- base::Sys.time()
[15:32:19.200]     ...future.result
[15:32:19.200] }
[15:32:19.208] assign_globals() ...
[15:32:19.208] List of 5
[15:32:19.208]  $ ...future.FUN            :function (x)  
[15:32:19.208]  $ future.call.arguments    : list()
[15:32:19.208]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:19.208]  $ ...future.elements_ii    :List of 3
[15:32:19.208]   ..$ a: num 1
[15:32:19.208]   ..$ b: num 2
[15:32:19.208]   ..$ c: num 3
[15:32:19.208]  $ ...future.seeds_ii       : NULL
[15:32:19.208]  $ ...future.globals.maxSize: NULL
[15:32:19.208]  - attr(*, "where")=List of 5
[15:32:19.208]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:19.208]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:19.208]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:19.208]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:19.208]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:19.208]  - attr(*, "resolved")= logi FALSE
[15:32:19.208]  - attr(*, "total_size")= num 848
[15:32:19.208]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:19.208]  - attr(*, "already-done")= logi TRUE
[15:32:19.220] - copied '...future.FUN' to environment
[15:32:19.220] - copied 'future.call.arguments' to environment
[15:32:19.221] - copied '...future.elements_ii' to environment
[15:32:19.221] - copied '...future.seeds_ii' to environment
[15:32:19.221] - copied '...future.globals.maxSize' to environment
[15:32:19.222] assign_globals() ... done
[15:32:19.222] plan(): Setting new future strategy stack:
[15:32:19.223] List of future strategies:
[15:32:19.223] 1. sequential:
[15:32:19.223]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:19.223]    - tweaked: FALSE
[15:32:19.223]    - call: NULL
[15:32:19.224] plan(): nbrOfWorkers() = 1
[15:32:19.227] plan(): Setting new future strategy stack:
[15:32:19.228] List of future strategies:
[15:32:19.228] 1. sequential:
[15:32:19.228]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:19.228]    - tweaked: FALSE
[15:32:19.228]    - call: plan(strategy)
[15:32:19.229] plan(): nbrOfWorkers() = 1
[15:32:19.229] SequentialFuture started (and completed)
[15:32:19.230] - Launch lazy future ... done
[15:32:19.230] run() for 'SequentialFuture' ... done
[15:32:19.231] Created future:
[15:32:19.231] SequentialFuture:
[15:32:19.231] Label: 'future_sapply-1'
[15:32:19.231] Expression:
[15:32:19.231] {
[15:32:19.231]     do.call(function(...) {
[15:32:19.231]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:19.231]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:19.231]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:19.231]             on.exit(options(oopts), add = TRUE)
[15:32:19.231]         }
[15:32:19.231]         {
[15:32:19.231]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:19.231]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:19.231]                 ...future.FUN(...future.X_jj, ...)
[15:32:19.231]             })
[15:32:19.231]         }
[15:32:19.231]     }, args = future.call.arguments)
[15:32:19.231] }
[15:32:19.231] Lazy evaluation: FALSE
[15:32:19.231] Asynchronous evaluation: FALSE
[15:32:19.231] Local evaluation: TRUE
[15:32:19.231] Environment: R_GlobalEnv
[15:32:19.231] Capture standard output: TRUE
[15:32:19.231] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:19.231] Globals: 5 objects totaling 0.99 KiB (function '...future.FUN' of 848 bytes, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:19.231] Packages: <none>
[15:32:19.231] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:19.231] Resolved: TRUE
[15:32:19.231] Value: 168 bytes of class 'list'
[15:32:19.231] Early signaling: FALSE
[15:32:19.231] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:19.231] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:19.235] Chunk #1 of 1 ... DONE
[15:32:19.235] Launching 1 futures (chunks) ... DONE
[15:32:19.235] Resolving 1 futures (chunks) ...
[15:32:19.236] resolve() on list ...
[15:32:19.236]  recursive: 0
[15:32:19.236]  length: 1
[15:32:19.236] 
[15:32:19.237] resolved() for 'SequentialFuture' ...
[15:32:19.237] - state: 'finished'
[15:32:19.238] - run: TRUE
[15:32:19.238] - result: 'FutureResult'
[15:32:19.238] resolved() for 'SequentialFuture' ... done
[15:32:19.239] Future #1
[15:32:19.239] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:19.240] - nx: 1
[15:32:19.240] - relay: TRUE
[15:32:19.240] - stdout: TRUE
[15:32:19.241] - signal: TRUE
[15:32:19.241] - resignal: FALSE
[15:32:19.241] - force: TRUE
[15:32:19.241] - relayed: [n=1] FALSE
[15:32:19.242] - queued futures: [n=1] FALSE
[15:32:19.242]  - until=1
[15:32:19.242]  - relaying element #1
[15:32:19.243] - relayed: [n=1] TRUE
[15:32:19.243] - queued futures: [n=1] TRUE
[15:32:19.243] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:19.244]  length: 0 (resolved future 1)
[15:32:19.244] Relaying remaining futures
[15:32:19.244] signalConditionsASAP(NULL, pos=0) ...
[15:32:19.245] - nx: 1
[15:32:19.245] - relay: TRUE
[15:32:19.245] - stdout: TRUE
[15:32:19.245] - signal: TRUE
[15:32:19.246] - resignal: FALSE
[15:32:19.246] - force: TRUE
[15:32:19.246] - relayed: [n=1] TRUE
[15:32:19.247] - queued futures: [n=1] TRUE
 - flush all
[15:32:19.247] - relayed: [n=1] TRUE
[15:32:19.247] - queued futures: [n=1] TRUE
[15:32:19.248] signalConditionsASAP(NULL, pos=0) ... done
[15:32:19.248] resolve() on list ... DONE
[15:32:19.248]  - Number of value chunks collected: 1
[15:32:19.249] Resolving 1 futures (chunks) ... DONE
[15:32:19.249] Reducing values from 1 chunks ...
[15:32:19.249]  - Number of values collected after concatenation: 3
[15:32:19.250]  - Number of values expected: 3
[15:32:19.250] Reducing values from 1 chunks ... DONE
[15:32:19.250] future_lapply() ... DONE
List of 2
 $ y0:List of 3
  ..$ a: num 1
  ..$ b: num 2
  ..$ c: num 3
 $ y1:List of 3
  ..$ a: num 1
  ..$ b: num 2
  ..$ c: num 3
List of 2
 $ y0:List of 3
  ..$ a: num 1
  ..$ b: num 2
  ..$ c: num 3
 $ y2:List of 3
  ..$ a: num 1
  ..$ b: num 2
  ..$ c: num 3
[15:32:19.265] future_lapply() ...
[15:32:19.267] Number of chunks: 1
[15:32:19.267] getGlobalsAndPackagesXApply() ...
[15:32:19.267]  - future.globals: TRUE
[15:32:19.267] getGlobalsAndPackages() ...
[15:32:19.268] Searching for globals...
[15:32:19.270] - globals found: [2] 'FUN', 'UseMethod'
[15:32:19.270] Searching for globals ... DONE
[15:32:19.271] Resolving globals: FALSE
[15:32:19.271] The total size of the 1 globals is 1.22 KiB (1248 bytes)
[15:32:19.272] The total size of the 1 globals exported for future expression ('FUN()') is 1.22 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.22 KiB of class 'function')
[15:32:19.272] - globals: [1] 'FUN'
[15:32:19.273] 
[15:32:19.273] getGlobalsAndPackages() ... DONE
[15:32:19.273]  - globals found/used: [n=1] 'FUN'
[15:32:19.274]  - needed namespaces: [n=0] 
[15:32:19.274] Finding globals ... DONE
[15:32:19.274]  - use_args: TRUE
[15:32:19.275]  - Getting '...' globals ...
[15:32:19.275] resolve() on list ...
[15:32:19.276]  recursive: 0
[15:32:19.276]  length: 1
[15:32:19.276]  elements: '...'
[15:32:19.277]  length: 0 (resolved future 1)
[15:32:19.277] resolve() on list ... DONE
[15:32:19.277]    - '...' content: [n=0] 
[15:32:19.278] List of 1
[15:32:19.278]  $ ...: list()
[15:32:19.278]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:19.278]  - attr(*, "where")=List of 1
[15:32:19.278]   ..$ ...:<environment: 0x00000276defad760> 
[15:32:19.278]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:19.278]  - attr(*, "resolved")= logi TRUE
[15:32:19.278]  - attr(*, "total_size")= num NA
[15:32:19.284]  - Getting '...' globals ... DONE
[15:32:19.284] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:19.285] List of 2
[15:32:19.285]  $ ...future.FUN:function (x, ...)  
[15:32:19.285]  $ ...          : list()
[15:32:19.285]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:19.285]  - attr(*, "where")=List of 2
[15:32:19.285]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:19.285]   ..$ ...          :<environment: 0x00000276defad760> 
[15:32:19.285]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:19.285]  - attr(*, "resolved")= logi FALSE
[15:32:19.285]  - attr(*, "total_size")= num 1248
[15:32:19.291] Packages to be attached in all futures: [n=0] 
[15:32:19.291] getGlobalsAndPackagesXApply() ... DONE
[15:32:19.292] Number of futures (= number of chunks): 1
[15:32:19.292] Launching 1 futures (chunks) ...
[15:32:19.293] Chunk #1 of 1 ...
[15:32:19.293]  - Finding globals in 'X' for chunk #1 ...
[15:32:19.293] getGlobalsAndPackages() ...
[15:32:19.294] Searching for globals...
[15:32:19.294] 
[15:32:19.295] Searching for globals ... DONE
[15:32:19.295] - globals: [0] <none>
[15:32:19.295] getGlobalsAndPackages() ... DONE
[15:32:19.295]    + additional globals found: [n=0] 
[15:32:19.296]    + additional namespaces needed: [n=0] 
[15:32:19.296]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:19.296]  - seeds: <none>
[15:32:19.297]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:19.297] getGlobalsAndPackages() ...
[15:32:19.297] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:19.298] Resolving globals: FALSE
[15:32:19.298] Tweak future expression to call with '...' arguments ...
[15:32:19.298] {
[15:32:19.298]     do.call(function(...) {
[15:32:19.298]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:19.298]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:19.298]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:19.298]             on.exit(options(oopts), add = TRUE)
[15:32:19.298]         }
[15:32:19.298]         {
[15:32:19.298]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:19.298]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:19.298]                 ...future.FUN(...future.X_jj, ...)
[15:32:19.298]             })
[15:32:19.298]         }
[15:32:19.298]     }, args = future.call.arguments)
[15:32:19.298] }
[15:32:19.299] Tweak future expression to call with '...' arguments ... DONE
[15:32:19.300] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:19.301] 
[15:32:19.301] getGlobalsAndPackages() ... DONE
[15:32:19.302] run() for 'Future' ...
[15:32:19.302] - state: 'created'
[15:32:19.302] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:19.303] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:19.304] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:19.304]   - Field: 'label'
[15:32:19.304]   - Field: 'local'
[15:32:19.305]   - Field: 'owner'
[15:32:19.305]   - Field: 'envir'
[15:32:19.305]   - Field: 'packages'
[15:32:19.306]   - Field: 'gc'
[15:32:19.306]   - Field: 'conditions'
[15:32:19.306]   - Field: 'expr'
[15:32:19.307]   - Field: 'uuid'
[15:32:19.307]   - Field: 'seed'
[15:32:19.307]   - Field: 'version'
[15:32:19.308]   - Field: 'result'
[15:32:19.308]   - Field: 'asynchronous'
[15:32:19.308]   - Field: 'calls'
[15:32:19.309]   - Field: 'globals'
[15:32:19.309]   - Field: 'stdout'
[15:32:19.309]   - Field: 'earlySignal'
[15:32:19.310]   - Field: 'lazy'
[15:32:19.310]   - Field: 'state'
[15:32:19.310] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:19.311] - Launch lazy future ...
[15:32:19.314] Packages needed by the future expression (n = 0): <none>
[15:32:19.315] Packages needed by future strategies (n = 0): <none>
[15:32:19.315] {
[15:32:19.315]     {
[15:32:19.315]         {
[15:32:19.315]             ...future.startTime <- base::Sys.time()
[15:32:19.315]             {
[15:32:19.315]                 {
[15:32:19.315]                   {
[15:32:19.315]                     base::local({
[15:32:19.315]                       has_future <- base::requireNamespace("future", 
[15:32:19.315]                         quietly = TRUE)
[15:32:19.315]                       if (has_future) {
[15:32:19.315]                         ns <- base::getNamespace("future")
[15:32:19.315]                         version <- ns[[".package"]][["version"]]
[15:32:19.315]                         if (is.null(version)) 
[15:32:19.315]                           version <- utils::packageVersion("future")
[15:32:19.315]                       }
[15:32:19.315]                       else {
[15:32:19.315]                         version <- NULL
[15:32:19.315]                       }
[15:32:19.315]                       if (!has_future || version < "1.8.0") {
[15:32:19.315]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:19.315]                           "", base::R.version$version.string), 
[15:32:19.315]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:19.315]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:19.315]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:19.315]                             "release", "version")], collapse = " "), 
[15:32:19.315]                           hostname = base::Sys.info()[["nodename"]])
[15:32:19.315]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:19.315]                           info)
[15:32:19.315]                         info <- base::paste(info, collapse = "; ")
[15:32:19.315]                         if (!has_future) {
[15:32:19.315]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:19.315]                             info)
[15:32:19.315]                         }
[15:32:19.315]                         else {
[15:32:19.315]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:19.315]                             info, version)
[15:32:19.315]                         }
[15:32:19.315]                         base::stop(msg)
[15:32:19.315]                       }
[15:32:19.315]                     })
[15:32:19.315]                   }
[15:32:19.315]                   ...future.strategy.old <- future::plan("list")
[15:32:19.315]                   options(future.plan = NULL)
[15:32:19.315]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:19.315]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:19.315]                 }
[15:32:19.315]                 ...future.workdir <- getwd()
[15:32:19.315]             }
[15:32:19.315]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:19.315]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:19.315]         }
[15:32:19.315]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:19.315]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:19.315]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:19.315]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:19.315]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:19.315]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:19.315]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:19.315]             base::names(...future.oldOptions))
[15:32:19.315]     }
[15:32:19.315]     if (FALSE) {
[15:32:19.315]     }
[15:32:19.315]     else {
[15:32:19.315]         if (TRUE) {
[15:32:19.315]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:19.315]                 open = "w")
[15:32:19.315]         }
[15:32:19.315]         else {
[15:32:19.315]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:19.315]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:19.315]         }
[15:32:19.315]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:19.315]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:19.315]             base::sink(type = "output", split = FALSE)
[15:32:19.315]             base::close(...future.stdout)
[15:32:19.315]         }, add = TRUE)
[15:32:19.315]     }
[15:32:19.315]     ...future.frame <- base::sys.nframe()
[15:32:19.315]     ...future.conditions <- base::list()
[15:32:19.315]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:19.315]     if (FALSE) {
[15:32:19.315]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:19.315]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:19.315]     }
[15:32:19.315]     ...future.result <- base::tryCatch({
[15:32:19.315]         base::withCallingHandlers({
[15:32:19.315]             ...future.value <- base::withVisible(base::local({
[15:32:19.315]                 do.call(function(...) {
[15:32:19.315]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:19.315]                   if (!identical(...future.globals.maxSize.org, 
[15:32:19.315]                     ...future.globals.maxSize)) {
[15:32:19.315]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:19.315]                     on.exit(options(oopts), add = TRUE)
[15:32:19.315]                   }
[15:32:19.315]                   {
[15:32:19.315]                     lapply(seq_along(...future.elements_ii), 
[15:32:19.315]                       FUN = function(jj) {
[15:32:19.315]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:19.315]                         ...future.FUN(...future.X_jj, ...)
[15:32:19.315]                       })
[15:32:19.315]                   }
[15:32:19.315]                 }, args = future.call.arguments)
[15:32:19.315]             }))
[15:32:19.315]             future::FutureResult(value = ...future.value$value, 
[15:32:19.315]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:19.315]                   ...future.rng), globalenv = if (FALSE) 
[15:32:19.315]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:19.315]                     ...future.globalenv.names))
[15:32:19.315]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:19.315]         }, condition = base::local({
[15:32:19.315]             c <- base::c
[15:32:19.315]             inherits <- base::inherits
[15:32:19.315]             invokeRestart <- base::invokeRestart
[15:32:19.315]             length <- base::length
[15:32:19.315]             list <- base::list
[15:32:19.315]             seq.int <- base::seq.int
[15:32:19.315]             signalCondition <- base::signalCondition
[15:32:19.315]             sys.calls <- base::sys.calls
[15:32:19.315]             `[[` <- base::`[[`
[15:32:19.315]             `+` <- base::`+`
[15:32:19.315]             `<<-` <- base::`<<-`
[15:32:19.315]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:19.315]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:19.315]                   3L)]
[15:32:19.315]             }
[15:32:19.315]             function(cond) {
[15:32:19.315]                 is_error <- inherits(cond, "error")
[15:32:19.315]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:19.315]                   NULL)
[15:32:19.315]                 if (is_error) {
[15:32:19.315]                   sessionInformation <- function() {
[15:32:19.315]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:19.315]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:19.315]                       search = base::search(), system = base::Sys.info())
[15:32:19.315]                   }
[15:32:19.315]                   ...future.conditions[[length(...future.conditions) + 
[15:32:19.315]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:19.315]                     cond$call), session = sessionInformation(), 
[15:32:19.315]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:19.315]                   signalCondition(cond)
[15:32:19.315]                 }
[15:32:19.315]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:19.315]                 "immediateCondition"))) {
[15:32:19.315]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:19.315]                   ...future.conditions[[length(...future.conditions) + 
[15:32:19.315]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:19.315]                   if (TRUE && !signal) {
[15:32:19.315]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:19.315]                     {
[15:32:19.315]                       inherits <- base::inherits
[15:32:19.315]                       invokeRestart <- base::invokeRestart
[15:32:19.315]                       is.null <- base::is.null
[15:32:19.315]                       muffled <- FALSE
[15:32:19.315]                       if (inherits(cond, "message")) {
[15:32:19.315]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:19.315]                         if (muffled) 
[15:32:19.315]                           invokeRestart("muffleMessage")
[15:32:19.315]                       }
[15:32:19.315]                       else if (inherits(cond, "warning")) {
[15:32:19.315]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:19.315]                         if (muffled) 
[15:32:19.315]                           invokeRestart("muffleWarning")
[15:32:19.315]                       }
[15:32:19.315]                       else if (inherits(cond, "condition")) {
[15:32:19.315]                         if (!is.null(pattern)) {
[15:32:19.315]                           computeRestarts <- base::computeRestarts
[15:32:19.315]                           grepl <- base::grepl
[15:32:19.315]                           restarts <- computeRestarts(cond)
[15:32:19.315]                           for (restart in restarts) {
[15:32:19.315]                             name <- restart$name
[15:32:19.315]                             if (is.null(name)) 
[15:32:19.315]                               next
[15:32:19.315]                             if (!grepl(pattern, name)) 
[15:32:19.315]                               next
[15:32:19.315]                             invokeRestart(restart)
[15:32:19.315]                             muffled <- TRUE
[15:32:19.315]                             break
[15:32:19.315]                           }
[15:32:19.315]                         }
[15:32:19.315]                       }
[15:32:19.315]                       invisible(muffled)
[15:32:19.315]                     }
[15:32:19.315]                     muffleCondition(cond, pattern = "^muffle")
[15:32:19.315]                   }
[15:32:19.315]                 }
[15:32:19.315]                 else {
[15:32:19.315]                   if (TRUE) {
[15:32:19.315]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:19.315]                     {
[15:32:19.315]                       inherits <- base::inherits
[15:32:19.315]                       invokeRestart <- base::invokeRestart
[15:32:19.315]                       is.null <- base::is.null
[15:32:19.315]                       muffled <- FALSE
[15:32:19.315]                       if (inherits(cond, "message")) {
[15:32:19.315]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:19.315]                         if (muffled) 
[15:32:19.315]                           invokeRestart("muffleMessage")
[15:32:19.315]                       }
[15:32:19.315]                       else if (inherits(cond, "warning")) {
[15:32:19.315]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:19.315]                         if (muffled) 
[15:32:19.315]                           invokeRestart("muffleWarning")
[15:32:19.315]                       }
[15:32:19.315]                       else if (inherits(cond, "condition")) {
[15:32:19.315]                         if (!is.null(pattern)) {
[15:32:19.315]                           computeRestarts <- base::computeRestarts
[15:32:19.315]                           grepl <- base::grepl
[15:32:19.315]                           restarts <- computeRestarts(cond)
[15:32:19.315]                           for (restart in restarts) {
[15:32:19.315]                             name <- restart$name
[15:32:19.315]                             if (is.null(name)) 
[15:32:19.315]                               next
[15:32:19.315]                             if (!grepl(pattern, name)) 
[15:32:19.315]                               next
[15:32:19.315]                             invokeRestart(restart)
[15:32:19.315]                             muffled <- TRUE
[15:32:19.315]                             break
[15:32:19.315]                           }
[15:32:19.315]                         }
[15:32:19.315]                       }
[15:32:19.315]                       invisible(muffled)
[15:32:19.315]                     }
[15:32:19.315]                     muffleCondition(cond, pattern = "^muffle")
[15:32:19.315]                   }
[15:32:19.315]                 }
[15:32:19.315]             }
[15:32:19.315]         }))
[15:32:19.315]     }, error = function(ex) {
[15:32:19.315]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:19.315]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:19.315]                 ...future.rng), started = ...future.startTime, 
[15:32:19.315]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:19.315]             version = "1.8"), class = "FutureResult")
[15:32:19.315]     }, finally = {
[15:32:19.315]         if (!identical(...future.workdir, getwd())) 
[15:32:19.315]             setwd(...future.workdir)
[15:32:19.315]         {
[15:32:19.315]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:19.315]                 ...future.oldOptions$nwarnings <- NULL
[15:32:19.315]             }
[15:32:19.315]             base::options(...future.oldOptions)
[15:32:19.315]             if (.Platform$OS.type == "windows") {
[15:32:19.315]                 old_names <- names(...future.oldEnvVars)
[15:32:19.315]                 envs <- base::Sys.getenv()
[15:32:19.315]                 names <- names(envs)
[15:32:19.315]                 common <- intersect(names, old_names)
[15:32:19.315]                 added <- setdiff(names, old_names)
[15:32:19.315]                 removed <- setdiff(old_names, names)
[15:32:19.315]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:19.315]                   envs[common]]
[15:32:19.315]                 NAMES <- toupper(changed)
[15:32:19.315]                 args <- list()
[15:32:19.315]                 for (kk in seq_along(NAMES)) {
[15:32:19.315]                   name <- changed[[kk]]
[15:32:19.315]                   NAME <- NAMES[[kk]]
[15:32:19.315]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:19.315]                     next
[15:32:19.315]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:19.315]                 }
[15:32:19.315]                 NAMES <- toupper(added)
[15:32:19.315]                 for (kk in seq_along(NAMES)) {
[15:32:19.315]                   name <- added[[kk]]
[15:32:19.315]                   NAME <- NAMES[[kk]]
[15:32:19.315]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:19.315]                     next
[15:32:19.315]                   args[[name]] <- ""
[15:32:19.315]                 }
[15:32:19.315]                 NAMES <- toupper(removed)
[15:32:19.315]                 for (kk in seq_along(NAMES)) {
[15:32:19.315]                   name <- removed[[kk]]
[15:32:19.315]                   NAME <- NAMES[[kk]]
[15:32:19.315]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:19.315]                     next
[15:32:19.315]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:19.315]                 }
[15:32:19.315]                 if (length(args) > 0) 
[15:32:19.315]                   base::do.call(base::Sys.setenv, args = args)
[15:32:19.315]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:19.315]             }
[15:32:19.315]             else {
[15:32:19.315]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:19.315]             }
[15:32:19.315]             {
[15:32:19.315]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:19.315]                   0L) {
[15:32:19.315]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:19.315]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:19.315]                   base::options(opts)
[15:32:19.315]                 }
[15:32:19.315]                 {
[15:32:19.315]                   {
[15:32:19.315]                     NULL
[15:32:19.315]                     RNGkind("Mersenne-Twister")
[15:32:19.315]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:19.315]                       inherits = FALSE)
[15:32:19.315]                   }
[15:32:19.315]                   options(future.plan = NULL)
[15:32:19.315]                   if (is.na(NA_character_)) 
[15:32:19.315]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:19.315]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:19.315]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:19.315]                     .init = FALSE)
[15:32:19.315]                 }
[15:32:19.315]             }
[15:32:19.315]         }
[15:32:19.315]     })
[15:32:19.315]     if (TRUE) {
[15:32:19.315]         base::sink(type = "output", split = FALSE)
[15:32:19.315]         if (TRUE) {
[15:32:19.315]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:19.315]         }
[15:32:19.315]         else {
[15:32:19.315]             ...future.result["stdout"] <- base::list(NULL)
[15:32:19.315]         }
[15:32:19.315]         base::close(...future.stdout)
[15:32:19.315]         ...future.stdout <- NULL
[15:32:19.315]     }
[15:32:19.315]     ...future.result$conditions <- ...future.conditions
[15:32:19.315]     ...future.result$finished <- base::Sys.time()
[15:32:19.315]     ...future.result
[15:32:19.315] }
[15:32:19.322] assign_globals() ...
[15:32:19.322] List of 5
[15:32:19.322]  $ ...future.FUN            :function (x, ...)  
[15:32:19.322]  $ future.call.arguments    : list()
[15:32:19.322]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:19.322]  $ ...future.elements_ii    :List of 3
[15:32:19.322]   ..$ a: num 1
[15:32:19.322]   ..$ b: num 2
[15:32:19.322]   ..$ c: num 3
[15:32:19.322]  $ ...future.seeds_ii       : NULL
[15:32:19.322]  $ ...future.globals.maxSize: NULL
[15:32:19.322]  - attr(*, "where")=List of 5
[15:32:19.322]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:19.322]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:19.322]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:19.322]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:19.322]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:19.322]  - attr(*, "resolved")= logi FALSE
[15:32:19.322]  - attr(*, "total_size")= num 1248
[15:32:19.322]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:19.322]  - attr(*, "already-done")= logi TRUE
[15:32:19.333] - copied '...future.FUN' to environment
[15:32:19.333] - copied 'future.call.arguments' to environment
[15:32:19.334] - copied '...future.elements_ii' to environment
[15:32:19.334] - copied '...future.seeds_ii' to environment
[15:32:19.334] - copied '...future.globals.maxSize' to environment
[15:32:19.334] assign_globals() ... done
[15:32:19.335] plan(): Setting new future strategy stack:
[15:32:19.335] List of future strategies:
[15:32:19.335] 1. sequential:
[15:32:19.335]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:19.335]    - tweaked: FALSE
[15:32:19.335]    - call: NULL
[15:32:19.336] plan(): nbrOfWorkers() = 1
[15:32:19.338] plan(): Setting new future strategy stack:
[15:32:19.339] List of future strategies:
[15:32:19.339] 1. sequential:
[15:32:19.339]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:19.339]    - tweaked: FALSE
[15:32:19.339]    - call: plan(strategy)
[15:32:19.340] plan(): nbrOfWorkers() = 1
[15:32:19.340] SequentialFuture started (and completed)
[15:32:19.340] - Launch lazy future ... done
[15:32:19.341] run() for 'SequentialFuture' ... done
[15:32:19.341] Created future:
[15:32:19.341] SequentialFuture:
[15:32:19.341] Label: 'future_sapply-1'
[15:32:19.341] Expression:
[15:32:19.341] {
[15:32:19.341]     do.call(function(...) {
[15:32:19.341]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:19.341]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:19.341]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:19.341]             on.exit(options(oopts), add = TRUE)
[15:32:19.341]         }
[15:32:19.341]         {
[15:32:19.341]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:19.341]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:19.341]                 ...future.FUN(...future.X_jj, ...)
[15:32:19.341]             })
[15:32:19.341]         }
[15:32:19.341]     }, args = future.call.arguments)
[15:32:19.341] }
[15:32:19.341] Lazy evaluation: FALSE
[15:32:19.341] Asynchronous evaluation: FALSE
[15:32:19.341] Local evaluation: TRUE
[15:32:19.341] Environment: R_GlobalEnv
[15:32:19.341] Capture standard output: TRUE
[15:32:19.341] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:19.341] Globals: 5 objects totaling 1.38 KiB (function '...future.FUN' of 1.22 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:19.341] Packages: <none>
[15:32:19.341] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:19.341] Resolved: TRUE
[15:32:19.341] Value: 672 bytes of class 'list'
[15:32:19.341] Early signaling: FALSE
[15:32:19.341] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:19.341] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:19.344] Chunk #1 of 1 ... DONE
[15:32:19.344] Launching 1 futures (chunks) ... DONE
[15:32:19.344] Resolving 1 futures (chunks) ...
[15:32:19.344] resolve() on list ...
[15:32:19.345]  recursive: 0
[15:32:19.345]  length: 1
[15:32:19.345] 
[15:32:19.346] resolved() for 'SequentialFuture' ...
[15:32:19.346] - state: 'finished'
[15:32:19.346] - run: TRUE
[15:32:19.346] - result: 'FutureResult'
[15:32:19.347] resolved() for 'SequentialFuture' ... done
[15:32:19.347] Future #1
[15:32:19.347] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:19.348] - nx: 1
[15:32:19.348] - relay: TRUE
[15:32:19.348] - stdout: TRUE
[15:32:19.348] - signal: TRUE
[15:32:19.349] - resignal: FALSE
[15:32:19.349] - force: TRUE
[15:32:19.349] - relayed: [n=1] FALSE
[15:32:19.349] - queued futures: [n=1] FALSE
[15:32:19.350]  - until=1
[15:32:19.350]  - relaying element #1
[15:32:19.351] - relayed: [n=1] TRUE
[15:32:19.351] - queued futures: [n=1] TRUE
[15:32:19.351] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:19.351]  length: 0 (resolved future 1)
[15:32:19.352] Relaying remaining futures
[15:32:19.352] signalConditionsASAP(NULL, pos=0) ...
[15:32:19.352] - nx: 1
[15:32:19.352] - relay: TRUE
[15:32:19.353] - stdout: TRUE
[15:32:19.353] - signal: TRUE
[15:32:19.353] - resignal: FALSE
[15:32:19.353] - force: TRUE
[15:32:19.354] - relayed: [n=1] TRUE
[15:32:19.354] - queued futures: [n=1] TRUE
 - flush all
[15:32:19.354] - relayed: [n=1] TRUE
[15:32:19.355] - queued futures: [n=1] TRUE
[15:32:19.355] signalConditionsASAP(NULL, pos=0) ... done
[15:32:19.355] resolve() on list ... DONE
[15:32:19.356]  - Number of value chunks collected: 1
[15:32:19.356] Resolving 1 futures (chunks) ... DONE
[15:32:19.356] Reducing values from 1 chunks ...
[15:32:19.356]  - Number of values collected after concatenation: 3
[15:32:19.357]  - Number of values expected: 3
[15:32:19.357] Reducing values from 1 chunks ... DONE
[15:32:19.357] future_lapply() ... DONE
List of 2
 $ y0:List of 3
  ..$ a: num [1, 1] 1
  ..$ b: num [1, 1] 2
  ..$ c: num [1, 1] 3
 $ y1:List of 3
  ..$ a: num [1, 1] 1
  ..$ b: num [1, 1] 2
  ..$ c: num [1, 1] 3
List of 2
 $ y0:List of 3
  ..$ a: num [1, 1] 1
  ..$ b: num [1, 1] 2
  ..$ c: num [1, 1] 3
 $ y2:List of 3
  ..$ a: num [1, 1] 1
  ..$ b: num [1, 1] 2
  ..$ c: num [1, 1] 3
[15:32:19.374] future_lapply() ...
[15:32:19.379] Number of chunks: 1
[15:32:19.379] getGlobalsAndPackagesXApply() ...
[15:32:19.380]  - future.globals: TRUE
[15:32:19.380] getGlobalsAndPackages() ...
[15:32:19.380] Searching for globals...
[15:32:19.383] - globals found: [5] 'FUN', '*', ':', 'outer', 'rep'
[15:32:19.384] Searching for globals ... DONE
[15:32:19.384] Resolving globals: FALSE
[15:32:19.385] The total size of the 1 globals is 4.62 KiB (4728 bytes)
[15:32:19.385] The total size of the 1 globals exported for future expression ('FUN()') is 4.62 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.62 KiB of class 'function')
[15:32:19.386] - globals: [1] 'FUN'
[15:32:19.386] 
[15:32:19.386] getGlobalsAndPackages() ... DONE
[15:32:19.387]  - globals found/used: [n=1] 'FUN'
[15:32:19.387]  - needed namespaces: [n=0] 
[15:32:19.387] Finding globals ... DONE
[15:32:19.387]  - use_args: TRUE
[15:32:19.388]  - Getting '...' globals ...
[15:32:19.388] resolve() on list ...
[15:32:19.389]  recursive: 0
[15:32:19.389]  length: 1
[15:32:19.389]  elements: '...'
[15:32:19.389]  length: 0 (resolved future 1)
[15:32:19.390] resolve() on list ... DONE
[15:32:19.390]    - '...' content: [n=0] 
[15:32:19.390] List of 1
[15:32:19.390]  $ ...: list()
[15:32:19.390]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:19.390]  - attr(*, "where")=List of 1
[15:32:19.390]   ..$ ...:<environment: 0x00000276e067ff48> 
[15:32:19.390]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:19.390]  - attr(*, "resolved")= logi TRUE
[15:32:19.390]  - attr(*, "total_size")= num NA
[15:32:19.395]  - Getting '...' globals ... DONE
[15:32:19.395] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:19.395] List of 2
[15:32:19.395]  $ ...future.FUN:function (x, y = 2 * 1:5)  
[15:32:19.395]  $ ...          : list()
[15:32:19.395]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:19.395]  - attr(*, "where")=List of 2
[15:32:19.395]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:19.395]   ..$ ...          :<environment: 0x00000276e067ff48> 
[15:32:19.395]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:19.395]  - attr(*, "resolved")= logi FALSE
[15:32:19.395]  - attr(*, "total_size")= num 4728
[15:32:19.399] Packages to be attached in all futures: [n=0] 
[15:32:19.401] getGlobalsAndPackagesXApply() ... DONE
[15:32:19.401] Number of futures (= number of chunks): 1
[15:32:19.401] Launching 1 futures (chunks) ...
[15:32:19.402] Chunk #1 of 1 ...
[15:32:19.402]  - Finding globals in 'X' for chunk #1 ...
[15:32:19.402] getGlobalsAndPackages() ...
[15:32:19.402] Searching for globals...
[15:32:19.403] 
[15:32:19.403] Searching for globals ... DONE
[15:32:19.403] - globals: [0] <none>
[15:32:19.403] getGlobalsAndPackages() ... DONE
[15:32:19.403]    + additional globals found: [n=0] 
[15:32:19.403]    + additional namespaces needed: [n=0] 
[15:32:19.404]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:19.404]  - seeds: <none>
[15:32:19.404]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:19.404] getGlobalsAndPackages() ...
[15:32:19.404] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:19.405] Resolving globals: FALSE
[15:32:19.405] Tweak future expression to call with '...' arguments ...
[15:32:19.405] {
[15:32:19.405]     do.call(function(...) {
[15:32:19.405]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:19.405]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:19.405]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:19.405]             on.exit(options(oopts), add = TRUE)
[15:32:19.405]         }
[15:32:19.405]         {
[15:32:19.405]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:19.405]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:19.405]                 ...future.FUN(...future.X_jj, ...)
[15:32:19.405]             })
[15:32:19.405]         }
[15:32:19.405]     }, args = future.call.arguments)
[15:32:19.405] }
[15:32:19.405] Tweak future expression to call with '...' arguments ... DONE
[15:32:19.406] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:19.406] 
[15:32:19.406] getGlobalsAndPackages() ... DONE
[15:32:19.407] run() for 'Future' ...
[15:32:19.407] - state: 'created'
[15:32:19.407] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:19.408] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:19.408] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:19.408]   - Field: 'label'
[15:32:19.409]   - Field: 'local'
[15:32:19.409]   - Field: 'owner'
[15:32:19.409]   - Field: 'envir'
[15:32:19.409]   - Field: 'packages'
[15:32:19.409]   - Field: 'gc'
[15:32:19.409]   - Field: 'conditions'
[15:32:19.410]   - Field: 'expr'
[15:32:19.410]   - Field: 'uuid'
[15:32:19.410]   - Field: 'seed'
[15:32:19.410]   - Field: 'version'
[15:32:19.410]   - Field: 'result'
[15:32:19.411]   - Field: 'asynchronous'
[15:32:19.411]   - Field: 'calls'
[15:32:19.411]   - Field: 'globals'
[15:32:19.411]   - Field: 'stdout'
[15:32:19.411]   - Field: 'earlySignal'
[15:32:19.411]   - Field: 'lazy'
[15:32:19.412]   - Field: 'state'
[15:32:19.412] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:19.412] - Launch lazy future ...
[15:32:19.412] Packages needed by the future expression (n = 0): <none>
[15:32:19.413] Packages needed by future strategies (n = 0): <none>
[15:32:19.413] {
[15:32:19.413]     {
[15:32:19.413]         {
[15:32:19.413]             ...future.startTime <- base::Sys.time()
[15:32:19.413]             {
[15:32:19.413]                 {
[15:32:19.413]                   {
[15:32:19.413]                     base::local({
[15:32:19.413]                       has_future <- base::requireNamespace("future", 
[15:32:19.413]                         quietly = TRUE)
[15:32:19.413]                       if (has_future) {
[15:32:19.413]                         ns <- base::getNamespace("future")
[15:32:19.413]                         version <- ns[[".package"]][["version"]]
[15:32:19.413]                         if (is.null(version)) 
[15:32:19.413]                           version <- utils::packageVersion("future")
[15:32:19.413]                       }
[15:32:19.413]                       else {
[15:32:19.413]                         version <- NULL
[15:32:19.413]                       }
[15:32:19.413]                       if (!has_future || version < "1.8.0") {
[15:32:19.413]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:19.413]                           "", base::R.version$version.string), 
[15:32:19.413]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:19.413]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:19.413]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:19.413]                             "release", "version")], collapse = " "), 
[15:32:19.413]                           hostname = base::Sys.info()[["nodename"]])
[15:32:19.413]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:19.413]                           info)
[15:32:19.413]                         info <- base::paste(info, collapse = "; ")
[15:32:19.413]                         if (!has_future) {
[15:32:19.413]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:19.413]                             info)
[15:32:19.413]                         }
[15:32:19.413]                         else {
[15:32:19.413]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:19.413]                             info, version)
[15:32:19.413]                         }
[15:32:19.413]                         base::stop(msg)
[15:32:19.413]                       }
[15:32:19.413]                     })
[15:32:19.413]                   }
[15:32:19.413]                   ...future.strategy.old <- future::plan("list")
[15:32:19.413]                   options(future.plan = NULL)
[15:32:19.413]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:19.413]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:19.413]                 }
[15:32:19.413]                 ...future.workdir <- getwd()
[15:32:19.413]             }
[15:32:19.413]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:19.413]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:19.413]         }
[15:32:19.413]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:19.413]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:19.413]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:19.413]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:19.413]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:19.413]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:19.413]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:19.413]             base::names(...future.oldOptions))
[15:32:19.413]     }
[15:32:19.413]     if (FALSE) {
[15:32:19.413]     }
[15:32:19.413]     else {
[15:32:19.413]         if (TRUE) {
[15:32:19.413]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:19.413]                 open = "w")
[15:32:19.413]         }
[15:32:19.413]         else {
[15:32:19.413]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:19.413]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:19.413]         }
[15:32:19.413]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:19.413]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:19.413]             base::sink(type = "output", split = FALSE)
[15:32:19.413]             base::close(...future.stdout)
[15:32:19.413]         }, add = TRUE)
[15:32:19.413]     }
[15:32:19.413]     ...future.frame <- base::sys.nframe()
[15:32:19.413]     ...future.conditions <- base::list()
[15:32:19.413]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:19.413]     if (FALSE) {
[15:32:19.413]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:19.413]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:19.413]     }
[15:32:19.413]     ...future.result <- base::tryCatch({
[15:32:19.413]         base::withCallingHandlers({
[15:32:19.413]             ...future.value <- base::withVisible(base::local({
[15:32:19.413]                 do.call(function(...) {
[15:32:19.413]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:19.413]                   if (!identical(...future.globals.maxSize.org, 
[15:32:19.413]                     ...future.globals.maxSize)) {
[15:32:19.413]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:19.413]                     on.exit(options(oopts), add = TRUE)
[15:32:19.413]                   }
[15:32:19.413]                   {
[15:32:19.413]                     lapply(seq_along(...future.elements_ii), 
[15:32:19.413]                       FUN = function(jj) {
[15:32:19.413]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:19.413]                         ...future.FUN(...future.X_jj, ...)
[15:32:19.413]                       })
[15:32:19.413]                   }
[15:32:19.413]                 }, args = future.call.arguments)
[15:32:19.413]             }))
[15:32:19.413]             future::FutureResult(value = ...future.value$value, 
[15:32:19.413]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:19.413]                   ...future.rng), globalenv = if (FALSE) 
[15:32:19.413]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:19.413]                     ...future.globalenv.names))
[15:32:19.413]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:19.413]         }, condition = base::local({
[15:32:19.413]             c <- base::c
[15:32:19.413]             inherits <- base::inherits
[15:32:19.413]             invokeRestart <- base::invokeRestart
[15:32:19.413]             length <- base::length
[15:32:19.413]             list <- base::list
[15:32:19.413]             seq.int <- base::seq.int
[15:32:19.413]             signalCondition <- base::signalCondition
[15:32:19.413]             sys.calls <- base::sys.calls
[15:32:19.413]             `[[` <- base::`[[`
[15:32:19.413]             `+` <- base::`+`
[15:32:19.413]             `<<-` <- base::`<<-`
[15:32:19.413]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:19.413]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:19.413]                   3L)]
[15:32:19.413]             }
[15:32:19.413]             function(cond) {
[15:32:19.413]                 is_error <- inherits(cond, "error")
[15:32:19.413]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:19.413]                   NULL)
[15:32:19.413]                 if (is_error) {
[15:32:19.413]                   sessionInformation <- function() {
[15:32:19.413]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:19.413]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:19.413]                       search = base::search(), system = base::Sys.info())
[15:32:19.413]                   }
[15:32:19.413]                   ...future.conditions[[length(...future.conditions) + 
[15:32:19.413]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:19.413]                     cond$call), session = sessionInformation(), 
[15:32:19.413]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:19.413]                   signalCondition(cond)
[15:32:19.413]                 }
[15:32:19.413]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:19.413]                 "immediateCondition"))) {
[15:32:19.413]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:19.413]                   ...future.conditions[[length(...future.conditions) + 
[15:32:19.413]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:19.413]                   if (TRUE && !signal) {
[15:32:19.413]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:19.413]                     {
[15:32:19.413]                       inherits <- base::inherits
[15:32:19.413]                       invokeRestart <- base::invokeRestart
[15:32:19.413]                       is.null <- base::is.null
[15:32:19.413]                       muffled <- FALSE
[15:32:19.413]                       if (inherits(cond, "message")) {
[15:32:19.413]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:19.413]                         if (muffled) 
[15:32:19.413]                           invokeRestart("muffleMessage")
[15:32:19.413]                       }
[15:32:19.413]                       else if (inherits(cond, "warning")) {
[15:32:19.413]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:19.413]                         if (muffled) 
[15:32:19.413]                           invokeRestart("muffleWarning")
[15:32:19.413]                       }
[15:32:19.413]                       else if (inherits(cond, "condition")) {
[15:32:19.413]                         if (!is.null(pattern)) {
[15:32:19.413]                           computeRestarts <- base::computeRestarts
[15:32:19.413]                           grepl <- base::grepl
[15:32:19.413]                           restarts <- computeRestarts(cond)
[15:32:19.413]                           for (restart in restarts) {
[15:32:19.413]                             name <- restart$name
[15:32:19.413]                             if (is.null(name)) 
[15:32:19.413]                               next
[15:32:19.413]                             if (!grepl(pattern, name)) 
[15:32:19.413]                               next
[15:32:19.413]                             invokeRestart(restart)
[15:32:19.413]                             muffled <- TRUE
[15:32:19.413]                             break
[15:32:19.413]                           }
[15:32:19.413]                         }
[15:32:19.413]                       }
[15:32:19.413]                       invisible(muffled)
[15:32:19.413]                     }
[15:32:19.413]                     muffleCondition(cond, pattern = "^muffle")
[15:32:19.413]                   }
[15:32:19.413]                 }
[15:32:19.413]                 else {
[15:32:19.413]                   if (TRUE) {
[15:32:19.413]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:19.413]                     {
[15:32:19.413]                       inherits <- base::inherits
[15:32:19.413]                       invokeRestart <- base::invokeRestart
[15:32:19.413]                       is.null <- base::is.null
[15:32:19.413]                       muffled <- FALSE
[15:32:19.413]                       if (inherits(cond, "message")) {
[15:32:19.413]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:19.413]                         if (muffled) 
[15:32:19.413]                           invokeRestart("muffleMessage")
[15:32:19.413]                       }
[15:32:19.413]                       else if (inherits(cond, "warning")) {
[15:32:19.413]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:19.413]                         if (muffled) 
[15:32:19.413]                           invokeRestart("muffleWarning")
[15:32:19.413]                       }
[15:32:19.413]                       else if (inherits(cond, "condition")) {
[15:32:19.413]                         if (!is.null(pattern)) {
[15:32:19.413]                           computeRestarts <- base::computeRestarts
[15:32:19.413]                           grepl <- base::grepl
[15:32:19.413]                           restarts <- computeRestarts(cond)
[15:32:19.413]                           for (restart in restarts) {
[15:32:19.413]                             name <- restart$name
[15:32:19.413]                             if (is.null(name)) 
[15:32:19.413]                               next
[15:32:19.413]                             if (!grepl(pattern, name)) 
[15:32:19.413]                               next
[15:32:19.413]                             invokeRestart(restart)
[15:32:19.413]                             muffled <- TRUE
[15:32:19.413]                             break
[15:32:19.413]                           }
[15:32:19.413]                         }
[15:32:19.413]                       }
[15:32:19.413]                       invisible(muffled)
[15:32:19.413]                     }
[15:32:19.413]                     muffleCondition(cond, pattern = "^muffle")
[15:32:19.413]                   }
[15:32:19.413]                 }
[15:32:19.413]             }
[15:32:19.413]         }))
[15:32:19.413]     }, error = function(ex) {
[15:32:19.413]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:19.413]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:19.413]                 ...future.rng), started = ...future.startTime, 
[15:32:19.413]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:19.413]             version = "1.8"), class = "FutureResult")
[15:32:19.413]     }, finally = {
[15:32:19.413]         if (!identical(...future.workdir, getwd())) 
[15:32:19.413]             setwd(...future.workdir)
[15:32:19.413]         {
[15:32:19.413]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:19.413]                 ...future.oldOptions$nwarnings <- NULL
[15:32:19.413]             }
[15:32:19.413]             base::options(...future.oldOptions)
[15:32:19.413]             if (.Platform$OS.type == "windows") {
[15:32:19.413]                 old_names <- names(...future.oldEnvVars)
[15:32:19.413]                 envs <- base::Sys.getenv()
[15:32:19.413]                 names <- names(envs)
[15:32:19.413]                 common <- intersect(names, old_names)
[15:32:19.413]                 added <- setdiff(names, old_names)
[15:32:19.413]                 removed <- setdiff(old_names, names)
[15:32:19.413]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:19.413]                   envs[common]]
[15:32:19.413]                 NAMES <- toupper(changed)
[15:32:19.413]                 args <- list()
[15:32:19.413]                 for (kk in seq_along(NAMES)) {
[15:32:19.413]                   name <- changed[[kk]]
[15:32:19.413]                   NAME <- NAMES[[kk]]
[15:32:19.413]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:19.413]                     next
[15:32:19.413]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:19.413]                 }
[15:32:19.413]                 NAMES <- toupper(added)
[15:32:19.413]                 for (kk in seq_along(NAMES)) {
[15:32:19.413]                   name <- added[[kk]]
[15:32:19.413]                   NAME <- NAMES[[kk]]
[15:32:19.413]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:19.413]                     next
[15:32:19.413]                   args[[name]] <- ""
[15:32:19.413]                 }
[15:32:19.413]                 NAMES <- toupper(removed)
[15:32:19.413]                 for (kk in seq_along(NAMES)) {
[15:32:19.413]                   name <- removed[[kk]]
[15:32:19.413]                   NAME <- NAMES[[kk]]
[15:32:19.413]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:19.413]                     next
[15:32:19.413]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:19.413]                 }
[15:32:19.413]                 if (length(args) > 0) 
[15:32:19.413]                   base::do.call(base::Sys.setenv, args = args)
[15:32:19.413]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:19.413]             }
[15:32:19.413]             else {
[15:32:19.413]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:19.413]             }
[15:32:19.413]             {
[15:32:19.413]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:19.413]                   0L) {
[15:32:19.413]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:19.413]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:19.413]                   base::options(opts)
[15:32:19.413]                 }
[15:32:19.413]                 {
[15:32:19.413]                   {
[15:32:19.413]                     NULL
[15:32:19.413]                     RNGkind("Mersenne-Twister")
[15:32:19.413]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:19.413]                       inherits = FALSE)
[15:32:19.413]                   }
[15:32:19.413]                   options(future.plan = NULL)
[15:32:19.413]                   if (is.na(NA_character_)) 
[15:32:19.413]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:19.413]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:19.413]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:19.413]                     .init = FALSE)
[15:32:19.413]                 }
[15:32:19.413]             }
[15:32:19.413]         }
[15:32:19.413]     })
[15:32:19.413]     if (TRUE) {
[15:32:19.413]         base::sink(type = "output", split = FALSE)
[15:32:19.413]         if (TRUE) {
[15:32:19.413]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:19.413]         }
[15:32:19.413]         else {
[15:32:19.413]             ...future.result["stdout"] <- base::list(NULL)
[15:32:19.413]         }
[15:32:19.413]         base::close(...future.stdout)
[15:32:19.413]         ...future.stdout <- NULL
[15:32:19.413]     }
[15:32:19.413]     ...future.result$conditions <- ...future.conditions
[15:32:19.413]     ...future.result$finished <- base::Sys.time()
[15:32:19.413]     ...future.result
[15:32:19.413] }
[15:32:19.417] assign_globals() ...
[15:32:19.417] List of 5
[15:32:19.417]  $ ...future.FUN            :function (x, y = 2 * 1:5)  
[15:32:19.417]  $ future.call.arguments    : list()
[15:32:19.417]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:19.417]  $ ...future.elements_ii    :List of 3
[15:32:19.417]   ..$ a: num 1
[15:32:19.417]   ..$ b: num 2
[15:32:19.417]   ..$ c: num 3
[15:32:19.417]  $ ...future.seeds_ii       : NULL
[15:32:19.417]  $ ...future.globals.maxSize: NULL
[15:32:19.417]  - attr(*, "where")=List of 5
[15:32:19.417]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:19.417]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:19.417]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:19.417]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:19.417]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:19.417]  - attr(*, "resolved")= logi FALSE
[15:32:19.417]  - attr(*, "total_size")= num 4728
[15:32:19.417]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:19.417]  - attr(*, "already-done")= logi TRUE
[15:32:19.425] - reassign environment for '...future.FUN'
[15:32:19.425] - copied '...future.FUN' to environment
[15:32:19.426] - copied 'future.call.arguments' to environment
[15:32:19.426] - copied '...future.elements_ii' to environment
[15:32:19.426] - copied '...future.seeds_ii' to environment
[15:32:19.427] - copied '...future.globals.maxSize' to environment
[15:32:19.427] assign_globals() ... done
[15:32:19.428] plan(): Setting new future strategy stack:
[15:32:19.428] List of future strategies:
[15:32:19.428] 1. sequential:
[15:32:19.428]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:19.428]    - tweaked: FALSE
[15:32:19.428]    - call: NULL
[15:32:19.429] plan(): nbrOfWorkers() = 1
[15:32:19.431] plan(): Setting new future strategy stack:
[15:32:19.431] List of future strategies:
[15:32:19.431] 1. sequential:
[15:32:19.431]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:19.431]    - tweaked: FALSE
[15:32:19.431]    - call: plan(strategy)
[15:32:19.432] plan(): nbrOfWorkers() = 1
[15:32:19.432] SequentialFuture started (and completed)
[15:32:19.433] - Launch lazy future ... done
[15:32:19.433] run() for 'SequentialFuture' ... done
[15:32:19.433] Created future:
[15:32:19.434] SequentialFuture:
[15:32:19.434] Label: 'future_sapply-1'
[15:32:19.434] Expression:
[15:32:19.434] {
[15:32:19.434]     do.call(function(...) {
[15:32:19.434]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:19.434]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:19.434]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:19.434]             on.exit(options(oopts), add = TRUE)
[15:32:19.434]         }
[15:32:19.434]         {
[15:32:19.434]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:19.434]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:19.434]                 ...future.FUN(...future.X_jj, ...)
[15:32:19.434]             })
[15:32:19.434]         }
[15:32:19.434]     }, args = future.call.arguments)
[15:32:19.434] }
[15:32:19.434] Lazy evaluation: FALSE
[15:32:19.434] Asynchronous evaluation: FALSE
[15:32:19.434] Local evaluation: TRUE
[15:32:19.434] Environment: R_GlobalEnv
[15:32:19.434] Capture standard output: TRUE
[15:32:19.434] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:19.434] Globals: 5 objects totaling 4.78 KiB (function '...future.FUN' of 4.62 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:19.434] Packages: <none>
[15:32:19.434] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:19.434] Resolved: TRUE
[15:32:19.434] Value: 1.01 KiB of class 'list'
[15:32:19.434] Early signaling: FALSE
[15:32:19.434] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:19.434] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:19.436] Chunk #1 of 1 ... DONE
[15:32:19.436] Launching 1 futures (chunks) ... DONE
[15:32:19.437] Resolving 1 futures (chunks) ...
[15:32:19.437] resolve() on list ...
[15:32:19.437]  recursive: 0
[15:32:19.437]  length: 1
[15:32:19.438] 
[15:32:19.438] resolved() for 'SequentialFuture' ...
[15:32:19.438] - state: 'finished'
[15:32:19.439] - run: TRUE
[15:32:19.439] - result: 'FutureResult'
[15:32:19.439] resolved() for 'SequentialFuture' ... done
[15:32:19.439] Future #1
[15:32:19.440] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:19.443] - nx: 1
[15:32:19.443] - relay: TRUE
[15:32:19.444] - stdout: TRUE
[15:32:19.444] - signal: TRUE
[15:32:19.444] - resignal: FALSE
[15:32:19.444] - force: TRUE
[15:32:19.445] - relayed: [n=1] FALSE
[15:32:19.445] - queued futures: [n=1] FALSE
[15:32:19.445]  - until=1
[15:32:19.445]  - relaying element #1
[15:32:19.446] - relayed: [n=1] TRUE
[15:32:19.446] - queued futures: [n=1] TRUE
[15:32:19.446] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:19.447]  length: 0 (resolved future 1)
[15:32:19.447] Relaying remaining futures
[15:32:19.447] signalConditionsASAP(NULL, pos=0) ...
[15:32:19.447] - nx: 1
[15:32:19.448] - relay: TRUE
[15:32:19.448] - stdout: TRUE
[15:32:19.448] - signal: TRUE
[15:32:19.448] - resignal: FALSE
[15:32:19.449] - force: TRUE
[15:32:19.449] - relayed: [n=1] TRUE
[15:32:19.449] - queued futures: [n=1] TRUE
 - flush all
[15:32:19.450] - relayed: [n=1] TRUE
[15:32:19.450] - queued futures: [n=1] TRUE
[15:32:19.450] signalConditionsASAP(NULL, pos=0) ... done
[15:32:19.450] resolve() on list ... DONE
[15:32:19.451]  - Number of value chunks collected: 1
[15:32:19.451] Resolving 1 futures (chunks) ... DONE
[15:32:19.451] Reducing values from 1 chunks ...
[15:32:19.452]  - Number of values collected after concatenation: 3
[15:32:19.452]  - Number of values expected: 3
[15:32:19.452] Reducing values from 1 chunks ... DONE
[15:32:19.452] future_lapply() ... DONE
List of 2
 $ y0:List of 3
  ..$ a: num [1:3, 1:5] 2 2 2 4 4 4 6 6 6 8 ...
  ..$ b: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
  ..$ c: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
 $ y1:List of 3
  ..$ a: num [1:3, 1:5] 2 2 2 4 4 4 6 6 6 8 ...
  ..$ b: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
  ..$ c: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
List of 2
 $ y0:List of 3
  ..$ a: num [1:3, 1:5] 2 2 2 4 4 4 6 6 6 8 ...
  ..$ b: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
  ..$ c: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
 $ y2:List of 3
  ..$ a: num [1:3, 1:5] 2 2 2 4 4 4 6 6 6 8 ...
  ..$ b: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
  ..$ c: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
[15:32:19.465] future_lapply() ...
[15:32:19.466] Number of chunks: 1
[15:32:19.466] getGlobalsAndPackagesXApply() ...
[15:32:19.466]  - future.globals: TRUE
[15:32:19.467] getGlobalsAndPackages() ...
[15:32:19.467] Searching for globals...
[15:32:19.469] - globals found: [1] 'FUN'
[15:32:19.469] Searching for globals ... DONE
[15:32:19.469] Resolving globals: FALSE
[15:32:19.470] The total size of the 1 globals is 848 bytes (848 bytes)
[15:32:19.471] The total size of the 1 globals exported for future expression ('FUN()') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:32:19.471] - globals: [1] 'FUN'
[15:32:19.471] 
[15:32:19.471] getGlobalsAndPackages() ... DONE
[15:32:19.472]  - globals found/used: [n=1] 'FUN'
[15:32:19.472]  - needed namespaces: [n=0] 
[15:32:19.472] Finding globals ... DONE
[15:32:19.472]  - use_args: TRUE
[15:32:19.473]  - Getting '...' globals ...
[15:32:19.473] resolve() on list ...
[15:32:19.473]  recursive: 0
[15:32:19.474]  length: 1
[15:32:19.474]  elements: '...'
[15:32:19.474]  length: 0 (resolved future 1)
[15:32:19.475] resolve() on list ... DONE
[15:32:19.475]    - '...' content: [n=0] 
[15:32:19.475] List of 1
[15:32:19.475]  $ ...: list()
[15:32:19.475]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:19.475]  - attr(*, "where")=List of 1
[15:32:19.475]   ..$ ...:<environment: 0x00000276e1cabe98> 
[15:32:19.475]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:19.475]  - attr(*, "resolved")= logi TRUE
[15:32:19.475]  - attr(*, "total_size")= num NA
[15:32:19.480]  - Getting '...' globals ... DONE
[15:32:19.480] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:19.481] List of 2
[15:32:19.481]  $ ...future.FUN:function (x)  
[15:32:19.481]  $ ...          : list()
[15:32:19.481]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:19.481]  - attr(*, "where")=List of 2
[15:32:19.481]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:19.481]   ..$ ...          :<environment: 0x00000276e1cabe98> 
[15:32:19.481]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:19.481]  - attr(*, "resolved")= logi FALSE
[15:32:19.481]  - attr(*, "total_size")= num 848
[15:32:19.489] Packages to be attached in all futures: [n=0] 
[15:32:19.489] getGlobalsAndPackagesXApply() ... DONE
[15:32:19.489] Number of futures (= number of chunks): 1
[15:32:19.490] Launching 1 futures (chunks) ...
[15:32:19.490] Chunk #1 of 1 ...
[15:32:19.490]  - Finding globals in 'X' for chunk #1 ...
[15:32:19.491] getGlobalsAndPackages() ...
[15:32:19.491] Searching for globals...
[15:32:19.492] 
[15:32:19.492] Searching for globals ... DONE
[15:32:19.492] - globals: [0] <none>
[15:32:19.492] getGlobalsAndPackages() ... DONE
[15:32:19.493]    + additional globals found: [n=0] 
[15:32:19.493]    + additional namespaces needed: [n=0] 
[15:32:19.493]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:19.493]  - seeds: <none>
[15:32:19.494]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:19.494] getGlobalsAndPackages() ...
[15:32:19.494] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:19.495] Resolving globals: FALSE
[15:32:19.495] Tweak future expression to call with '...' arguments ...
[15:32:19.495] {
[15:32:19.495]     do.call(function(...) {
[15:32:19.495]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:19.495]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:19.495]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:19.495]             on.exit(options(oopts), add = TRUE)
[15:32:19.495]         }
[15:32:19.495]         {
[15:32:19.495]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:19.495]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:19.495]                 ...future.FUN(...future.X_jj, ...)
[15:32:19.495]             })
[15:32:19.495]         }
[15:32:19.495]     }, args = future.call.arguments)
[15:32:19.495] }
[15:32:19.496] Tweak future expression to call with '...' arguments ... DONE
[15:32:19.497] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:19.497] 
[15:32:19.497] getGlobalsAndPackages() ... DONE
[15:32:19.498] run() for 'Future' ...
[15:32:19.498] - state: 'created'
[15:32:19.499] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:19.499] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:19.500] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:19.500]   - Field: 'label'
[15:32:19.500]   - Field: 'local'
[15:32:19.500]   - Field: 'owner'
[15:32:19.501]   - Field: 'envir'
[15:32:19.501]   - Field: 'packages'
[15:32:19.501]   - Field: 'gc'
[15:32:19.502]   - Field: 'conditions'
[15:32:19.502]   - Field: 'expr'
[15:32:19.502]   - Field: 'uuid'
[15:32:19.503]   - Field: 'seed'
[15:32:19.503]   - Field: 'version'
[15:32:19.503]   - Field: 'result'
[15:32:19.503]   - Field: 'asynchronous'
[15:32:19.504]   - Field: 'calls'
[15:32:19.504]   - Field: 'globals'
[15:32:19.504]   - Field: 'stdout'
[15:32:19.505]   - Field: 'earlySignal'
[15:32:19.505]   - Field: 'lazy'
[15:32:19.505]   - Field: 'state'
[15:32:19.505] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:19.506] - Launch lazy future ...
[15:32:19.506] Packages needed by the future expression (n = 0): <none>
[15:32:19.507] Packages needed by future strategies (n = 0): <none>
[15:32:19.507] {
[15:32:19.507]     {
[15:32:19.507]         {
[15:32:19.507]             ...future.startTime <- base::Sys.time()
[15:32:19.507]             {
[15:32:19.507]                 {
[15:32:19.507]                   {
[15:32:19.507]                     base::local({
[15:32:19.507]                       has_future <- base::requireNamespace("future", 
[15:32:19.507]                         quietly = TRUE)
[15:32:19.507]                       if (has_future) {
[15:32:19.507]                         ns <- base::getNamespace("future")
[15:32:19.507]                         version <- ns[[".package"]][["version"]]
[15:32:19.507]                         if (is.null(version)) 
[15:32:19.507]                           version <- utils::packageVersion("future")
[15:32:19.507]                       }
[15:32:19.507]                       else {
[15:32:19.507]                         version <- NULL
[15:32:19.507]                       }
[15:32:19.507]                       if (!has_future || version < "1.8.0") {
[15:32:19.507]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:19.507]                           "", base::R.version$version.string), 
[15:32:19.507]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:19.507]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:19.507]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:19.507]                             "release", "version")], collapse = " "), 
[15:32:19.507]                           hostname = base::Sys.info()[["nodename"]])
[15:32:19.507]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:19.507]                           info)
[15:32:19.507]                         info <- base::paste(info, collapse = "; ")
[15:32:19.507]                         if (!has_future) {
[15:32:19.507]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:19.507]                             info)
[15:32:19.507]                         }
[15:32:19.507]                         else {
[15:32:19.507]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:19.507]                             info, version)
[15:32:19.507]                         }
[15:32:19.507]                         base::stop(msg)
[15:32:19.507]                       }
[15:32:19.507]                     })
[15:32:19.507]                   }
[15:32:19.507]                   ...future.strategy.old <- future::plan("list")
[15:32:19.507]                   options(future.plan = NULL)
[15:32:19.507]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:19.507]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:19.507]                 }
[15:32:19.507]                 ...future.workdir <- getwd()
[15:32:19.507]             }
[15:32:19.507]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:19.507]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:19.507]         }
[15:32:19.507]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:19.507]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:19.507]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:19.507]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:19.507]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:19.507]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:19.507]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:19.507]             base::names(...future.oldOptions))
[15:32:19.507]     }
[15:32:19.507]     if (FALSE) {
[15:32:19.507]     }
[15:32:19.507]     else {
[15:32:19.507]         if (TRUE) {
[15:32:19.507]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:19.507]                 open = "w")
[15:32:19.507]         }
[15:32:19.507]         else {
[15:32:19.507]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:19.507]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:19.507]         }
[15:32:19.507]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:19.507]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:19.507]             base::sink(type = "output", split = FALSE)
[15:32:19.507]             base::close(...future.stdout)
[15:32:19.507]         }, add = TRUE)
[15:32:19.507]     }
[15:32:19.507]     ...future.frame <- base::sys.nframe()
[15:32:19.507]     ...future.conditions <- base::list()
[15:32:19.507]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:19.507]     if (FALSE) {
[15:32:19.507]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:19.507]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:19.507]     }
[15:32:19.507]     ...future.result <- base::tryCatch({
[15:32:19.507]         base::withCallingHandlers({
[15:32:19.507]             ...future.value <- base::withVisible(base::local({
[15:32:19.507]                 do.call(function(...) {
[15:32:19.507]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:19.507]                   if (!identical(...future.globals.maxSize.org, 
[15:32:19.507]                     ...future.globals.maxSize)) {
[15:32:19.507]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:19.507]                     on.exit(options(oopts), add = TRUE)
[15:32:19.507]                   }
[15:32:19.507]                   {
[15:32:19.507]                     lapply(seq_along(...future.elements_ii), 
[15:32:19.507]                       FUN = function(jj) {
[15:32:19.507]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:19.507]                         ...future.FUN(...future.X_jj, ...)
[15:32:19.507]                       })
[15:32:19.507]                   }
[15:32:19.507]                 }, args = future.call.arguments)
[15:32:19.507]             }))
[15:32:19.507]             future::FutureResult(value = ...future.value$value, 
[15:32:19.507]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:19.507]                   ...future.rng), globalenv = if (FALSE) 
[15:32:19.507]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:19.507]                     ...future.globalenv.names))
[15:32:19.507]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:19.507]         }, condition = base::local({
[15:32:19.507]             c <- base::c
[15:32:19.507]             inherits <- base::inherits
[15:32:19.507]             invokeRestart <- base::invokeRestart
[15:32:19.507]             length <- base::length
[15:32:19.507]             list <- base::list
[15:32:19.507]             seq.int <- base::seq.int
[15:32:19.507]             signalCondition <- base::signalCondition
[15:32:19.507]             sys.calls <- base::sys.calls
[15:32:19.507]             `[[` <- base::`[[`
[15:32:19.507]             `+` <- base::`+`
[15:32:19.507]             `<<-` <- base::`<<-`
[15:32:19.507]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:19.507]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:19.507]                   3L)]
[15:32:19.507]             }
[15:32:19.507]             function(cond) {
[15:32:19.507]                 is_error <- inherits(cond, "error")
[15:32:19.507]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:19.507]                   NULL)
[15:32:19.507]                 if (is_error) {
[15:32:19.507]                   sessionInformation <- function() {
[15:32:19.507]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:19.507]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:19.507]                       search = base::search(), system = base::Sys.info())
[15:32:19.507]                   }
[15:32:19.507]                   ...future.conditions[[length(...future.conditions) + 
[15:32:19.507]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:19.507]                     cond$call), session = sessionInformation(), 
[15:32:19.507]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:19.507]                   signalCondition(cond)
[15:32:19.507]                 }
[15:32:19.507]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:19.507]                 "immediateCondition"))) {
[15:32:19.507]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:19.507]                   ...future.conditions[[length(...future.conditions) + 
[15:32:19.507]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:19.507]                   if (TRUE && !signal) {
[15:32:19.507]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:19.507]                     {
[15:32:19.507]                       inherits <- base::inherits
[15:32:19.507]                       invokeRestart <- base::invokeRestart
[15:32:19.507]                       is.null <- base::is.null
[15:32:19.507]                       muffled <- FALSE
[15:32:19.507]                       if (inherits(cond, "message")) {
[15:32:19.507]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:19.507]                         if (muffled) 
[15:32:19.507]                           invokeRestart("muffleMessage")
[15:32:19.507]                       }
[15:32:19.507]                       else if (inherits(cond, "warning")) {
[15:32:19.507]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:19.507]                         if (muffled) 
[15:32:19.507]                           invokeRestart("muffleWarning")
[15:32:19.507]                       }
[15:32:19.507]                       else if (inherits(cond, "condition")) {
[15:32:19.507]                         if (!is.null(pattern)) {
[15:32:19.507]                           computeRestarts <- base::computeRestarts
[15:32:19.507]                           grepl <- base::grepl
[15:32:19.507]                           restarts <- computeRestarts(cond)
[15:32:19.507]                           for (restart in restarts) {
[15:32:19.507]                             name <- restart$name
[15:32:19.507]                             if (is.null(name)) 
[15:32:19.507]                               next
[15:32:19.507]                             if (!grepl(pattern, name)) 
[15:32:19.507]                               next
[15:32:19.507]                             invokeRestart(restart)
[15:32:19.507]                             muffled <- TRUE
[15:32:19.507]                             break
[15:32:19.507]                           }
[15:32:19.507]                         }
[15:32:19.507]                       }
[15:32:19.507]                       invisible(muffled)
[15:32:19.507]                     }
[15:32:19.507]                     muffleCondition(cond, pattern = "^muffle")
[15:32:19.507]                   }
[15:32:19.507]                 }
[15:32:19.507]                 else {
[15:32:19.507]                   if (TRUE) {
[15:32:19.507]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:19.507]                     {
[15:32:19.507]                       inherits <- base::inherits
[15:32:19.507]                       invokeRestart <- base::invokeRestart
[15:32:19.507]                       is.null <- base::is.null
[15:32:19.507]                       muffled <- FALSE
[15:32:19.507]                       if (inherits(cond, "message")) {
[15:32:19.507]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:19.507]                         if (muffled) 
[15:32:19.507]                           invokeRestart("muffleMessage")
[15:32:19.507]                       }
[15:32:19.507]                       else if (inherits(cond, "warning")) {
[15:32:19.507]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:19.507]                         if (muffled) 
[15:32:19.507]                           invokeRestart("muffleWarning")
[15:32:19.507]                       }
[15:32:19.507]                       else if (inherits(cond, "condition")) {
[15:32:19.507]                         if (!is.null(pattern)) {
[15:32:19.507]                           computeRestarts <- base::computeRestarts
[15:32:19.507]                           grepl <- base::grepl
[15:32:19.507]                           restarts <- computeRestarts(cond)
[15:32:19.507]                           for (restart in restarts) {
[15:32:19.507]                             name <- restart$name
[15:32:19.507]                             if (is.null(name)) 
[15:32:19.507]                               next
[15:32:19.507]                             if (!grepl(pattern, name)) 
[15:32:19.507]                               next
[15:32:19.507]                             invokeRestart(restart)
[15:32:19.507]                             muffled <- TRUE
[15:32:19.507]                             break
[15:32:19.507]                           }
[15:32:19.507]                         }
[15:32:19.507]                       }
[15:32:19.507]                       invisible(muffled)
[15:32:19.507]                     }
[15:32:19.507]                     muffleCondition(cond, pattern = "^muffle")
[15:32:19.507]                   }
[15:32:19.507]                 }
[15:32:19.507]             }
[15:32:19.507]         }))
[15:32:19.507]     }, error = function(ex) {
[15:32:19.507]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:19.507]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:19.507]                 ...future.rng), started = ...future.startTime, 
[15:32:19.507]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:19.507]             version = "1.8"), class = "FutureResult")
[15:32:19.507]     }, finally = {
[15:32:19.507]         if (!identical(...future.workdir, getwd())) 
[15:32:19.507]             setwd(...future.workdir)
[15:32:19.507]         {
[15:32:19.507]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:19.507]                 ...future.oldOptions$nwarnings <- NULL
[15:32:19.507]             }
[15:32:19.507]             base::options(...future.oldOptions)
[15:32:19.507]             if (.Platform$OS.type == "windows") {
[15:32:19.507]                 old_names <- names(...future.oldEnvVars)
[15:32:19.507]                 envs <- base::Sys.getenv()
[15:32:19.507]                 names <- names(envs)
[15:32:19.507]                 common <- intersect(names, old_names)
[15:32:19.507]                 added <- setdiff(names, old_names)
[15:32:19.507]                 removed <- setdiff(old_names, names)
[15:32:19.507]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:19.507]                   envs[common]]
[15:32:19.507]                 NAMES <- toupper(changed)
[15:32:19.507]                 args <- list()
[15:32:19.507]                 for (kk in seq_along(NAMES)) {
[15:32:19.507]                   name <- changed[[kk]]
[15:32:19.507]                   NAME <- NAMES[[kk]]
[15:32:19.507]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:19.507]                     next
[15:32:19.507]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:19.507]                 }
[15:32:19.507]                 NAMES <- toupper(added)
[15:32:19.507]                 for (kk in seq_along(NAMES)) {
[15:32:19.507]                   name <- added[[kk]]
[15:32:19.507]                   NAME <- NAMES[[kk]]
[15:32:19.507]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:19.507]                     next
[15:32:19.507]                   args[[name]] <- ""
[15:32:19.507]                 }
[15:32:19.507]                 NAMES <- toupper(removed)
[15:32:19.507]                 for (kk in seq_along(NAMES)) {
[15:32:19.507]                   name <- removed[[kk]]
[15:32:19.507]                   NAME <- NAMES[[kk]]
[15:32:19.507]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:19.507]                     next
[15:32:19.507]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:19.507]                 }
[15:32:19.507]                 if (length(args) > 0) 
[15:32:19.507]                   base::do.call(base::Sys.setenv, args = args)
[15:32:19.507]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:19.507]             }
[15:32:19.507]             else {
[15:32:19.507]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:19.507]             }
[15:32:19.507]             {
[15:32:19.507]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:19.507]                   0L) {
[15:32:19.507]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:19.507]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:19.507]                   base::options(opts)
[15:32:19.507]                 }
[15:32:19.507]                 {
[15:32:19.507]                   {
[15:32:19.507]                     NULL
[15:32:19.507]                     RNGkind("Mersenne-Twister")
[15:32:19.507]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:19.507]                       inherits = FALSE)
[15:32:19.507]                   }
[15:32:19.507]                   options(future.plan = NULL)
[15:32:19.507]                   if (is.na(NA_character_)) 
[15:32:19.507]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:19.507]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:19.507]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:19.507]                     .init = FALSE)
[15:32:19.507]                 }
[15:32:19.507]             }
[15:32:19.507]         }
[15:32:19.507]     })
[15:32:19.507]     if (TRUE) {
[15:32:19.507]         base::sink(type = "output", split = FALSE)
[15:32:19.507]         if (TRUE) {
[15:32:19.507]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:19.507]         }
[15:32:19.507]         else {
[15:32:19.507]             ...future.result["stdout"] <- base::list(NULL)
[15:32:19.507]         }
[15:32:19.507]         base::close(...future.stdout)
[15:32:19.507]         ...future.stdout <- NULL
[15:32:19.507]     }
[15:32:19.507]     ...future.result$conditions <- ...future.conditions
[15:32:19.507]     ...future.result$finished <- base::Sys.time()
[15:32:19.507]     ...future.result
[15:32:19.507] }
[15:32:19.514] assign_globals() ...
[15:32:19.515] List of 5
[15:32:19.515]  $ ...future.FUN            :function (x)  
[15:32:19.515]  $ future.call.arguments    : list()
[15:32:19.515]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:19.515]  $ ...future.elements_ii    :List of 3
[15:32:19.515]   ..$ a: num 1
[15:32:19.515]   ..$ b: num 2
[15:32:19.515]   ..$ c: num 3
[15:32:19.515]  $ ...future.seeds_ii       : NULL
[15:32:19.515]  $ ...future.globals.maxSize: NULL
[15:32:19.515]  - attr(*, "where")=List of 5
[15:32:19.515]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:19.515]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:19.515]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:19.515]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:19.515]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:19.515]  - attr(*, "resolved")= logi FALSE
[15:32:19.515]  - attr(*, "total_size")= num 848
[15:32:19.515]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:19.515]  - attr(*, "already-done")= logi TRUE
[15:32:19.525] - copied '...future.FUN' to environment
[15:32:19.526] - copied 'future.call.arguments' to environment
[15:32:19.526] - copied '...future.elements_ii' to environment
[15:32:19.526] - copied '...future.seeds_ii' to environment
[15:32:19.526] - copied '...future.globals.maxSize' to environment
[15:32:19.527] assign_globals() ... done
[15:32:19.527] plan(): Setting new future strategy stack:
[15:32:19.528] List of future strategies:
[15:32:19.528] 1. sequential:
[15:32:19.528]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:19.528]    - tweaked: FALSE
[15:32:19.528]    - call: NULL
[15:32:19.529] plan(): nbrOfWorkers() = 1
[15:32:19.531] plan(): Setting new future strategy stack:
[15:32:19.531] List of future strategies:
[15:32:19.531] 1. sequential:
[15:32:19.531]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:19.531]    - tweaked: FALSE
[15:32:19.531]    - call: plan(strategy)
[15:32:19.532] plan(): nbrOfWorkers() = 1
[15:32:19.532] SequentialFuture started (and completed)
[15:32:19.533] - Launch lazy future ... done
[15:32:19.533] run() for 'SequentialFuture' ... done
[15:32:19.533] Created future:
[15:32:19.534] SequentialFuture:
[15:32:19.534] Label: 'future_sapply-1'
[15:32:19.534] Expression:
[15:32:19.534] {
[15:32:19.534]     do.call(function(...) {
[15:32:19.534]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:19.534]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:19.534]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:19.534]             on.exit(options(oopts), add = TRUE)
[15:32:19.534]         }
[15:32:19.534]         {
[15:32:19.534]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:19.534]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:19.534]                 ...future.FUN(...future.X_jj, ...)
[15:32:19.534]             })
[15:32:19.534]         }
[15:32:19.534]     }, args = future.call.arguments)
[15:32:19.534] }
[15:32:19.534] Lazy evaluation: FALSE
[15:32:19.534] Asynchronous evaluation: FALSE
[15:32:19.534] Local evaluation: TRUE
[15:32:19.534] Environment: R_GlobalEnv
[15:32:19.534] Capture standard output: TRUE
[15:32:19.534] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:19.534] Globals: 5 objects totaling 0.99 KiB (function '...future.FUN' of 848 bytes, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:19.534] Packages: <none>
[15:32:19.534] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:19.534] Resolved: TRUE
[15:32:19.534] Value: 168 bytes of class 'list'
[15:32:19.534] Early signaling: FALSE
[15:32:19.534] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:19.534] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:19.539] Chunk #1 of 1 ... DONE
[15:32:19.539] Launching 1 futures (chunks) ... DONE
[15:32:19.539] Resolving 1 futures (chunks) ...
[15:32:19.539] resolve() on list ...
[15:32:19.540]  recursive: 0
[15:32:19.540]  length: 1
[15:32:19.540] 
[15:32:19.540] resolved() for 'SequentialFuture' ...
[15:32:19.541] - state: 'finished'
[15:32:19.541] - run: TRUE
[15:32:19.542] - result: 'FutureResult'
[15:32:19.542] resolved() for 'SequentialFuture' ... done
[15:32:19.542] Future #1
[15:32:19.543] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:19.543] - nx: 1
[15:32:19.543] - relay: TRUE
[15:32:19.544] - stdout: TRUE
[15:32:19.544] - signal: TRUE
[15:32:19.544] - resignal: FALSE
[15:32:19.544] - force: TRUE
[15:32:19.545] - relayed: [n=1] FALSE
[15:32:19.545] - queued futures: [n=1] FALSE
[15:32:19.545]  - until=1
[15:32:19.545]  - relaying element #1
[15:32:19.546] - relayed: [n=1] TRUE
[15:32:19.546] - queued futures: [n=1] TRUE
[15:32:19.546] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:19.547]  length: 0 (resolved future 1)
[15:32:19.547] Relaying remaining futures
[15:32:19.547] signalConditionsASAP(NULL, pos=0) ...
[15:32:19.548] - nx: 1
[15:32:19.548] - relay: TRUE
[15:32:19.548] - stdout: TRUE
[15:32:19.548] - signal: TRUE
[15:32:19.549] - resignal: FALSE
[15:32:19.549] - force: TRUE
[15:32:19.549] - relayed: [n=1] TRUE
[15:32:19.549] - queued futures: [n=1] TRUE
 - flush all
[15:32:19.550] - relayed: [n=1] TRUE
[15:32:19.550] - queued futures: [n=1] TRUE
[15:32:19.550] signalConditionsASAP(NULL, pos=0) ... done
[15:32:19.551] resolve() on list ... DONE
[15:32:19.551]  - Number of value chunks collected: 1
[15:32:19.551] Resolving 1 futures (chunks) ... DONE
[15:32:19.552] Reducing values from 1 chunks ...
[15:32:19.552]  - Number of values collected after concatenation: 3
[15:32:19.552]  - Number of values expected: 3
[15:32:19.553] Reducing values from 1 chunks ... DONE
[15:32:19.553] future_lapply() ... DONE
List of 2
 $ y0: Named num [1:3] 1 2 3
  ..- attr(*, "names")= chr [1:3] "a" "b" "c"
 $ y1: Named num [1:3] 1 2 3
  ..- attr(*, "names")= chr [1:3] "a" "b" "c"
[15:32:19.556] future_lapply() ...
[15:32:19.558] Number of chunks: 1
[15:32:19.558] getGlobalsAndPackagesXApply() ...
[15:32:19.558]  - future.globals: TRUE
[15:32:19.558] getGlobalsAndPackages() ...
[15:32:19.559] Searching for globals...
[15:32:19.561] - globals found: [2] 'FUN', 'UseMethod'
[15:32:19.561] Searching for globals ... DONE
[15:32:19.561] Resolving globals: FALSE
[15:32:19.562] The total size of the 1 globals is 1.22 KiB (1248 bytes)
[15:32:19.563] The total size of the 1 globals exported for future expression ('FUN()') is 1.22 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.22 KiB of class 'function')
[15:32:19.563] - globals: [1] 'FUN'
[15:32:19.564] 
[15:32:19.564] getGlobalsAndPackages() ... DONE
[15:32:19.564]  - globals found/used: [n=1] 'FUN'
[15:32:19.564]  - needed namespaces: [n=0] 
[15:32:19.565] Finding globals ... DONE
[15:32:19.565]  - use_args: TRUE
[15:32:19.565]  - Getting '...' globals ...
[15:32:19.566] resolve() on list ...
[15:32:19.566]  recursive: 0
[15:32:19.567]  length: 1
[15:32:19.567]  elements: '...'
[15:32:19.567]  length: 0 (resolved future 1)
[15:32:19.567] resolve() on list ... DONE
[15:32:19.568]    - '...' content: [n=0] 
[15:32:19.568] List of 1
[15:32:19.568]  $ ...: list()
[15:32:19.568]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:19.568]  - attr(*, "where")=List of 1
[15:32:19.568]   ..$ ...:<environment: 0x00000276e1957ae8> 
[15:32:19.568]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:19.568]  - attr(*, "resolved")= logi TRUE
[15:32:19.568]  - attr(*, "total_size")= num NA
[15:32:19.573]  - Getting '...' globals ... DONE
[15:32:19.573] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:19.574] List of 2
[15:32:19.574]  $ ...future.FUN:function (x, ...)  
[15:32:19.574]  $ ...          : list()
[15:32:19.574]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:19.574]  - attr(*, "where")=List of 2
[15:32:19.574]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:19.574]   ..$ ...          :<environment: 0x00000276e1957ae8> 
[15:32:19.574]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:19.574]  - attr(*, "resolved")= logi FALSE
[15:32:19.574]  - attr(*, "total_size")= num 1248
[15:32:19.582] Packages to be attached in all futures: [n=0] 
[15:32:19.582] getGlobalsAndPackagesXApply() ... DONE
[15:32:19.583] Number of futures (= number of chunks): 1
[15:32:19.583] Launching 1 futures (chunks) ...
[15:32:19.583] Chunk #1 of 1 ...
[15:32:19.584]  - Finding globals in 'X' for chunk #1 ...
[15:32:19.584] getGlobalsAndPackages() ...
[15:32:19.584] Searching for globals...
[15:32:19.585] 
[15:32:19.585] Searching for globals ... DONE
[15:32:19.585] - globals: [0] <none>
[15:32:19.585] getGlobalsAndPackages() ... DONE
[15:32:19.586]    + additional globals found: [n=0] 
[15:32:19.586]    + additional namespaces needed: [n=0] 
[15:32:19.586]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:19.586]  - seeds: <none>
[15:32:19.586]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:19.587] getGlobalsAndPackages() ...
[15:32:19.587] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:19.587] Resolving globals: FALSE
[15:32:19.588] Tweak future expression to call with '...' arguments ...
[15:32:19.588] {
[15:32:19.588]     do.call(function(...) {
[15:32:19.588]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:19.588]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:19.588]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:19.588]             on.exit(options(oopts), add = TRUE)
[15:32:19.588]         }
[15:32:19.588]         {
[15:32:19.588]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:19.588]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:19.588]                 ...future.FUN(...future.X_jj, ...)
[15:32:19.588]             })
[15:32:19.588]         }
[15:32:19.588]     }, args = future.call.arguments)
[15:32:19.588] }
[15:32:19.588] Tweak future expression to call with '...' arguments ... DONE
[15:32:19.589] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:19.590] 
[15:32:19.590] getGlobalsAndPackages() ... DONE
[15:32:19.590] run() for 'Future' ...
[15:32:19.591] - state: 'created'
[15:32:19.591] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:19.592] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:19.592] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:19.592]   - Field: 'label'
[15:32:19.592]   - Field: 'local'
[15:32:19.592]   - Field: 'owner'
[15:32:19.593]   - Field: 'envir'
[15:32:19.593]   - Field: 'packages'
[15:32:19.593]   - Field: 'gc'
[15:32:19.594]   - Field: 'conditions'
[15:32:19.594]   - Field: 'expr'
[15:32:19.594]   - Field: 'uuid'
[15:32:19.594]   - Field: 'seed'
[15:32:19.595]   - Field: 'version'
[15:32:19.595]   - Field: 'result'
[15:32:19.595]   - Field: 'asynchronous'
[15:32:19.595]   - Field: 'calls'
[15:32:19.596]   - Field: 'globals'
[15:32:19.596]   - Field: 'stdout'
[15:32:19.596]   - Field: 'earlySignal'
[15:32:19.596]   - Field: 'lazy'
[15:32:19.596]   - Field: 'state'
[15:32:19.596] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:19.597] - Launch lazy future ...
[15:32:19.597] Packages needed by the future expression (n = 0): <none>
[15:32:19.597] Packages needed by future strategies (n = 0): <none>
[15:32:19.598] {
[15:32:19.598]     {
[15:32:19.598]         {
[15:32:19.598]             ...future.startTime <- base::Sys.time()
[15:32:19.598]             {
[15:32:19.598]                 {
[15:32:19.598]                   {
[15:32:19.598]                     base::local({
[15:32:19.598]                       has_future <- base::requireNamespace("future", 
[15:32:19.598]                         quietly = TRUE)
[15:32:19.598]                       if (has_future) {
[15:32:19.598]                         ns <- base::getNamespace("future")
[15:32:19.598]                         version <- ns[[".package"]][["version"]]
[15:32:19.598]                         if (is.null(version)) 
[15:32:19.598]                           version <- utils::packageVersion("future")
[15:32:19.598]                       }
[15:32:19.598]                       else {
[15:32:19.598]                         version <- NULL
[15:32:19.598]                       }
[15:32:19.598]                       if (!has_future || version < "1.8.0") {
[15:32:19.598]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:19.598]                           "", base::R.version$version.string), 
[15:32:19.598]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:19.598]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:19.598]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:19.598]                             "release", "version")], collapse = " "), 
[15:32:19.598]                           hostname = base::Sys.info()[["nodename"]])
[15:32:19.598]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:19.598]                           info)
[15:32:19.598]                         info <- base::paste(info, collapse = "; ")
[15:32:19.598]                         if (!has_future) {
[15:32:19.598]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:19.598]                             info)
[15:32:19.598]                         }
[15:32:19.598]                         else {
[15:32:19.598]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:19.598]                             info, version)
[15:32:19.598]                         }
[15:32:19.598]                         base::stop(msg)
[15:32:19.598]                       }
[15:32:19.598]                     })
[15:32:19.598]                   }
[15:32:19.598]                   ...future.strategy.old <- future::plan("list")
[15:32:19.598]                   options(future.plan = NULL)
[15:32:19.598]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:19.598]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:19.598]                 }
[15:32:19.598]                 ...future.workdir <- getwd()
[15:32:19.598]             }
[15:32:19.598]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:19.598]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:19.598]         }
[15:32:19.598]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:19.598]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:19.598]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:19.598]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:19.598]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:19.598]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:19.598]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:19.598]             base::names(...future.oldOptions))
[15:32:19.598]     }
[15:32:19.598]     if (FALSE) {
[15:32:19.598]     }
[15:32:19.598]     else {
[15:32:19.598]         if (TRUE) {
[15:32:19.598]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:19.598]                 open = "w")
[15:32:19.598]         }
[15:32:19.598]         else {
[15:32:19.598]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:19.598]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:19.598]         }
[15:32:19.598]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:19.598]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:19.598]             base::sink(type = "output", split = FALSE)
[15:32:19.598]             base::close(...future.stdout)
[15:32:19.598]         }, add = TRUE)
[15:32:19.598]     }
[15:32:19.598]     ...future.frame <- base::sys.nframe()
[15:32:19.598]     ...future.conditions <- base::list()
[15:32:19.598]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:19.598]     if (FALSE) {
[15:32:19.598]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:19.598]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:19.598]     }
[15:32:19.598]     ...future.result <- base::tryCatch({
[15:32:19.598]         base::withCallingHandlers({
[15:32:19.598]             ...future.value <- base::withVisible(base::local({
[15:32:19.598]                 do.call(function(...) {
[15:32:19.598]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:19.598]                   if (!identical(...future.globals.maxSize.org, 
[15:32:19.598]                     ...future.globals.maxSize)) {
[15:32:19.598]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:19.598]                     on.exit(options(oopts), add = TRUE)
[15:32:19.598]                   }
[15:32:19.598]                   {
[15:32:19.598]                     lapply(seq_along(...future.elements_ii), 
[15:32:19.598]                       FUN = function(jj) {
[15:32:19.598]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:19.598]                         ...future.FUN(...future.X_jj, ...)
[15:32:19.598]                       })
[15:32:19.598]                   }
[15:32:19.598]                 }, args = future.call.arguments)
[15:32:19.598]             }))
[15:32:19.598]             future::FutureResult(value = ...future.value$value, 
[15:32:19.598]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:19.598]                   ...future.rng), globalenv = if (FALSE) 
[15:32:19.598]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:19.598]                     ...future.globalenv.names))
[15:32:19.598]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:19.598]         }, condition = base::local({
[15:32:19.598]             c <- base::c
[15:32:19.598]             inherits <- base::inherits
[15:32:19.598]             invokeRestart <- base::invokeRestart
[15:32:19.598]             length <- base::length
[15:32:19.598]             list <- base::list
[15:32:19.598]             seq.int <- base::seq.int
[15:32:19.598]             signalCondition <- base::signalCondition
[15:32:19.598]             sys.calls <- base::sys.calls
[15:32:19.598]             `[[` <- base::`[[`
[15:32:19.598]             `+` <- base::`+`
[15:32:19.598]             `<<-` <- base::`<<-`
[15:32:19.598]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:19.598]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:19.598]                   3L)]
[15:32:19.598]             }
[15:32:19.598]             function(cond) {
[15:32:19.598]                 is_error <- inherits(cond, "error")
[15:32:19.598]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:19.598]                   NULL)
[15:32:19.598]                 if (is_error) {
[15:32:19.598]                   sessionInformation <- function() {
[15:32:19.598]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:19.598]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:19.598]                       search = base::search(), system = base::Sys.info())
[15:32:19.598]                   }
[15:32:19.598]                   ...future.conditions[[length(...future.conditions) + 
[15:32:19.598]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:19.598]                     cond$call), session = sessionInformation(), 
[15:32:19.598]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:19.598]                   signalCondition(cond)
[15:32:19.598]                 }
[15:32:19.598]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:19.598]                 "immediateCondition"))) {
[15:32:19.598]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:19.598]                   ...future.conditions[[length(...future.conditions) + 
[15:32:19.598]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:19.598]                   if (TRUE && !signal) {
[15:32:19.598]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:19.598]                     {
[15:32:19.598]                       inherits <- base::inherits
[15:32:19.598]                       invokeRestart <- base::invokeRestart
[15:32:19.598]                       is.null <- base::is.null
[15:32:19.598]                       muffled <- FALSE
[15:32:19.598]                       if (inherits(cond, "message")) {
[15:32:19.598]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:19.598]                         if (muffled) 
[15:32:19.598]                           invokeRestart("muffleMessage")
[15:32:19.598]                       }
[15:32:19.598]                       else if (inherits(cond, "warning")) {
[15:32:19.598]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:19.598]                         if (muffled) 
[15:32:19.598]                           invokeRestart("muffleWarning")
[15:32:19.598]                       }
[15:32:19.598]                       else if (inherits(cond, "condition")) {
[15:32:19.598]                         if (!is.null(pattern)) {
[15:32:19.598]                           computeRestarts <- base::computeRestarts
[15:32:19.598]                           grepl <- base::grepl
[15:32:19.598]                           restarts <- computeRestarts(cond)
[15:32:19.598]                           for (restart in restarts) {
[15:32:19.598]                             name <- restart$name
[15:32:19.598]                             if (is.null(name)) 
[15:32:19.598]                               next
[15:32:19.598]                             if (!grepl(pattern, name)) 
[15:32:19.598]                               next
[15:32:19.598]                             invokeRestart(restart)
[15:32:19.598]                             muffled <- TRUE
[15:32:19.598]                             break
[15:32:19.598]                           }
[15:32:19.598]                         }
[15:32:19.598]                       }
[15:32:19.598]                       invisible(muffled)
[15:32:19.598]                     }
[15:32:19.598]                     muffleCondition(cond, pattern = "^muffle")
[15:32:19.598]                   }
[15:32:19.598]                 }
[15:32:19.598]                 else {
[15:32:19.598]                   if (TRUE) {
[15:32:19.598]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:19.598]                     {
[15:32:19.598]                       inherits <- base::inherits
[15:32:19.598]                       invokeRestart <- base::invokeRestart
[15:32:19.598]                       is.null <- base::is.null
[15:32:19.598]                       muffled <- FALSE
[15:32:19.598]                       if (inherits(cond, "message")) {
[15:32:19.598]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:19.598]                         if (muffled) 
[15:32:19.598]                           invokeRestart("muffleMessage")
[15:32:19.598]                       }
[15:32:19.598]                       else if (inherits(cond, "warning")) {
[15:32:19.598]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:19.598]                         if (muffled) 
[15:32:19.598]                           invokeRestart("muffleWarning")
[15:32:19.598]                       }
[15:32:19.598]                       else if (inherits(cond, "condition")) {
[15:32:19.598]                         if (!is.null(pattern)) {
[15:32:19.598]                           computeRestarts <- base::computeRestarts
[15:32:19.598]                           grepl <- base::grepl
[15:32:19.598]                           restarts <- computeRestarts(cond)
[15:32:19.598]                           for (restart in restarts) {
[15:32:19.598]                             name <- restart$name
[15:32:19.598]                             if (is.null(name)) 
[15:32:19.598]                               next
[15:32:19.598]                             if (!grepl(pattern, name)) 
[15:32:19.598]                               next
[15:32:19.598]                             invokeRestart(restart)
[15:32:19.598]                             muffled <- TRUE
[15:32:19.598]                             break
[15:32:19.598]                           }
[15:32:19.598]                         }
[15:32:19.598]                       }
[15:32:19.598]                       invisible(muffled)
[15:32:19.598]                     }
[15:32:19.598]                     muffleCondition(cond, pattern = "^muffle")
[15:32:19.598]                   }
[15:32:19.598]                 }
[15:32:19.598]             }
[15:32:19.598]         }))
[15:32:19.598]     }, error = function(ex) {
[15:32:19.598]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:19.598]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:19.598]                 ...future.rng), started = ...future.startTime, 
[15:32:19.598]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:19.598]             version = "1.8"), class = "FutureResult")
[15:32:19.598]     }, finally = {
[15:32:19.598]         if (!identical(...future.workdir, getwd())) 
[15:32:19.598]             setwd(...future.workdir)
[15:32:19.598]         {
[15:32:19.598]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:19.598]                 ...future.oldOptions$nwarnings <- NULL
[15:32:19.598]             }
[15:32:19.598]             base::options(...future.oldOptions)
[15:32:19.598]             if (.Platform$OS.type == "windows") {
[15:32:19.598]                 old_names <- names(...future.oldEnvVars)
[15:32:19.598]                 envs <- base::Sys.getenv()
[15:32:19.598]                 names <- names(envs)
[15:32:19.598]                 common <- intersect(names, old_names)
[15:32:19.598]                 added <- setdiff(names, old_names)
[15:32:19.598]                 removed <- setdiff(old_names, names)
[15:32:19.598]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:19.598]                   envs[common]]
[15:32:19.598]                 NAMES <- toupper(changed)
[15:32:19.598]                 args <- list()
[15:32:19.598]                 for (kk in seq_along(NAMES)) {
[15:32:19.598]                   name <- changed[[kk]]
[15:32:19.598]                   NAME <- NAMES[[kk]]
[15:32:19.598]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:19.598]                     next
[15:32:19.598]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:19.598]                 }
[15:32:19.598]                 NAMES <- toupper(added)
[15:32:19.598]                 for (kk in seq_along(NAMES)) {
[15:32:19.598]                   name <- added[[kk]]
[15:32:19.598]                   NAME <- NAMES[[kk]]
[15:32:19.598]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:19.598]                     next
[15:32:19.598]                   args[[name]] <- ""
[15:32:19.598]                 }
[15:32:19.598]                 NAMES <- toupper(removed)
[15:32:19.598]                 for (kk in seq_along(NAMES)) {
[15:32:19.598]                   name <- removed[[kk]]
[15:32:19.598]                   NAME <- NAMES[[kk]]
[15:32:19.598]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:19.598]                     next
[15:32:19.598]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:19.598]                 }
[15:32:19.598]                 if (length(args) > 0) 
[15:32:19.598]                   base::do.call(base::Sys.setenv, args = args)
[15:32:19.598]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:19.598]             }
[15:32:19.598]             else {
[15:32:19.598]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:19.598]             }
[15:32:19.598]             {
[15:32:19.598]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:19.598]                   0L) {
[15:32:19.598]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:19.598]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:19.598]                   base::options(opts)
[15:32:19.598]                 }
[15:32:19.598]                 {
[15:32:19.598]                   {
[15:32:19.598]                     NULL
[15:32:19.598]                     RNGkind("Mersenne-Twister")
[15:32:19.598]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:19.598]                       inherits = FALSE)
[15:32:19.598]                   }
[15:32:19.598]                   options(future.plan = NULL)
[15:32:19.598]                   if (is.na(NA_character_)) 
[15:32:19.598]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:19.598]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:19.598]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:19.598]                     .init = FALSE)
[15:32:19.598]                 }
[15:32:19.598]             }
[15:32:19.598]         }
[15:32:19.598]     })
[15:32:19.598]     if (TRUE) {
[15:32:19.598]         base::sink(type = "output", split = FALSE)
[15:32:19.598]         if (TRUE) {
[15:32:19.598]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:19.598]         }
[15:32:19.598]         else {
[15:32:19.598]             ...future.result["stdout"] <- base::list(NULL)
[15:32:19.598]         }
[15:32:19.598]         base::close(...future.stdout)
[15:32:19.598]         ...future.stdout <- NULL
[15:32:19.598]     }
[15:32:19.598]     ...future.result$conditions <- ...future.conditions
[15:32:19.598]     ...future.result$finished <- base::Sys.time()
[15:32:19.598]     ...future.result
[15:32:19.598] }
[15:32:19.602] assign_globals() ...
[15:32:19.602] List of 5
[15:32:19.602]  $ ...future.FUN            :function (x, ...)  
[15:32:19.602]  $ future.call.arguments    : list()
[15:32:19.602]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:19.602]  $ ...future.elements_ii    :List of 3
[15:32:19.602]   ..$ a: num 1
[15:32:19.602]   ..$ b: num 2
[15:32:19.602]   ..$ c: num 3
[15:32:19.602]  $ ...future.seeds_ii       : NULL
[15:32:19.602]  $ ...future.globals.maxSize: NULL
[15:32:19.602]  - attr(*, "where")=List of 5
[15:32:19.602]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:19.602]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:19.602]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:19.602]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:19.602]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:19.602]  - attr(*, "resolved")= logi FALSE
[15:32:19.602]  - attr(*, "total_size")= num 1248
[15:32:19.602]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:19.602]  - attr(*, "already-done")= logi TRUE
[15:32:19.610] - copied '...future.FUN' to environment
[15:32:19.610] - copied 'future.call.arguments' to environment
[15:32:19.610] - copied '...future.elements_ii' to environment
[15:32:19.611] - copied '...future.seeds_ii' to environment
[15:32:19.611] - copied '...future.globals.maxSize' to environment
[15:32:19.611] assign_globals() ... done
[15:32:19.612] plan(): Setting new future strategy stack:
[15:32:19.612] List of future strategies:
[15:32:19.612] 1. sequential:
[15:32:19.612]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:19.612]    - tweaked: FALSE
[15:32:19.612]    - call: NULL
[15:32:19.613] plan(): nbrOfWorkers() = 1
[15:32:19.614] plan(): Setting new future strategy stack:
[15:32:19.614] List of future strategies:
[15:32:19.614] 1. sequential:
[15:32:19.614]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:19.614]    - tweaked: FALSE
[15:32:19.614]    - call: plan(strategy)
[15:32:19.615] plan(): nbrOfWorkers() = 1
[15:32:19.616] SequentialFuture started (and completed)
[15:32:19.616] - Launch lazy future ... done
[15:32:19.616] run() for 'SequentialFuture' ... done
[15:32:19.617] Created future:
[15:32:19.617] SequentialFuture:
[15:32:19.617] Label: 'future_sapply-1'
[15:32:19.617] Expression:
[15:32:19.617] {
[15:32:19.617]     do.call(function(...) {
[15:32:19.617]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:19.617]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:19.617]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:19.617]             on.exit(options(oopts), add = TRUE)
[15:32:19.617]         }
[15:32:19.617]         {
[15:32:19.617]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:19.617]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:19.617]                 ...future.FUN(...future.X_jj, ...)
[15:32:19.617]             })
[15:32:19.617]         }
[15:32:19.617]     }, args = future.call.arguments)
[15:32:19.617] }
[15:32:19.617] Lazy evaluation: FALSE
[15:32:19.617] Asynchronous evaluation: FALSE
[15:32:19.617] Local evaluation: TRUE
[15:32:19.617] Environment: R_GlobalEnv
[15:32:19.617] Capture standard output: TRUE
[15:32:19.617] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:19.617] Globals: 5 objects totaling 1.38 KiB (function '...future.FUN' of 1.22 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:19.617] Packages: <none>
[15:32:19.617] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:19.617] Resolved: TRUE
[15:32:19.617] Value: 672 bytes of class 'list'
[15:32:19.617] Early signaling: FALSE
[15:32:19.617] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:19.617] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:19.618] Chunk #1 of 1 ... DONE
[15:32:19.619] Launching 1 futures (chunks) ... DONE
[15:32:19.619] Resolving 1 futures (chunks) ...
[15:32:19.619] resolve() on list ...
[15:32:19.619]  recursive: 0
[15:32:19.619]  length: 1
[15:32:19.620] 
[15:32:19.620] resolved() for 'SequentialFuture' ...
[15:32:19.620] - state: 'finished'
[15:32:19.620] - run: TRUE
[15:32:19.623] - result: 'FutureResult'
[15:32:19.623] resolved() for 'SequentialFuture' ... done
[15:32:19.624] Future #1
[15:32:19.624] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:19.625] - nx: 1
[15:32:19.625] - relay: TRUE
[15:32:19.625] - stdout: TRUE
[15:32:19.626] - signal: TRUE
[15:32:19.626] - resignal: FALSE
[15:32:19.626] - force: TRUE
[15:32:19.626] - relayed: [n=1] FALSE
[15:32:19.627] - queued futures: [n=1] FALSE
[15:32:19.627]  - until=1
[15:32:19.627]  - relaying element #1
[15:32:19.628] - relayed: [n=1] TRUE
[15:32:19.628] - queued futures: [n=1] TRUE
[15:32:19.628] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:19.629]  length: 0 (resolved future 1)
[15:32:19.629] Relaying remaining futures
[15:32:19.629] signalConditionsASAP(NULL, pos=0) ...
[15:32:19.629] - nx: 1
[15:32:19.630] - relay: TRUE
[15:32:19.630] - stdout: TRUE
[15:32:19.630] - signal: TRUE
[15:32:19.630] - resignal: FALSE
[15:32:19.631] - force: TRUE
[15:32:19.631] - relayed: [n=1] TRUE
[15:32:19.631] - queued futures: [n=1] TRUE
 - flush all
[15:32:19.632] - relayed: [n=1] TRUE
[15:32:19.632] - queued futures: [n=1] TRUE
[15:32:19.632] signalConditionsASAP(NULL, pos=0) ... done
[15:32:19.632] resolve() on list ... DONE
[15:32:19.633]  - Number of value chunks collected: 1
[15:32:19.633] Resolving 1 futures (chunks) ... DONE
[15:32:19.633] Reducing values from 1 chunks ...
[15:32:19.634]  - Number of values collected after concatenation: 3
[15:32:19.634]  - Number of values expected: 3
[15:32:19.634] Reducing values from 1 chunks ... DONE
[15:32:19.635] future_lapply() ... DONE
List of 2
 $ y0: Named num [1:3] 1 2 3
  ..- attr(*, "names")= chr [1:3] "a" "b" "c"
 $ y1: Named num [1:3] 1 2 3
  ..- attr(*, "names")= chr [1:3] "a" "b" "c"
[15:32:19.638] future_lapply() ...
[15:32:19.640] Number of chunks: 1
[15:32:19.640] getGlobalsAndPackagesXApply() ...
[15:32:19.640]  - future.globals: TRUE
[15:32:19.640] getGlobalsAndPackages() ...
[15:32:19.641] Searching for globals...
[15:32:19.644] - globals found: [5] 'FUN', '*', ':', 'outer', 'rep'
[15:32:19.644] Searching for globals ... DONE
[15:32:19.644] Resolving globals: FALSE
[15:32:19.645] The total size of the 1 globals is 4.62 KiB (4728 bytes)
[15:32:19.646] The total size of the 1 globals exported for future expression ('FUN()') is 4.62 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.62 KiB of class 'function')
[15:32:19.646] - globals: [1] 'FUN'
[15:32:19.647] 
[15:32:19.647] getGlobalsAndPackages() ... DONE
[15:32:19.647]  - globals found/used: [n=1] 'FUN'
[15:32:19.647]  - needed namespaces: [n=0] 
[15:32:19.648] Finding globals ... DONE
[15:32:19.648]  - use_args: TRUE
[15:32:19.648]  - Getting '...' globals ...
[15:32:19.649] resolve() on list ...
[15:32:19.649]  recursive: 0
[15:32:19.649]  length: 1
[15:32:19.650]  elements: '...'
[15:32:19.650]  length: 0 (resolved future 1)
[15:32:19.650] resolve() on list ... DONE
[15:32:19.650]    - '...' content: [n=0] 
[15:32:19.651] List of 1
[15:32:19.651]  $ ...: list()
[15:32:19.651]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:19.651]  - attr(*, "where")=List of 1
[15:32:19.651]   ..$ ...:<environment: 0x00000276dec20bc0> 
[15:32:19.651]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:19.651]  - attr(*, "resolved")= logi TRUE
[15:32:19.651]  - attr(*, "total_size")= num NA
[15:32:19.656]  - Getting '...' globals ... DONE
[15:32:19.656] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:19.656] List of 2
[15:32:19.656]  $ ...future.FUN:function (x, y = 2 * 1:5)  
[15:32:19.656]  $ ...          : list()
[15:32:19.656]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:19.656]  - attr(*, "where")=List of 2
[15:32:19.656]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:19.656]   ..$ ...          :<environment: 0x00000276dec20bc0> 
[15:32:19.656]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:19.656]  - attr(*, "resolved")= logi FALSE
[15:32:19.656]  - attr(*, "total_size")= num 4728
[15:32:19.662] Packages to be attached in all futures: [n=0] 
[15:32:19.662] getGlobalsAndPackagesXApply() ... DONE
[15:32:19.663] Number of futures (= number of chunks): 1
[15:32:19.663] Launching 1 futures (chunks) ...
[15:32:19.663] Chunk #1 of 1 ...
[15:32:19.663]  - Finding globals in 'X' for chunk #1 ...
[15:32:19.666] getGlobalsAndPackages() ...
[15:32:19.667] Searching for globals...
[15:32:19.667] 
[15:32:19.667] Searching for globals ... DONE
[15:32:19.668] - globals: [0] <none>
[15:32:19.668] getGlobalsAndPackages() ... DONE
[15:32:19.668]    + additional globals found: [n=0] 
[15:32:19.669]    + additional namespaces needed: [n=0] 
[15:32:19.669]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:19.669]  - seeds: <none>
[15:32:19.669]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:19.670] getGlobalsAndPackages() ...
[15:32:19.670] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:19.670] Resolving globals: FALSE
[15:32:19.671] Tweak future expression to call with '...' arguments ...
[15:32:19.671] {
[15:32:19.671]     do.call(function(...) {
[15:32:19.671]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:19.671]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:19.671]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:19.671]             on.exit(options(oopts), add = TRUE)
[15:32:19.671]         }
[15:32:19.671]         {
[15:32:19.671]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:19.671]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:19.671]                 ...future.FUN(...future.X_jj, ...)
[15:32:19.671]             })
[15:32:19.671]         }
[15:32:19.671]     }, args = future.call.arguments)
[15:32:19.671] }
[15:32:19.672] Tweak future expression to call with '...' arguments ... DONE
[15:32:19.672] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:19.673] 
[15:32:19.673] getGlobalsAndPackages() ... DONE
[15:32:19.674] run() for 'Future' ...
[15:32:19.674] - state: 'created'
[15:32:19.674] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:19.675] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:19.675] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:19.675]   - Field: 'label'
[15:32:19.676]   - Field: 'local'
[15:32:19.676]   - Field: 'owner'
[15:32:19.676]   - Field: 'envir'
[15:32:19.677]   - Field: 'packages'
[15:32:19.677]   - Field: 'gc'
[15:32:19.677]   - Field: 'conditions'
[15:32:19.678]   - Field: 'expr'
[15:32:19.678]   - Field: 'uuid'
[15:32:19.678]   - Field: 'seed'
[15:32:19.678]   - Field: 'version'
[15:32:19.679]   - Field: 'result'
[15:32:19.679]   - Field: 'asynchronous'
[15:32:19.679]   - Field: 'calls'
[15:32:19.680]   - Field: 'globals'
[15:32:19.680]   - Field: 'stdout'
[15:32:19.680]   - Field: 'earlySignal'
[15:32:19.680]   - Field: 'lazy'
[15:32:19.681]   - Field: 'state'
[15:32:19.681] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:19.681] - Launch lazy future ...
[15:32:19.682] Packages needed by the future expression (n = 0): <none>
[15:32:19.682] Packages needed by future strategies (n = 0): <none>
[15:32:19.683] {
[15:32:19.683]     {
[15:32:19.683]         {
[15:32:19.683]             ...future.startTime <- base::Sys.time()
[15:32:19.683]             {
[15:32:19.683]                 {
[15:32:19.683]                   {
[15:32:19.683]                     base::local({
[15:32:19.683]                       has_future <- base::requireNamespace("future", 
[15:32:19.683]                         quietly = TRUE)
[15:32:19.683]                       if (has_future) {
[15:32:19.683]                         ns <- base::getNamespace("future")
[15:32:19.683]                         version <- ns[[".package"]][["version"]]
[15:32:19.683]                         if (is.null(version)) 
[15:32:19.683]                           version <- utils::packageVersion("future")
[15:32:19.683]                       }
[15:32:19.683]                       else {
[15:32:19.683]                         version <- NULL
[15:32:19.683]                       }
[15:32:19.683]                       if (!has_future || version < "1.8.0") {
[15:32:19.683]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:19.683]                           "", base::R.version$version.string), 
[15:32:19.683]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:19.683]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:19.683]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:19.683]                             "release", "version")], collapse = " "), 
[15:32:19.683]                           hostname = base::Sys.info()[["nodename"]])
[15:32:19.683]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:19.683]                           info)
[15:32:19.683]                         info <- base::paste(info, collapse = "; ")
[15:32:19.683]                         if (!has_future) {
[15:32:19.683]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:19.683]                             info)
[15:32:19.683]                         }
[15:32:19.683]                         else {
[15:32:19.683]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:19.683]                             info, version)
[15:32:19.683]                         }
[15:32:19.683]                         base::stop(msg)
[15:32:19.683]                       }
[15:32:19.683]                     })
[15:32:19.683]                   }
[15:32:19.683]                   ...future.strategy.old <- future::plan("list")
[15:32:19.683]                   options(future.plan = NULL)
[15:32:19.683]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:19.683]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:19.683]                 }
[15:32:19.683]                 ...future.workdir <- getwd()
[15:32:19.683]             }
[15:32:19.683]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:19.683]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:19.683]         }
[15:32:19.683]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:19.683]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:19.683]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:19.683]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:19.683]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:19.683]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:19.683]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:19.683]             base::names(...future.oldOptions))
[15:32:19.683]     }
[15:32:19.683]     if (FALSE) {
[15:32:19.683]     }
[15:32:19.683]     else {
[15:32:19.683]         if (TRUE) {
[15:32:19.683]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:19.683]                 open = "w")
[15:32:19.683]         }
[15:32:19.683]         else {
[15:32:19.683]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:19.683]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:19.683]         }
[15:32:19.683]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:19.683]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:19.683]             base::sink(type = "output", split = FALSE)
[15:32:19.683]             base::close(...future.stdout)
[15:32:19.683]         }, add = TRUE)
[15:32:19.683]     }
[15:32:19.683]     ...future.frame <- base::sys.nframe()
[15:32:19.683]     ...future.conditions <- base::list()
[15:32:19.683]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:19.683]     if (FALSE) {
[15:32:19.683]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:19.683]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:19.683]     }
[15:32:19.683]     ...future.result <- base::tryCatch({
[15:32:19.683]         base::withCallingHandlers({
[15:32:19.683]             ...future.value <- base::withVisible(base::local({
[15:32:19.683]                 do.call(function(...) {
[15:32:19.683]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:19.683]                   if (!identical(...future.globals.maxSize.org, 
[15:32:19.683]                     ...future.globals.maxSize)) {
[15:32:19.683]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:19.683]                     on.exit(options(oopts), add = TRUE)
[15:32:19.683]                   }
[15:32:19.683]                   {
[15:32:19.683]                     lapply(seq_along(...future.elements_ii), 
[15:32:19.683]                       FUN = function(jj) {
[15:32:19.683]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:19.683]                         ...future.FUN(...future.X_jj, ...)
[15:32:19.683]                       })
[15:32:19.683]                   }
[15:32:19.683]                 }, args = future.call.arguments)
[15:32:19.683]             }))
[15:32:19.683]             future::FutureResult(value = ...future.value$value, 
[15:32:19.683]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:19.683]                   ...future.rng), globalenv = if (FALSE) 
[15:32:19.683]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:19.683]                     ...future.globalenv.names))
[15:32:19.683]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:19.683]         }, condition = base::local({
[15:32:19.683]             c <- base::c
[15:32:19.683]             inherits <- base::inherits
[15:32:19.683]             invokeRestart <- base::invokeRestart
[15:32:19.683]             length <- base::length
[15:32:19.683]             list <- base::list
[15:32:19.683]             seq.int <- base::seq.int
[15:32:19.683]             signalCondition <- base::signalCondition
[15:32:19.683]             sys.calls <- base::sys.calls
[15:32:19.683]             `[[` <- base::`[[`
[15:32:19.683]             `+` <- base::`+`
[15:32:19.683]             `<<-` <- base::`<<-`
[15:32:19.683]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:19.683]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:19.683]                   3L)]
[15:32:19.683]             }
[15:32:19.683]             function(cond) {
[15:32:19.683]                 is_error <- inherits(cond, "error")
[15:32:19.683]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:19.683]                   NULL)
[15:32:19.683]                 if (is_error) {
[15:32:19.683]                   sessionInformation <- function() {
[15:32:19.683]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:19.683]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:19.683]                       search = base::search(), system = base::Sys.info())
[15:32:19.683]                   }
[15:32:19.683]                   ...future.conditions[[length(...future.conditions) + 
[15:32:19.683]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:19.683]                     cond$call), session = sessionInformation(), 
[15:32:19.683]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:19.683]                   signalCondition(cond)
[15:32:19.683]                 }
[15:32:19.683]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:19.683]                 "immediateCondition"))) {
[15:32:19.683]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:19.683]                   ...future.conditions[[length(...future.conditions) + 
[15:32:19.683]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:19.683]                   if (TRUE && !signal) {
[15:32:19.683]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:19.683]                     {
[15:32:19.683]                       inherits <- base::inherits
[15:32:19.683]                       invokeRestart <- base::invokeRestart
[15:32:19.683]                       is.null <- base::is.null
[15:32:19.683]                       muffled <- FALSE
[15:32:19.683]                       if (inherits(cond, "message")) {
[15:32:19.683]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:19.683]                         if (muffled) 
[15:32:19.683]                           invokeRestart("muffleMessage")
[15:32:19.683]                       }
[15:32:19.683]                       else if (inherits(cond, "warning")) {
[15:32:19.683]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:19.683]                         if (muffled) 
[15:32:19.683]                           invokeRestart("muffleWarning")
[15:32:19.683]                       }
[15:32:19.683]                       else if (inherits(cond, "condition")) {
[15:32:19.683]                         if (!is.null(pattern)) {
[15:32:19.683]                           computeRestarts <- base::computeRestarts
[15:32:19.683]                           grepl <- base::grepl
[15:32:19.683]                           restarts <- computeRestarts(cond)
[15:32:19.683]                           for (restart in restarts) {
[15:32:19.683]                             name <- restart$name
[15:32:19.683]                             if (is.null(name)) 
[15:32:19.683]                               next
[15:32:19.683]                             if (!grepl(pattern, name)) 
[15:32:19.683]                               next
[15:32:19.683]                             invokeRestart(restart)
[15:32:19.683]                             muffled <- TRUE
[15:32:19.683]                             break
[15:32:19.683]                           }
[15:32:19.683]                         }
[15:32:19.683]                       }
[15:32:19.683]                       invisible(muffled)
[15:32:19.683]                     }
[15:32:19.683]                     muffleCondition(cond, pattern = "^muffle")
[15:32:19.683]                   }
[15:32:19.683]                 }
[15:32:19.683]                 else {
[15:32:19.683]                   if (TRUE) {
[15:32:19.683]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:19.683]                     {
[15:32:19.683]                       inherits <- base::inherits
[15:32:19.683]                       invokeRestart <- base::invokeRestart
[15:32:19.683]                       is.null <- base::is.null
[15:32:19.683]                       muffled <- FALSE
[15:32:19.683]                       if (inherits(cond, "message")) {
[15:32:19.683]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:19.683]                         if (muffled) 
[15:32:19.683]                           invokeRestart("muffleMessage")
[15:32:19.683]                       }
[15:32:19.683]                       else if (inherits(cond, "warning")) {
[15:32:19.683]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:19.683]                         if (muffled) 
[15:32:19.683]                           invokeRestart("muffleWarning")
[15:32:19.683]                       }
[15:32:19.683]                       else if (inherits(cond, "condition")) {
[15:32:19.683]                         if (!is.null(pattern)) {
[15:32:19.683]                           computeRestarts <- base::computeRestarts
[15:32:19.683]                           grepl <- base::grepl
[15:32:19.683]                           restarts <- computeRestarts(cond)
[15:32:19.683]                           for (restart in restarts) {
[15:32:19.683]                             name <- restart$name
[15:32:19.683]                             if (is.null(name)) 
[15:32:19.683]                               next
[15:32:19.683]                             if (!grepl(pattern, name)) 
[15:32:19.683]                               next
[15:32:19.683]                             invokeRestart(restart)
[15:32:19.683]                             muffled <- TRUE
[15:32:19.683]                             break
[15:32:19.683]                           }
[15:32:19.683]                         }
[15:32:19.683]                       }
[15:32:19.683]                       invisible(muffled)
[15:32:19.683]                     }
[15:32:19.683]                     muffleCondition(cond, pattern = "^muffle")
[15:32:19.683]                   }
[15:32:19.683]                 }
[15:32:19.683]             }
[15:32:19.683]         }))
[15:32:19.683]     }, error = function(ex) {
[15:32:19.683]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:19.683]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:19.683]                 ...future.rng), started = ...future.startTime, 
[15:32:19.683]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:19.683]             version = "1.8"), class = "FutureResult")
[15:32:19.683]     }, finally = {
[15:32:19.683]         if (!identical(...future.workdir, getwd())) 
[15:32:19.683]             setwd(...future.workdir)
[15:32:19.683]         {
[15:32:19.683]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:19.683]                 ...future.oldOptions$nwarnings <- NULL
[15:32:19.683]             }
[15:32:19.683]             base::options(...future.oldOptions)
[15:32:19.683]             if (.Platform$OS.type == "windows") {
[15:32:19.683]                 old_names <- names(...future.oldEnvVars)
[15:32:19.683]                 envs <- base::Sys.getenv()
[15:32:19.683]                 names <- names(envs)
[15:32:19.683]                 common <- intersect(names, old_names)
[15:32:19.683]                 added <- setdiff(names, old_names)
[15:32:19.683]                 removed <- setdiff(old_names, names)
[15:32:19.683]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:19.683]                   envs[common]]
[15:32:19.683]                 NAMES <- toupper(changed)
[15:32:19.683]                 args <- list()
[15:32:19.683]                 for (kk in seq_along(NAMES)) {
[15:32:19.683]                   name <- changed[[kk]]
[15:32:19.683]                   NAME <- NAMES[[kk]]
[15:32:19.683]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:19.683]                     next
[15:32:19.683]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:19.683]                 }
[15:32:19.683]                 NAMES <- toupper(added)
[15:32:19.683]                 for (kk in seq_along(NAMES)) {
[15:32:19.683]                   name <- added[[kk]]
[15:32:19.683]                   NAME <- NAMES[[kk]]
[15:32:19.683]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:19.683]                     next
[15:32:19.683]                   args[[name]] <- ""
[15:32:19.683]                 }
[15:32:19.683]                 NAMES <- toupper(removed)
[15:32:19.683]                 for (kk in seq_along(NAMES)) {
[15:32:19.683]                   name <- removed[[kk]]
[15:32:19.683]                   NAME <- NAMES[[kk]]
[15:32:19.683]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:19.683]                     next
[15:32:19.683]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:19.683]                 }
[15:32:19.683]                 if (length(args) > 0) 
[15:32:19.683]                   base::do.call(base::Sys.setenv, args = args)
[15:32:19.683]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:19.683]             }
[15:32:19.683]             else {
[15:32:19.683]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:19.683]             }
[15:32:19.683]             {
[15:32:19.683]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:19.683]                   0L) {
[15:32:19.683]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:19.683]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:19.683]                   base::options(opts)
[15:32:19.683]                 }
[15:32:19.683]                 {
[15:32:19.683]                   {
[15:32:19.683]                     NULL
[15:32:19.683]                     RNGkind("Mersenne-Twister")
[15:32:19.683]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:19.683]                       inherits = FALSE)
[15:32:19.683]                   }
[15:32:19.683]                   options(future.plan = NULL)
[15:32:19.683]                   if (is.na(NA_character_)) 
[15:32:19.683]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:19.683]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:19.683]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:19.683]                     .init = FALSE)
[15:32:19.683]                 }
[15:32:19.683]             }
[15:32:19.683]         }
[15:32:19.683]     })
[15:32:19.683]     if (TRUE) {
[15:32:19.683]         base::sink(type = "output", split = FALSE)
[15:32:19.683]         if (TRUE) {
[15:32:19.683]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:19.683]         }
[15:32:19.683]         else {
[15:32:19.683]             ...future.result["stdout"] <- base::list(NULL)
[15:32:19.683]         }
[15:32:19.683]         base::close(...future.stdout)
[15:32:19.683]         ...future.stdout <- NULL
[15:32:19.683]     }
[15:32:19.683]     ...future.result$conditions <- ...future.conditions
[15:32:19.683]     ...future.result$finished <- base::Sys.time()
[15:32:19.683]     ...future.result
[15:32:19.683] }
[15:32:19.690] assign_globals() ...
[15:32:19.690] List of 5
[15:32:19.690]  $ ...future.FUN            :function (x, y = 2 * 1:5)  
[15:32:19.690]  $ future.call.arguments    : list()
[15:32:19.690]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:19.690]  $ ...future.elements_ii    :List of 3
[15:32:19.690]   ..$ a: num 1
[15:32:19.690]   ..$ b: num 2
[15:32:19.690]   ..$ c: num 3
[15:32:19.690]  $ ...future.seeds_ii       : NULL
[15:32:19.690]  $ ...future.globals.maxSize: NULL
[15:32:19.690]  - attr(*, "where")=List of 5
[15:32:19.690]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:19.690]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:19.690]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:19.690]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:19.690]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:19.690]  - attr(*, "resolved")= logi FALSE
[15:32:19.690]  - attr(*, "total_size")= num 4728
[15:32:19.690]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:19.690]  - attr(*, "already-done")= logi TRUE
[15:32:19.701] - reassign environment for '...future.FUN'
[15:32:19.701] - copied '...future.FUN' to environment
[15:32:19.701] - copied 'future.call.arguments' to environment
[15:32:19.702] - copied '...future.elements_ii' to environment
[15:32:19.702] - copied '...future.seeds_ii' to environment
[15:32:19.702] - copied '...future.globals.maxSize' to environment
[15:32:19.703] assign_globals() ... done
[15:32:19.703] plan(): Setting new future strategy stack:
[15:32:19.704] List of future strategies:
[15:32:19.704] 1. sequential:
[15:32:19.704]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:19.704]    - tweaked: FALSE
[15:32:19.704]    - call: NULL
[15:32:19.704] plan(): nbrOfWorkers() = 1
[15:32:19.706] plan(): Setting new future strategy stack:
[15:32:19.706] List of future strategies:
[15:32:19.706] 1. sequential:
[15:32:19.706]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:19.706]    - tweaked: FALSE
[15:32:19.706]    - call: plan(strategy)
[15:32:19.707] plan(): nbrOfWorkers() = 1
[15:32:19.707] SequentialFuture started (and completed)
[15:32:19.707] - Launch lazy future ... done
[15:32:19.707] run() for 'SequentialFuture' ... done
[15:32:19.708] Created future:
[15:32:19.708] SequentialFuture:
[15:32:19.708] Label: 'future_sapply-1'
[15:32:19.708] Expression:
[15:32:19.708] {
[15:32:19.708]     do.call(function(...) {
[15:32:19.708]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:19.708]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:19.708]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:19.708]             on.exit(options(oopts), add = TRUE)
[15:32:19.708]         }
[15:32:19.708]         {
[15:32:19.708]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:19.708]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:19.708]                 ...future.FUN(...future.X_jj, ...)
[15:32:19.708]             })
[15:32:19.708]         }
[15:32:19.708]     }, args = future.call.arguments)
[15:32:19.708] }
[15:32:19.708] Lazy evaluation: FALSE
[15:32:19.708] Asynchronous evaluation: FALSE
[15:32:19.708] Local evaluation: TRUE
[15:32:19.708] Environment: R_GlobalEnv
[15:32:19.708] Capture standard output: TRUE
[15:32:19.708] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:19.708] Globals: 5 objects totaling 4.78 KiB (function '...future.FUN' of 4.62 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:19.708] Packages: <none>
[15:32:19.708] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:19.708] Resolved: TRUE
[15:32:19.708] Value: 1.01 KiB of class 'list'
[15:32:19.708] Early signaling: FALSE
[15:32:19.708] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:19.708] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:19.709] Chunk #1 of 1 ... DONE
[15:32:19.710] Launching 1 futures (chunks) ... DONE
[15:32:19.710] Resolving 1 futures (chunks) ...
[15:32:19.710] resolve() on list ...
[15:32:19.710]  recursive: 0
[15:32:19.710]  length: 1
[15:32:19.710] 
[15:32:19.711] resolved() for 'SequentialFuture' ...
[15:32:19.711] - state: 'finished'
[15:32:19.711] - run: TRUE
[15:32:19.711] - result: 'FutureResult'
[15:32:19.711] resolved() for 'SequentialFuture' ... done
[15:32:19.712] Future #1
[15:32:19.714] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:19.714] - nx: 1
[15:32:19.714] - relay: TRUE
[15:32:19.714] - stdout: TRUE
[15:32:19.714] - signal: TRUE
[15:32:19.715] - resignal: FALSE
[15:32:19.715] - force: TRUE
[15:32:19.715] - relayed: [n=1] FALSE
[15:32:19.715] - queued futures: [n=1] FALSE
[15:32:19.715]  - until=1
[15:32:19.715]  - relaying element #1
[15:32:19.716] - relayed: [n=1] TRUE
[15:32:19.716] - queued futures: [n=1] TRUE
[15:32:19.716] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:19.716]  length: 0 (resolved future 1)
[15:32:19.717] Relaying remaining futures
[15:32:19.717] signalConditionsASAP(NULL, pos=0) ...
[15:32:19.717] - nx: 1
[15:32:19.717] - relay: TRUE
[15:32:19.717] - stdout: TRUE
[15:32:19.717] - signal: TRUE
[15:32:19.717] - resignal: FALSE
[15:32:19.718] - force: TRUE
[15:32:19.718] - relayed: [n=1] TRUE
[15:32:19.718] - queued futures: [n=1] TRUE
 - flush all
[15:32:19.719] - relayed: [n=1] TRUE
[15:32:19.719] - queued futures: [n=1] TRUE
[15:32:19.719] signalConditionsASAP(NULL, pos=0) ... done
[15:32:19.720] resolve() on list ... DONE
[15:32:19.720]  - Number of value chunks collected: 1
[15:32:19.720] Resolving 1 futures (chunks) ... DONE
[15:32:19.720] Reducing values from 1 chunks ...
[15:32:19.721]  - Number of values collected after concatenation: 3
[15:32:19.721]  - Number of values expected: 3
[15:32:19.721] Reducing values from 1 chunks ... DONE
[15:32:19.722] future_lapply() ... DONE
List of 2
 $ y0: num [1:15, 1:3] 2 2 2 4 4 4 6 6 6 8 ...
  ..- attr(*, "dimnames")=List of 2
  .. ..$ : NULL
  .. ..$ : chr [1:3] "a" "b" "c"
 $ y1: num [1:15, 1:3] 2 2 2 4 4 4 6 6 6 8 ...
  ..- attr(*, "dimnames")=List of 2
  .. ..$ : NULL
  .. ..$ : chr [1:3] "a" "b" "c"
[15:32:19.726] future_lapply() ...
[15:32:19.727] Number of chunks: 1
[15:32:19.727] getGlobalsAndPackagesXApply() ...
[15:32:19.727]  - future.globals: TRUE
[15:32:19.728] getGlobalsAndPackages() ...
[15:32:19.728] Searching for globals...
[15:32:19.729] - globals found: [1] 'FUN'
[15:32:19.729] Searching for globals ... DONE
[15:32:19.730] Resolving globals: FALSE
[15:32:19.730] The total size of the 1 globals is 848 bytes (848 bytes)
[15:32:19.730] The total size of the 1 globals exported for future expression ('FUN()') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:32:19.731] - globals: [1] 'FUN'
[15:32:19.731] 
[15:32:19.731] getGlobalsAndPackages() ... DONE
[15:32:19.731]  - globals found/used: [n=1] 'FUN'
[15:32:19.731]  - needed namespaces: [n=0] 
[15:32:19.732] Finding globals ... DONE
[15:32:19.732]  - use_args: TRUE
[15:32:19.732]  - Getting '...' globals ...
[15:32:19.732] resolve() on list ...
[15:32:19.732]  recursive: 0
[15:32:19.733]  length: 1
[15:32:19.733]  elements: '...'
[15:32:19.733]  length: 0 (resolved future 1)
[15:32:19.733] resolve() on list ... DONE
[15:32:19.733]    - '...' content: [n=0] 
[15:32:19.734] List of 1
[15:32:19.734]  $ ...: list()
[15:32:19.734]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:19.734]  - attr(*, "where")=List of 1
[15:32:19.734]   ..$ ...:<environment: 0x00000276e0788d50> 
[15:32:19.734]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:19.734]  - attr(*, "resolved")= logi TRUE
[15:32:19.734]  - attr(*, "total_size")= num NA
[15:32:19.738]  - Getting '...' globals ... DONE
[15:32:19.739] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:19.739] List of 2
[15:32:19.739]  $ ...future.FUN:function (x)  
[15:32:19.739]  $ ...          : list()
[15:32:19.739]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:19.739]  - attr(*, "where")=List of 2
[15:32:19.739]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:19.739]   ..$ ...          :<environment: 0x00000276e0788d50> 
[15:32:19.739]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:19.739]  - attr(*, "resolved")= logi FALSE
[15:32:19.739]  - attr(*, "total_size")= num 848
[15:32:19.743] Packages to be attached in all futures: [n=0] 
[15:32:19.744] getGlobalsAndPackagesXApply() ... DONE
[15:32:19.744] Number of futures (= number of chunks): 1
[15:32:19.744] Launching 1 futures (chunks) ...
[15:32:19.745] Chunk #1 of 1 ...
[15:32:19.745]  - Finding globals in 'X' for chunk #1 ...
[15:32:19.745] getGlobalsAndPackages() ...
[15:32:19.745] Searching for globals...
[15:32:19.749] 
[15:32:19.749] Searching for globals ... DONE
[15:32:19.749] - globals: [0] <none>
[15:32:19.749] getGlobalsAndPackages() ... DONE
[15:32:19.750]    + additional globals found: [n=0] 
[15:32:19.750]    + additional namespaces needed: [n=0] 
[15:32:19.750]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:19.750]  - seeds: <none>
[15:32:19.750]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:19.751] getGlobalsAndPackages() ...
[15:32:19.751] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:19.752] Resolving globals: FALSE
[15:32:19.752] Tweak future expression to call with '...' arguments ...
[15:32:19.752] {
[15:32:19.752]     do.call(function(...) {
[15:32:19.752]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:19.752]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:19.752]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:19.752]             on.exit(options(oopts), add = TRUE)
[15:32:19.752]         }
[15:32:19.752]         {
[15:32:19.752]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:19.752]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:19.752]                 ...future.FUN(...future.X_jj, ...)
[15:32:19.752]             })
[15:32:19.752]         }
[15:32:19.752]     }, args = future.call.arguments)
[15:32:19.752] }
[15:32:19.753] Tweak future expression to call with '...' arguments ... DONE
[15:32:19.753] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:19.754] 
[15:32:19.754] getGlobalsAndPackages() ... DONE
[15:32:19.754] run() for 'Future' ...
[15:32:19.755] - state: 'created'
[15:32:19.755] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:19.756] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:19.756] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:19.756]   - Field: 'label'
[15:32:19.756]   - Field: 'local'
[15:32:19.757]   - Field: 'owner'
[15:32:19.757]   - Field: 'envir'
[15:32:19.757]   - Field: 'packages'
[15:32:19.758]   - Field: 'gc'
[15:32:19.758]   - Field: 'conditions'
[15:32:19.758]   - Field: 'expr'
[15:32:19.758]   - Field: 'uuid'
[15:32:19.759]   - Field: 'seed'
[15:32:19.759]   - Field: 'version'
[15:32:19.759]   - Field: 'result'
[15:32:19.759]   - Field: 'asynchronous'
[15:32:19.760]   - Field: 'calls'
[15:32:19.760]   - Field: 'globals'
[15:32:19.760]   - Field: 'stdout'
[15:32:19.760]   - Field: 'earlySignal'
[15:32:19.761]   - Field: 'lazy'
[15:32:19.761]   - Field: 'state'
[15:32:19.761] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:19.761] - Launch lazy future ...
[15:32:19.762] Packages needed by the future expression (n = 0): <none>
[15:32:19.762] Packages needed by future strategies (n = 0): <none>
[15:32:19.763] {
[15:32:19.763]     {
[15:32:19.763]         {
[15:32:19.763]             ...future.startTime <- base::Sys.time()
[15:32:19.763]             {
[15:32:19.763]                 {
[15:32:19.763]                   {
[15:32:19.763]                     base::local({
[15:32:19.763]                       has_future <- base::requireNamespace("future", 
[15:32:19.763]                         quietly = TRUE)
[15:32:19.763]                       if (has_future) {
[15:32:19.763]                         ns <- base::getNamespace("future")
[15:32:19.763]                         version <- ns[[".package"]][["version"]]
[15:32:19.763]                         if (is.null(version)) 
[15:32:19.763]                           version <- utils::packageVersion("future")
[15:32:19.763]                       }
[15:32:19.763]                       else {
[15:32:19.763]                         version <- NULL
[15:32:19.763]                       }
[15:32:19.763]                       if (!has_future || version < "1.8.0") {
[15:32:19.763]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:19.763]                           "", base::R.version$version.string), 
[15:32:19.763]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:19.763]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:19.763]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:19.763]                             "release", "version")], collapse = " "), 
[15:32:19.763]                           hostname = base::Sys.info()[["nodename"]])
[15:32:19.763]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:19.763]                           info)
[15:32:19.763]                         info <- base::paste(info, collapse = "; ")
[15:32:19.763]                         if (!has_future) {
[15:32:19.763]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:19.763]                             info)
[15:32:19.763]                         }
[15:32:19.763]                         else {
[15:32:19.763]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:19.763]                             info, version)
[15:32:19.763]                         }
[15:32:19.763]                         base::stop(msg)
[15:32:19.763]                       }
[15:32:19.763]                     })
[15:32:19.763]                   }
[15:32:19.763]                   ...future.strategy.old <- future::plan("list")
[15:32:19.763]                   options(future.plan = NULL)
[15:32:19.763]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:19.763]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:19.763]                 }
[15:32:19.763]                 ...future.workdir <- getwd()
[15:32:19.763]             }
[15:32:19.763]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:19.763]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:19.763]         }
[15:32:19.763]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:19.763]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:19.763]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:19.763]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:19.763]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:19.763]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:19.763]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:19.763]             base::names(...future.oldOptions))
[15:32:19.763]     }
[15:32:19.763]     if (FALSE) {
[15:32:19.763]     }
[15:32:19.763]     else {
[15:32:19.763]         if (TRUE) {
[15:32:19.763]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:19.763]                 open = "w")
[15:32:19.763]         }
[15:32:19.763]         else {
[15:32:19.763]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:19.763]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:19.763]         }
[15:32:19.763]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:19.763]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:19.763]             base::sink(type = "output", split = FALSE)
[15:32:19.763]             base::close(...future.stdout)
[15:32:19.763]         }, add = TRUE)
[15:32:19.763]     }
[15:32:19.763]     ...future.frame <- base::sys.nframe()
[15:32:19.763]     ...future.conditions <- base::list()
[15:32:19.763]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:19.763]     if (FALSE) {
[15:32:19.763]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:19.763]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:19.763]     }
[15:32:19.763]     ...future.result <- base::tryCatch({
[15:32:19.763]         base::withCallingHandlers({
[15:32:19.763]             ...future.value <- base::withVisible(base::local({
[15:32:19.763]                 do.call(function(...) {
[15:32:19.763]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:19.763]                   if (!identical(...future.globals.maxSize.org, 
[15:32:19.763]                     ...future.globals.maxSize)) {
[15:32:19.763]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:19.763]                     on.exit(options(oopts), add = TRUE)
[15:32:19.763]                   }
[15:32:19.763]                   {
[15:32:19.763]                     lapply(seq_along(...future.elements_ii), 
[15:32:19.763]                       FUN = function(jj) {
[15:32:19.763]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:19.763]                         ...future.FUN(...future.X_jj, ...)
[15:32:19.763]                       })
[15:32:19.763]                   }
[15:32:19.763]                 }, args = future.call.arguments)
[15:32:19.763]             }))
[15:32:19.763]             future::FutureResult(value = ...future.value$value, 
[15:32:19.763]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:19.763]                   ...future.rng), globalenv = if (FALSE) 
[15:32:19.763]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:19.763]                     ...future.globalenv.names))
[15:32:19.763]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:19.763]         }, condition = base::local({
[15:32:19.763]             c <- base::c
[15:32:19.763]             inherits <- base::inherits
[15:32:19.763]             invokeRestart <- base::invokeRestart
[15:32:19.763]             length <- base::length
[15:32:19.763]             list <- base::list
[15:32:19.763]             seq.int <- base::seq.int
[15:32:19.763]             signalCondition <- base::signalCondition
[15:32:19.763]             sys.calls <- base::sys.calls
[15:32:19.763]             `[[` <- base::`[[`
[15:32:19.763]             `+` <- base::`+`
[15:32:19.763]             `<<-` <- base::`<<-`
[15:32:19.763]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:19.763]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:19.763]                   3L)]
[15:32:19.763]             }
[15:32:19.763]             function(cond) {
[15:32:19.763]                 is_error <- inherits(cond, "error")
[15:32:19.763]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:19.763]                   NULL)
[15:32:19.763]                 if (is_error) {
[15:32:19.763]                   sessionInformation <- function() {
[15:32:19.763]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:19.763]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:19.763]                       search = base::search(), system = base::Sys.info())
[15:32:19.763]                   }
[15:32:19.763]                   ...future.conditions[[length(...future.conditions) + 
[15:32:19.763]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:19.763]                     cond$call), session = sessionInformation(), 
[15:32:19.763]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:19.763]                   signalCondition(cond)
[15:32:19.763]                 }
[15:32:19.763]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:19.763]                 "immediateCondition"))) {
[15:32:19.763]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:19.763]                   ...future.conditions[[length(...future.conditions) + 
[15:32:19.763]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:19.763]                   if (TRUE && !signal) {
[15:32:19.763]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:19.763]                     {
[15:32:19.763]                       inherits <- base::inherits
[15:32:19.763]                       invokeRestart <- base::invokeRestart
[15:32:19.763]                       is.null <- base::is.null
[15:32:19.763]                       muffled <- FALSE
[15:32:19.763]                       if (inherits(cond, "message")) {
[15:32:19.763]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:19.763]                         if (muffled) 
[15:32:19.763]                           invokeRestart("muffleMessage")
[15:32:19.763]                       }
[15:32:19.763]                       else if (inherits(cond, "warning")) {
[15:32:19.763]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:19.763]                         if (muffled) 
[15:32:19.763]                           invokeRestart("muffleWarning")
[15:32:19.763]                       }
[15:32:19.763]                       else if (inherits(cond, "condition")) {
[15:32:19.763]                         if (!is.null(pattern)) {
[15:32:19.763]                           computeRestarts <- base::computeRestarts
[15:32:19.763]                           grepl <- base::grepl
[15:32:19.763]                           restarts <- computeRestarts(cond)
[15:32:19.763]                           for (restart in restarts) {
[15:32:19.763]                             name <- restart$name
[15:32:19.763]                             if (is.null(name)) 
[15:32:19.763]                               next
[15:32:19.763]                             if (!grepl(pattern, name)) 
[15:32:19.763]                               next
[15:32:19.763]                             invokeRestart(restart)
[15:32:19.763]                             muffled <- TRUE
[15:32:19.763]                             break
[15:32:19.763]                           }
[15:32:19.763]                         }
[15:32:19.763]                       }
[15:32:19.763]                       invisible(muffled)
[15:32:19.763]                     }
[15:32:19.763]                     muffleCondition(cond, pattern = "^muffle")
[15:32:19.763]                   }
[15:32:19.763]                 }
[15:32:19.763]                 else {
[15:32:19.763]                   if (TRUE) {
[15:32:19.763]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:19.763]                     {
[15:32:19.763]                       inherits <- base::inherits
[15:32:19.763]                       invokeRestart <- base::invokeRestart
[15:32:19.763]                       is.null <- base::is.null
[15:32:19.763]                       muffled <- FALSE
[15:32:19.763]                       if (inherits(cond, "message")) {
[15:32:19.763]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:19.763]                         if (muffled) 
[15:32:19.763]                           invokeRestart("muffleMessage")
[15:32:19.763]                       }
[15:32:19.763]                       else if (inherits(cond, "warning")) {
[15:32:19.763]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:19.763]                         if (muffled) 
[15:32:19.763]                           invokeRestart("muffleWarning")
[15:32:19.763]                       }
[15:32:19.763]                       else if (inherits(cond, "condition")) {
[15:32:19.763]                         if (!is.null(pattern)) {
[15:32:19.763]                           computeRestarts <- base::computeRestarts
[15:32:19.763]                           grepl <- base::grepl
[15:32:19.763]                           restarts <- computeRestarts(cond)
[15:32:19.763]                           for (restart in restarts) {
[15:32:19.763]                             name <- restart$name
[15:32:19.763]                             if (is.null(name)) 
[15:32:19.763]                               next
[15:32:19.763]                             if (!grepl(pattern, name)) 
[15:32:19.763]                               next
[15:32:19.763]                             invokeRestart(restart)
[15:32:19.763]                             muffled <- TRUE
[15:32:19.763]                             break
[15:32:19.763]                           }
[15:32:19.763]                         }
[15:32:19.763]                       }
[15:32:19.763]                       invisible(muffled)
[15:32:19.763]                     }
[15:32:19.763]                     muffleCondition(cond, pattern = "^muffle")
[15:32:19.763]                   }
[15:32:19.763]                 }
[15:32:19.763]             }
[15:32:19.763]         }))
[15:32:19.763]     }, error = function(ex) {
[15:32:19.763]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:19.763]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:19.763]                 ...future.rng), started = ...future.startTime, 
[15:32:19.763]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:19.763]             version = "1.8"), class = "FutureResult")
[15:32:19.763]     }, finally = {
[15:32:19.763]         if (!identical(...future.workdir, getwd())) 
[15:32:19.763]             setwd(...future.workdir)
[15:32:19.763]         {
[15:32:19.763]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:19.763]                 ...future.oldOptions$nwarnings <- NULL
[15:32:19.763]             }
[15:32:19.763]             base::options(...future.oldOptions)
[15:32:19.763]             if (.Platform$OS.type == "windows") {
[15:32:19.763]                 old_names <- names(...future.oldEnvVars)
[15:32:19.763]                 envs <- base::Sys.getenv()
[15:32:19.763]                 names <- names(envs)
[15:32:19.763]                 common <- intersect(names, old_names)
[15:32:19.763]                 added <- setdiff(names, old_names)
[15:32:19.763]                 removed <- setdiff(old_names, names)
[15:32:19.763]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:19.763]                   envs[common]]
[15:32:19.763]                 NAMES <- toupper(changed)
[15:32:19.763]                 args <- list()
[15:32:19.763]                 for (kk in seq_along(NAMES)) {
[15:32:19.763]                   name <- changed[[kk]]
[15:32:19.763]                   NAME <- NAMES[[kk]]
[15:32:19.763]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:19.763]                     next
[15:32:19.763]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:19.763]                 }
[15:32:19.763]                 NAMES <- toupper(added)
[15:32:19.763]                 for (kk in seq_along(NAMES)) {
[15:32:19.763]                   name <- added[[kk]]
[15:32:19.763]                   NAME <- NAMES[[kk]]
[15:32:19.763]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:19.763]                     next
[15:32:19.763]                   args[[name]] <- ""
[15:32:19.763]                 }
[15:32:19.763]                 NAMES <- toupper(removed)
[15:32:19.763]                 for (kk in seq_along(NAMES)) {
[15:32:19.763]                   name <- removed[[kk]]
[15:32:19.763]                   NAME <- NAMES[[kk]]
[15:32:19.763]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:19.763]                     next
[15:32:19.763]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:19.763]                 }
[15:32:19.763]                 if (length(args) > 0) 
[15:32:19.763]                   base::do.call(base::Sys.setenv, args = args)
[15:32:19.763]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:19.763]             }
[15:32:19.763]             else {
[15:32:19.763]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:19.763]             }
[15:32:19.763]             {
[15:32:19.763]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:19.763]                   0L) {
[15:32:19.763]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:19.763]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:19.763]                   base::options(opts)
[15:32:19.763]                 }
[15:32:19.763]                 {
[15:32:19.763]                   {
[15:32:19.763]                     NULL
[15:32:19.763]                     RNGkind("Mersenne-Twister")
[15:32:19.763]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:19.763]                       inherits = FALSE)
[15:32:19.763]                   }
[15:32:19.763]                   options(future.plan = NULL)
[15:32:19.763]                   if (is.na(NA_character_)) 
[15:32:19.763]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:19.763]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:19.763]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:19.763]                     .init = FALSE)
[15:32:19.763]                 }
[15:32:19.763]             }
[15:32:19.763]         }
[15:32:19.763]     })
[15:32:19.763]     if (TRUE) {
[15:32:19.763]         base::sink(type = "output", split = FALSE)
[15:32:19.763]         if (TRUE) {
[15:32:19.763]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:19.763]         }
[15:32:19.763]         else {
[15:32:19.763]             ...future.result["stdout"] <- base::list(NULL)
[15:32:19.763]         }
[15:32:19.763]         base::close(...future.stdout)
[15:32:19.763]         ...future.stdout <- NULL
[15:32:19.763]     }
[15:32:19.763]     ...future.result$conditions <- ...future.conditions
[15:32:19.763]     ...future.result$finished <- base::Sys.time()
[15:32:19.763]     ...future.result
[15:32:19.763] }
[15:32:19.769] assign_globals() ...
[15:32:19.769] List of 5
[15:32:19.769]  $ ...future.FUN            :function (x)  
[15:32:19.769]  $ future.call.arguments    : list()
[15:32:19.769]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:19.769]  $ ...future.elements_ii    :List of 3
[15:32:19.769]   ..$ a: num 1
[15:32:19.769]   ..$ b: num 2
[15:32:19.769]   ..$ c: num 3
[15:32:19.769]  $ ...future.seeds_ii       : NULL
[15:32:19.769]  $ ...future.globals.maxSize: NULL
[15:32:19.769]  - attr(*, "where")=List of 5
[15:32:19.769]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:19.769]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:19.769]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:19.769]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:19.769]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:19.769]  - attr(*, "resolved")= logi FALSE
[15:32:19.769]  - attr(*, "total_size")= num 848
[15:32:19.769]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:19.769]  - attr(*, "already-done")= logi TRUE
[15:32:19.779] - copied '...future.FUN' to environment
[15:32:19.780] - copied 'future.call.arguments' to environment
[15:32:19.780] - copied '...future.elements_ii' to environment
[15:32:19.780] - copied '...future.seeds_ii' to environment
[15:32:19.780] - copied '...future.globals.maxSize' to environment
[15:32:19.781] assign_globals() ... done
[15:32:19.781] plan(): Setting new future strategy stack:
[15:32:19.782] List of future strategies:
[15:32:19.782] 1. sequential:
[15:32:19.782]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:19.782]    - tweaked: FALSE
[15:32:19.782]    - call: NULL
[15:32:19.783] plan(): nbrOfWorkers() = 1
[15:32:19.785] plan(): Setting new future strategy stack:
[15:32:19.785] List of future strategies:
[15:32:19.785] 1. sequential:
[15:32:19.785]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:19.785]    - tweaked: FALSE
[15:32:19.785]    - call: plan(strategy)
[15:32:19.786] plan(): nbrOfWorkers() = 1
[15:32:19.786] SequentialFuture started (and completed)
[15:32:19.787] - Launch lazy future ... done
[15:32:19.787] run() for 'SequentialFuture' ... done
[15:32:19.787] Created future:
[15:32:19.788] SequentialFuture:
[15:32:19.788] Label: 'future_sapply-1'
[15:32:19.788] Expression:
[15:32:19.788] {
[15:32:19.788]     do.call(function(...) {
[15:32:19.788]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:19.788]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:19.788]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:19.788]             on.exit(options(oopts), add = TRUE)
[15:32:19.788]         }
[15:32:19.788]         {
[15:32:19.788]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:19.788]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:19.788]                 ...future.FUN(...future.X_jj, ...)
[15:32:19.788]             })
[15:32:19.788]         }
[15:32:19.788]     }, args = future.call.arguments)
[15:32:19.788] }
[15:32:19.788] Lazy evaluation: FALSE
[15:32:19.788] Asynchronous evaluation: FALSE
[15:32:19.788] Local evaluation: TRUE
[15:32:19.788] Environment: R_GlobalEnv
[15:32:19.788] Capture standard output: TRUE
[15:32:19.788] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:19.788] Globals: 5 objects totaling 0.99 KiB (function '...future.FUN' of 848 bytes, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:19.788] Packages: <none>
[15:32:19.788] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:19.788] Resolved: TRUE
[15:32:19.788] Value: 168 bytes of class 'list'
[15:32:19.788] Early signaling: FALSE
[15:32:19.788] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:19.788] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:19.790] Chunk #1 of 1 ... DONE
[15:32:19.790] Launching 1 futures (chunks) ... DONE
[15:32:19.790] Resolving 1 futures (chunks) ...
[15:32:19.791] resolve() on list ...
[15:32:19.791]  recursive: 0
[15:32:19.791]  length: 1
[15:32:19.791] 
[15:32:19.792] resolved() for 'SequentialFuture' ...
[15:32:19.792] - state: 'finished'
[15:32:19.792] - run: TRUE
[15:32:19.793] - result: 'FutureResult'
[15:32:19.793] resolved() for 'SequentialFuture' ... done
[15:32:19.793] Future #1
[15:32:19.794] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:19.794] - nx: 1
[15:32:19.794] - relay: TRUE
[15:32:19.797] - stdout: TRUE
[15:32:19.798] - signal: TRUE
[15:32:19.798] - resignal: FALSE
[15:32:19.798] - force: TRUE
[15:32:19.798] - relayed: [n=1] FALSE
[15:32:19.799] - queued futures: [n=1] FALSE
[15:32:19.799]  - until=1
[15:32:19.799]  - relaying element #1
[15:32:19.800] - relayed: [n=1] TRUE
[15:32:19.800] - queued futures: [n=1] TRUE
[15:32:19.800] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:19.801]  length: 0 (resolved future 1)
[15:32:19.801] Relaying remaining futures
[15:32:19.801] signalConditionsASAP(NULL, pos=0) ...
[15:32:19.801] - nx: 1
[15:32:19.802] - relay: TRUE
[15:32:19.802] - stdout: TRUE
[15:32:19.802] - signal: TRUE
[15:32:19.802] - resignal: FALSE
[15:32:19.803] - force: TRUE
[15:32:19.803] - relayed: [n=1] TRUE
[15:32:19.803] - queued futures: [n=1] TRUE
 - flush all
[15:32:19.804] - relayed: [n=1] TRUE
[15:32:19.804] - queued futures: [n=1] TRUE
[15:32:19.804] signalConditionsASAP(NULL, pos=0) ... done
[15:32:19.804] resolve() on list ... DONE
[15:32:19.805]  - Number of value chunks collected: 1
[15:32:19.805] Resolving 1 futures (chunks) ... DONE
[15:32:19.805] Reducing values from 1 chunks ...
[15:32:19.806]  - Number of values collected after concatenation: 3
[15:32:19.806]  - Number of values expected: 3
[15:32:19.806] Reducing values from 1 chunks ... DONE
[15:32:19.806] future_lapply() ... DONE
List of 2
 $ y0: Named num [1:3] 1 2 3
  ..- attr(*, "names")= chr [1:3] "a" "b" "c"
 $ y1: Named num [1:3] 1 2 3
  ..- attr(*, "names")= chr [1:3] "a" "b" "c"
[15:32:19.810] future_lapply() ...
[15:32:19.811] Number of chunks: 1
[15:32:19.811] getGlobalsAndPackagesXApply() ...
[15:32:19.811]  - future.globals: TRUE
[15:32:19.812] getGlobalsAndPackages() ...
[15:32:19.812] Searching for globals...
[15:32:19.814] - globals found: [2] 'FUN', 'UseMethod'
[15:32:19.814] Searching for globals ... DONE
[15:32:19.815] Resolving globals: FALSE
[15:32:19.815] The total size of the 1 globals is 1.22 KiB (1248 bytes)
[15:32:19.816] The total size of the 1 globals exported for future expression ('FUN()') is 1.22 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.22 KiB of class 'function')
[15:32:19.816] - globals: [1] 'FUN'
[15:32:19.817] 
[15:32:19.817] getGlobalsAndPackages() ... DONE
[15:32:19.817]  - globals found/used: [n=1] 'FUN'
[15:32:19.818]  - needed namespaces: [n=0] 
[15:32:19.818] Finding globals ... DONE
[15:32:19.818]  - use_args: TRUE
[15:32:19.818]  - Getting '...' globals ...
[15:32:19.819] resolve() on list ...
[15:32:19.819]  recursive: 0
[15:32:19.820]  length: 1
[15:32:19.820]  elements: '...'
[15:32:19.820]  length: 0 (resolved future 1)
[15:32:19.820] resolve() on list ... DONE
[15:32:19.821]    - '...' content: [n=0] 
[15:32:19.821] List of 1
[15:32:19.821]  $ ...: list()
[15:32:19.821]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:19.821]  - attr(*, "where")=List of 1
[15:32:19.821]   ..$ ...:<environment: 0x00000276e036e998> 
[15:32:19.821]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:19.821]  - attr(*, "resolved")= logi TRUE
[15:32:19.821]  - attr(*, "total_size")= num NA
[15:32:19.826]  - Getting '...' globals ... DONE
[15:32:19.826] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:19.827] List of 2
[15:32:19.827]  $ ...future.FUN:function (x, ...)  
[15:32:19.827]  $ ...          : list()
[15:32:19.827]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:19.827]  - attr(*, "where")=List of 2
[15:32:19.827]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:19.827]   ..$ ...          :<environment: 0x00000276e036e998> 
[15:32:19.827]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:19.827]  - attr(*, "resolved")= logi FALSE
[15:32:19.827]  - attr(*, "total_size")= num 1248
[15:32:19.831] Packages to be attached in all futures: [n=0] 
[15:32:19.831] getGlobalsAndPackagesXApply() ... DONE
[15:32:19.832] Number of futures (= number of chunks): 1
[15:32:19.832] Launching 1 futures (chunks) ...
[15:32:19.832] Chunk #1 of 1 ...
[15:32:19.832]  - Finding globals in 'X' for chunk #1 ...
[15:32:19.832] getGlobalsAndPackages() ...
[15:32:19.833] Searching for globals...
[15:32:19.833] 
[15:32:19.833] Searching for globals ... DONE
[15:32:19.833] - globals: [0] <none>
[15:32:19.834] getGlobalsAndPackages() ... DONE
[15:32:19.834]    + additional globals found: [n=0] 
[15:32:19.834]    + additional namespaces needed: [n=0] 
[15:32:19.834]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:19.834]  - seeds: <none>
[15:32:19.836]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:19.837] getGlobalsAndPackages() ...
[15:32:19.837] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:19.837] Resolving globals: FALSE
[15:32:19.837] Tweak future expression to call with '...' arguments ...
[15:32:19.837] {
[15:32:19.837]     do.call(function(...) {
[15:32:19.837]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:19.837]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:19.837]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:19.837]             on.exit(options(oopts), add = TRUE)
[15:32:19.837]         }
[15:32:19.837]         {
[15:32:19.837]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:19.837]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:19.837]                 ...future.FUN(...future.X_jj, ...)
[15:32:19.837]             })
[15:32:19.837]         }
[15:32:19.837]     }, args = future.call.arguments)
[15:32:19.837] }
[15:32:19.838] Tweak future expression to call with '...' arguments ... DONE
[15:32:19.838] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:19.839] 
[15:32:19.839] getGlobalsAndPackages() ... DONE
[15:32:19.839] run() for 'Future' ...
[15:32:19.839] - state: 'created'
[15:32:19.840] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:19.840] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:19.840] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:19.840]   - Field: 'label'
[15:32:19.841]   - Field: 'local'
[15:32:19.841]   - Field: 'owner'
[15:32:19.841]   - Field: 'envir'
[15:32:19.841]   - Field: 'packages'
[15:32:19.841]   - Field: 'gc'
[15:32:19.842]   - Field: 'conditions'
[15:32:19.842]   - Field: 'expr'
[15:32:19.842]   - Field: 'uuid'
[15:32:19.842]   - Field: 'seed'
[15:32:19.842]   - Field: 'version'
[15:32:19.843]   - Field: 'result'
[15:32:19.843]   - Field: 'asynchronous'
[15:32:19.843]   - Field: 'calls'
[15:32:19.843]   - Field: 'globals'
[15:32:19.843]   - Field: 'stdout'
[15:32:19.843]   - Field: 'earlySignal'
[15:32:19.844]   - Field: 'lazy'
[15:32:19.844]   - Field: 'state'
[15:32:19.844] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:19.844] - Launch lazy future ...
[15:32:19.844] Packages needed by the future expression (n = 0): <none>
[15:32:19.845] Packages needed by future strategies (n = 0): <none>
[15:32:19.845] {
[15:32:19.845]     {
[15:32:19.845]         {
[15:32:19.845]             ...future.startTime <- base::Sys.time()
[15:32:19.845]             {
[15:32:19.845]                 {
[15:32:19.845]                   {
[15:32:19.845]                     base::local({
[15:32:19.845]                       has_future <- base::requireNamespace("future", 
[15:32:19.845]                         quietly = TRUE)
[15:32:19.845]                       if (has_future) {
[15:32:19.845]                         ns <- base::getNamespace("future")
[15:32:19.845]                         version <- ns[[".package"]][["version"]]
[15:32:19.845]                         if (is.null(version)) 
[15:32:19.845]                           version <- utils::packageVersion("future")
[15:32:19.845]                       }
[15:32:19.845]                       else {
[15:32:19.845]                         version <- NULL
[15:32:19.845]                       }
[15:32:19.845]                       if (!has_future || version < "1.8.0") {
[15:32:19.845]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:19.845]                           "", base::R.version$version.string), 
[15:32:19.845]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:19.845]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:19.845]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:19.845]                             "release", "version")], collapse = " "), 
[15:32:19.845]                           hostname = base::Sys.info()[["nodename"]])
[15:32:19.845]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:19.845]                           info)
[15:32:19.845]                         info <- base::paste(info, collapse = "; ")
[15:32:19.845]                         if (!has_future) {
[15:32:19.845]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:19.845]                             info)
[15:32:19.845]                         }
[15:32:19.845]                         else {
[15:32:19.845]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:19.845]                             info, version)
[15:32:19.845]                         }
[15:32:19.845]                         base::stop(msg)
[15:32:19.845]                       }
[15:32:19.845]                     })
[15:32:19.845]                   }
[15:32:19.845]                   ...future.strategy.old <- future::plan("list")
[15:32:19.845]                   options(future.plan = NULL)
[15:32:19.845]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:19.845]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:19.845]                 }
[15:32:19.845]                 ...future.workdir <- getwd()
[15:32:19.845]             }
[15:32:19.845]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:19.845]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:19.845]         }
[15:32:19.845]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:19.845]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:19.845]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:19.845]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:19.845]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:19.845]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:19.845]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:19.845]             base::names(...future.oldOptions))
[15:32:19.845]     }
[15:32:19.845]     if (FALSE) {
[15:32:19.845]     }
[15:32:19.845]     else {
[15:32:19.845]         if (TRUE) {
[15:32:19.845]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:19.845]                 open = "w")
[15:32:19.845]         }
[15:32:19.845]         else {
[15:32:19.845]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:19.845]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:19.845]         }
[15:32:19.845]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:19.845]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:19.845]             base::sink(type = "output", split = FALSE)
[15:32:19.845]             base::close(...future.stdout)
[15:32:19.845]         }, add = TRUE)
[15:32:19.845]     }
[15:32:19.845]     ...future.frame <- base::sys.nframe()
[15:32:19.845]     ...future.conditions <- base::list()
[15:32:19.845]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:19.845]     if (FALSE) {
[15:32:19.845]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:19.845]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:19.845]     }
[15:32:19.845]     ...future.result <- base::tryCatch({
[15:32:19.845]         base::withCallingHandlers({
[15:32:19.845]             ...future.value <- base::withVisible(base::local({
[15:32:19.845]                 do.call(function(...) {
[15:32:19.845]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:19.845]                   if (!identical(...future.globals.maxSize.org, 
[15:32:19.845]                     ...future.globals.maxSize)) {
[15:32:19.845]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:19.845]                     on.exit(options(oopts), add = TRUE)
[15:32:19.845]                   }
[15:32:19.845]                   {
[15:32:19.845]                     lapply(seq_along(...future.elements_ii), 
[15:32:19.845]                       FUN = function(jj) {
[15:32:19.845]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:19.845]                         ...future.FUN(...future.X_jj, ...)
[15:32:19.845]                       })
[15:32:19.845]                   }
[15:32:19.845]                 }, args = future.call.arguments)
[15:32:19.845]             }))
[15:32:19.845]             future::FutureResult(value = ...future.value$value, 
[15:32:19.845]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:19.845]                   ...future.rng), globalenv = if (FALSE) 
[15:32:19.845]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:19.845]                     ...future.globalenv.names))
[15:32:19.845]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:19.845]         }, condition = base::local({
[15:32:19.845]             c <- base::c
[15:32:19.845]             inherits <- base::inherits
[15:32:19.845]             invokeRestart <- base::invokeRestart
[15:32:19.845]             length <- base::length
[15:32:19.845]             list <- base::list
[15:32:19.845]             seq.int <- base::seq.int
[15:32:19.845]             signalCondition <- base::signalCondition
[15:32:19.845]             sys.calls <- base::sys.calls
[15:32:19.845]             `[[` <- base::`[[`
[15:32:19.845]             `+` <- base::`+`
[15:32:19.845]             `<<-` <- base::`<<-`
[15:32:19.845]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:19.845]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:19.845]                   3L)]
[15:32:19.845]             }
[15:32:19.845]             function(cond) {
[15:32:19.845]                 is_error <- inherits(cond, "error")
[15:32:19.845]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:19.845]                   NULL)
[15:32:19.845]                 if (is_error) {
[15:32:19.845]                   sessionInformation <- function() {
[15:32:19.845]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:19.845]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:19.845]                       search = base::search(), system = base::Sys.info())
[15:32:19.845]                   }
[15:32:19.845]                   ...future.conditions[[length(...future.conditions) + 
[15:32:19.845]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:19.845]                     cond$call), session = sessionInformation(), 
[15:32:19.845]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:19.845]                   signalCondition(cond)
[15:32:19.845]                 }
[15:32:19.845]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:19.845]                 "immediateCondition"))) {
[15:32:19.845]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:19.845]                   ...future.conditions[[length(...future.conditions) + 
[15:32:19.845]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:19.845]                   if (TRUE && !signal) {
[15:32:19.845]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:19.845]                     {
[15:32:19.845]                       inherits <- base::inherits
[15:32:19.845]                       invokeRestart <- base::invokeRestart
[15:32:19.845]                       is.null <- base::is.null
[15:32:19.845]                       muffled <- FALSE
[15:32:19.845]                       if (inherits(cond, "message")) {
[15:32:19.845]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:19.845]                         if (muffled) 
[15:32:19.845]                           invokeRestart("muffleMessage")
[15:32:19.845]                       }
[15:32:19.845]                       else if (inherits(cond, "warning")) {
[15:32:19.845]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:19.845]                         if (muffled) 
[15:32:19.845]                           invokeRestart("muffleWarning")
[15:32:19.845]                       }
[15:32:19.845]                       else if (inherits(cond, "condition")) {
[15:32:19.845]                         if (!is.null(pattern)) {
[15:32:19.845]                           computeRestarts <- base::computeRestarts
[15:32:19.845]                           grepl <- base::grepl
[15:32:19.845]                           restarts <- computeRestarts(cond)
[15:32:19.845]                           for (restart in restarts) {
[15:32:19.845]                             name <- restart$name
[15:32:19.845]                             if (is.null(name)) 
[15:32:19.845]                               next
[15:32:19.845]                             if (!grepl(pattern, name)) 
[15:32:19.845]                               next
[15:32:19.845]                             invokeRestart(restart)
[15:32:19.845]                             muffled <- TRUE
[15:32:19.845]                             break
[15:32:19.845]                           }
[15:32:19.845]                         }
[15:32:19.845]                       }
[15:32:19.845]                       invisible(muffled)
[15:32:19.845]                     }
[15:32:19.845]                     muffleCondition(cond, pattern = "^muffle")
[15:32:19.845]                   }
[15:32:19.845]                 }
[15:32:19.845]                 else {
[15:32:19.845]                   if (TRUE) {
[15:32:19.845]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:19.845]                     {
[15:32:19.845]                       inherits <- base::inherits
[15:32:19.845]                       invokeRestart <- base::invokeRestart
[15:32:19.845]                       is.null <- base::is.null
[15:32:19.845]                       muffled <- FALSE
[15:32:19.845]                       if (inherits(cond, "message")) {
[15:32:19.845]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:19.845]                         if (muffled) 
[15:32:19.845]                           invokeRestart("muffleMessage")
[15:32:19.845]                       }
[15:32:19.845]                       else if (inherits(cond, "warning")) {
[15:32:19.845]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:19.845]                         if (muffled) 
[15:32:19.845]                           invokeRestart("muffleWarning")
[15:32:19.845]                       }
[15:32:19.845]                       else if (inherits(cond, "condition")) {
[15:32:19.845]                         if (!is.null(pattern)) {
[15:32:19.845]                           computeRestarts <- base::computeRestarts
[15:32:19.845]                           grepl <- base::grepl
[15:32:19.845]                           restarts <- computeRestarts(cond)
[15:32:19.845]                           for (restart in restarts) {
[15:32:19.845]                             name <- restart$name
[15:32:19.845]                             if (is.null(name)) 
[15:32:19.845]                               next
[15:32:19.845]                             if (!grepl(pattern, name)) 
[15:32:19.845]                               next
[15:32:19.845]                             invokeRestart(restart)
[15:32:19.845]                             muffled <- TRUE
[15:32:19.845]                             break
[15:32:19.845]                           }
[15:32:19.845]                         }
[15:32:19.845]                       }
[15:32:19.845]                       invisible(muffled)
[15:32:19.845]                     }
[15:32:19.845]                     muffleCondition(cond, pattern = "^muffle")
[15:32:19.845]                   }
[15:32:19.845]                 }
[15:32:19.845]             }
[15:32:19.845]         }))
[15:32:19.845]     }, error = function(ex) {
[15:32:19.845]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:19.845]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:19.845]                 ...future.rng), started = ...future.startTime, 
[15:32:19.845]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:19.845]             version = "1.8"), class = "FutureResult")
[15:32:19.845]     }, finally = {
[15:32:19.845]         if (!identical(...future.workdir, getwd())) 
[15:32:19.845]             setwd(...future.workdir)
[15:32:19.845]         {
[15:32:19.845]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:19.845]                 ...future.oldOptions$nwarnings <- NULL
[15:32:19.845]             }
[15:32:19.845]             base::options(...future.oldOptions)
[15:32:19.845]             if (.Platform$OS.type == "windows") {
[15:32:19.845]                 old_names <- names(...future.oldEnvVars)
[15:32:19.845]                 envs <- base::Sys.getenv()
[15:32:19.845]                 names <- names(envs)
[15:32:19.845]                 common <- intersect(names, old_names)
[15:32:19.845]                 added <- setdiff(names, old_names)
[15:32:19.845]                 removed <- setdiff(old_names, names)
[15:32:19.845]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:19.845]                   envs[common]]
[15:32:19.845]                 NAMES <- toupper(changed)
[15:32:19.845]                 args <- list()
[15:32:19.845]                 for (kk in seq_along(NAMES)) {
[15:32:19.845]                   name <- changed[[kk]]
[15:32:19.845]                   NAME <- NAMES[[kk]]
[15:32:19.845]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:19.845]                     next
[15:32:19.845]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:19.845]                 }
[15:32:19.845]                 NAMES <- toupper(added)
[15:32:19.845]                 for (kk in seq_along(NAMES)) {
[15:32:19.845]                   name <- added[[kk]]
[15:32:19.845]                   NAME <- NAMES[[kk]]
[15:32:19.845]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:19.845]                     next
[15:32:19.845]                   args[[name]] <- ""
[15:32:19.845]                 }
[15:32:19.845]                 NAMES <- toupper(removed)
[15:32:19.845]                 for (kk in seq_along(NAMES)) {
[15:32:19.845]                   name <- removed[[kk]]
[15:32:19.845]                   NAME <- NAMES[[kk]]
[15:32:19.845]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:19.845]                     next
[15:32:19.845]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:19.845]                 }
[15:32:19.845]                 if (length(args) > 0) 
[15:32:19.845]                   base::do.call(base::Sys.setenv, args = args)
[15:32:19.845]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:19.845]             }
[15:32:19.845]             else {
[15:32:19.845]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:19.845]             }
[15:32:19.845]             {
[15:32:19.845]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:19.845]                   0L) {
[15:32:19.845]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:19.845]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:19.845]                   base::options(opts)
[15:32:19.845]                 }
[15:32:19.845]                 {
[15:32:19.845]                   {
[15:32:19.845]                     NULL
[15:32:19.845]                     RNGkind("Mersenne-Twister")
[15:32:19.845]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:19.845]                       inherits = FALSE)
[15:32:19.845]                   }
[15:32:19.845]                   options(future.plan = NULL)
[15:32:19.845]                   if (is.na(NA_character_)) 
[15:32:19.845]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:19.845]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:19.845]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:19.845]                     .init = FALSE)
[15:32:19.845]                 }
[15:32:19.845]             }
[15:32:19.845]         }
[15:32:19.845]     })
[15:32:19.845]     if (TRUE) {
[15:32:19.845]         base::sink(type = "output", split = FALSE)
[15:32:19.845]         if (TRUE) {
[15:32:19.845]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:19.845]         }
[15:32:19.845]         else {
[15:32:19.845]             ...future.result["stdout"] <- base::list(NULL)
[15:32:19.845]         }
[15:32:19.845]         base::close(...future.stdout)
[15:32:19.845]         ...future.stdout <- NULL
[15:32:19.845]     }
[15:32:19.845]     ...future.result$conditions <- ...future.conditions
[15:32:19.845]     ...future.result$finished <- base::Sys.time()
[15:32:19.845]     ...future.result
[15:32:19.845] }
[15:32:19.849] assign_globals() ...
[15:32:19.850] List of 5
[15:32:19.850]  $ ...future.FUN            :function (x, ...)  
[15:32:19.850]  $ future.call.arguments    : list()
[15:32:19.850]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:19.850]  $ ...future.elements_ii    :List of 3
[15:32:19.850]   ..$ a: num 1
[15:32:19.850]   ..$ b: num 2
[15:32:19.850]   ..$ c: num 3
[15:32:19.850]  $ ...future.seeds_ii       : NULL
[15:32:19.850]  $ ...future.globals.maxSize: NULL
[15:32:19.850]  - attr(*, "where")=List of 5
[15:32:19.850]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:19.850]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:19.850]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:19.850]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:19.850]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:19.850]  - attr(*, "resolved")= logi FALSE
[15:32:19.850]  - attr(*, "total_size")= num 1248
[15:32:19.850]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:19.850]  - attr(*, "already-done")= logi TRUE
[15:32:19.856] - copied '...future.FUN' to environment
[15:32:19.857] - copied 'future.call.arguments' to environment
[15:32:19.857] - copied '...future.elements_ii' to environment
[15:32:19.857] - copied '...future.seeds_ii' to environment
[15:32:19.857] - copied '...future.globals.maxSize' to environment
[15:32:19.857] assign_globals() ... done
[15:32:19.858] plan(): Setting new future strategy stack:
[15:32:19.858] List of future strategies:
[15:32:19.858] 1. sequential:
[15:32:19.858]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:19.858]    - tweaked: FALSE
[15:32:19.858]    - call: NULL
[15:32:19.859] plan(): nbrOfWorkers() = 1
[15:32:19.861] plan(): Setting new future strategy stack:
[15:32:19.861] List of future strategies:
[15:32:19.861] 1. sequential:
[15:32:19.861]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:19.861]    - tweaked: FALSE
[15:32:19.861]    - call: plan(strategy)
[15:32:19.862] plan(): nbrOfWorkers() = 1
[15:32:19.863] SequentialFuture started (and completed)
[15:32:19.863] - Launch lazy future ... done
[15:32:19.863] run() for 'SequentialFuture' ... done
[15:32:19.864] Created future:
[15:32:19.864] SequentialFuture:
[15:32:19.864] Label: 'future_sapply-1'
[15:32:19.864] Expression:
[15:32:19.864] {
[15:32:19.864]     do.call(function(...) {
[15:32:19.864]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:19.864]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:19.864]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:19.864]             on.exit(options(oopts), add = TRUE)
[15:32:19.864]         }
[15:32:19.864]         {
[15:32:19.864]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:19.864]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:19.864]                 ...future.FUN(...future.X_jj, ...)
[15:32:19.864]             })
[15:32:19.864]         }
[15:32:19.864]     }, args = future.call.arguments)
[15:32:19.864] }
[15:32:19.864] Lazy evaluation: FALSE
[15:32:19.864] Asynchronous evaluation: FALSE
[15:32:19.864] Local evaluation: TRUE
[15:32:19.864] Environment: R_GlobalEnv
[15:32:19.864] Capture standard output: TRUE
[15:32:19.864] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:19.864] Globals: 5 objects totaling 1.38 KiB (function '...future.FUN' of 1.22 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:19.864] Packages: <none>
[15:32:19.864] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:19.864] Resolved: TRUE
[15:32:19.864] Value: 672 bytes of class 'list'
[15:32:19.864] Early signaling: FALSE
[15:32:19.864] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:19.864] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:19.866] Chunk #1 of 1 ... DONE
[15:32:19.867] Launching 1 futures (chunks) ... DONE
[15:32:19.867] Resolving 1 futures (chunks) ...
[15:32:19.867] resolve() on list ...
[15:32:19.867]  recursive: 0
[15:32:19.868]  length: 1
[15:32:19.868] 
[15:32:19.868] resolved() for 'SequentialFuture' ...
[15:32:19.869] - state: 'finished'
[15:32:19.869] - run: TRUE
[15:32:19.869] - result: 'FutureResult'
[15:32:19.870] resolved() for 'SequentialFuture' ... done
[15:32:19.870] Future #1
[15:32:19.870] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:19.871] - nx: 1
[15:32:19.871] - relay: TRUE
[15:32:19.871] - stdout: TRUE
[15:32:19.872] - signal: TRUE
[15:32:19.872] - resignal: FALSE
[15:32:19.872] - force: TRUE
[15:32:19.872] - relayed: [n=1] FALSE
[15:32:19.873] - queued futures: [n=1] FALSE
[15:32:19.873]  - until=1
[15:32:19.877]  - relaying element #1
[15:32:19.877] - relayed: [n=1] TRUE
[15:32:19.878] - queued futures: [n=1] TRUE
[15:32:19.878] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:19.878]  length: 0 (resolved future 1)
[15:32:19.879] Relaying remaining futures
[15:32:19.879] signalConditionsASAP(NULL, pos=0) ...
[15:32:19.879] - nx: 1
[15:32:19.879] - relay: TRUE
[15:32:19.880] - stdout: TRUE
[15:32:19.880] - signal: TRUE
[15:32:19.880] - resignal: FALSE
[15:32:19.880] - force: TRUE
[15:32:19.881] - relayed: [n=1] TRUE
[15:32:19.881] - queued futures: [n=1] TRUE
 - flush all
[15:32:19.881] - relayed: [n=1] TRUE
[15:32:19.882] - queued futures: [n=1] TRUE
[15:32:19.882] signalConditionsASAP(NULL, pos=0) ... done
[15:32:19.882] resolve() on list ... DONE
[15:32:19.883]  - Number of value chunks collected: 1
[15:32:19.883] Resolving 1 futures (chunks) ... DONE
[15:32:19.883] Reducing values from 1 chunks ...
[15:32:19.884]  - Number of values collected after concatenation: 3
[15:32:19.884]  - Number of values expected: 3
[15:32:19.884] Reducing values from 1 chunks ... DONE
[15:32:19.884] future_lapply() ... DONE
List of 2
 $ y0: Named num [1:3] 1 2 3
  ..- attr(*, "names")= chr [1:3] "a" "b" "c"
 $ y1: Named num [1:3] 1 2 3
  ..- attr(*, "names")= chr [1:3] "a" "b" "c"
[15:32:19.888] future_lapply() ...
[15:32:19.890] Number of chunks: 1
[15:32:19.890] getGlobalsAndPackagesXApply() ...
[15:32:19.890]  - future.globals: TRUE
[15:32:19.891] getGlobalsAndPackages() ...
[15:32:19.891] Searching for globals...
[15:32:19.894] - globals found: [5] 'FUN', '*', ':', 'outer', 'rep'
[15:32:19.895] Searching for globals ... DONE
[15:32:19.895] Resolving globals: FALSE
[15:32:19.896] The total size of the 1 globals is 4.62 KiB (4728 bytes)
[15:32:19.897] The total size of the 1 globals exported for future expression ('FUN()') is 4.62 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.62 KiB of class 'function')
[15:32:19.897] - globals: [1] 'FUN'
[15:32:19.897] 
[15:32:19.897] getGlobalsAndPackages() ... DONE
[15:32:19.898]  - globals found/used: [n=1] 'FUN'
[15:32:19.898]  - needed namespaces: [n=0] 
[15:32:19.898] Finding globals ... DONE
[15:32:19.899]  - use_args: TRUE
[15:32:19.899]  - Getting '...' globals ...
[15:32:19.900] resolve() on list ...
[15:32:19.900]  recursive: 0
[15:32:19.900]  length: 1
[15:32:19.901]  elements: '...'
[15:32:19.901]  length: 0 (resolved future 1)
[15:32:19.901] resolve() on list ... DONE
[15:32:19.902]    - '...' content: [n=0] 
[15:32:19.902] List of 1
[15:32:19.902]  $ ...: list()
[15:32:19.902]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:19.902]  - attr(*, "where")=List of 1
[15:32:19.902]   ..$ ...:<environment: 0x00000276e0658c30> 
[15:32:19.902]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:19.902]  - attr(*, "resolved")= logi TRUE
[15:32:19.902]  - attr(*, "total_size")= num NA
[15:32:19.907]  - Getting '...' globals ... DONE
[15:32:19.908] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:19.908] List of 2
[15:32:19.908]  $ ...future.FUN:function (x, y = 2 * 1:5)  
[15:32:19.908]  $ ...          : list()
[15:32:19.908]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:19.908]  - attr(*, "where")=List of 2
[15:32:19.908]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:19.908]   ..$ ...          :<environment: 0x00000276e0658c30> 
[15:32:19.908]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:19.908]  - attr(*, "resolved")= logi FALSE
[15:32:19.908]  - attr(*, "total_size")= num 4728
[15:32:19.914] Packages to be attached in all futures: [n=0] 
[15:32:19.914] getGlobalsAndPackagesXApply() ... DONE
[15:32:19.915] Number of futures (= number of chunks): 1
[15:32:19.915] Launching 1 futures (chunks) ...
[15:32:19.915] Chunk #1 of 1 ...
[15:32:19.916]  - Finding globals in 'X' for chunk #1 ...
[15:32:19.916] getGlobalsAndPackages() ...
[15:32:19.916] Searching for globals...
[15:32:19.917] 
[15:32:19.917] Searching for globals ... DONE
[15:32:19.917] - globals: [0] <none>
[15:32:19.956] getGlobalsAndPackages() ... DONE
[15:32:19.956]    + additional globals found: [n=0] 
[15:32:19.957]    + additional namespaces needed: [n=0] 
[15:32:19.957]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:19.957]  - seeds: <none>
[15:32:19.958]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:19.958] getGlobalsAndPackages() ...
[15:32:19.958] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:19.959] Resolving globals: FALSE
[15:32:19.959] Tweak future expression to call with '...' arguments ...
[15:32:19.959] {
[15:32:19.959]     do.call(function(...) {
[15:32:19.959]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:19.959]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:19.959]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:19.959]             on.exit(options(oopts), add = TRUE)
[15:32:19.959]         }
[15:32:19.959]         {
[15:32:19.959]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:19.959]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:19.959]                 ...future.FUN(...future.X_jj, ...)
[15:32:19.959]             })
[15:32:19.959]         }
[15:32:19.959]     }, args = future.call.arguments)
[15:32:19.959] }
[15:32:19.960] Tweak future expression to call with '...' arguments ... DONE
[15:32:19.961] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:19.961] 
[15:32:19.962] getGlobalsAndPackages() ... DONE
[15:32:19.962] run() for 'Future' ...
[15:32:19.963] - state: 'created'
[15:32:19.963] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:19.964] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:19.964] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:19.964]   - Field: 'label'
[15:32:19.965]   - Field: 'local'
[15:32:19.965]   - Field: 'owner'
[15:32:19.965]   - Field: 'envir'
[15:32:19.966]   - Field: 'packages'
[15:32:19.966]   - Field: 'gc'
[15:32:19.966]   - Field: 'conditions'
[15:32:19.967]   - Field: 'expr'
[15:32:19.967]   - Field: 'uuid'
[15:32:19.967]   - Field: 'seed'
[15:32:19.968]   - Field: 'version'
[15:32:19.968]   - Field: 'result'
[15:32:19.968]   - Field: 'asynchronous'
[15:32:19.969]   - Field: 'calls'
[15:32:19.969]   - Field: 'globals'
[15:32:19.969]   - Field: 'stdout'
[15:32:19.970]   - Field: 'earlySignal'
[15:32:19.970]   - Field: 'lazy'
[15:32:19.970]   - Field: 'state'
[15:32:19.971] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:19.971] - Launch lazy future ...
[15:32:19.971] Packages needed by the future expression (n = 0): <none>
[15:32:19.972] Packages needed by future strategies (n = 0): <none>
[15:32:19.973] {
[15:32:19.973]     {
[15:32:19.973]         {
[15:32:19.973]             ...future.startTime <- base::Sys.time()
[15:32:19.973]             {
[15:32:19.973]                 {
[15:32:19.973]                   {
[15:32:19.973]                     base::local({
[15:32:19.973]                       has_future <- base::requireNamespace("future", 
[15:32:19.973]                         quietly = TRUE)
[15:32:19.973]                       if (has_future) {
[15:32:19.973]                         ns <- base::getNamespace("future")
[15:32:19.973]                         version <- ns[[".package"]][["version"]]
[15:32:19.973]                         if (is.null(version)) 
[15:32:19.973]                           version <- utils::packageVersion("future")
[15:32:19.973]                       }
[15:32:19.973]                       else {
[15:32:19.973]                         version <- NULL
[15:32:19.973]                       }
[15:32:19.973]                       if (!has_future || version < "1.8.0") {
[15:32:19.973]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:19.973]                           "", base::R.version$version.string), 
[15:32:19.973]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:19.973]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:19.973]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:19.973]                             "release", "version")], collapse = " "), 
[15:32:19.973]                           hostname = base::Sys.info()[["nodename"]])
[15:32:19.973]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:19.973]                           info)
[15:32:19.973]                         info <- base::paste(info, collapse = "; ")
[15:32:19.973]                         if (!has_future) {
[15:32:19.973]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:19.973]                             info)
[15:32:19.973]                         }
[15:32:19.973]                         else {
[15:32:19.973]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:19.973]                             info, version)
[15:32:19.973]                         }
[15:32:19.973]                         base::stop(msg)
[15:32:19.973]                       }
[15:32:19.973]                     })
[15:32:19.973]                   }
[15:32:19.973]                   ...future.strategy.old <- future::plan("list")
[15:32:19.973]                   options(future.plan = NULL)
[15:32:19.973]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:19.973]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:19.973]                 }
[15:32:19.973]                 ...future.workdir <- getwd()
[15:32:19.973]             }
[15:32:19.973]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:19.973]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:19.973]         }
[15:32:19.973]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:19.973]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:19.973]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:19.973]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:19.973]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:19.973]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:19.973]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:19.973]             base::names(...future.oldOptions))
[15:32:19.973]     }
[15:32:19.973]     if (FALSE) {
[15:32:19.973]     }
[15:32:19.973]     else {
[15:32:19.973]         if (TRUE) {
[15:32:19.973]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:19.973]                 open = "w")
[15:32:19.973]         }
[15:32:19.973]         else {
[15:32:19.973]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:19.973]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:19.973]         }
[15:32:19.973]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:19.973]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:19.973]             base::sink(type = "output", split = FALSE)
[15:32:19.973]             base::close(...future.stdout)
[15:32:19.973]         }, add = TRUE)
[15:32:19.973]     }
[15:32:19.973]     ...future.frame <- base::sys.nframe()
[15:32:19.973]     ...future.conditions <- base::list()
[15:32:19.973]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:19.973]     if (FALSE) {
[15:32:19.973]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:19.973]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:19.973]     }
[15:32:19.973]     ...future.result <- base::tryCatch({
[15:32:19.973]         base::withCallingHandlers({
[15:32:19.973]             ...future.value <- base::withVisible(base::local({
[15:32:19.973]                 do.call(function(...) {
[15:32:19.973]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:19.973]                   if (!identical(...future.globals.maxSize.org, 
[15:32:19.973]                     ...future.globals.maxSize)) {
[15:32:19.973]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:19.973]                     on.exit(options(oopts), add = TRUE)
[15:32:19.973]                   }
[15:32:19.973]                   {
[15:32:19.973]                     lapply(seq_along(...future.elements_ii), 
[15:32:19.973]                       FUN = function(jj) {
[15:32:19.973]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:19.973]                         ...future.FUN(...future.X_jj, ...)
[15:32:19.973]                       })
[15:32:19.973]                   }
[15:32:19.973]                 }, args = future.call.arguments)
[15:32:19.973]             }))
[15:32:19.973]             future::FutureResult(value = ...future.value$value, 
[15:32:19.973]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:19.973]                   ...future.rng), globalenv = if (FALSE) 
[15:32:19.973]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:19.973]                     ...future.globalenv.names))
[15:32:19.973]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:19.973]         }, condition = base::local({
[15:32:19.973]             c <- base::c
[15:32:19.973]             inherits <- base::inherits
[15:32:19.973]             invokeRestart <- base::invokeRestart
[15:32:19.973]             length <- base::length
[15:32:19.973]             list <- base::list
[15:32:19.973]             seq.int <- base::seq.int
[15:32:19.973]             signalCondition <- base::signalCondition
[15:32:19.973]             sys.calls <- base::sys.calls
[15:32:19.973]             `[[` <- base::`[[`
[15:32:19.973]             `+` <- base::`+`
[15:32:19.973]             `<<-` <- base::`<<-`
[15:32:19.973]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:19.973]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:19.973]                   3L)]
[15:32:19.973]             }
[15:32:19.973]             function(cond) {
[15:32:19.973]                 is_error <- inherits(cond, "error")
[15:32:19.973]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:19.973]                   NULL)
[15:32:19.973]                 if (is_error) {
[15:32:19.973]                   sessionInformation <- function() {
[15:32:19.973]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:19.973]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:19.973]                       search = base::search(), system = base::Sys.info())
[15:32:19.973]                   }
[15:32:19.973]                   ...future.conditions[[length(...future.conditions) + 
[15:32:19.973]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:19.973]                     cond$call), session = sessionInformation(), 
[15:32:19.973]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:19.973]                   signalCondition(cond)
[15:32:19.973]                 }
[15:32:19.973]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:19.973]                 "immediateCondition"))) {
[15:32:19.973]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:19.973]                   ...future.conditions[[length(...future.conditions) + 
[15:32:19.973]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:19.973]                   if (TRUE && !signal) {
[15:32:19.973]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:19.973]                     {
[15:32:19.973]                       inherits <- base::inherits
[15:32:19.973]                       invokeRestart <- base::invokeRestart
[15:32:19.973]                       is.null <- base::is.null
[15:32:19.973]                       muffled <- FALSE
[15:32:19.973]                       if (inherits(cond, "message")) {
[15:32:19.973]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:19.973]                         if (muffled) 
[15:32:19.973]                           invokeRestart("muffleMessage")
[15:32:19.973]                       }
[15:32:19.973]                       else if (inherits(cond, "warning")) {
[15:32:19.973]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:19.973]                         if (muffled) 
[15:32:19.973]                           invokeRestart("muffleWarning")
[15:32:19.973]                       }
[15:32:19.973]                       else if (inherits(cond, "condition")) {
[15:32:19.973]                         if (!is.null(pattern)) {
[15:32:19.973]                           computeRestarts <- base::computeRestarts
[15:32:19.973]                           grepl <- base::grepl
[15:32:19.973]                           restarts <- computeRestarts(cond)
[15:32:19.973]                           for (restart in restarts) {
[15:32:19.973]                             name <- restart$name
[15:32:19.973]                             if (is.null(name)) 
[15:32:19.973]                               next
[15:32:19.973]                             if (!grepl(pattern, name)) 
[15:32:19.973]                               next
[15:32:19.973]                             invokeRestart(restart)
[15:32:19.973]                             muffled <- TRUE
[15:32:19.973]                             break
[15:32:19.973]                           }
[15:32:19.973]                         }
[15:32:19.973]                       }
[15:32:19.973]                       invisible(muffled)
[15:32:19.973]                     }
[15:32:19.973]                     muffleCondition(cond, pattern = "^muffle")
[15:32:19.973]                   }
[15:32:19.973]                 }
[15:32:19.973]                 else {
[15:32:19.973]                   if (TRUE) {
[15:32:19.973]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:19.973]                     {
[15:32:19.973]                       inherits <- base::inherits
[15:32:19.973]                       invokeRestart <- base::invokeRestart
[15:32:19.973]                       is.null <- base::is.null
[15:32:19.973]                       muffled <- FALSE
[15:32:19.973]                       if (inherits(cond, "message")) {
[15:32:19.973]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:19.973]                         if (muffled) 
[15:32:19.973]                           invokeRestart("muffleMessage")
[15:32:19.973]                       }
[15:32:19.973]                       else if (inherits(cond, "warning")) {
[15:32:19.973]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:19.973]                         if (muffled) 
[15:32:19.973]                           invokeRestart("muffleWarning")
[15:32:19.973]                       }
[15:32:19.973]                       else if (inherits(cond, "condition")) {
[15:32:19.973]                         if (!is.null(pattern)) {
[15:32:19.973]                           computeRestarts <- base::computeRestarts
[15:32:19.973]                           grepl <- base::grepl
[15:32:19.973]                           restarts <- computeRestarts(cond)
[15:32:19.973]                           for (restart in restarts) {
[15:32:19.973]                             name <- restart$name
[15:32:19.973]                             if (is.null(name)) 
[15:32:19.973]                               next
[15:32:19.973]                             if (!grepl(pattern, name)) 
[15:32:19.973]                               next
[15:32:19.973]                             invokeRestart(restart)
[15:32:19.973]                             muffled <- TRUE
[15:32:19.973]                             break
[15:32:19.973]                           }
[15:32:19.973]                         }
[15:32:19.973]                       }
[15:32:19.973]                       invisible(muffled)
[15:32:19.973]                     }
[15:32:19.973]                     muffleCondition(cond, pattern = "^muffle")
[15:32:19.973]                   }
[15:32:19.973]                 }
[15:32:19.973]             }
[15:32:19.973]         }))
[15:32:19.973]     }, error = function(ex) {
[15:32:19.973]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:19.973]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:19.973]                 ...future.rng), started = ...future.startTime, 
[15:32:19.973]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:19.973]             version = "1.8"), class = "FutureResult")
[15:32:19.973]     }, finally = {
[15:32:19.973]         if (!identical(...future.workdir, getwd())) 
[15:32:19.973]             setwd(...future.workdir)
[15:32:19.973]         {
[15:32:19.973]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:19.973]                 ...future.oldOptions$nwarnings <- NULL
[15:32:19.973]             }
[15:32:19.973]             base::options(...future.oldOptions)
[15:32:19.973]             if (.Platform$OS.type == "windows") {
[15:32:19.973]                 old_names <- names(...future.oldEnvVars)
[15:32:19.973]                 envs <- base::Sys.getenv()
[15:32:19.973]                 names <- names(envs)
[15:32:19.973]                 common <- intersect(names, old_names)
[15:32:19.973]                 added <- setdiff(names, old_names)
[15:32:19.973]                 removed <- setdiff(old_names, names)
[15:32:19.973]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:19.973]                   envs[common]]
[15:32:19.973]                 NAMES <- toupper(changed)
[15:32:19.973]                 args <- list()
[15:32:19.973]                 for (kk in seq_along(NAMES)) {
[15:32:19.973]                   name <- changed[[kk]]
[15:32:19.973]                   NAME <- NAMES[[kk]]
[15:32:19.973]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:19.973]                     next
[15:32:19.973]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:19.973]                 }
[15:32:19.973]                 NAMES <- toupper(added)
[15:32:19.973]                 for (kk in seq_along(NAMES)) {
[15:32:19.973]                   name <- added[[kk]]
[15:32:19.973]                   NAME <- NAMES[[kk]]
[15:32:19.973]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:19.973]                     next
[15:32:19.973]                   args[[name]] <- ""
[15:32:19.973]                 }
[15:32:19.973]                 NAMES <- toupper(removed)
[15:32:19.973]                 for (kk in seq_along(NAMES)) {
[15:32:19.973]                   name <- removed[[kk]]
[15:32:19.973]                   NAME <- NAMES[[kk]]
[15:32:19.973]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:19.973]                     next
[15:32:19.973]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:19.973]                 }
[15:32:19.973]                 if (length(args) > 0) 
[15:32:19.973]                   base::do.call(base::Sys.setenv, args = args)
[15:32:19.973]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:19.973]             }
[15:32:19.973]             else {
[15:32:19.973]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:19.973]             }
[15:32:19.973]             {
[15:32:19.973]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:19.973]                   0L) {
[15:32:19.973]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:19.973]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:19.973]                   base::options(opts)
[15:32:19.973]                 }
[15:32:19.973]                 {
[15:32:19.973]                   {
[15:32:19.973]                     NULL
[15:32:19.973]                     RNGkind("Mersenne-Twister")
[15:32:19.973]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:19.973]                       inherits = FALSE)
[15:32:19.973]                   }
[15:32:19.973]                   options(future.plan = NULL)
[15:32:19.973]                   if (is.na(NA_character_)) 
[15:32:19.973]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:19.973]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:19.973]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:19.973]                     .init = FALSE)
[15:32:19.973]                 }
[15:32:19.973]             }
[15:32:19.973]         }
[15:32:19.973]     })
[15:32:19.973]     if (TRUE) {
[15:32:19.973]         base::sink(type = "output", split = FALSE)
[15:32:19.973]         if (TRUE) {
[15:32:19.973]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:19.973]         }
[15:32:19.973]         else {
[15:32:19.973]             ...future.result["stdout"] <- base::list(NULL)
[15:32:19.973]         }
[15:32:19.973]         base::close(...future.stdout)
[15:32:19.973]         ...future.stdout <- NULL
[15:32:19.973]     }
[15:32:19.973]     ...future.result$conditions <- ...future.conditions
[15:32:19.973]     ...future.result$finished <- base::Sys.time()
[15:32:19.973]     ...future.result
[15:32:19.973] }
[15:32:19.980] assign_globals() ...
[15:32:19.980] List of 5
[15:32:19.980]  $ ...future.FUN            :function (x, y = 2 * 1:5)  
[15:32:19.980]  $ future.call.arguments    : list()
[15:32:19.980]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:19.980]  $ ...future.elements_ii    :List of 3
[15:32:19.980]   ..$ a: num 1
[15:32:19.980]   ..$ b: num 2
[15:32:19.980]   ..$ c: num 3
[15:32:19.980]  $ ...future.seeds_ii       : NULL
[15:32:19.980]  $ ...future.globals.maxSize: NULL
[15:32:19.980]  - attr(*, "where")=List of 5
[15:32:19.980]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:19.980]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:19.980]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:19.980]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:19.980]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:19.980]  - attr(*, "resolved")= logi FALSE
[15:32:19.980]  - attr(*, "total_size")= num 4728
[15:32:19.980]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:19.980]  - attr(*, "already-done")= logi TRUE
[15:32:19.991] - reassign environment for '...future.FUN'
[15:32:19.991] - copied '...future.FUN' to environment
[15:32:19.992] - copied 'future.call.arguments' to environment
[15:32:19.992] - copied '...future.elements_ii' to environment
[15:32:19.992] - copied '...future.seeds_ii' to environment
[15:32:19.992] - copied '...future.globals.maxSize' to environment
[15:32:19.993] assign_globals() ... done
[15:32:19.993] plan(): Setting new future strategy stack:
[15:32:19.994] List of future strategies:
[15:32:19.994] 1. sequential:
[15:32:19.994]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:19.994]    - tweaked: FALSE
[15:32:19.994]    - call: NULL
[15:32:19.995] plan(): nbrOfWorkers() = 1
[15:32:19.997] plan(): Setting new future strategy stack:
[15:32:19.997] List of future strategies:
[15:32:19.997] 1. sequential:
[15:32:19.997]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:19.997]    - tweaked: FALSE
[15:32:19.997]    - call: plan(strategy)
[15:32:19.998] plan(): nbrOfWorkers() = 1
[15:32:19.998] SequentialFuture started (and completed)
[15:32:19.999] - Launch lazy future ... done
[15:32:19.999] run() for 'SequentialFuture' ... done
[15:32:19.999] Created future:
[15:32:20.000] SequentialFuture:
[15:32:20.000] Label: 'future_sapply-1'
[15:32:20.000] Expression:
[15:32:20.000] {
[15:32:20.000]     do.call(function(...) {
[15:32:20.000]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:20.000]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:20.000]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:20.000]             on.exit(options(oopts), add = TRUE)
[15:32:20.000]         }
[15:32:20.000]         {
[15:32:20.000]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:20.000]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:20.000]                 ...future.FUN(...future.X_jj, ...)
[15:32:20.000]             })
[15:32:20.000]         }
[15:32:20.000]     }, args = future.call.arguments)
[15:32:20.000] }
[15:32:20.000] Lazy evaluation: FALSE
[15:32:20.000] Asynchronous evaluation: FALSE
[15:32:20.000] Local evaluation: TRUE
[15:32:20.000] Environment: R_GlobalEnv
[15:32:20.000] Capture standard output: TRUE
[15:32:20.000] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:20.000] Globals: 5 objects totaling 4.78 KiB (function '...future.FUN' of 4.62 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:20.000] Packages: <none>
[15:32:20.000] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:20.000] Resolved: TRUE
[15:32:20.000] Value: 1.01 KiB of class 'list'
[15:32:20.000] Early signaling: FALSE
[15:32:20.000] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:20.000] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:20.002] Chunk #1 of 1 ... DONE
[15:32:20.002] Launching 1 futures (chunks) ... DONE
[15:32:20.003] Resolving 1 futures (chunks) ...
[15:32:20.003] resolve() on list ...
[15:32:20.003]  recursive: 0
[15:32:20.003]  length: 1
[15:32:20.004] 
[15:32:20.004] resolved() for 'SequentialFuture' ...
[15:32:20.004] - state: 'finished'
[15:32:20.005] - run: TRUE
[15:32:20.005] - result: 'FutureResult'
[15:32:20.005] resolved() for 'SequentialFuture' ... done
[15:32:20.005] Future #1
[15:32:20.006] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:20.006] - nx: 1
[15:32:20.006] - relay: TRUE
[15:32:20.007] - stdout: TRUE
[15:32:20.007] - signal: TRUE
[15:32:20.007] - resignal: FALSE
[15:32:20.007] - force: TRUE
[15:32:20.008] - relayed: [n=1] FALSE
[15:32:20.008] - queued futures: [n=1] FALSE
[15:32:20.008]  - until=1
[15:32:20.009]  - relaying element #1
[15:32:20.009] - relayed: [n=1] TRUE
[15:32:20.009] - queued futures: [n=1] TRUE
[15:32:20.010] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:20.010]  length: 0 (resolved future 1)
[15:32:20.010] Relaying remaining futures
[15:32:20.011] signalConditionsASAP(NULL, pos=0) ...
[15:32:20.011] - nx: 1
[15:32:20.011] - relay: TRUE
[15:32:20.011] - stdout: TRUE
[15:32:20.012] - signal: TRUE
[15:32:20.012] - resignal: FALSE
[15:32:20.012] - force: TRUE
[15:32:20.012] - relayed: [n=1] TRUE
[15:32:20.013] - queued futures: [n=1] TRUE
 - flush all
[15:32:20.013] - relayed: [n=1] TRUE
[15:32:20.013] - queued futures: [n=1] TRUE
[15:32:20.016] signalConditionsASAP(NULL, pos=0) ... done
[15:32:20.016] resolve() on list ... DONE
[15:32:20.017]  - Number of value chunks collected: 1
[15:32:20.017] Resolving 1 futures (chunks) ... DONE
[15:32:20.018] Reducing values from 1 chunks ...
[15:32:20.018]  - Number of values collected after concatenation: 3
[15:32:20.018]  - Number of values expected: 3
[15:32:20.018] Reducing values from 1 chunks ... DONE
[15:32:20.019] future_lapply() ... DONE
List of 2
 $ y0: num [1:3, 1:5, 1:3] 2 2 2 4 4 4 6 6 6 8 ...
  ..- attr(*, "dimnames")=List of 3
  .. ..$ : NULL
  .. ..$ : NULL
  .. ..$ : chr [1:3] "a" "b" "c"
 $ y1: num [1:3, 1:5, 1:3] 2 2 2 4 4 4 6 6 6 8 ...
  ..- attr(*, "dimnames")=List of 3
  .. ..$ : NULL
  .. ..$ : NULL
  .. ..$ : chr [1:3] "a" "b" "c"
[15:32:20.025] future_lapply() ...
[15:32:20.026] Number of chunks: 1
[15:32:20.026] getGlobalsAndPackagesXApply() ...
[15:32:20.027]  - future.globals: TRUE
[15:32:20.027] getGlobalsAndPackages() ...
[15:32:20.027] Searching for globals...
[15:32:20.029] - globals found: [1] 'FUN'
[15:32:20.030] Searching for globals ... DONE
[15:32:20.030] Resolving globals: FALSE
[15:32:20.031] The total size of the 1 globals is 848 bytes (848 bytes)
[15:32:20.031] The total size of the 1 globals exported for future expression ('FUN()') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:32:20.032] - globals: [1] 'FUN'
[15:32:20.032] 
[15:32:20.032] getGlobalsAndPackages() ... DONE
[15:32:20.032]  - globals found/used: [n=1] 'FUN'
[15:32:20.033]  - needed namespaces: [n=0] 
[15:32:20.033] Finding globals ... DONE
[15:32:20.033]  - use_args: TRUE
[15:32:20.034]  - Getting '...' globals ...
[15:32:20.034] resolve() on list ...
[15:32:20.035]  recursive: 0
[15:32:20.035]  length: 1
[15:32:20.035]  elements: '...'
[15:32:20.035]  length: 0 (resolved future 1)
[15:32:20.036] resolve() on list ... DONE
[15:32:20.036]    - '...' content: [n=0] 
[15:32:20.036] List of 1
[15:32:20.036]  $ ...: list()
[15:32:20.036]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:20.036]  - attr(*, "where")=List of 1
[15:32:20.036]   ..$ ...:<environment: 0x00000276def2a5a8> 
[15:32:20.036]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:20.036]  - attr(*, "resolved")= logi TRUE
[15:32:20.036]  - attr(*, "total_size")= num NA
[15:32:20.041]  - Getting '...' globals ... DONE
[15:32:20.042] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:20.042] List of 2
[15:32:20.042]  $ ...future.FUN:function (x)  
[15:32:20.042]  $ ...          : list()
[15:32:20.042]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:20.042]  - attr(*, "where")=List of 2
[15:32:20.042]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:20.042]   ..$ ...          :<environment: 0x00000276def2a5a8> 
[15:32:20.042]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:20.042]  - attr(*, "resolved")= logi FALSE
[15:32:20.042]  - attr(*, "total_size")= num 848
[15:32:20.047] Packages to be attached in all futures: [n=0] 
[15:32:20.048] getGlobalsAndPackagesXApply() ... DONE
[15:32:20.048] Number of futures (= number of chunks): 1
[15:32:20.048] Launching 1 futures (chunks) ...
[15:32:20.049] Chunk #1 of 1 ...
[15:32:20.049]  - Finding globals in 'X' for chunk #1 ...
[15:32:20.049] getGlobalsAndPackages() ...
[15:32:20.050] Searching for globals...
[15:32:20.050] 
[15:32:20.051] Searching for globals ... DONE
[15:32:20.051] - globals: [0] <none>
[15:32:20.051] getGlobalsAndPackages() ... DONE
[15:32:20.051]    + additional globals found: [n=0] 
[15:32:20.052]    + additional namespaces needed: [n=0] 
[15:32:20.052]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:20.052]  - seeds: <none>
[15:32:20.052]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:20.053] getGlobalsAndPackages() ...
[15:32:20.053] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:20.053] Resolving globals: FALSE
[15:32:20.054] Tweak future expression to call with '...' arguments ...
[15:32:20.054] {
[15:32:20.054]     do.call(function(...) {
[15:32:20.054]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:20.054]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:20.054]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:20.054]             on.exit(options(oopts), add = TRUE)
[15:32:20.054]         }
[15:32:20.054]         {
[15:32:20.054]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:20.054]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:20.054]                 ...future.FUN(...future.X_jj, ...)
[15:32:20.054]             })
[15:32:20.054]         }
[15:32:20.054]     }, args = future.call.arguments)
[15:32:20.054] }
[15:32:20.055] Tweak future expression to call with '...' arguments ... DONE
[15:32:20.056] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:20.056] 
[15:32:20.056] getGlobalsAndPackages() ... DONE
[15:32:20.057] run() for 'Future' ...
[15:32:20.057] - state: 'created'
[15:32:20.058] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:20.058] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:20.059] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:20.059]   - Field: 'label'
[15:32:20.059]   - Field: 'local'
[15:32:20.060]   - Field: 'owner'
[15:32:20.060]   - Field: 'envir'
[15:32:20.060]   - Field: 'packages'
[15:32:20.061]   - Field: 'gc'
[15:32:20.061]   - Field: 'conditions'
[15:32:20.061]   - Field: 'expr'
[15:32:20.061]   - Field: 'uuid'
[15:32:20.062]   - Field: 'seed'
[15:32:20.062]   - Field: 'version'
[15:32:20.062]   - Field: 'result'
[15:32:20.063]   - Field: 'asynchronous'
[15:32:20.063]   - Field: 'calls'
[15:32:20.066]   - Field: 'globals'
[15:32:20.066]   - Field: 'stdout'
[15:32:20.067]   - Field: 'earlySignal'
[15:32:20.067]   - Field: 'lazy'
[15:32:20.067]   - Field: 'state'
[15:32:20.068] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:20.068] - Launch lazy future ...
[15:32:20.068] Packages needed by the future expression (n = 0): <none>
[15:32:20.069] Packages needed by future strategies (n = 0): <none>
[15:32:20.070] {
[15:32:20.070]     {
[15:32:20.070]         {
[15:32:20.070]             ...future.startTime <- base::Sys.time()
[15:32:20.070]             {
[15:32:20.070]                 {
[15:32:20.070]                   {
[15:32:20.070]                     base::local({
[15:32:20.070]                       has_future <- base::requireNamespace("future", 
[15:32:20.070]                         quietly = TRUE)
[15:32:20.070]                       if (has_future) {
[15:32:20.070]                         ns <- base::getNamespace("future")
[15:32:20.070]                         version <- ns[[".package"]][["version"]]
[15:32:20.070]                         if (is.null(version)) 
[15:32:20.070]                           version <- utils::packageVersion("future")
[15:32:20.070]                       }
[15:32:20.070]                       else {
[15:32:20.070]                         version <- NULL
[15:32:20.070]                       }
[15:32:20.070]                       if (!has_future || version < "1.8.0") {
[15:32:20.070]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:20.070]                           "", base::R.version$version.string), 
[15:32:20.070]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:20.070]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:20.070]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:20.070]                             "release", "version")], collapse = " "), 
[15:32:20.070]                           hostname = base::Sys.info()[["nodename"]])
[15:32:20.070]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:20.070]                           info)
[15:32:20.070]                         info <- base::paste(info, collapse = "; ")
[15:32:20.070]                         if (!has_future) {
[15:32:20.070]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:20.070]                             info)
[15:32:20.070]                         }
[15:32:20.070]                         else {
[15:32:20.070]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:20.070]                             info, version)
[15:32:20.070]                         }
[15:32:20.070]                         base::stop(msg)
[15:32:20.070]                       }
[15:32:20.070]                     })
[15:32:20.070]                   }
[15:32:20.070]                   ...future.strategy.old <- future::plan("list")
[15:32:20.070]                   options(future.plan = NULL)
[15:32:20.070]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:20.070]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:20.070]                 }
[15:32:20.070]                 ...future.workdir <- getwd()
[15:32:20.070]             }
[15:32:20.070]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:20.070]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:20.070]         }
[15:32:20.070]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:20.070]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:20.070]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:20.070]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:20.070]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:20.070]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:20.070]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:20.070]             base::names(...future.oldOptions))
[15:32:20.070]     }
[15:32:20.070]     if (FALSE) {
[15:32:20.070]     }
[15:32:20.070]     else {
[15:32:20.070]         if (TRUE) {
[15:32:20.070]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:20.070]                 open = "w")
[15:32:20.070]         }
[15:32:20.070]         else {
[15:32:20.070]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:20.070]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:20.070]         }
[15:32:20.070]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:20.070]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:20.070]             base::sink(type = "output", split = FALSE)
[15:32:20.070]             base::close(...future.stdout)
[15:32:20.070]         }, add = TRUE)
[15:32:20.070]     }
[15:32:20.070]     ...future.frame <- base::sys.nframe()
[15:32:20.070]     ...future.conditions <- base::list()
[15:32:20.070]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:20.070]     if (FALSE) {
[15:32:20.070]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:20.070]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:20.070]     }
[15:32:20.070]     ...future.result <- base::tryCatch({
[15:32:20.070]         base::withCallingHandlers({
[15:32:20.070]             ...future.value <- base::withVisible(base::local({
[15:32:20.070]                 do.call(function(...) {
[15:32:20.070]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:20.070]                   if (!identical(...future.globals.maxSize.org, 
[15:32:20.070]                     ...future.globals.maxSize)) {
[15:32:20.070]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:20.070]                     on.exit(options(oopts), add = TRUE)
[15:32:20.070]                   }
[15:32:20.070]                   {
[15:32:20.070]                     lapply(seq_along(...future.elements_ii), 
[15:32:20.070]                       FUN = function(jj) {
[15:32:20.070]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:20.070]                         ...future.FUN(...future.X_jj, ...)
[15:32:20.070]                       })
[15:32:20.070]                   }
[15:32:20.070]                 }, args = future.call.arguments)
[15:32:20.070]             }))
[15:32:20.070]             future::FutureResult(value = ...future.value$value, 
[15:32:20.070]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:20.070]                   ...future.rng), globalenv = if (FALSE) 
[15:32:20.070]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:20.070]                     ...future.globalenv.names))
[15:32:20.070]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:20.070]         }, condition = base::local({
[15:32:20.070]             c <- base::c
[15:32:20.070]             inherits <- base::inherits
[15:32:20.070]             invokeRestart <- base::invokeRestart
[15:32:20.070]             length <- base::length
[15:32:20.070]             list <- base::list
[15:32:20.070]             seq.int <- base::seq.int
[15:32:20.070]             signalCondition <- base::signalCondition
[15:32:20.070]             sys.calls <- base::sys.calls
[15:32:20.070]             `[[` <- base::`[[`
[15:32:20.070]             `+` <- base::`+`
[15:32:20.070]             `<<-` <- base::`<<-`
[15:32:20.070]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:20.070]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:20.070]                   3L)]
[15:32:20.070]             }
[15:32:20.070]             function(cond) {
[15:32:20.070]                 is_error <- inherits(cond, "error")
[15:32:20.070]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:20.070]                   NULL)
[15:32:20.070]                 if (is_error) {
[15:32:20.070]                   sessionInformation <- function() {
[15:32:20.070]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:20.070]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:20.070]                       search = base::search(), system = base::Sys.info())
[15:32:20.070]                   }
[15:32:20.070]                   ...future.conditions[[length(...future.conditions) + 
[15:32:20.070]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:20.070]                     cond$call), session = sessionInformation(), 
[15:32:20.070]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:20.070]                   signalCondition(cond)
[15:32:20.070]                 }
[15:32:20.070]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:20.070]                 "immediateCondition"))) {
[15:32:20.070]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:20.070]                   ...future.conditions[[length(...future.conditions) + 
[15:32:20.070]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:20.070]                   if (TRUE && !signal) {
[15:32:20.070]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:20.070]                     {
[15:32:20.070]                       inherits <- base::inherits
[15:32:20.070]                       invokeRestart <- base::invokeRestart
[15:32:20.070]                       is.null <- base::is.null
[15:32:20.070]                       muffled <- FALSE
[15:32:20.070]                       if (inherits(cond, "message")) {
[15:32:20.070]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:20.070]                         if (muffled) 
[15:32:20.070]                           invokeRestart("muffleMessage")
[15:32:20.070]                       }
[15:32:20.070]                       else if (inherits(cond, "warning")) {
[15:32:20.070]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:20.070]                         if (muffled) 
[15:32:20.070]                           invokeRestart("muffleWarning")
[15:32:20.070]                       }
[15:32:20.070]                       else if (inherits(cond, "condition")) {
[15:32:20.070]                         if (!is.null(pattern)) {
[15:32:20.070]                           computeRestarts <- base::computeRestarts
[15:32:20.070]                           grepl <- base::grepl
[15:32:20.070]                           restarts <- computeRestarts(cond)
[15:32:20.070]                           for (restart in restarts) {
[15:32:20.070]                             name <- restart$name
[15:32:20.070]                             if (is.null(name)) 
[15:32:20.070]                               next
[15:32:20.070]                             if (!grepl(pattern, name)) 
[15:32:20.070]                               next
[15:32:20.070]                             invokeRestart(restart)
[15:32:20.070]                             muffled <- TRUE
[15:32:20.070]                             break
[15:32:20.070]                           }
[15:32:20.070]                         }
[15:32:20.070]                       }
[15:32:20.070]                       invisible(muffled)
[15:32:20.070]                     }
[15:32:20.070]                     muffleCondition(cond, pattern = "^muffle")
[15:32:20.070]                   }
[15:32:20.070]                 }
[15:32:20.070]                 else {
[15:32:20.070]                   if (TRUE) {
[15:32:20.070]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:20.070]                     {
[15:32:20.070]                       inherits <- base::inherits
[15:32:20.070]                       invokeRestart <- base::invokeRestart
[15:32:20.070]                       is.null <- base::is.null
[15:32:20.070]                       muffled <- FALSE
[15:32:20.070]                       if (inherits(cond, "message")) {
[15:32:20.070]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:20.070]                         if (muffled) 
[15:32:20.070]                           invokeRestart("muffleMessage")
[15:32:20.070]                       }
[15:32:20.070]                       else if (inherits(cond, "warning")) {
[15:32:20.070]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:20.070]                         if (muffled) 
[15:32:20.070]                           invokeRestart("muffleWarning")
[15:32:20.070]                       }
[15:32:20.070]                       else if (inherits(cond, "condition")) {
[15:32:20.070]                         if (!is.null(pattern)) {
[15:32:20.070]                           computeRestarts <- base::computeRestarts
[15:32:20.070]                           grepl <- base::grepl
[15:32:20.070]                           restarts <- computeRestarts(cond)
[15:32:20.070]                           for (restart in restarts) {
[15:32:20.070]                             name <- restart$name
[15:32:20.070]                             if (is.null(name)) 
[15:32:20.070]                               next
[15:32:20.070]                             if (!grepl(pattern, name)) 
[15:32:20.070]                               next
[15:32:20.070]                             invokeRestart(restart)
[15:32:20.070]                             muffled <- TRUE
[15:32:20.070]                             break
[15:32:20.070]                           }
[15:32:20.070]                         }
[15:32:20.070]                       }
[15:32:20.070]                       invisible(muffled)
[15:32:20.070]                     }
[15:32:20.070]                     muffleCondition(cond, pattern = "^muffle")
[15:32:20.070]                   }
[15:32:20.070]                 }
[15:32:20.070]             }
[15:32:20.070]         }))
[15:32:20.070]     }, error = function(ex) {
[15:32:20.070]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:20.070]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:20.070]                 ...future.rng), started = ...future.startTime, 
[15:32:20.070]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:20.070]             version = "1.8"), class = "FutureResult")
[15:32:20.070]     }, finally = {
[15:32:20.070]         if (!identical(...future.workdir, getwd())) 
[15:32:20.070]             setwd(...future.workdir)
[15:32:20.070]         {
[15:32:20.070]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:20.070]                 ...future.oldOptions$nwarnings <- NULL
[15:32:20.070]             }
[15:32:20.070]             base::options(...future.oldOptions)
[15:32:20.070]             if (.Platform$OS.type == "windows") {
[15:32:20.070]                 old_names <- names(...future.oldEnvVars)
[15:32:20.070]                 envs <- base::Sys.getenv()
[15:32:20.070]                 names <- names(envs)
[15:32:20.070]                 common <- intersect(names, old_names)
[15:32:20.070]                 added <- setdiff(names, old_names)
[15:32:20.070]                 removed <- setdiff(old_names, names)
[15:32:20.070]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:20.070]                   envs[common]]
[15:32:20.070]                 NAMES <- toupper(changed)
[15:32:20.070]                 args <- list()
[15:32:20.070]                 for (kk in seq_along(NAMES)) {
[15:32:20.070]                   name <- changed[[kk]]
[15:32:20.070]                   NAME <- NAMES[[kk]]
[15:32:20.070]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:20.070]                     next
[15:32:20.070]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:20.070]                 }
[15:32:20.070]                 NAMES <- toupper(added)
[15:32:20.070]                 for (kk in seq_along(NAMES)) {
[15:32:20.070]                   name <- added[[kk]]
[15:32:20.070]                   NAME <- NAMES[[kk]]
[15:32:20.070]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:20.070]                     next
[15:32:20.070]                   args[[name]] <- ""
[15:32:20.070]                 }
[15:32:20.070]                 NAMES <- toupper(removed)
[15:32:20.070]                 for (kk in seq_along(NAMES)) {
[15:32:20.070]                   name <- removed[[kk]]
[15:32:20.070]                   NAME <- NAMES[[kk]]
[15:32:20.070]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:20.070]                     next
[15:32:20.070]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:20.070]                 }
[15:32:20.070]                 if (length(args) > 0) 
[15:32:20.070]                   base::do.call(base::Sys.setenv, args = args)
[15:32:20.070]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:20.070]             }
[15:32:20.070]             else {
[15:32:20.070]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:20.070]             }
[15:32:20.070]             {
[15:32:20.070]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:20.070]                   0L) {
[15:32:20.070]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:20.070]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:20.070]                   base::options(opts)
[15:32:20.070]                 }
[15:32:20.070]                 {
[15:32:20.070]                   {
[15:32:20.070]                     NULL
[15:32:20.070]                     RNGkind("Mersenne-Twister")
[15:32:20.070]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:20.070]                       inherits = FALSE)
[15:32:20.070]                   }
[15:32:20.070]                   options(future.plan = NULL)
[15:32:20.070]                   if (is.na(NA_character_)) 
[15:32:20.070]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:20.070]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:20.070]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:20.070]                     .init = FALSE)
[15:32:20.070]                 }
[15:32:20.070]             }
[15:32:20.070]         }
[15:32:20.070]     })
[15:32:20.070]     if (TRUE) {
[15:32:20.070]         base::sink(type = "output", split = FALSE)
[15:32:20.070]         if (TRUE) {
[15:32:20.070]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:20.070]         }
[15:32:20.070]         else {
[15:32:20.070]             ...future.result["stdout"] <- base::list(NULL)
[15:32:20.070]         }
[15:32:20.070]         base::close(...future.stdout)
[15:32:20.070]         ...future.stdout <- NULL
[15:32:20.070]     }
[15:32:20.070]     ...future.result$conditions <- ...future.conditions
[15:32:20.070]     ...future.result$finished <- base::Sys.time()
[15:32:20.070]     ...future.result
[15:32:20.070] }
[15:32:20.077] assign_globals() ...
[15:32:20.077] List of 5
[15:32:20.077]  $ ...future.FUN            :function (x)  
[15:32:20.077]  $ future.call.arguments    : list()
[15:32:20.077]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:20.077]  $ ...future.elements_ii    :List of 3
[15:32:20.077]   ..$ a: num 1
[15:32:20.077]   ..$ b: num 2
[15:32:20.077]   ..$ c: num 3
[15:32:20.077]  $ ...future.seeds_ii       : NULL
[15:32:20.077]  $ ...future.globals.maxSize: NULL
[15:32:20.077]  - attr(*, "where")=List of 5
[15:32:20.077]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:20.077]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:20.077]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:20.077]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:20.077]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:20.077]  - attr(*, "resolved")= logi FALSE
[15:32:20.077]  - attr(*, "total_size")= num 848
[15:32:20.077]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:20.077]  - attr(*, "already-done")= logi TRUE
[15:32:20.088] - copied '...future.FUN' to environment
[15:32:20.088] - copied 'future.call.arguments' to environment
[15:32:20.088] - copied '...future.elements_ii' to environment
[15:32:20.089] - copied '...future.seeds_ii' to environment
[15:32:20.089] - copied '...future.globals.maxSize' to environment
[15:32:20.089] assign_globals() ... done
[15:32:20.090] plan(): Setting new future strategy stack:
[15:32:20.090] List of future strategies:
[15:32:20.090] 1. sequential:
[15:32:20.090]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:20.090]    - tweaked: FALSE
[15:32:20.090]    - call: NULL
[15:32:20.091] plan(): nbrOfWorkers() = 1
[15:32:20.093] plan(): Setting new future strategy stack:
[15:32:20.094] List of future strategies:
[15:32:20.094] 1. sequential:
[15:32:20.094]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:20.094]    - tweaked: FALSE
[15:32:20.094]    - call: plan(strategy)
[15:32:20.095] plan(): nbrOfWorkers() = 1
[15:32:20.095] SequentialFuture started (and completed)
[15:32:20.095] - Launch lazy future ... done
[15:32:20.096] run() for 'SequentialFuture' ... done
[15:32:20.096] Created future:
[15:32:20.096] SequentialFuture:
[15:32:20.096] Label: 'future_sapply-1'
[15:32:20.096] Expression:
[15:32:20.096] {
[15:32:20.096]     do.call(function(...) {
[15:32:20.096]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:20.096]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:20.096]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:20.096]             on.exit(options(oopts), add = TRUE)
[15:32:20.096]         }
[15:32:20.096]         {
[15:32:20.096]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:20.096]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:20.096]                 ...future.FUN(...future.X_jj, ...)
[15:32:20.096]             })
[15:32:20.096]         }
[15:32:20.096]     }, args = future.call.arguments)
[15:32:20.096] }
[15:32:20.096] Lazy evaluation: FALSE
[15:32:20.096] Asynchronous evaluation: FALSE
[15:32:20.096] Local evaluation: TRUE
[15:32:20.096] Environment: R_GlobalEnv
[15:32:20.096] Capture standard output: TRUE
[15:32:20.096] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:20.096] Globals: 5 objects totaling 0.99 KiB (function '...future.FUN' of 848 bytes, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:20.096] Packages: <none>
[15:32:20.096] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:20.096] Resolved: TRUE
[15:32:20.096] Value: 168 bytes of class 'list'
[15:32:20.096] Early signaling: FALSE
[15:32:20.096] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:20.096] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:20.099] Chunk #1 of 1 ... DONE
[15:32:20.099] Launching 1 futures (chunks) ... DONE
[15:32:20.099] Resolving 1 futures (chunks) ...
[15:32:20.099] resolve() on list ...
[15:32:20.100]  recursive: 0
[15:32:20.100]  length: 1
[15:32:20.100] 
[15:32:20.101] resolved() for 'SequentialFuture' ...
[15:32:20.101] - state: 'finished'
[15:32:20.101] - run: TRUE
[15:32:20.102] - result: 'FutureResult'
[15:32:20.102] resolved() for 'SequentialFuture' ... done
[15:32:20.102] Future #1
[15:32:20.103] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:20.103] - nx: 1
[15:32:20.103] - relay: TRUE
[15:32:20.103] - stdout: TRUE
[15:32:20.104] - signal: TRUE
[15:32:20.104] - resignal: FALSE
[15:32:20.104] - force: TRUE
[15:32:20.104] - relayed: [n=1] FALSE
[15:32:20.105] - queued futures: [n=1] FALSE
[15:32:20.105]  - until=1
[15:32:20.105]  - relaying element #1
[15:32:20.106] - relayed: [n=1] TRUE
[15:32:20.106] - queued futures: [n=1] TRUE
[15:32:20.106] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:20.107]  length: 0 (resolved future 1)
[15:32:20.107] Relaying remaining futures
[15:32:20.107] signalConditionsASAP(NULL, pos=0) ...
[15:32:20.107] - nx: 1
[15:32:20.108] - relay: TRUE
[15:32:20.108] - stdout: TRUE
[15:32:20.108] - signal: TRUE
[15:32:20.108] - resignal: FALSE
[15:32:20.109] - force: TRUE
[15:32:20.109] - relayed: [n=1] TRUE
[15:32:20.109] - queued futures: [n=1] TRUE
 - flush all
[15:32:20.110] - relayed: [n=1] TRUE
[15:32:20.110] - queued futures: [n=1] TRUE
[15:32:20.110] signalConditionsASAP(NULL, pos=0) ... done
[15:32:20.110] resolve() on list ... DONE
[15:32:20.111]  - Number of value chunks collected: 1
[15:32:20.111] Resolving 1 futures (chunks) ... DONE
[15:32:20.111] Reducing values from 1 chunks ...
[15:32:20.112]  - Number of values collected after concatenation: 3
[15:32:20.112]  - Number of values expected: 3
[15:32:20.112] Reducing values from 1 chunks ... DONE
[15:32:20.112] future_lapply() ... DONE
List of 2
 $ y0:List of 3
  ..$ a: num 1
  ..$ b: num 2
  ..$ c: num 3
 $ y1:List of 3
  ..$ a: num 1
  ..$ b: num 2
  ..$ c: num 3
List of 2
 $ y0:List of 3
  ..$ a: num 1
  ..$ b: num 2
  ..$ c: num 3
 $ y2:List of 3
  ..$ a: num 1
  ..$ b: num 2
  ..$ c: num 3
[15:32:20.126] future_lapply() ...
[15:32:20.127] Number of chunks: 1
[15:32:20.127] getGlobalsAndPackagesXApply() ...
[15:32:20.128]  - future.globals: TRUE
[15:32:20.128] getGlobalsAndPackages() ...
[15:32:20.128] Searching for globals...
[15:32:20.130] - globals found: [2] 'FUN', 'UseMethod'
[15:32:20.130] Searching for globals ... DONE
[15:32:20.131] Resolving globals: FALSE
[15:32:20.131] The total size of the 1 globals is 1.22 KiB (1248 bytes)
[15:32:20.132] The total size of the 1 globals exported for future expression ('FUN()') is 1.22 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.22 KiB of class 'function')
[15:32:20.132] - globals: [1] 'FUN'
[15:32:20.133] 
[15:32:20.133] getGlobalsAndPackages() ... DONE
[15:32:20.133]  - globals found/used: [n=1] 'FUN'
[15:32:20.133]  - needed namespaces: [n=0] 
[15:32:20.134] Finding globals ... DONE
[15:32:20.134]  - use_args: TRUE
[15:32:20.134]  - Getting '...' globals ...
[15:32:20.135] resolve() on list ...
[15:32:20.135]  recursive: 0
[15:32:20.135]  length: 1
[15:32:20.136]  elements: '...'
[15:32:20.136]  length: 0 (resolved future 1)
[15:32:20.136] resolve() on list ... DONE
[15:32:20.137]    - '...' content: [n=0] 
[15:32:20.137] List of 1
[15:32:20.137]  $ ...: list()
[15:32:20.137]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:20.137]  - attr(*, "where")=List of 1
[15:32:20.137]   ..$ ...:<environment: 0x00000276e05c3688> 
[15:32:20.137]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:20.137]  - attr(*, "resolved")= logi TRUE
[15:32:20.137]  - attr(*, "total_size")= num NA
[15:32:20.142]  - Getting '...' globals ... DONE
[15:32:20.142] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:20.142] List of 2
[15:32:20.142]  $ ...future.FUN:function (x, ...)  
[15:32:20.142]  $ ...          : list()
[15:32:20.142]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:20.142]  - attr(*, "where")=List of 2
[15:32:20.142]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:20.142]   ..$ ...          :<environment: 0x00000276e05c3688> 
[15:32:20.142]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:20.142]  - attr(*, "resolved")= logi FALSE
[15:32:20.142]  - attr(*, "total_size")= num 1248
[15:32:20.148] Packages to be attached in all futures: [n=0] 
[15:32:20.148] getGlobalsAndPackagesXApply() ... DONE
[15:32:20.148] Number of futures (= number of chunks): 1
[15:32:20.149] Launching 1 futures (chunks) ...
[15:32:20.149] Chunk #1 of 1 ...
[15:32:20.149]  - Finding globals in 'X' for chunk #1 ...
[15:32:20.150] getGlobalsAndPackages() ...
[15:32:20.150] Searching for globals...
[15:32:20.150] 
[15:32:20.151] Searching for globals ... DONE
[15:32:20.151] - globals: [0] <none>
[15:32:20.151] getGlobalsAndPackages() ... DONE
[15:32:20.151]    + additional globals found: [n=0] 
[15:32:20.152]    + additional namespaces needed: [n=0] 
[15:32:20.152]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:20.152]  - seeds: <none>
[15:32:20.152]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:20.153] getGlobalsAndPackages() ...
[15:32:20.153] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:20.153] Resolving globals: FALSE
[15:32:20.154] Tweak future expression to call with '...' arguments ...
[15:32:20.154] {
[15:32:20.154]     do.call(function(...) {
[15:32:20.154]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:20.154]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:20.154]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:20.154]             on.exit(options(oopts), add = TRUE)
[15:32:20.154]         }
[15:32:20.154]         {
[15:32:20.154]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:20.154]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:20.154]                 ...future.FUN(...future.X_jj, ...)
[15:32:20.154]             })
[15:32:20.154]         }
[15:32:20.154]     }, args = future.call.arguments)
[15:32:20.154] }
[15:32:20.155] Tweak future expression to call with '...' arguments ... DONE
[15:32:20.155] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:20.156] 
[15:32:20.156] getGlobalsAndPackages() ... DONE
[15:32:20.157] run() for 'Future' ...
[15:32:20.157] - state: 'created'
[15:32:20.157] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:20.158] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:20.158] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:20.158]   - Field: 'label'
[15:32:20.159]   - Field: 'local'
[15:32:20.159]   - Field: 'owner'
[15:32:20.159]   - Field: 'envir'
[15:32:20.160]   - Field: 'packages'
[15:32:20.160]   - Field: 'gc'
[15:32:20.160]   - Field: 'conditions'
[15:32:20.160]   - Field: 'expr'
[15:32:20.161]   - Field: 'uuid'
[15:32:20.161]   - Field: 'seed'
[15:32:20.161]   - Field: 'version'
[15:32:20.161]   - Field: 'result'
[15:32:20.162]   - Field: 'asynchronous'
[15:32:20.162]   - Field: 'calls'
[15:32:20.162]   - Field: 'globals'
[15:32:20.163]   - Field: 'stdout'
[15:32:20.163]   - Field: 'earlySignal'
[15:32:20.163]   - Field: 'lazy'
[15:32:20.163]   - Field: 'state'
[15:32:20.164] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:20.164] - Launch lazy future ...
[15:32:20.164] Packages needed by the future expression (n = 0): <none>
[15:32:20.167] Packages needed by future strategies (n = 0): <none>
[15:32:20.168] {
[15:32:20.168]     {
[15:32:20.168]         {
[15:32:20.168]             ...future.startTime <- base::Sys.time()
[15:32:20.168]             {
[15:32:20.168]                 {
[15:32:20.168]                   {
[15:32:20.168]                     base::local({
[15:32:20.168]                       has_future <- base::requireNamespace("future", 
[15:32:20.168]                         quietly = TRUE)
[15:32:20.168]                       if (has_future) {
[15:32:20.168]                         ns <- base::getNamespace("future")
[15:32:20.168]                         version <- ns[[".package"]][["version"]]
[15:32:20.168]                         if (is.null(version)) 
[15:32:20.168]                           version <- utils::packageVersion("future")
[15:32:20.168]                       }
[15:32:20.168]                       else {
[15:32:20.168]                         version <- NULL
[15:32:20.168]                       }
[15:32:20.168]                       if (!has_future || version < "1.8.0") {
[15:32:20.168]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:20.168]                           "", base::R.version$version.string), 
[15:32:20.168]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:20.168]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:20.168]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:20.168]                             "release", "version")], collapse = " "), 
[15:32:20.168]                           hostname = base::Sys.info()[["nodename"]])
[15:32:20.168]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:20.168]                           info)
[15:32:20.168]                         info <- base::paste(info, collapse = "; ")
[15:32:20.168]                         if (!has_future) {
[15:32:20.168]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:20.168]                             info)
[15:32:20.168]                         }
[15:32:20.168]                         else {
[15:32:20.168]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:20.168]                             info, version)
[15:32:20.168]                         }
[15:32:20.168]                         base::stop(msg)
[15:32:20.168]                       }
[15:32:20.168]                     })
[15:32:20.168]                   }
[15:32:20.168]                   ...future.strategy.old <- future::plan("list")
[15:32:20.168]                   options(future.plan = NULL)
[15:32:20.168]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:20.168]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:20.168]                 }
[15:32:20.168]                 ...future.workdir <- getwd()
[15:32:20.168]             }
[15:32:20.168]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:20.168]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:20.168]         }
[15:32:20.168]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:20.168]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:20.168]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:20.168]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:20.168]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:20.168]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:20.168]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:20.168]             base::names(...future.oldOptions))
[15:32:20.168]     }
[15:32:20.168]     if (FALSE) {
[15:32:20.168]     }
[15:32:20.168]     else {
[15:32:20.168]         if (TRUE) {
[15:32:20.168]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:20.168]                 open = "w")
[15:32:20.168]         }
[15:32:20.168]         else {
[15:32:20.168]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:20.168]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:20.168]         }
[15:32:20.168]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:20.168]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:20.168]             base::sink(type = "output", split = FALSE)
[15:32:20.168]             base::close(...future.stdout)
[15:32:20.168]         }, add = TRUE)
[15:32:20.168]     }
[15:32:20.168]     ...future.frame <- base::sys.nframe()
[15:32:20.168]     ...future.conditions <- base::list()
[15:32:20.168]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:20.168]     if (FALSE) {
[15:32:20.168]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:20.168]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:20.168]     }
[15:32:20.168]     ...future.result <- base::tryCatch({
[15:32:20.168]         base::withCallingHandlers({
[15:32:20.168]             ...future.value <- base::withVisible(base::local({
[15:32:20.168]                 do.call(function(...) {
[15:32:20.168]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:20.168]                   if (!identical(...future.globals.maxSize.org, 
[15:32:20.168]                     ...future.globals.maxSize)) {
[15:32:20.168]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:20.168]                     on.exit(options(oopts), add = TRUE)
[15:32:20.168]                   }
[15:32:20.168]                   {
[15:32:20.168]                     lapply(seq_along(...future.elements_ii), 
[15:32:20.168]                       FUN = function(jj) {
[15:32:20.168]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:20.168]                         ...future.FUN(...future.X_jj, ...)
[15:32:20.168]                       })
[15:32:20.168]                   }
[15:32:20.168]                 }, args = future.call.arguments)
[15:32:20.168]             }))
[15:32:20.168]             future::FutureResult(value = ...future.value$value, 
[15:32:20.168]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:20.168]                   ...future.rng), globalenv = if (FALSE) 
[15:32:20.168]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:20.168]                     ...future.globalenv.names))
[15:32:20.168]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:20.168]         }, condition = base::local({
[15:32:20.168]             c <- base::c
[15:32:20.168]             inherits <- base::inherits
[15:32:20.168]             invokeRestart <- base::invokeRestart
[15:32:20.168]             length <- base::length
[15:32:20.168]             list <- base::list
[15:32:20.168]             seq.int <- base::seq.int
[15:32:20.168]             signalCondition <- base::signalCondition
[15:32:20.168]             sys.calls <- base::sys.calls
[15:32:20.168]             `[[` <- base::`[[`
[15:32:20.168]             `+` <- base::`+`
[15:32:20.168]             `<<-` <- base::`<<-`
[15:32:20.168]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:20.168]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:20.168]                   3L)]
[15:32:20.168]             }
[15:32:20.168]             function(cond) {
[15:32:20.168]                 is_error <- inherits(cond, "error")
[15:32:20.168]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:20.168]                   NULL)
[15:32:20.168]                 if (is_error) {
[15:32:20.168]                   sessionInformation <- function() {
[15:32:20.168]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:20.168]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:20.168]                       search = base::search(), system = base::Sys.info())
[15:32:20.168]                   }
[15:32:20.168]                   ...future.conditions[[length(...future.conditions) + 
[15:32:20.168]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:20.168]                     cond$call), session = sessionInformation(), 
[15:32:20.168]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:20.168]                   signalCondition(cond)
[15:32:20.168]                 }
[15:32:20.168]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:20.168]                 "immediateCondition"))) {
[15:32:20.168]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:20.168]                   ...future.conditions[[length(...future.conditions) + 
[15:32:20.168]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:20.168]                   if (TRUE && !signal) {
[15:32:20.168]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:20.168]                     {
[15:32:20.168]                       inherits <- base::inherits
[15:32:20.168]                       invokeRestart <- base::invokeRestart
[15:32:20.168]                       is.null <- base::is.null
[15:32:20.168]                       muffled <- FALSE
[15:32:20.168]                       if (inherits(cond, "message")) {
[15:32:20.168]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:20.168]                         if (muffled) 
[15:32:20.168]                           invokeRestart("muffleMessage")
[15:32:20.168]                       }
[15:32:20.168]                       else if (inherits(cond, "warning")) {
[15:32:20.168]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:20.168]                         if (muffled) 
[15:32:20.168]                           invokeRestart("muffleWarning")
[15:32:20.168]                       }
[15:32:20.168]                       else if (inherits(cond, "condition")) {
[15:32:20.168]                         if (!is.null(pattern)) {
[15:32:20.168]                           computeRestarts <- base::computeRestarts
[15:32:20.168]                           grepl <- base::grepl
[15:32:20.168]                           restarts <- computeRestarts(cond)
[15:32:20.168]                           for (restart in restarts) {
[15:32:20.168]                             name <- restart$name
[15:32:20.168]                             if (is.null(name)) 
[15:32:20.168]                               next
[15:32:20.168]                             if (!grepl(pattern, name)) 
[15:32:20.168]                               next
[15:32:20.168]                             invokeRestart(restart)
[15:32:20.168]                             muffled <- TRUE
[15:32:20.168]                             break
[15:32:20.168]                           }
[15:32:20.168]                         }
[15:32:20.168]                       }
[15:32:20.168]                       invisible(muffled)
[15:32:20.168]                     }
[15:32:20.168]                     muffleCondition(cond, pattern = "^muffle")
[15:32:20.168]                   }
[15:32:20.168]                 }
[15:32:20.168]                 else {
[15:32:20.168]                   if (TRUE) {
[15:32:20.168]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:20.168]                     {
[15:32:20.168]                       inherits <- base::inherits
[15:32:20.168]                       invokeRestart <- base::invokeRestart
[15:32:20.168]                       is.null <- base::is.null
[15:32:20.168]                       muffled <- FALSE
[15:32:20.168]                       if (inherits(cond, "message")) {
[15:32:20.168]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:20.168]                         if (muffled) 
[15:32:20.168]                           invokeRestart("muffleMessage")
[15:32:20.168]                       }
[15:32:20.168]                       else if (inherits(cond, "warning")) {
[15:32:20.168]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:20.168]                         if (muffled) 
[15:32:20.168]                           invokeRestart("muffleWarning")
[15:32:20.168]                       }
[15:32:20.168]                       else if (inherits(cond, "condition")) {
[15:32:20.168]                         if (!is.null(pattern)) {
[15:32:20.168]                           computeRestarts <- base::computeRestarts
[15:32:20.168]                           grepl <- base::grepl
[15:32:20.168]                           restarts <- computeRestarts(cond)
[15:32:20.168]                           for (restart in restarts) {
[15:32:20.168]                             name <- restart$name
[15:32:20.168]                             if (is.null(name)) 
[15:32:20.168]                               next
[15:32:20.168]                             if (!grepl(pattern, name)) 
[15:32:20.168]                               next
[15:32:20.168]                             invokeRestart(restart)
[15:32:20.168]                             muffled <- TRUE
[15:32:20.168]                             break
[15:32:20.168]                           }
[15:32:20.168]                         }
[15:32:20.168]                       }
[15:32:20.168]                       invisible(muffled)
[15:32:20.168]                     }
[15:32:20.168]                     muffleCondition(cond, pattern = "^muffle")
[15:32:20.168]                   }
[15:32:20.168]                 }
[15:32:20.168]             }
[15:32:20.168]         }))
[15:32:20.168]     }, error = function(ex) {
[15:32:20.168]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:20.168]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:20.168]                 ...future.rng), started = ...future.startTime, 
[15:32:20.168]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:20.168]             version = "1.8"), class = "FutureResult")
[15:32:20.168]     }, finally = {
[15:32:20.168]         if (!identical(...future.workdir, getwd())) 
[15:32:20.168]             setwd(...future.workdir)
[15:32:20.168]         {
[15:32:20.168]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:20.168]                 ...future.oldOptions$nwarnings <- NULL
[15:32:20.168]             }
[15:32:20.168]             base::options(...future.oldOptions)
[15:32:20.168]             if (.Platform$OS.type == "windows") {
[15:32:20.168]                 old_names <- names(...future.oldEnvVars)
[15:32:20.168]                 envs <- base::Sys.getenv()
[15:32:20.168]                 names <- names(envs)
[15:32:20.168]                 common <- intersect(names, old_names)
[15:32:20.168]                 added <- setdiff(names, old_names)
[15:32:20.168]                 removed <- setdiff(old_names, names)
[15:32:20.168]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:20.168]                   envs[common]]
[15:32:20.168]                 NAMES <- toupper(changed)
[15:32:20.168]                 args <- list()
[15:32:20.168]                 for (kk in seq_along(NAMES)) {
[15:32:20.168]                   name <- changed[[kk]]
[15:32:20.168]                   NAME <- NAMES[[kk]]
[15:32:20.168]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:20.168]                     next
[15:32:20.168]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:20.168]                 }
[15:32:20.168]                 NAMES <- toupper(added)
[15:32:20.168]                 for (kk in seq_along(NAMES)) {
[15:32:20.168]                   name <- added[[kk]]
[15:32:20.168]                   NAME <- NAMES[[kk]]
[15:32:20.168]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:20.168]                     next
[15:32:20.168]                   args[[name]] <- ""
[15:32:20.168]                 }
[15:32:20.168]                 NAMES <- toupper(removed)
[15:32:20.168]                 for (kk in seq_along(NAMES)) {
[15:32:20.168]                   name <- removed[[kk]]
[15:32:20.168]                   NAME <- NAMES[[kk]]
[15:32:20.168]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:20.168]                     next
[15:32:20.168]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:20.168]                 }
[15:32:20.168]                 if (length(args) > 0) 
[15:32:20.168]                   base::do.call(base::Sys.setenv, args = args)
[15:32:20.168]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:20.168]             }
[15:32:20.168]             else {
[15:32:20.168]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:20.168]             }
[15:32:20.168]             {
[15:32:20.168]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:20.168]                   0L) {
[15:32:20.168]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:20.168]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:20.168]                   base::options(opts)
[15:32:20.168]                 }
[15:32:20.168]                 {
[15:32:20.168]                   {
[15:32:20.168]                     NULL
[15:32:20.168]                     RNGkind("Mersenne-Twister")
[15:32:20.168]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:20.168]                       inherits = FALSE)
[15:32:20.168]                   }
[15:32:20.168]                   options(future.plan = NULL)
[15:32:20.168]                   if (is.na(NA_character_)) 
[15:32:20.168]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:20.168]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:20.168]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:20.168]                     .init = FALSE)
[15:32:20.168]                 }
[15:32:20.168]             }
[15:32:20.168]         }
[15:32:20.168]     })
[15:32:20.168]     if (TRUE) {
[15:32:20.168]         base::sink(type = "output", split = FALSE)
[15:32:20.168]         if (TRUE) {
[15:32:20.168]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:20.168]         }
[15:32:20.168]         else {
[15:32:20.168]             ...future.result["stdout"] <- base::list(NULL)
[15:32:20.168]         }
[15:32:20.168]         base::close(...future.stdout)
[15:32:20.168]         ...future.stdout <- NULL
[15:32:20.168]     }
[15:32:20.168]     ...future.result$conditions <- ...future.conditions
[15:32:20.168]     ...future.result$finished <- base::Sys.time()
[15:32:20.168]     ...future.result
[15:32:20.168] }
[15:32:20.174] assign_globals() ...
[15:32:20.175] List of 5
[15:32:20.175]  $ ...future.FUN            :function (x, ...)  
[15:32:20.175]  $ future.call.arguments    : list()
[15:32:20.175]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:20.175]  $ ...future.elements_ii    :List of 3
[15:32:20.175]   ..$ a: num 1
[15:32:20.175]   ..$ b: num 2
[15:32:20.175]   ..$ c: num 3
[15:32:20.175]  $ ...future.seeds_ii       : NULL
[15:32:20.175]  $ ...future.globals.maxSize: NULL
[15:32:20.175]  - attr(*, "where")=List of 5
[15:32:20.175]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:20.175]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:20.175]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:20.175]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:20.175]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:20.175]  - attr(*, "resolved")= logi FALSE
[15:32:20.175]  - attr(*, "total_size")= num 1248
[15:32:20.175]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:20.175]  - attr(*, "already-done")= logi TRUE
[15:32:20.184] - copied '...future.FUN' to environment
[15:32:20.184] - copied 'future.call.arguments' to environment
[15:32:20.184] - copied '...future.elements_ii' to environment
[15:32:20.185] - copied '...future.seeds_ii' to environment
[15:32:20.185] - copied '...future.globals.maxSize' to environment
[15:32:20.185] assign_globals() ... done
[15:32:20.186] plan(): Setting new future strategy stack:
[15:32:20.186] List of future strategies:
[15:32:20.186] 1. sequential:
[15:32:20.186]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:20.186]    - tweaked: FALSE
[15:32:20.186]    - call: NULL
[15:32:20.187] plan(): nbrOfWorkers() = 1
[15:32:20.189] plan(): Setting new future strategy stack:
[15:32:20.189] List of future strategies:
[15:32:20.189] 1. sequential:
[15:32:20.189]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:20.189]    - tweaked: FALSE
[15:32:20.189]    - call: plan(strategy)
[15:32:20.190] plan(): nbrOfWorkers() = 1
[15:32:20.190] SequentialFuture started (and completed)
[15:32:20.190] - Launch lazy future ... done
[15:32:20.191] run() for 'SequentialFuture' ... done
[15:32:20.191] Created future:
[15:32:20.191] SequentialFuture:
[15:32:20.191] Label: 'future_sapply-1'
[15:32:20.191] Expression:
[15:32:20.191] {
[15:32:20.191]     do.call(function(...) {
[15:32:20.191]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:20.191]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:20.191]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:20.191]             on.exit(options(oopts), add = TRUE)
[15:32:20.191]         }
[15:32:20.191]         {
[15:32:20.191]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:20.191]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:20.191]                 ...future.FUN(...future.X_jj, ...)
[15:32:20.191]             })
[15:32:20.191]         }
[15:32:20.191]     }, args = future.call.arguments)
[15:32:20.191] }
[15:32:20.191] Lazy evaluation: FALSE
[15:32:20.191] Asynchronous evaluation: FALSE
[15:32:20.191] Local evaluation: TRUE
[15:32:20.191] Environment: R_GlobalEnv
[15:32:20.191] Capture standard output: TRUE
[15:32:20.191] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:20.191] Globals: 5 objects totaling 1.38 KiB (function '...future.FUN' of 1.22 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:20.191] Packages: <none>
[15:32:20.191] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:20.191] Resolved: TRUE
[15:32:20.191] Value: 672 bytes of class 'list'
[15:32:20.191] Early signaling: FALSE
[15:32:20.191] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:20.191] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:20.193] Chunk #1 of 1 ... DONE
[15:32:20.193] Launching 1 futures (chunks) ... DONE
[15:32:20.194] Resolving 1 futures (chunks) ...
[15:32:20.194] resolve() on list ...
[15:32:20.194]  recursive: 0
[15:32:20.194]  length: 1
[15:32:20.194] 
[15:32:20.195] resolved() for 'SequentialFuture' ...
[15:32:20.195] - state: 'finished'
[15:32:20.195] - run: TRUE
[15:32:20.196] - result: 'FutureResult'
[15:32:20.196] resolved() for 'SequentialFuture' ... done
[15:32:20.196] Future #1
[15:32:20.196] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:20.197] - nx: 1
[15:32:20.197] - relay: TRUE
[15:32:20.197] - stdout: TRUE
[15:32:20.197] - signal: TRUE
[15:32:20.198] - resignal: FALSE
[15:32:20.198] - force: TRUE
[15:32:20.198] - relayed: [n=1] FALSE
[15:32:20.198] - queued futures: [n=1] FALSE
[15:32:20.199]  - until=1
[15:32:20.199]  - relaying element #1
[15:32:20.199] - relayed: [n=1] TRUE
[15:32:20.200] - queued futures: [n=1] TRUE
[15:32:20.200] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:20.200]  length: 0 (resolved future 1)
[15:32:20.200] Relaying remaining futures
[15:32:20.201] signalConditionsASAP(NULL, pos=0) ...
[15:32:20.201] - nx: 1
[15:32:20.201] - relay: TRUE
[15:32:20.201] - stdout: TRUE
[15:32:20.202] - signal: TRUE
[15:32:20.202] - resignal: FALSE
[15:32:20.202] - force: TRUE
[15:32:20.202] - relayed: [n=1] TRUE
[15:32:20.203] - queued futures: [n=1] TRUE
 - flush all
[15:32:20.203] - relayed: [n=1] TRUE
[15:32:20.203] - queued futures: [n=1] TRUE
[15:32:20.203] signalConditionsASAP(NULL, pos=0) ... done
[15:32:20.204] resolve() on list ... DONE
[15:32:20.204]  - Number of value chunks collected: 1
[15:32:20.204] Resolving 1 futures (chunks) ... DONE
[15:32:20.205] Reducing values from 1 chunks ...
[15:32:20.205]  - Number of values collected after concatenation: 3
[15:32:20.205]  - Number of values expected: 3
[15:32:20.205] Reducing values from 1 chunks ... DONE
[15:32:20.206] future_lapply() ... DONE
List of 2
 $ y0:List of 3
  ..$ a: num [1, 1] 1
  ..$ b: num [1, 1] 2
  ..$ c: num [1, 1] 3
 $ y1:List of 3
  ..$ a: num [1, 1] 1
  ..$ b: num [1, 1] 2
  ..$ c: num [1, 1] 3
List of 2
 $ y0:List of 3
  ..$ a: num [1, 1] 1
  ..$ b: num [1, 1] 2
  ..$ c: num [1, 1] 3
 $ y2:List of 3
  ..$ a: num [1, 1] 1
  ..$ b: num [1, 1] 2
  ..$ c: num [1, 1] 3
[15:32:20.220] future_lapply() ...
[15:32:20.221] Number of chunks: 1
[15:32:20.221] getGlobalsAndPackagesXApply() ...
[15:32:20.222]  - future.globals: TRUE
[15:32:20.222] getGlobalsAndPackages() ...
[15:32:20.222] Searching for globals...
[15:32:20.225] - globals found: [5] 'FUN', '*', ':', 'outer', 'rep'
[15:32:20.225] Searching for globals ... DONE
[15:32:20.226] Resolving globals: FALSE
[15:32:20.226] The total size of the 1 globals is 4.62 KiB (4728 bytes)
[15:32:20.227] The total size of the 1 globals exported for future expression ('FUN()') is 4.62 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.62 KiB of class 'function')
[15:32:20.227] - globals: [1] 'FUN'
[15:32:20.228] 
[15:32:20.228] getGlobalsAndPackages() ... DONE
[15:32:20.228]  - globals found/used: [n=1] 'FUN'
[15:32:20.228]  - needed namespaces: [n=0] 
[15:32:20.229] Finding globals ... DONE
[15:32:20.229]  - use_args: TRUE
[15:32:20.229]  - Getting '...' globals ...
[15:32:20.230] resolve() on list ...
[15:32:20.230]  recursive: 0
[15:32:20.230]  length: 1
[15:32:20.230]  elements: '...'
[15:32:20.231]  length: 0 (resolved future 1)
[15:32:20.231] resolve() on list ... DONE
[15:32:20.231]    - '...' content: [n=0] 
[15:32:20.232] List of 1
[15:32:20.232]  $ ...: list()
[15:32:20.232]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:20.232]  - attr(*, "where")=List of 1
[15:32:20.232]   ..$ ...:<environment: 0x00000276e060a2d0> 
[15:32:20.232]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:20.232]  - attr(*, "resolved")= logi TRUE
[15:32:20.232]  - attr(*, "total_size")= num NA
[15:32:20.236]  - Getting '...' globals ... DONE
[15:32:20.237] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:20.237] List of 2
[15:32:20.237]  $ ...future.FUN:function (x, y = 2 * 1:5)  
[15:32:20.237]  $ ...          : list()
[15:32:20.237]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:20.237]  - attr(*, "where")=List of 2
[15:32:20.237]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:20.237]   ..$ ...          :<environment: 0x00000276e060a2d0> 
[15:32:20.237]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:20.237]  - attr(*, "resolved")= logi FALSE
[15:32:20.237]  - attr(*, "total_size")= num 4728
[15:32:20.241] Packages to be attached in all futures: [n=0] 
[15:32:20.242] getGlobalsAndPackagesXApply() ... DONE
[15:32:20.242] Number of futures (= number of chunks): 1
[15:32:20.242] Launching 1 futures (chunks) ...
[15:32:20.242] Chunk #1 of 1 ...
[15:32:20.243]  - Finding globals in 'X' for chunk #1 ...
[15:32:20.243] getGlobalsAndPackages() ...
[15:32:20.243] Searching for globals...
[15:32:20.244] 
[15:32:20.244] Searching for globals ... DONE
[15:32:20.244] - globals: [0] <none>
[15:32:20.244] getGlobalsAndPackages() ... DONE
[15:32:20.245]    + additional globals found: [n=0] 
[15:32:20.245]    + additional namespaces needed: [n=0] 
[15:32:20.245]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:20.245]  - seeds: <none>
[15:32:20.246]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:20.246] getGlobalsAndPackages() ...
[15:32:20.246] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:20.246] Resolving globals: FALSE
[15:32:20.247] Tweak future expression to call with '...' arguments ...
[15:32:20.247] {
[15:32:20.247]     do.call(function(...) {
[15:32:20.247]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:20.247]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:20.247]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:20.247]             on.exit(options(oopts), add = TRUE)
[15:32:20.247]         }
[15:32:20.247]         {
[15:32:20.247]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:20.247]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:20.247]                 ...future.FUN(...future.X_jj, ...)
[15:32:20.247]             })
[15:32:20.247]         }
[15:32:20.247]     }, args = future.call.arguments)
[15:32:20.247] }
[15:32:20.247] Tweak future expression to call with '...' arguments ... DONE
[15:32:20.248] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:20.248] 
[15:32:20.249] getGlobalsAndPackages() ... DONE
[15:32:20.249] run() for 'Future' ...
[15:32:20.250] - state: 'created'
[15:32:20.251] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:20.251] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:20.252] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:20.252]   - Field: 'label'
[15:32:20.253]   - Field: 'local'
[15:32:20.253]   - Field: 'owner'
[15:32:20.254]   - Field: 'envir'
[15:32:20.254]   - Field: 'packages'
[15:32:20.254]   - Field: 'gc'
[15:32:20.255]   - Field: 'conditions'
[15:32:20.255]   - Field: 'expr'
[15:32:20.255]   - Field: 'uuid'
[15:32:20.256]   - Field: 'seed'
[15:32:20.256]   - Field: 'version'
[15:32:20.256]   - Field: 'result'
[15:32:20.259]   - Field: 'asynchronous'
[15:32:20.259]   - Field: 'calls'
[15:32:20.259]   - Field: 'globals'
[15:32:20.260]   - Field: 'stdout'
[15:32:20.260]   - Field: 'earlySignal'
[15:32:20.260]   - Field: 'lazy'
[15:32:20.260]   - Field: 'state'
[15:32:20.261] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:20.261] - Launch lazy future ...
[15:32:20.261] Packages needed by the future expression (n = 0): <none>
[15:32:20.261] Packages needed by future strategies (n = 0): <none>
[15:32:20.262] {
[15:32:20.262]     {
[15:32:20.262]         {
[15:32:20.262]             ...future.startTime <- base::Sys.time()
[15:32:20.262]             {
[15:32:20.262]                 {
[15:32:20.262]                   {
[15:32:20.262]                     base::local({
[15:32:20.262]                       has_future <- base::requireNamespace("future", 
[15:32:20.262]                         quietly = TRUE)
[15:32:20.262]                       if (has_future) {
[15:32:20.262]                         ns <- base::getNamespace("future")
[15:32:20.262]                         version <- ns[[".package"]][["version"]]
[15:32:20.262]                         if (is.null(version)) 
[15:32:20.262]                           version <- utils::packageVersion("future")
[15:32:20.262]                       }
[15:32:20.262]                       else {
[15:32:20.262]                         version <- NULL
[15:32:20.262]                       }
[15:32:20.262]                       if (!has_future || version < "1.8.0") {
[15:32:20.262]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:20.262]                           "", base::R.version$version.string), 
[15:32:20.262]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:20.262]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:20.262]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:20.262]                             "release", "version")], collapse = " "), 
[15:32:20.262]                           hostname = base::Sys.info()[["nodename"]])
[15:32:20.262]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:20.262]                           info)
[15:32:20.262]                         info <- base::paste(info, collapse = "; ")
[15:32:20.262]                         if (!has_future) {
[15:32:20.262]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:20.262]                             info)
[15:32:20.262]                         }
[15:32:20.262]                         else {
[15:32:20.262]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:20.262]                             info, version)
[15:32:20.262]                         }
[15:32:20.262]                         base::stop(msg)
[15:32:20.262]                       }
[15:32:20.262]                     })
[15:32:20.262]                   }
[15:32:20.262]                   ...future.strategy.old <- future::plan("list")
[15:32:20.262]                   options(future.plan = NULL)
[15:32:20.262]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:20.262]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:20.262]                 }
[15:32:20.262]                 ...future.workdir <- getwd()
[15:32:20.262]             }
[15:32:20.262]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:20.262]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:20.262]         }
[15:32:20.262]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:20.262]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:20.262]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:20.262]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:20.262]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:20.262]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:20.262]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:20.262]             base::names(...future.oldOptions))
[15:32:20.262]     }
[15:32:20.262]     if (FALSE) {
[15:32:20.262]     }
[15:32:20.262]     else {
[15:32:20.262]         if (TRUE) {
[15:32:20.262]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:20.262]                 open = "w")
[15:32:20.262]         }
[15:32:20.262]         else {
[15:32:20.262]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:20.262]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:20.262]         }
[15:32:20.262]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:20.262]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:20.262]             base::sink(type = "output", split = FALSE)
[15:32:20.262]             base::close(...future.stdout)
[15:32:20.262]         }, add = TRUE)
[15:32:20.262]     }
[15:32:20.262]     ...future.frame <- base::sys.nframe()
[15:32:20.262]     ...future.conditions <- base::list()
[15:32:20.262]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:20.262]     if (FALSE) {
[15:32:20.262]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:20.262]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:20.262]     }
[15:32:20.262]     ...future.result <- base::tryCatch({
[15:32:20.262]         base::withCallingHandlers({
[15:32:20.262]             ...future.value <- base::withVisible(base::local({
[15:32:20.262]                 do.call(function(...) {
[15:32:20.262]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:20.262]                   if (!identical(...future.globals.maxSize.org, 
[15:32:20.262]                     ...future.globals.maxSize)) {
[15:32:20.262]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:20.262]                     on.exit(options(oopts), add = TRUE)
[15:32:20.262]                   }
[15:32:20.262]                   {
[15:32:20.262]                     lapply(seq_along(...future.elements_ii), 
[15:32:20.262]                       FUN = function(jj) {
[15:32:20.262]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:20.262]                         ...future.FUN(...future.X_jj, ...)
[15:32:20.262]                       })
[15:32:20.262]                   }
[15:32:20.262]                 }, args = future.call.arguments)
[15:32:20.262]             }))
[15:32:20.262]             future::FutureResult(value = ...future.value$value, 
[15:32:20.262]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:20.262]                   ...future.rng), globalenv = if (FALSE) 
[15:32:20.262]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:20.262]                     ...future.globalenv.names))
[15:32:20.262]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:20.262]         }, condition = base::local({
[15:32:20.262]             c <- base::c
[15:32:20.262]             inherits <- base::inherits
[15:32:20.262]             invokeRestart <- base::invokeRestart
[15:32:20.262]             length <- base::length
[15:32:20.262]             list <- base::list
[15:32:20.262]             seq.int <- base::seq.int
[15:32:20.262]             signalCondition <- base::signalCondition
[15:32:20.262]             sys.calls <- base::sys.calls
[15:32:20.262]             `[[` <- base::`[[`
[15:32:20.262]             `+` <- base::`+`
[15:32:20.262]             `<<-` <- base::`<<-`
[15:32:20.262]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:20.262]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:20.262]                   3L)]
[15:32:20.262]             }
[15:32:20.262]             function(cond) {
[15:32:20.262]                 is_error <- inherits(cond, "error")
[15:32:20.262]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:20.262]                   NULL)
[15:32:20.262]                 if (is_error) {
[15:32:20.262]                   sessionInformation <- function() {
[15:32:20.262]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:20.262]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:20.262]                       search = base::search(), system = base::Sys.info())
[15:32:20.262]                   }
[15:32:20.262]                   ...future.conditions[[length(...future.conditions) + 
[15:32:20.262]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:20.262]                     cond$call), session = sessionInformation(), 
[15:32:20.262]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:20.262]                   signalCondition(cond)
[15:32:20.262]                 }
[15:32:20.262]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:20.262]                 "immediateCondition"))) {
[15:32:20.262]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:20.262]                   ...future.conditions[[length(...future.conditions) + 
[15:32:20.262]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:20.262]                   if (TRUE && !signal) {
[15:32:20.262]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:20.262]                     {
[15:32:20.262]                       inherits <- base::inherits
[15:32:20.262]                       invokeRestart <- base::invokeRestart
[15:32:20.262]                       is.null <- base::is.null
[15:32:20.262]                       muffled <- FALSE
[15:32:20.262]                       if (inherits(cond, "message")) {
[15:32:20.262]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:20.262]                         if (muffled) 
[15:32:20.262]                           invokeRestart("muffleMessage")
[15:32:20.262]                       }
[15:32:20.262]                       else if (inherits(cond, "warning")) {
[15:32:20.262]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:20.262]                         if (muffled) 
[15:32:20.262]                           invokeRestart("muffleWarning")
[15:32:20.262]                       }
[15:32:20.262]                       else if (inherits(cond, "condition")) {
[15:32:20.262]                         if (!is.null(pattern)) {
[15:32:20.262]                           computeRestarts <- base::computeRestarts
[15:32:20.262]                           grepl <- base::grepl
[15:32:20.262]                           restarts <- computeRestarts(cond)
[15:32:20.262]                           for (restart in restarts) {
[15:32:20.262]                             name <- restart$name
[15:32:20.262]                             if (is.null(name)) 
[15:32:20.262]                               next
[15:32:20.262]                             if (!grepl(pattern, name)) 
[15:32:20.262]                               next
[15:32:20.262]                             invokeRestart(restart)
[15:32:20.262]                             muffled <- TRUE
[15:32:20.262]                             break
[15:32:20.262]                           }
[15:32:20.262]                         }
[15:32:20.262]                       }
[15:32:20.262]                       invisible(muffled)
[15:32:20.262]                     }
[15:32:20.262]                     muffleCondition(cond, pattern = "^muffle")
[15:32:20.262]                   }
[15:32:20.262]                 }
[15:32:20.262]                 else {
[15:32:20.262]                   if (TRUE) {
[15:32:20.262]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:20.262]                     {
[15:32:20.262]                       inherits <- base::inherits
[15:32:20.262]                       invokeRestart <- base::invokeRestart
[15:32:20.262]                       is.null <- base::is.null
[15:32:20.262]                       muffled <- FALSE
[15:32:20.262]                       if (inherits(cond, "message")) {
[15:32:20.262]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:20.262]                         if (muffled) 
[15:32:20.262]                           invokeRestart("muffleMessage")
[15:32:20.262]                       }
[15:32:20.262]                       else if (inherits(cond, "warning")) {
[15:32:20.262]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:20.262]                         if (muffled) 
[15:32:20.262]                           invokeRestart("muffleWarning")
[15:32:20.262]                       }
[15:32:20.262]                       else if (inherits(cond, "condition")) {
[15:32:20.262]                         if (!is.null(pattern)) {
[15:32:20.262]                           computeRestarts <- base::computeRestarts
[15:32:20.262]                           grepl <- base::grepl
[15:32:20.262]                           restarts <- computeRestarts(cond)
[15:32:20.262]                           for (restart in restarts) {
[15:32:20.262]                             name <- restart$name
[15:32:20.262]                             if (is.null(name)) 
[15:32:20.262]                               next
[15:32:20.262]                             if (!grepl(pattern, name)) 
[15:32:20.262]                               next
[15:32:20.262]                             invokeRestart(restart)
[15:32:20.262]                             muffled <- TRUE
[15:32:20.262]                             break
[15:32:20.262]                           }
[15:32:20.262]                         }
[15:32:20.262]                       }
[15:32:20.262]                       invisible(muffled)
[15:32:20.262]                     }
[15:32:20.262]                     muffleCondition(cond, pattern = "^muffle")
[15:32:20.262]                   }
[15:32:20.262]                 }
[15:32:20.262]             }
[15:32:20.262]         }))
[15:32:20.262]     }, error = function(ex) {
[15:32:20.262]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:20.262]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:20.262]                 ...future.rng), started = ...future.startTime, 
[15:32:20.262]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:20.262]             version = "1.8"), class = "FutureResult")
[15:32:20.262]     }, finally = {
[15:32:20.262]         if (!identical(...future.workdir, getwd())) 
[15:32:20.262]             setwd(...future.workdir)
[15:32:20.262]         {
[15:32:20.262]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:20.262]                 ...future.oldOptions$nwarnings <- NULL
[15:32:20.262]             }
[15:32:20.262]             base::options(...future.oldOptions)
[15:32:20.262]             if (.Platform$OS.type == "windows") {
[15:32:20.262]                 old_names <- names(...future.oldEnvVars)
[15:32:20.262]                 envs <- base::Sys.getenv()
[15:32:20.262]                 names <- names(envs)
[15:32:20.262]                 common <- intersect(names, old_names)
[15:32:20.262]                 added <- setdiff(names, old_names)
[15:32:20.262]                 removed <- setdiff(old_names, names)
[15:32:20.262]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:20.262]                   envs[common]]
[15:32:20.262]                 NAMES <- toupper(changed)
[15:32:20.262]                 args <- list()
[15:32:20.262]                 for (kk in seq_along(NAMES)) {
[15:32:20.262]                   name <- changed[[kk]]
[15:32:20.262]                   NAME <- NAMES[[kk]]
[15:32:20.262]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:20.262]                     next
[15:32:20.262]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:20.262]                 }
[15:32:20.262]                 NAMES <- toupper(added)
[15:32:20.262]                 for (kk in seq_along(NAMES)) {
[15:32:20.262]                   name <- added[[kk]]
[15:32:20.262]                   NAME <- NAMES[[kk]]
[15:32:20.262]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:20.262]                     next
[15:32:20.262]                   args[[name]] <- ""
[15:32:20.262]                 }
[15:32:20.262]                 NAMES <- toupper(removed)
[15:32:20.262]                 for (kk in seq_along(NAMES)) {
[15:32:20.262]                   name <- removed[[kk]]
[15:32:20.262]                   NAME <- NAMES[[kk]]
[15:32:20.262]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:20.262]                     next
[15:32:20.262]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:20.262]                 }
[15:32:20.262]                 if (length(args) > 0) 
[15:32:20.262]                   base::do.call(base::Sys.setenv, args = args)
[15:32:20.262]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:20.262]             }
[15:32:20.262]             else {
[15:32:20.262]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:20.262]             }
[15:32:20.262]             {
[15:32:20.262]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:20.262]                   0L) {
[15:32:20.262]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:20.262]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:20.262]                   base::options(opts)
[15:32:20.262]                 }
[15:32:20.262]                 {
[15:32:20.262]                   {
[15:32:20.262]                     NULL
[15:32:20.262]                     RNGkind("Mersenne-Twister")
[15:32:20.262]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:20.262]                       inherits = FALSE)
[15:32:20.262]                   }
[15:32:20.262]                   options(future.plan = NULL)
[15:32:20.262]                   if (is.na(NA_character_)) 
[15:32:20.262]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:20.262]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:20.262]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:20.262]                     .init = FALSE)
[15:32:20.262]                 }
[15:32:20.262]             }
[15:32:20.262]         }
[15:32:20.262]     })
[15:32:20.262]     if (TRUE) {
[15:32:20.262]         base::sink(type = "output", split = FALSE)
[15:32:20.262]         if (TRUE) {
[15:32:20.262]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:20.262]         }
[15:32:20.262]         else {
[15:32:20.262]             ...future.result["stdout"] <- base::list(NULL)
[15:32:20.262]         }
[15:32:20.262]         base::close(...future.stdout)
[15:32:20.262]         ...future.stdout <- NULL
[15:32:20.262]     }
[15:32:20.262]     ...future.result$conditions <- ...future.conditions
[15:32:20.262]     ...future.result$finished <- base::Sys.time()
[15:32:20.262]     ...future.result
[15:32:20.262] }
[15:32:20.268] assign_globals() ...
[15:32:20.268] List of 5
[15:32:20.268]  $ ...future.FUN            :function (x, y = 2 * 1:5)  
[15:32:20.268]  $ future.call.arguments    : list()
[15:32:20.268]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:20.268]  $ ...future.elements_ii    :List of 3
[15:32:20.268]   ..$ a: num 1
[15:32:20.268]   ..$ b: num 2
[15:32:20.268]   ..$ c: num 3
[15:32:20.268]  $ ...future.seeds_ii       : NULL
[15:32:20.268]  $ ...future.globals.maxSize: NULL
[15:32:20.268]  - attr(*, "where")=List of 5
[15:32:20.268]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:20.268]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:20.268]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:20.268]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:20.268]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:20.268]  - attr(*, "resolved")= logi FALSE
[15:32:20.268]  - attr(*, "total_size")= num 4728
[15:32:20.268]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:20.268]  - attr(*, "already-done")= logi TRUE
[15:32:20.279] - reassign environment for '...future.FUN'
[15:32:20.279] - copied '...future.FUN' to environment
[15:32:20.279] - copied 'future.call.arguments' to environment
[15:32:20.280] - copied '...future.elements_ii' to environment
[15:32:20.280] - copied '...future.seeds_ii' to environment
[15:32:20.280] - copied '...future.globals.maxSize' to environment
[15:32:20.281] assign_globals() ... done
[15:32:20.281] plan(): Setting new future strategy stack:
[15:32:20.282] List of future strategies:
[15:32:20.282] 1. sequential:
[15:32:20.282]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:20.282]    - tweaked: FALSE
[15:32:20.282]    - call: NULL
[15:32:20.283] plan(): nbrOfWorkers() = 1
[15:32:20.285] plan(): Setting new future strategy stack:
[15:32:20.285] List of future strategies:
[15:32:20.285] 1. sequential:
[15:32:20.285]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:20.285]    - tweaked: FALSE
[15:32:20.285]    - call: plan(strategy)
[15:32:20.286] plan(): nbrOfWorkers() = 1
[15:32:20.286] SequentialFuture started (and completed)
[15:32:20.287] - Launch lazy future ... done
[15:32:20.287] run() for 'SequentialFuture' ... done
[15:32:20.287] Created future:
[15:32:20.288] SequentialFuture:
[15:32:20.288] Label: 'future_sapply-1'
[15:32:20.288] Expression:
[15:32:20.288] {
[15:32:20.288]     do.call(function(...) {
[15:32:20.288]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:20.288]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:20.288]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:20.288]             on.exit(options(oopts), add = TRUE)
[15:32:20.288]         }
[15:32:20.288]         {
[15:32:20.288]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:20.288]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:20.288]                 ...future.FUN(...future.X_jj, ...)
[15:32:20.288]             })
[15:32:20.288]         }
[15:32:20.288]     }, args = future.call.arguments)
[15:32:20.288] }
[15:32:20.288] Lazy evaluation: FALSE
[15:32:20.288] Asynchronous evaluation: FALSE
[15:32:20.288] Local evaluation: TRUE
[15:32:20.288] Environment: R_GlobalEnv
[15:32:20.288] Capture standard output: TRUE
[15:32:20.288] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:20.288] Globals: 5 objects totaling 4.78 KiB (function '...future.FUN' of 4.62 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:20.288] Packages: <none>
[15:32:20.288] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:20.288] Resolved: TRUE
[15:32:20.288] Value: 1.01 KiB of class 'list'
[15:32:20.288] Early signaling: FALSE
[15:32:20.288] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:20.288] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:20.290] Chunk #1 of 1 ... DONE
[15:32:20.290] Launching 1 futures (chunks) ... DONE
[15:32:20.290] Resolving 1 futures (chunks) ...
[15:32:20.291] resolve() on list ...
[15:32:20.291]  recursive: 0
[15:32:20.291]  length: 1
[15:32:20.291] 
[15:32:20.292] resolved() for 'SequentialFuture' ...
[15:32:20.292] - state: 'finished'
[15:32:20.292] - run: TRUE
[15:32:20.293] - result: 'FutureResult'
[15:32:20.293] resolved() for 'SequentialFuture' ... done
[15:32:20.293] Future #1
[15:32:20.294] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:20.294] - nx: 1
[15:32:20.294] - relay: TRUE
[15:32:20.295] - stdout: TRUE
[15:32:20.295] - signal: TRUE
[15:32:20.295] - resignal: FALSE
[15:32:20.295] - force: TRUE
[15:32:20.296] - relayed: [n=1] FALSE
[15:32:20.296] - queued futures: [n=1] FALSE
[15:32:20.296]  - until=1
[15:32:20.297]  - relaying element #1
[15:32:20.297] - relayed: [n=1] TRUE
[15:32:20.297] - queued futures: [n=1] TRUE
[15:32:20.298] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:20.298]  length: 0 (resolved future 1)
[15:32:20.298] Relaying remaining futures
[15:32:20.299] signalConditionsASAP(NULL, pos=0) ...
[15:32:20.299] - nx: 1
[15:32:20.299] - relay: TRUE
[15:32:20.299] - stdout: TRUE
[15:32:20.300] - signal: TRUE
[15:32:20.300] - resignal: FALSE
[15:32:20.300] - force: TRUE
[15:32:20.300] - relayed: [n=1] TRUE
[15:32:20.301] - queued futures: [n=1] TRUE
 - flush all
[15:32:20.301] - relayed: [n=1] TRUE
[15:32:20.301] - queued futures: [n=1] TRUE
[15:32:20.302] signalConditionsASAP(NULL, pos=0) ... done
[15:32:20.302] resolve() on list ... DONE
[15:32:20.302]  - Number of value chunks collected: 1
[15:32:20.303] Resolving 1 futures (chunks) ... DONE
[15:32:20.303] Reducing values from 1 chunks ...
[15:32:20.303]  - Number of values collected after concatenation: 3
[15:32:20.303]  - Number of values expected: 3
[15:32:20.304] Reducing values from 1 chunks ... DONE
[15:32:20.304] future_lapply() ... DONE
List of 2
 $ y0:List of 3
  ..$ a: num [1:3, 1:5] 2 2 2 4 4 4 6 6 6 8 ...
  ..$ b: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
  ..$ c: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
 $ y1:List of 3
  ..$ a: num [1:3, 1:5] 2 2 2 4 4 4 6 6 6 8 ...
  ..$ b: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
  ..$ c: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
List of 2
 $ y0:List of 3
  ..$ a: num [1:3, 1:5] 2 2 2 4 4 4 6 6 6 8 ...
  ..$ b: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
  ..$ c: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
 $ y2:List of 3
  ..$ a: num [1:3, 1:5] 2 2 2 4 4 4 6 6 6 8 ...
  ..$ b: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
  ..$ c: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
[15:32:20.319] future_lapply() ...
[15:32:20.320] Number of chunks: 1
[15:32:20.320] getGlobalsAndPackagesXApply() ...
[15:32:20.321]  - future.globals: TRUE
[15:32:20.321] getGlobalsAndPackages() ...
[15:32:20.321] Searching for globals...
[15:32:20.323] - globals found: [1] 'FUN'
[15:32:20.323] Searching for globals ... DONE
[15:32:20.324] Resolving globals: FALSE
[15:32:20.324] The total size of the 1 globals is 848 bytes (848 bytes)
[15:32:20.325] The total size of the 1 globals exported for future expression ('FUN()') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:32:20.325] - globals: [1] 'FUN'
[15:32:20.326] 
[15:32:20.327] getGlobalsAndPackages() ... DONE
[15:32:20.327]  - globals found/used: [n=1] 'FUN'
[15:32:20.328]  - needed namespaces: [n=0] 
[15:32:20.328] Finding globals ... DONE
[15:32:20.328]  - use_args: TRUE
[15:32:20.329]  - Getting '...' globals ...
[15:32:20.329] resolve() on list ...
[15:32:20.329]  recursive: 0
[15:32:20.330]  length: 1
[15:32:20.330]  elements: '...'
[15:32:20.330]  length: 0 (resolved future 1)
[15:32:20.330] resolve() on list ... DONE
[15:32:20.331]    - '...' content: [n=0] 
[15:32:20.331] List of 1
[15:32:20.331]  $ ...: list()
[15:32:20.331]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:20.331]  - attr(*, "where")=List of 1
[15:32:20.331]   ..$ ...:<environment: 0x00000276dee7e958> 
[15:32:20.331]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:20.331]  - attr(*, "resolved")= logi TRUE
[15:32:20.331]  - attr(*, "total_size")= num NA
[15:32:20.335]  - Getting '...' globals ... DONE
[15:32:20.336] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:20.336] List of 2
[15:32:20.336]  $ ...future.FUN:function (x)  
[15:32:20.336]  $ ...          : list()
[15:32:20.336]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:20.336]  - attr(*, "where")=List of 2
[15:32:20.336]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:20.336]   ..$ ...          :<environment: 0x00000276dee7e958> 
[15:32:20.336]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:20.336]  - attr(*, "resolved")= logi FALSE
[15:32:20.336]  - attr(*, "total_size")= num 848
[15:32:20.341] Packages to be attached in all futures: [n=0] 
[15:32:20.341] getGlobalsAndPackagesXApply() ... DONE
[15:32:20.342] Number of futures (= number of chunks): 1
[15:32:20.342] Launching 1 futures (chunks) ...
[15:32:20.342] Chunk #1 of 1 ...
[15:32:20.343]  - Finding globals in 'X' for chunk #1 ...
[15:32:20.343] getGlobalsAndPackages() ...
[15:32:20.343] Searching for globals...
[15:32:20.344] 
[15:32:20.344] Searching for globals ... DONE
[15:32:20.344] - globals: [0] <none>
[15:32:20.345] getGlobalsAndPackages() ... DONE
[15:32:20.345]    + additional globals found: [n=0] 
[15:32:20.345]    + additional namespaces needed: [n=0] 
[15:32:20.345]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:20.346]  - seeds: <none>
[15:32:20.346]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:20.346] getGlobalsAndPackages() ...
[15:32:20.346] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:20.347] Resolving globals: FALSE
[15:32:20.347] Tweak future expression to call with '...' arguments ...
[15:32:20.347] {
[15:32:20.347]     do.call(function(...) {
[15:32:20.347]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:20.347]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:20.347]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:20.347]             on.exit(options(oopts), add = TRUE)
[15:32:20.347]         }
[15:32:20.347]         {
[15:32:20.347]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:20.347]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:20.347]                 ...future.FUN(...future.X_jj, ...)
[15:32:20.347]             })
[15:32:20.347]         }
[15:32:20.347]     }, args = future.call.arguments)
[15:32:20.347] }
[15:32:20.348] Tweak future expression to call with '...' arguments ... DONE
[15:32:20.349] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:20.349] 
[15:32:20.349] getGlobalsAndPackages() ... DONE
[15:32:20.350] run() for 'Future' ...
[15:32:20.350] - state: 'created'
[15:32:20.351] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:20.351] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:20.352] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:20.352]   - Field: 'label'
[15:32:20.352]   - Field: 'local'
[15:32:20.353]   - Field: 'owner'
[15:32:20.355]   - Field: 'envir'
[15:32:20.356]   - Field: 'packages'
[15:32:20.356]   - Field: 'gc'
[15:32:20.356]   - Field: 'conditions'
[15:32:20.357]   - Field: 'expr'
[15:32:20.357]   - Field: 'uuid'
[15:32:20.357]   - Field: 'seed'
[15:32:20.357]   - Field: 'version'
[15:32:20.357]   - Field: 'result'
[15:32:20.357]   - Field: 'asynchronous'
[15:32:20.358]   - Field: 'calls'
[15:32:20.358]   - Field: 'globals'
[15:32:20.358]   - Field: 'stdout'
[15:32:20.358]   - Field: 'earlySignal'
[15:32:20.359]   - Field: 'lazy'
[15:32:20.359]   - Field: 'state'
[15:32:20.359] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:20.359] - Launch lazy future ...
[15:32:20.360] Packages needed by the future expression (n = 0): <none>
[15:32:20.360] Packages needed by future strategies (n = 0): <none>
[15:32:20.361] {
[15:32:20.361]     {
[15:32:20.361]         {
[15:32:20.361]             ...future.startTime <- base::Sys.time()
[15:32:20.361]             {
[15:32:20.361]                 {
[15:32:20.361]                   {
[15:32:20.361]                     base::local({
[15:32:20.361]                       has_future <- base::requireNamespace("future", 
[15:32:20.361]                         quietly = TRUE)
[15:32:20.361]                       if (has_future) {
[15:32:20.361]                         ns <- base::getNamespace("future")
[15:32:20.361]                         version <- ns[[".package"]][["version"]]
[15:32:20.361]                         if (is.null(version)) 
[15:32:20.361]                           version <- utils::packageVersion("future")
[15:32:20.361]                       }
[15:32:20.361]                       else {
[15:32:20.361]                         version <- NULL
[15:32:20.361]                       }
[15:32:20.361]                       if (!has_future || version < "1.8.0") {
[15:32:20.361]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:20.361]                           "", base::R.version$version.string), 
[15:32:20.361]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:20.361]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:20.361]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:20.361]                             "release", "version")], collapse = " "), 
[15:32:20.361]                           hostname = base::Sys.info()[["nodename"]])
[15:32:20.361]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:20.361]                           info)
[15:32:20.361]                         info <- base::paste(info, collapse = "; ")
[15:32:20.361]                         if (!has_future) {
[15:32:20.361]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:20.361]                             info)
[15:32:20.361]                         }
[15:32:20.361]                         else {
[15:32:20.361]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:20.361]                             info, version)
[15:32:20.361]                         }
[15:32:20.361]                         base::stop(msg)
[15:32:20.361]                       }
[15:32:20.361]                     })
[15:32:20.361]                   }
[15:32:20.361]                   ...future.strategy.old <- future::plan("list")
[15:32:20.361]                   options(future.plan = NULL)
[15:32:20.361]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:20.361]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:20.361]                 }
[15:32:20.361]                 ...future.workdir <- getwd()
[15:32:20.361]             }
[15:32:20.361]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:20.361]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:20.361]         }
[15:32:20.361]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:20.361]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:20.361]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:20.361]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:20.361]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:20.361]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:20.361]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:20.361]             base::names(...future.oldOptions))
[15:32:20.361]     }
[15:32:20.361]     if (FALSE) {
[15:32:20.361]     }
[15:32:20.361]     else {
[15:32:20.361]         if (TRUE) {
[15:32:20.361]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:20.361]                 open = "w")
[15:32:20.361]         }
[15:32:20.361]         else {
[15:32:20.361]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:20.361]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:20.361]         }
[15:32:20.361]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:20.361]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:20.361]             base::sink(type = "output", split = FALSE)
[15:32:20.361]             base::close(...future.stdout)
[15:32:20.361]         }, add = TRUE)
[15:32:20.361]     }
[15:32:20.361]     ...future.frame <- base::sys.nframe()
[15:32:20.361]     ...future.conditions <- base::list()
[15:32:20.361]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:20.361]     if (FALSE) {
[15:32:20.361]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:20.361]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:20.361]     }
[15:32:20.361]     ...future.result <- base::tryCatch({
[15:32:20.361]         base::withCallingHandlers({
[15:32:20.361]             ...future.value <- base::withVisible(base::local({
[15:32:20.361]                 do.call(function(...) {
[15:32:20.361]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:20.361]                   if (!identical(...future.globals.maxSize.org, 
[15:32:20.361]                     ...future.globals.maxSize)) {
[15:32:20.361]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:20.361]                     on.exit(options(oopts), add = TRUE)
[15:32:20.361]                   }
[15:32:20.361]                   {
[15:32:20.361]                     lapply(seq_along(...future.elements_ii), 
[15:32:20.361]                       FUN = function(jj) {
[15:32:20.361]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:20.361]                         ...future.FUN(...future.X_jj, ...)
[15:32:20.361]                       })
[15:32:20.361]                   }
[15:32:20.361]                 }, args = future.call.arguments)
[15:32:20.361]             }))
[15:32:20.361]             future::FutureResult(value = ...future.value$value, 
[15:32:20.361]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:20.361]                   ...future.rng), globalenv = if (FALSE) 
[15:32:20.361]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:20.361]                     ...future.globalenv.names))
[15:32:20.361]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:20.361]         }, condition = base::local({
[15:32:20.361]             c <- base::c
[15:32:20.361]             inherits <- base::inherits
[15:32:20.361]             invokeRestart <- base::invokeRestart
[15:32:20.361]             length <- base::length
[15:32:20.361]             list <- base::list
[15:32:20.361]             seq.int <- base::seq.int
[15:32:20.361]             signalCondition <- base::signalCondition
[15:32:20.361]             sys.calls <- base::sys.calls
[15:32:20.361]             `[[` <- base::`[[`
[15:32:20.361]             `+` <- base::`+`
[15:32:20.361]             `<<-` <- base::`<<-`
[15:32:20.361]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:20.361]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:20.361]                   3L)]
[15:32:20.361]             }
[15:32:20.361]             function(cond) {
[15:32:20.361]                 is_error <- inherits(cond, "error")
[15:32:20.361]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:20.361]                   NULL)
[15:32:20.361]                 if (is_error) {
[15:32:20.361]                   sessionInformation <- function() {
[15:32:20.361]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:20.361]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:20.361]                       search = base::search(), system = base::Sys.info())
[15:32:20.361]                   }
[15:32:20.361]                   ...future.conditions[[length(...future.conditions) + 
[15:32:20.361]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:20.361]                     cond$call), session = sessionInformation(), 
[15:32:20.361]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:20.361]                   signalCondition(cond)
[15:32:20.361]                 }
[15:32:20.361]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:20.361]                 "immediateCondition"))) {
[15:32:20.361]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:20.361]                   ...future.conditions[[length(...future.conditions) + 
[15:32:20.361]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:20.361]                   if (TRUE && !signal) {
[15:32:20.361]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:20.361]                     {
[15:32:20.361]                       inherits <- base::inherits
[15:32:20.361]                       invokeRestart <- base::invokeRestart
[15:32:20.361]                       is.null <- base::is.null
[15:32:20.361]                       muffled <- FALSE
[15:32:20.361]                       if (inherits(cond, "message")) {
[15:32:20.361]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:20.361]                         if (muffled) 
[15:32:20.361]                           invokeRestart("muffleMessage")
[15:32:20.361]                       }
[15:32:20.361]                       else if (inherits(cond, "warning")) {
[15:32:20.361]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:20.361]                         if (muffled) 
[15:32:20.361]                           invokeRestart("muffleWarning")
[15:32:20.361]                       }
[15:32:20.361]                       else if (inherits(cond, "condition")) {
[15:32:20.361]                         if (!is.null(pattern)) {
[15:32:20.361]                           computeRestarts <- base::computeRestarts
[15:32:20.361]                           grepl <- base::grepl
[15:32:20.361]                           restarts <- computeRestarts(cond)
[15:32:20.361]                           for (restart in restarts) {
[15:32:20.361]                             name <- restart$name
[15:32:20.361]                             if (is.null(name)) 
[15:32:20.361]                               next
[15:32:20.361]                             if (!grepl(pattern, name)) 
[15:32:20.361]                               next
[15:32:20.361]                             invokeRestart(restart)
[15:32:20.361]                             muffled <- TRUE
[15:32:20.361]                             break
[15:32:20.361]                           }
[15:32:20.361]                         }
[15:32:20.361]                       }
[15:32:20.361]                       invisible(muffled)
[15:32:20.361]                     }
[15:32:20.361]                     muffleCondition(cond, pattern = "^muffle")
[15:32:20.361]                   }
[15:32:20.361]                 }
[15:32:20.361]                 else {
[15:32:20.361]                   if (TRUE) {
[15:32:20.361]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:20.361]                     {
[15:32:20.361]                       inherits <- base::inherits
[15:32:20.361]                       invokeRestart <- base::invokeRestart
[15:32:20.361]                       is.null <- base::is.null
[15:32:20.361]                       muffled <- FALSE
[15:32:20.361]                       if (inherits(cond, "message")) {
[15:32:20.361]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:20.361]                         if (muffled) 
[15:32:20.361]                           invokeRestart("muffleMessage")
[15:32:20.361]                       }
[15:32:20.361]                       else if (inherits(cond, "warning")) {
[15:32:20.361]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:20.361]                         if (muffled) 
[15:32:20.361]                           invokeRestart("muffleWarning")
[15:32:20.361]                       }
[15:32:20.361]                       else if (inherits(cond, "condition")) {
[15:32:20.361]                         if (!is.null(pattern)) {
[15:32:20.361]                           computeRestarts <- base::computeRestarts
[15:32:20.361]                           grepl <- base::grepl
[15:32:20.361]                           restarts <- computeRestarts(cond)
[15:32:20.361]                           for (restart in restarts) {
[15:32:20.361]                             name <- restart$name
[15:32:20.361]                             if (is.null(name)) 
[15:32:20.361]                               next
[15:32:20.361]                             if (!grepl(pattern, name)) 
[15:32:20.361]                               next
[15:32:20.361]                             invokeRestart(restart)
[15:32:20.361]                             muffled <- TRUE
[15:32:20.361]                             break
[15:32:20.361]                           }
[15:32:20.361]                         }
[15:32:20.361]                       }
[15:32:20.361]                       invisible(muffled)
[15:32:20.361]                     }
[15:32:20.361]                     muffleCondition(cond, pattern = "^muffle")
[15:32:20.361]                   }
[15:32:20.361]                 }
[15:32:20.361]             }
[15:32:20.361]         }))
[15:32:20.361]     }, error = function(ex) {
[15:32:20.361]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:20.361]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:20.361]                 ...future.rng), started = ...future.startTime, 
[15:32:20.361]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:20.361]             version = "1.8"), class = "FutureResult")
[15:32:20.361]     }, finally = {
[15:32:20.361]         if (!identical(...future.workdir, getwd())) 
[15:32:20.361]             setwd(...future.workdir)
[15:32:20.361]         {
[15:32:20.361]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:20.361]                 ...future.oldOptions$nwarnings <- NULL
[15:32:20.361]             }
[15:32:20.361]             base::options(...future.oldOptions)
[15:32:20.361]             if (.Platform$OS.type == "windows") {
[15:32:20.361]                 old_names <- names(...future.oldEnvVars)
[15:32:20.361]                 envs <- base::Sys.getenv()
[15:32:20.361]                 names <- names(envs)
[15:32:20.361]                 common <- intersect(names, old_names)
[15:32:20.361]                 added <- setdiff(names, old_names)
[15:32:20.361]                 removed <- setdiff(old_names, names)
[15:32:20.361]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:20.361]                   envs[common]]
[15:32:20.361]                 NAMES <- toupper(changed)
[15:32:20.361]                 args <- list()
[15:32:20.361]                 for (kk in seq_along(NAMES)) {
[15:32:20.361]                   name <- changed[[kk]]
[15:32:20.361]                   NAME <- NAMES[[kk]]
[15:32:20.361]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:20.361]                     next
[15:32:20.361]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:20.361]                 }
[15:32:20.361]                 NAMES <- toupper(added)
[15:32:20.361]                 for (kk in seq_along(NAMES)) {
[15:32:20.361]                   name <- added[[kk]]
[15:32:20.361]                   NAME <- NAMES[[kk]]
[15:32:20.361]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:20.361]                     next
[15:32:20.361]                   args[[name]] <- ""
[15:32:20.361]                 }
[15:32:20.361]                 NAMES <- toupper(removed)
[15:32:20.361]                 for (kk in seq_along(NAMES)) {
[15:32:20.361]                   name <- removed[[kk]]
[15:32:20.361]                   NAME <- NAMES[[kk]]
[15:32:20.361]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:20.361]                     next
[15:32:20.361]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:20.361]                 }
[15:32:20.361]                 if (length(args) > 0) 
[15:32:20.361]                   base::do.call(base::Sys.setenv, args = args)
[15:32:20.361]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:20.361]             }
[15:32:20.361]             else {
[15:32:20.361]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:20.361]             }
[15:32:20.361]             {
[15:32:20.361]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:20.361]                   0L) {
[15:32:20.361]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:20.361]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:20.361]                   base::options(opts)
[15:32:20.361]                 }
[15:32:20.361]                 {
[15:32:20.361]                   {
[15:32:20.361]                     NULL
[15:32:20.361]                     RNGkind("Mersenne-Twister")
[15:32:20.361]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:20.361]                       inherits = FALSE)
[15:32:20.361]                   }
[15:32:20.361]                   options(future.plan = NULL)
[15:32:20.361]                   if (is.na(NA_character_)) 
[15:32:20.361]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:20.361]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:20.361]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:20.361]                     .init = FALSE)
[15:32:20.361]                 }
[15:32:20.361]             }
[15:32:20.361]         }
[15:32:20.361]     })
[15:32:20.361]     if (TRUE) {
[15:32:20.361]         base::sink(type = "output", split = FALSE)
[15:32:20.361]         if (TRUE) {
[15:32:20.361]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:20.361]         }
[15:32:20.361]         else {
[15:32:20.361]             ...future.result["stdout"] <- base::list(NULL)
[15:32:20.361]         }
[15:32:20.361]         base::close(...future.stdout)
[15:32:20.361]         ...future.stdout <- NULL
[15:32:20.361]     }
[15:32:20.361]     ...future.result$conditions <- ...future.conditions
[15:32:20.361]     ...future.result$finished <- base::Sys.time()
[15:32:20.361]     ...future.result
[15:32:20.361] }
[15:32:20.366] assign_globals() ...
[15:32:20.367] List of 5
[15:32:20.367]  $ ...future.FUN            :function (x)  
[15:32:20.367]  $ future.call.arguments    : list()
[15:32:20.367]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:20.367]  $ ...future.elements_ii    :List of 3
[15:32:20.367]   ..$ a: num 1
[15:32:20.367]   ..$ b: num 2
[15:32:20.367]   ..$ c: num 3
[15:32:20.367]  $ ...future.seeds_ii       : NULL
[15:32:20.367]  $ ...future.globals.maxSize: NULL
[15:32:20.367]  - attr(*, "where")=List of 5
[15:32:20.367]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:20.367]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:20.367]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:20.367]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:20.367]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:20.367]  - attr(*, "resolved")= logi FALSE
[15:32:20.367]  - attr(*, "total_size")= num 848
[15:32:20.367]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:20.367]  - attr(*, "already-done")= logi TRUE
[15:32:20.376] - copied '...future.FUN' to environment
[15:32:20.376] - copied 'future.call.arguments' to environment
[15:32:20.376] - copied '...future.elements_ii' to environment
[15:32:20.376] - copied '...future.seeds_ii' to environment
[15:32:20.377] - copied '...future.globals.maxSize' to environment
[15:32:20.377] assign_globals() ... done
[15:32:20.378] plan(): Setting new future strategy stack:
[15:32:20.378] List of future strategies:
[15:32:20.378] 1. sequential:
[15:32:20.378]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:20.378]    - tweaked: FALSE
[15:32:20.378]    - call: NULL
[15:32:20.379] plan(): nbrOfWorkers() = 1
[15:32:20.380] plan(): Setting new future strategy stack:
[15:32:20.380] List of future strategies:
[15:32:20.380] 1. sequential:
[15:32:20.380]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:20.380]    - tweaked: FALSE
[15:32:20.380]    - call: plan(strategy)
[15:32:20.381] plan(): nbrOfWorkers() = 1
[15:32:20.382] SequentialFuture started (and completed)
[15:32:20.382] - Launch lazy future ... done
[15:32:20.382] run() for 'SequentialFuture' ... done
[15:32:20.383] Created future:
[15:32:20.383] SequentialFuture:
[15:32:20.383] Label: 'future_sapply-1'
[15:32:20.383] Expression:
[15:32:20.383] {
[15:32:20.383]     do.call(function(...) {
[15:32:20.383]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:20.383]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:20.383]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:20.383]             on.exit(options(oopts), add = TRUE)
[15:32:20.383]         }
[15:32:20.383]         {
[15:32:20.383]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:20.383]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:20.383]                 ...future.FUN(...future.X_jj, ...)
[15:32:20.383]             })
[15:32:20.383]         }
[15:32:20.383]     }, args = future.call.arguments)
[15:32:20.383] }
[15:32:20.383] Lazy evaluation: FALSE
[15:32:20.383] Asynchronous evaluation: FALSE
[15:32:20.383] Local evaluation: TRUE
[15:32:20.383] Environment: R_GlobalEnv
[15:32:20.383] Capture standard output: TRUE
[15:32:20.383] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:20.383] Globals: 5 objects totaling 0.99 KiB (function '...future.FUN' of 848 bytes, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:20.383] Packages: <none>
[15:32:20.383] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:20.383] Resolved: TRUE
[15:32:20.383] Value: 168 bytes of class 'list'
[15:32:20.383] Early signaling: FALSE
[15:32:20.383] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:20.383] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:20.385] Chunk #1 of 1 ... DONE
[15:32:20.385] Launching 1 futures (chunks) ... DONE
[15:32:20.386] Resolving 1 futures (chunks) ...
[15:32:20.386] resolve() on list ...
[15:32:20.386]  recursive: 0
[15:32:20.386]  length: 1
[15:32:20.387] 
[15:32:20.387] resolved() for 'SequentialFuture' ...
[15:32:20.387] - state: 'finished'
[15:32:20.388] - run: TRUE
[15:32:20.388] - result: 'FutureResult'
[15:32:20.388] resolved() for 'SequentialFuture' ... done
[15:32:20.389] Future #1
[15:32:20.389] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:20.389] - nx: 1
[15:32:20.390] - relay: TRUE
[15:32:20.390] - stdout: TRUE
[15:32:20.391] - signal: TRUE
[15:32:20.391] - resignal: FALSE
[15:32:20.391] - force: TRUE
[15:32:20.392] - relayed: [n=1] FALSE
[15:32:20.392] - queued futures: [n=1] FALSE
[15:32:20.392]  - until=1
[15:32:20.393]  - relaying element #1
[15:32:20.393] - relayed: [n=1] TRUE
[15:32:20.393] - queued futures: [n=1] TRUE
[15:32:20.393] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:20.394]  length: 0 (resolved future 1)
[15:32:20.394] Relaying remaining futures
[15:32:20.394] signalConditionsASAP(NULL, pos=0) ...
[15:32:20.395] - nx: 1
[15:32:20.395] - relay: TRUE
[15:32:20.396] - stdout: TRUE
[15:32:20.396] - signal: TRUE
[15:32:20.396] - resignal: FALSE
[15:32:20.396] - force: TRUE
[15:32:20.396] - relayed: [n=1] TRUE
[15:32:20.397] - queued futures: [n=1] TRUE
 - flush all
[15:32:20.397] - relayed: [n=1] TRUE
[15:32:20.397] - queued futures: [n=1] TRUE
[15:32:20.397] signalConditionsASAP(NULL, pos=0) ... done
[15:32:20.398] resolve() on list ... DONE
[15:32:20.398]  - Number of value chunks collected: 1
[15:32:20.398] Resolving 1 futures (chunks) ... DONE
[15:32:20.399] Reducing values from 1 chunks ...
[15:32:20.399]  - Number of values collected after concatenation: 3
[15:32:20.399]  - Number of values expected: 3
[15:32:20.399] Reducing values from 1 chunks ... DONE
[15:32:20.399] future_lapply() ... DONE
List of 2
 $ y0: Named num [1:3] 1 2 3
  ..- attr(*, "names")= chr [1:3] "a" "b" "c"
 $ y1: Named num [1:3] 1 2 3
  ..- attr(*, "names")= chr [1:3] "a" "b" "c"
[15:32:20.406] future_lapply() ...
[15:32:20.407] Number of chunks: 1
[15:32:20.407] getGlobalsAndPackagesXApply() ...
[15:32:20.408]  - future.globals: TRUE
[15:32:20.408] getGlobalsAndPackages() ...
[15:32:20.408] Searching for globals...
[15:32:20.410] - globals found: [2] 'FUN', 'UseMethod'
[15:32:20.410] Searching for globals ... DONE
[15:32:20.410] Resolving globals: FALSE
[15:32:20.411] The total size of the 1 globals is 1.22 KiB (1248 bytes)
[15:32:20.411] The total size of the 1 globals exported for future expression ('FUN()') is 1.22 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.22 KiB of class 'function')
[15:32:20.411] - globals: [1] 'FUN'
[15:32:20.412] 
[15:32:20.412] getGlobalsAndPackages() ... DONE
[15:32:20.412]  - globals found/used: [n=1] 'FUN'
[15:32:20.412]  - needed namespaces: [n=0] 
[15:32:20.412] Finding globals ... DONE
[15:32:20.412]  - use_args: TRUE
[15:32:20.413]  - Getting '...' globals ...
[15:32:20.413] resolve() on list ...
[15:32:20.413]  recursive: 0
[15:32:20.414]  length: 1
[15:32:20.414]  elements: '...'
[15:32:20.414]  length: 0 (resolved future 1)
[15:32:20.414] resolve() on list ... DONE
[15:32:20.414]    - '...' content: [n=0] 
[15:32:20.415] List of 1
[15:32:20.415]  $ ...: list()
[15:32:20.415]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:20.415]  - attr(*, "where")=List of 1
[15:32:20.415]   ..$ ...:<environment: 0x00000276e1c20df8> 
[15:32:20.415]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:20.415]  - attr(*, "resolved")= logi TRUE
[15:32:20.415]  - attr(*, "total_size")= num NA
[15:32:20.420]  - Getting '...' globals ... DONE
[15:32:20.420] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:20.421] List of 2
[15:32:20.421]  $ ...future.FUN:function (x, ...)  
[15:32:20.421]  $ ...          : list()
[15:32:20.421]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:20.421]  - attr(*, "where")=List of 2
[15:32:20.421]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:20.421]   ..$ ...          :<environment: 0x00000276e1c20df8> 
[15:32:20.421]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:20.421]  - attr(*, "resolved")= logi FALSE
[15:32:20.421]  - attr(*, "total_size")= num 1248
[15:32:20.425] Packages to be attached in all futures: [n=0] 
[15:32:20.426] getGlobalsAndPackagesXApply() ... DONE
[15:32:20.426] Number of futures (= number of chunks): 1
[15:32:20.426] Launching 1 futures (chunks) ...
[15:32:20.426] Chunk #1 of 1 ...
[15:32:20.427]  - Finding globals in 'X' for chunk #1 ...
[15:32:20.427] getGlobalsAndPackages() ...
[15:32:20.427] Searching for globals...
[15:32:20.427] 
[15:32:20.428] Searching for globals ... DONE
[15:32:20.428] - globals: [0] <none>
[15:32:20.428] getGlobalsAndPackages() ... DONE
[15:32:20.428]    + additional globals found: [n=0] 
[15:32:20.428]    + additional namespaces needed: [n=0] 
[15:32:20.428]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:20.429]  - seeds: <none>
[15:32:20.429]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:20.429] getGlobalsAndPackages() ...
[15:32:20.429] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:20.430] Resolving globals: FALSE
[15:32:20.430] Tweak future expression to call with '...' arguments ...
[15:32:20.430] {
[15:32:20.430]     do.call(function(...) {
[15:32:20.430]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:20.430]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:20.430]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:20.430]             on.exit(options(oopts), add = TRUE)
[15:32:20.430]         }
[15:32:20.430]         {
[15:32:20.430]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:20.430]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:20.430]                 ...future.FUN(...future.X_jj, ...)
[15:32:20.430]             })
[15:32:20.430]         }
[15:32:20.430]     }, args = future.call.arguments)
[15:32:20.430] }
[15:32:20.431] Tweak future expression to call with '...' arguments ... DONE
[15:32:20.431] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:20.431] 
[15:32:20.432] getGlobalsAndPackages() ... DONE
[15:32:20.432] run() for 'Future' ...
[15:32:20.432] - state: 'created'
[15:32:20.433] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:20.433] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:20.433] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:20.434]   - Field: 'label'
[15:32:20.434]   - Field: 'local'
[15:32:20.434]   - Field: 'owner'
[15:32:20.434]   - Field: 'envir'
[15:32:20.434]   - Field: 'packages'
[15:32:20.435]   - Field: 'gc'
[15:32:20.435]   - Field: 'conditions'
[15:32:20.435]   - Field: 'expr'
[15:32:20.435]   - Field: 'uuid'
[15:32:20.435]   - Field: 'seed'
[15:32:20.435]   - Field: 'version'
[15:32:20.436]   - Field: 'result'
[15:32:20.436]   - Field: 'asynchronous'
[15:32:20.436]   - Field: 'calls'
[15:32:20.436]   - Field: 'globals'
[15:32:20.436]   - Field: 'stdout'
[15:32:20.437]   - Field: 'earlySignal'
[15:32:20.437]   - Field: 'lazy'
[15:32:20.437]   - Field: 'state'
[15:32:20.438] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:20.438] - Launch lazy future ...
[15:32:20.438] Packages needed by the future expression (n = 0): <none>
[15:32:20.439] Packages needed by future strategies (n = 0): <none>
[15:32:20.439] {
[15:32:20.439]     {
[15:32:20.439]         {
[15:32:20.439]             ...future.startTime <- base::Sys.time()
[15:32:20.439]             {
[15:32:20.439]                 {
[15:32:20.439]                   {
[15:32:20.439]                     base::local({
[15:32:20.439]                       has_future <- base::requireNamespace("future", 
[15:32:20.439]                         quietly = TRUE)
[15:32:20.439]                       if (has_future) {
[15:32:20.439]                         ns <- base::getNamespace("future")
[15:32:20.439]                         version <- ns[[".package"]][["version"]]
[15:32:20.439]                         if (is.null(version)) 
[15:32:20.439]                           version <- utils::packageVersion("future")
[15:32:20.439]                       }
[15:32:20.439]                       else {
[15:32:20.439]                         version <- NULL
[15:32:20.439]                       }
[15:32:20.439]                       if (!has_future || version < "1.8.0") {
[15:32:20.439]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:20.439]                           "", base::R.version$version.string), 
[15:32:20.439]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:20.439]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:20.439]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:20.439]                             "release", "version")], collapse = " "), 
[15:32:20.439]                           hostname = base::Sys.info()[["nodename"]])
[15:32:20.439]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:20.439]                           info)
[15:32:20.439]                         info <- base::paste(info, collapse = "; ")
[15:32:20.439]                         if (!has_future) {
[15:32:20.439]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:20.439]                             info)
[15:32:20.439]                         }
[15:32:20.439]                         else {
[15:32:20.439]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:20.439]                             info, version)
[15:32:20.439]                         }
[15:32:20.439]                         base::stop(msg)
[15:32:20.439]                       }
[15:32:20.439]                     })
[15:32:20.439]                   }
[15:32:20.439]                   ...future.strategy.old <- future::plan("list")
[15:32:20.439]                   options(future.plan = NULL)
[15:32:20.439]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:20.439]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:20.439]                 }
[15:32:20.439]                 ...future.workdir <- getwd()
[15:32:20.439]             }
[15:32:20.439]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:20.439]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:20.439]         }
[15:32:20.439]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:20.439]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:20.439]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:20.439]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:20.439]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:20.439]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:20.439]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:20.439]             base::names(...future.oldOptions))
[15:32:20.439]     }
[15:32:20.439]     if (FALSE) {
[15:32:20.439]     }
[15:32:20.439]     else {
[15:32:20.439]         if (TRUE) {
[15:32:20.439]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:20.439]                 open = "w")
[15:32:20.439]         }
[15:32:20.439]         else {
[15:32:20.439]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:20.439]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:20.439]         }
[15:32:20.439]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:20.439]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:20.439]             base::sink(type = "output", split = FALSE)
[15:32:20.439]             base::close(...future.stdout)
[15:32:20.439]         }, add = TRUE)
[15:32:20.439]     }
[15:32:20.439]     ...future.frame <- base::sys.nframe()
[15:32:20.439]     ...future.conditions <- base::list()
[15:32:20.439]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:20.439]     if (FALSE) {
[15:32:20.439]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:20.439]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:20.439]     }
[15:32:20.439]     ...future.result <- base::tryCatch({
[15:32:20.439]         base::withCallingHandlers({
[15:32:20.439]             ...future.value <- base::withVisible(base::local({
[15:32:20.439]                 do.call(function(...) {
[15:32:20.439]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:20.439]                   if (!identical(...future.globals.maxSize.org, 
[15:32:20.439]                     ...future.globals.maxSize)) {
[15:32:20.439]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:20.439]                     on.exit(options(oopts), add = TRUE)
[15:32:20.439]                   }
[15:32:20.439]                   {
[15:32:20.439]                     lapply(seq_along(...future.elements_ii), 
[15:32:20.439]                       FUN = function(jj) {
[15:32:20.439]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:20.439]                         ...future.FUN(...future.X_jj, ...)
[15:32:20.439]                       })
[15:32:20.439]                   }
[15:32:20.439]                 }, args = future.call.arguments)
[15:32:20.439]             }))
[15:32:20.439]             future::FutureResult(value = ...future.value$value, 
[15:32:20.439]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:20.439]                   ...future.rng), globalenv = if (FALSE) 
[15:32:20.439]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:20.439]                     ...future.globalenv.names))
[15:32:20.439]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:20.439]         }, condition = base::local({
[15:32:20.439]             c <- base::c
[15:32:20.439]             inherits <- base::inherits
[15:32:20.439]             invokeRestart <- base::invokeRestart
[15:32:20.439]             length <- base::length
[15:32:20.439]             list <- base::list
[15:32:20.439]             seq.int <- base::seq.int
[15:32:20.439]             signalCondition <- base::signalCondition
[15:32:20.439]             sys.calls <- base::sys.calls
[15:32:20.439]             `[[` <- base::`[[`
[15:32:20.439]             `+` <- base::`+`
[15:32:20.439]             `<<-` <- base::`<<-`
[15:32:20.439]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:20.439]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:20.439]                   3L)]
[15:32:20.439]             }
[15:32:20.439]             function(cond) {
[15:32:20.439]                 is_error <- inherits(cond, "error")
[15:32:20.439]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:20.439]                   NULL)
[15:32:20.439]                 if (is_error) {
[15:32:20.439]                   sessionInformation <- function() {
[15:32:20.439]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:20.439]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:20.439]                       search = base::search(), system = base::Sys.info())
[15:32:20.439]                   }
[15:32:20.439]                   ...future.conditions[[length(...future.conditions) + 
[15:32:20.439]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:20.439]                     cond$call), session = sessionInformation(), 
[15:32:20.439]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:20.439]                   signalCondition(cond)
[15:32:20.439]                 }
[15:32:20.439]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:20.439]                 "immediateCondition"))) {
[15:32:20.439]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:20.439]                   ...future.conditions[[length(...future.conditions) + 
[15:32:20.439]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:20.439]                   if (TRUE && !signal) {
[15:32:20.439]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:20.439]                     {
[15:32:20.439]                       inherits <- base::inherits
[15:32:20.439]                       invokeRestart <- base::invokeRestart
[15:32:20.439]                       is.null <- base::is.null
[15:32:20.439]                       muffled <- FALSE
[15:32:20.439]                       if (inherits(cond, "message")) {
[15:32:20.439]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:20.439]                         if (muffled) 
[15:32:20.439]                           invokeRestart("muffleMessage")
[15:32:20.439]                       }
[15:32:20.439]                       else if (inherits(cond, "warning")) {
[15:32:20.439]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:20.439]                         if (muffled) 
[15:32:20.439]                           invokeRestart("muffleWarning")
[15:32:20.439]                       }
[15:32:20.439]                       else if (inherits(cond, "condition")) {
[15:32:20.439]                         if (!is.null(pattern)) {
[15:32:20.439]                           computeRestarts <- base::computeRestarts
[15:32:20.439]                           grepl <- base::grepl
[15:32:20.439]                           restarts <- computeRestarts(cond)
[15:32:20.439]                           for (restart in restarts) {
[15:32:20.439]                             name <- restart$name
[15:32:20.439]                             if (is.null(name)) 
[15:32:20.439]                               next
[15:32:20.439]                             if (!grepl(pattern, name)) 
[15:32:20.439]                               next
[15:32:20.439]                             invokeRestart(restart)
[15:32:20.439]                             muffled <- TRUE
[15:32:20.439]                             break
[15:32:20.439]                           }
[15:32:20.439]                         }
[15:32:20.439]                       }
[15:32:20.439]                       invisible(muffled)
[15:32:20.439]                     }
[15:32:20.439]                     muffleCondition(cond, pattern = "^muffle")
[15:32:20.439]                   }
[15:32:20.439]                 }
[15:32:20.439]                 else {
[15:32:20.439]                   if (TRUE) {
[15:32:20.439]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:20.439]                     {
[15:32:20.439]                       inherits <- base::inherits
[15:32:20.439]                       invokeRestart <- base::invokeRestart
[15:32:20.439]                       is.null <- base::is.null
[15:32:20.439]                       muffled <- FALSE
[15:32:20.439]                       if (inherits(cond, "message")) {
[15:32:20.439]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:20.439]                         if (muffled) 
[15:32:20.439]                           invokeRestart("muffleMessage")
[15:32:20.439]                       }
[15:32:20.439]                       else if (inherits(cond, "warning")) {
[15:32:20.439]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:20.439]                         if (muffled) 
[15:32:20.439]                           invokeRestart("muffleWarning")
[15:32:20.439]                       }
[15:32:20.439]                       else if (inherits(cond, "condition")) {
[15:32:20.439]                         if (!is.null(pattern)) {
[15:32:20.439]                           computeRestarts <- base::computeRestarts
[15:32:20.439]                           grepl <- base::grepl
[15:32:20.439]                           restarts <- computeRestarts(cond)
[15:32:20.439]                           for (restart in restarts) {
[15:32:20.439]                             name <- restart$name
[15:32:20.439]                             if (is.null(name)) 
[15:32:20.439]                               next
[15:32:20.439]                             if (!grepl(pattern, name)) 
[15:32:20.439]                               next
[15:32:20.439]                             invokeRestart(restart)
[15:32:20.439]                             muffled <- TRUE
[15:32:20.439]                             break
[15:32:20.439]                           }
[15:32:20.439]                         }
[15:32:20.439]                       }
[15:32:20.439]                       invisible(muffled)
[15:32:20.439]                     }
[15:32:20.439]                     muffleCondition(cond, pattern = "^muffle")
[15:32:20.439]                   }
[15:32:20.439]                 }
[15:32:20.439]             }
[15:32:20.439]         }))
[15:32:20.439]     }, error = function(ex) {
[15:32:20.439]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:20.439]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:20.439]                 ...future.rng), started = ...future.startTime, 
[15:32:20.439]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:20.439]             version = "1.8"), class = "FutureResult")
[15:32:20.439]     }, finally = {
[15:32:20.439]         if (!identical(...future.workdir, getwd())) 
[15:32:20.439]             setwd(...future.workdir)
[15:32:20.439]         {
[15:32:20.439]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:20.439]                 ...future.oldOptions$nwarnings <- NULL
[15:32:20.439]             }
[15:32:20.439]             base::options(...future.oldOptions)
[15:32:20.439]             if (.Platform$OS.type == "windows") {
[15:32:20.439]                 old_names <- names(...future.oldEnvVars)
[15:32:20.439]                 envs <- base::Sys.getenv()
[15:32:20.439]                 names <- names(envs)
[15:32:20.439]                 common <- intersect(names, old_names)
[15:32:20.439]                 added <- setdiff(names, old_names)
[15:32:20.439]                 removed <- setdiff(old_names, names)
[15:32:20.439]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:20.439]                   envs[common]]
[15:32:20.439]                 NAMES <- toupper(changed)
[15:32:20.439]                 args <- list()
[15:32:20.439]                 for (kk in seq_along(NAMES)) {
[15:32:20.439]                   name <- changed[[kk]]
[15:32:20.439]                   NAME <- NAMES[[kk]]
[15:32:20.439]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:20.439]                     next
[15:32:20.439]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:20.439]                 }
[15:32:20.439]                 NAMES <- toupper(added)
[15:32:20.439]                 for (kk in seq_along(NAMES)) {
[15:32:20.439]                   name <- added[[kk]]
[15:32:20.439]                   NAME <- NAMES[[kk]]
[15:32:20.439]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:20.439]                     next
[15:32:20.439]                   args[[name]] <- ""
[15:32:20.439]                 }
[15:32:20.439]                 NAMES <- toupper(removed)
[15:32:20.439]                 for (kk in seq_along(NAMES)) {
[15:32:20.439]                   name <- removed[[kk]]
[15:32:20.439]                   NAME <- NAMES[[kk]]
[15:32:20.439]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:20.439]                     next
[15:32:20.439]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:20.439]                 }
[15:32:20.439]                 if (length(args) > 0) 
[15:32:20.439]                   base::do.call(base::Sys.setenv, args = args)
[15:32:20.439]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:20.439]             }
[15:32:20.439]             else {
[15:32:20.439]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:20.439]             }
[15:32:20.439]             {
[15:32:20.439]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:20.439]                   0L) {
[15:32:20.439]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:20.439]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:20.439]                   base::options(opts)
[15:32:20.439]                 }
[15:32:20.439]                 {
[15:32:20.439]                   {
[15:32:20.439]                     NULL
[15:32:20.439]                     RNGkind("Mersenne-Twister")
[15:32:20.439]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:20.439]                       inherits = FALSE)
[15:32:20.439]                   }
[15:32:20.439]                   options(future.plan = NULL)
[15:32:20.439]                   if (is.na(NA_character_)) 
[15:32:20.439]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:20.439]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:20.439]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:20.439]                     .init = FALSE)
[15:32:20.439]                 }
[15:32:20.439]             }
[15:32:20.439]         }
[15:32:20.439]     })
[15:32:20.439]     if (TRUE) {
[15:32:20.439]         base::sink(type = "output", split = FALSE)
[15:32:20.439]         if (TRUE) {
[15:32:20.439]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:20.439]         }
[15:32:20.439]         else {
[15:32:20.439]             ...future.result["stdout"] <- base::list(NULL)
[15:32:20.439]         }
[15:32:20.439]         base::close(...future.stdout)
[15:32:20.439]         ...future.stdout <- NULL
[15:32:20.439]     }
[15:32:20.439]     ...future.result$conditions <- ...future.conditions
[15:32:20.439]     ...future.result$finished <- base::Sys.time()
[15:32:20.439]     ...future.result
[15:32:20.439] }
[15:32:20.444] assign_globals() ...
[15:32:20.444] List of 5
[15:32:20.444]  $ ...future.FUN            :function (x, ...)  
[15:32:20.444]  $ future.call.arguments    : list()
[15:32:20.444]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:20.444]  $ ...future.elements_ii    :List of 3
[15:32:20.444]   ..$ a: num 1
[15:32:20.444]   ..$ b: num 2
[15:32:20.444]   ..$ c: num 3
[15:32:20.444]  $ ...future.seeds_ii       : NULL
[15:32:20.444]  $ ...future.globals.maxSize: NULL
[15:32:20.444]  - attr(*, "where")=List of 5
[15:32:20.444]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:20.444]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:20.444]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:20.444]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:20.444]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:20.444]  - attr(*, "resolved")= logi FALSE
[15:32:20.444]  - attr(*, "total_size")= num 1248
[15:32:20.444]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:20.444]  - attr(*, "already-done")= logi TRUE
[15:32:20.455] - copied '...future.FUN' to environment
[15:32:20.455] - copied 'future.call.arguments' to environment
[15:32:20.455] - copied '...future.elements_ii' to environment
[15:32:20.455] - copied '...future.seeds_ii' to environment
[15:32:20.456] - copied '...future.globals.maxSize' to environment
[15:32:20.456] assign_globals() ... done
[15:32:20.456] plan(): Setting new future strategy stack:
[15:32:20.456] List of future strategies:
[15:32:20.456] 1. sequential:
[15:32:20.456]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:20.456]    - tweaked: FALSE
[15:32:20.456]    - call: NULL
[15:32:20.457] plan(): nbrOfWorkers() = 1
[15:32:20.459] plan(): Setting new future strategy stack:
[15:32:20.459] List of future strategies:
[15:32:20.459] 1. sequential:
[15:32:20.459]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:20.459]    - tweaked: FALSE
[15:32:20.459]    - call: plan(strategy)
[15:32:20.459] plan(): nbrOfWorkers() = 1
[15:32:20.460] SequentialFuture started (and completed)
[15:32:20.460] - Launch lazy future ... done
[15:32:20.460] run() for 'SequentialFuture' ... done
[15:32:20.460] Created future:
[15:32:20.460] SequentialFuture:
[15:32:20.460] Label: 'future_sapply-1'
[15:32:20.460] Expression:
[15:32:20.460] {
[15:32:20.460]     do.call(function(...) {
[15:32:20.460]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:20.460]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:20.460]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:20.460]             on.exit(options(oopts), add = TRUE)
[15:32:20.460]         }
[15:32:20.460]         {
[15:32:20.460]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:20.460]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:20.460]                 ...future.FUN(...future.X_jj, ...)
[15:32:20.460]             })
[15:32:20.460]         }
[15:32:20.460]     }, args = future.call.arguments)
[15:32:20.460] }
[15:32:20.460] Lazy evaluation: FALSE
[15:32:20.460] Asynchronous evaluation: FALSE
[15:32:20.460] Local evaluation: TRUE
[15:32:20.460] Environment: R_GlobalEnv
[15:32:20.460] Capture standard output: TRUE
[15:32:20.460] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:20.460] Globals: 5 objects totaling 1.38 KiB (function '...future.FUN' of 1.22 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:20.460] Packages: <none>
[15:32:20.460] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:20.460] Resolved: TRUE
[15:32:20.460] Value: 672 bytes of class 'list'
[15:32:20.460] Early signaling: FALSE
[15:32:20.460] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:20.460] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:20.462] Chunk #1 of 1 ... DONE
[15:32:20.462] Launching 1 futures (chunks) ... DONE
[15:32:20.462] Resolving 1 futures (chunks) ...
[15:32:20.462] resolve() on list ...
[15:32:20.463]  recursive: 0
[15:32:20.463]  length: 1
[15:32:20.463] 
[15:32:20.463] resolved() for 'SequentialFuture' ...
[15:32:20.463] - state: 'finished'
[15:32:20.464] - run: TRUE
[15:32:20.464] - result: 'FutureResult'
[15:32:20.464] resolved() for 'SequentialFuture' ... done
[15:32:20.464] Future #1
[15:32:20.464] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:20.464] - nx: 1
[15:32:20.465] - relay: TRUE
[15:32:20.465] - stdout: TRUE
[15:32:20.465] - signal: TRUE
[15:32:20.465] - resignal: FALSE
[15:32:20.465] - force: TRUE
[15:32:20.465] - relayed: [n=1] FALSE
[15:32:20.466] - queued futures: [n=1] FALSE
[15:32:20.466]  - until=1
[15:32:20.466]  - relaying element #1
[15:32:20.466] - relayed: [n=1] TRUE
[15:32:20.466] - queued futures: [n=1] TRUE
[15:32:20.467] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:20.467]  length: 0 (resolved future 1)
[15:32:20.467] Relaying remaining futures
[15:32:20.467] signalConditionsASAP(NULL, pos=0) ...
[15:32:20.467] - nx: 1
[15:32:20.467] - relay: TRUE
[15:32:20.468] - stdout: TRUE
[15:32:20.468] - signal: TRUE
[15:32:20.468] - resignal: FALSE
[15:32:20.468] - force: TRUE
[15:32:20.468] - relayed: [n=1] TRUE
[15:32:20.469] - queued futures: [n=1] TRUE
 - flush all
[15:32:20.469] - relayed: [n=1] TRUE
[15:32:20.469] - queued futures: [n=1] TRUE
[15:32:20.470] signalConditionsASAP(NULL, pos=0) ... done
[15:32:20.470] resolve() on list ... DONE
[15:32:20.470]  - Number of value chunks collected: 1
[15:32:20.470] Resolving 1 futures (chunks) ... DONE
[15:32:20.471] Reducing values from 1 chunks ...
[15:32:20.471]  - Number of values collected after concatenation: 3
[15:32:20.471]  - Number of values expected: 3
[15:32:20.471] Reducing values from 1 chunks ... DONE
[15:32:20.472] future_lapply() ... DONE
List of 2
 $ y0: Named num [1:3] 1 2 3
  ..- attr(*, "names")= chr [1:3] "a" "b" "c"
 $ y1: Named num [1:3] 1 2 3
  ..- attr(*, "names")= chr [1:3] "a" "b" "c"
[15:32:20.475] future_lapply() ...
[15:32:20.477] Number of chunks: 1
[15:32:20.477] getGlobalsAndPackagesXApply() ...
[15:32:20.477]  - future.globals: TRUE
[15:32:20.477] getGlobalsAndPackages() ...
[15:32:20.478] Searching for globals...
[15:32:20.484] - globals found: [5] 'FUN', '*', ':', 'outer', 'rep'
[15:32:20.485] Searching for globals ... DONE
[15:32:20.485] Resolving globals: FALSE
[15:32:20.486] The total size of the 1 globals is 4.62 KiB (4728 bytes)
[15:32:20.487] The total size of the 1 globals exported for future expression ('FUN()') is 4.62 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.62 KiB of class 'function')
[15:32:20.487] - globals: [1] 'FUN'
[15:32:20.488] 
[15:32:20.488] getGlobalsAndPackages() ... DONE
[15:32:20.488]  - globals found/used: [n=1] 'FUN'
[15:32:20.488]  - needed namespaces: [n=0] 
[15:32:20.489] Finding globals ... DONE
[15:32:20.489]  - use_args: TRUE
[15:32:20.489]  - Getting '...' globals ...
[15:32:20.490] resolve() on list ...
[15:32:20.490]  recursive: 0
[15:32:20.490]  length: 1
[15:32:20.491]  elements: '...'
[15:32:20.491]  length: 0 (resolved future 1)
[15:32:20.491] resolve() on list ... DONE
[15:32:20.491]    - '...' content: [n=0] 
[15:32:20.492] List of 1
[15:32:20.492]  $ ...: list()
[15:32:20.492]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:20.492]  - attr(*, "where")=List of 1
[15:32:20.492]   ..$ ...:<environment: 0x00000276e249aa08> 
[15:32:20.492]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:20.492]  - attr(*, "resolved")= logi TRUE
[15:32:20.492]  - attr(*, "total_size")= num NA
[15:32:20.497]  - Getting '...' globals ... DONE
[15:32:20.497] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:20.497] List of 2
[15:32:20.497]  $ ...future.FUN:function (x, y = 2 * 1:5)  
[15:32:20.497]  $ ...          : list()
[15:32:20.497]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:20.497]  - attr(*, "where")=List of 2
[15:32:20.497]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:20.497]   ..$ ...          :<environment: 0x00000276e249aa08> 
[15:32:20.497]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:20.497]  - attr(*, "resolved")= logi FALSE
[15:32:20.497]  - attr(*, "total_size")= num 4728
[15:32:20.502] Packages to be attached in all futures: [n=0] 
[15:32:20.503] getGlobalsAndPackagesXApply() ... DONE
[15:32:20.503] Number of futures (= number of chunks): 1
[15:32:20.503] Launching 1 futures (chunks) ...
[15:32:20.504] Chunk #1 of 1 ...
[15:32:20.504]  - Finding globals in 'X' for chunk #1 ...
[15:32:20.504] getGlobalsAndPackages() ...
[15:32:20.504] Searching for globals...
[15:32:20.505] 
[15:32:20.505] Searching for globals ... DONE
[15:32:20.505] - globals: [0] <none>
[15:32:20.506] getGlobalsAndPackages() ... DONE
[15:32:20.506]    + additional globals found: [n=0] 
[15:32:20.506]    + additional namespaces needed: [n=0] 
[15:32:20.506]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:20.507]  - seeds: <none>
[15:32:20.507]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:20.507] getGlobalsAndPackages() ...
[15:32:20.508] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:20.508] Resolving globals: FALSE
[15:32:20.508] Tweak future expression to call with '...' arguments ...
[15:32:20.508] {
[15:32:20.508]     do.call(function(...) {
[15:32:20.508]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:20.508]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:20.508]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:20.508]             on.exit(options(oopts), add = TRUE)
[15:32:20.508]         }
[15:32:20.508]         {
[15:32:20.508]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:20.508]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:20.508]                 ...future.FUN(...future.X_jj, ...)
[15:32:20.508]             })
[15:32:20.508]         }
[15:32:20.508]     }, args = future.call.arguments)
[15:32:20.508] }
[15:32:20.509] Tweak future expression to call with '...' arguments ... DONE
[15:32:20.510] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:20.510] 
[15:32:20.510] getGlobalsAndPackages() ... DONE
[15:32:20.511] run() for 'Future' ...
[15:32:20.511] - state: 'created'
[15:32:20.512] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:20.512] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:20.513] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:20.513]   - Field: 'label'
[15:32:20.513]   - Field: 'local'
[15:32:20.513]   - Field: 'owner'
[15:32:20.514]   - Field: 'envir'
[15:32:20.514]   - Field: 'packages'
[15:32:20.514]   - Field: 'gc'
[15:32:20.515]   - Field: 'conditions'
[15:32:20.515]   - Field: 'expr'
[15:32:20.515]   - Field: 'uuid'
[15:32:20.515]   - Field: 'seed'
[15:32:20.516]   - Field: 'version'
[15:32:20.516]   - Field: 'result'
[15:32:20.516]   - Field: 'asynchronous'
[15:32:20.516]   - Field: 'calls'
[15:32:20.517]   - Field: 'globals'
[15:32:20.517]   - Field: 'stdout'
[15:32:20.517]   - Field: 'earlySignal'
[15:32:20.517]   - Field: 'lazy'
[15:32:20.518]   - Field: 'state'
[15:32:20.518] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:20.518] - Launch lazy future ...
[15:32:20.519] Packages needed by the future expression (n = 0): <none>
[15:32:20.519] Packages needed by future strategies (n = 0): <none>
[15:32:20.520] {
[15:32:20.520]     {
[15:32:20.520]         {
[15:32:20.520]             ...future.startTime <- base::Sys.time()
[15:32:20.520]             {
[15:32:20.520]                 {
[15:32:20.520]                   {
[15:32:20.520]                     base::local({
[15:32:20.520]                       has_future <- base::requireNamespace("future", 
[15:32:20.520]                         quietly = TRUE)
[15:32:20.520]                       if (has_future) {
[15:32:20.520]                         ns <- base::getNamespace("future")
[15:32:20.520]                         version <- ns[[".package"]][["version"]]
[15:32:20.520]                         if (is.null(version)) 
[15:32:20.520]                           version <- utils::packageVersion("future")
[15:32:20.520]                       }
[15:32:20.520]                       else {
[15:32:20.520]                         version <- NULL
[15:32:20.520]                       }
[15:32:20.520]                       if (!has_future || version < "1.8.0") {
[15:32:20.520]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:20.520]                           "", base::R.version$version.string), 
[15:32:20.520]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:20.520]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:20.520]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:20.520]                             "release", "version")], collapse = " "), 
[15:32:20.520]                           hostname = base::Sys.info()[["nodename"]])
[15:32:20.520]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:20.520]                           info)
[15:32:20.520]                         info <- base::paste(info, collapse = "; ")
[15:32:20.520]                         if (!has_future) {
[15:32:20.520]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:20.520]                             info)
[15:32:20.520]                         }
[15:32:20.520]                         else {
[15:32:20.520]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:20.520]                             info, version)
[15:32:20.520]                         }
[15:32:20.520]                         base::stop(msg)
[15:32:20.520]                       }
[15:32:20.520]                     })
[15:32:20.520]                   }
[15:32:20.520]                   ...future.strategy.old <- future::plan("list")
[15:32:20.520]                   options(future.plan = NULL)
[15:32:20.520]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:20.520]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:20.520]                 }
[15:32:20.520]                 ...future.workdir <- getwd()
[15:32:20.520]             }
[15:32:20.520]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:20.520]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:20.520]         }
[15:32:20.520]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:20.520]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:20.520]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:20.520]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:20.520]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:20.520]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:20.520]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:20.520]             base::names(...future.oldOptions))
[15:32:20.520]     }
[15:32:20.520]     if (FALSE) {
[15:32:20.520]     }
[15:32:20.520]     else {
[15:32:20.520]         if (TRUE) {
[15:32:20.520]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:20.520]                 open = "w")
[15:32:20.520]         }
[15:32:20.520]         else {
[15:32:20.520]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:20.520]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:20.520]         }
[15:32:20.520]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:20.520]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:20.520]             base::sink(type = "output", split = FALSE)
[15:32:20.520]             base::close(...future.stdout)
[15:32:20.520]         }, add = TRUE)
[15:32:20.520]     }
[15:32:20.520]     ...future.frame <- base::sys.nframe()
[15:32:20.520]     ...future.conditions <- base::list()
[15:32:20.520]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:20.520]     if (FALSE) {
[15:32:20.520]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:20.520]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:20.520]     }
[15:32:20.520]     ...future.result <- base::tryCatch({
[15:32:20.520]         base::withCallingHandlers({
[15:32:20.520]             ...future.value <- base::withVisible(base::local({
[15:32:20.520]                 do.call(function(...) {
[15:32:20.520]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:20.520]                   if (!identical(...future.globals.maxSize.org, 
[15:32:20.520]                     ...future.globals.maxSize)) {
[15:32:20.520]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:20.520]                     on.exit(options(oopts), add = TRUE)
[15:32:20.520]                   }
[15:32:20.520]                   {
[15:32:20.520]                     lapply(seq_along(...future.elements_ii), 
[15:32:20.520]                       FUN = function(jj) {
[15:32:20.520]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:20.520]                         ...future.FUN(...future.X_jj, ...)
[15:32:20.520]                       })
[15:32:20.520]                   }
[15:32:20.520]                 }, args = future.call.arguments)
[15:32:20.520]             }))
[15:32:20.520]             future::FutureResult(value = ...future.value$value, 
[15:32:20.520]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:20.520]                   ...future.rng), globalenv = if (FALSE) 
[15:32:20.520]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:20.520]                     ...future.globalenv.names))
[15:32:20.520]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:20.520]         }, condition = base::local({
[15:32:20.520]             c <- base::c
[15:32:20.520]             inherits <- base::inherits
[15:32:20.520]             invokeRestart <- base::invokeRestart
[15:32:20.520]             length <- base::length
[15:32:20.520]             list <- base::list
[15:32:20.520]             seq.int <- base::seq.int
[15:32:20.520]             signalCondition <- base::signalCondition
[15:32:20.520]             sys.calls <- base::sys.calls
[15:32:20.520]             `[[` <- base::`[[`
[15:32:20.520]             `+` <- base::`+`
[15:32:20.520]             `<<-` <- base::`<<-`
[15:32:20.520]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:20.520]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:20.520]                   3L)]
[15:32:20.520]             }
[15:32:20.520]             function(cond) {
[15:32:20.520]                 is_error <- inherits(cond, "error")
[15:32:20.520]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:20.520]                   NULL)
[15:32:20.520]                 if (is_error) {
[15:32:20.520]                   sessionInformation <- function() {
[15:32:20.520]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:20.520]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:20.520]                       search = base::search(), system = base::Sys.info())
[15:32:20.520]                   }
[15:32:20.520]                   ...future.conditions[[length(...future.conditions) + 
[15:32:20.520]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:20.520]                     cond$call), session = sessionInformation(), 
[15:32:20.520]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:20.520]                   signalCondition(cond)
[15:32:20.520]                 }
[15:32:20.520]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:20.520]                 "immediateCondition"))) {
[15:32:20.520]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:20.520]                   ...future.conditions[[length(...future.conditions) + 
[15:32:20.520]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:20.520]                   if (TRUE && !signal) {
[15:32:20.520]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:20.520]                     {
[15:32:20.520]                       inherits <- base::inherits
[15:32:20.520]                       invokeRestart <- base::invokeRestart
[15:32:20.520]                       is.null <- base::is.null
[15:32:20.520]                       muffled <- FALSE
[15:32:20.520]                       if (inherits(cond, "message")) {
[15:32:20.520]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:20.520]                         if (muffled) 
[15:32:20.520]                           invokeRestart("muffleMessage")
[15:32:20.520]                       }
[15:32:20.520]                       else if (inherits(cond, "warning")) {
[15:32:20.520]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:20.520]                         if (muffled) 
[15:32:20.520]                           invokeRestart("muffleWarning")
[15:32:20.520]                       }
[15:32:20.520]                       else if (inherits(cond, "condition")) {
[15:32:20.520]                         if (!is.null(pattern)) {
[15:32:20.520]                           computeRestarts <- base::computeRestarts
[15:32:20.520]                           grepl <- base::grepl
[15:32:20.520]                           restarts <- computeRestarts(cond)
[15:32:20.520]                           for (restart in restarts) {
[15:32:20.520]                             name <- restart$name
[15:32:20.520]                             if (is.null(name)) 
[15:32:20.520]                               next
[15:32:20.520]                             if (!grepl(pattern, name)) 
[15:32:20.520]                               next
[15:32:20.520]                             invokeRestart(restart)
[15:32:20.520]                             muffled <- TRUE
[15:32:20.520]                             break
[15:32:20.520]                           }
[15:32:20.520]                         }
[15:32:20.520]                       }
[15:32:20.520]                       invisible(muffled)
[15:32:20.520]                     }
[15:32:20.520]                     muffleCondition(cond, pattern = "^muffle")
[15:32:20.520]                   }
[15:32:20.520]                 }
[15:32:20.520]                 else {
[15:32:20.520]                   if (TRUE) {
[15:32:20.520]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:20.520]                     {
[15:32:20.520]                       inherits <- base::inherits
[15:32:20.520]                       invokeRestart <- base::invokeRestart
[15:32:20.520]                       is.null <- base::is.null
[15:32:20.520]                       muffled <- FALSE
[15:32:20.520]                       if (inherits(cond, "message")) {
[15:32:20.520]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:20.520]                         if (muffled) 
[15:32:20.520]                           invokeRestart("muffleMessage")
[15:32:20.520]                       }
[15:32:20.520]                       else if (inherits(cond, "warning")) {
[15:32:20.520]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:20.520]                         if (muffled) 
[15:32:20.520]                           invokeRestart("muffleWarning")
[15:32:20.520]                       }
[15:32:20.520]                       else if (inherits(cond, "condition")) {
[15:32:20.520]                         if (!is.null(pattern)) {
[15:32:20.520]                           computeRestarts <- base::computeRestarts
[15:32:20.520]                           grepl <- base::grepl
[15:32:20.520]                           restarts <- computeRestarts(cond)
[15:32:20.520]                           for (restart in restarts) {
[15:32:20.520]                             name <- restart$name
[15:32:20.520]                             if (is.null(name)) 
[15:32:20.520]                               next
[15:32:20.520]                             if (!grepl(pattern, name)) 
[15:32:20.520]                               next
[15:32:20.520]                             invokeRestart(restart)
[15:32:20.520]                             muffled <- TRUE
[15:32:20.520]                             break
[15:32:20.520]                           }
[15:32:20.520]                         }
[15:32:20.520]                       }
[15:32:20.520]                       invisible(muffled)
[15:32:20.520]                     }
[15:32:20.520]                     muffleCondition(cond, pattern = "^muffle")
[15:32:20.520]                   }
[15:32:20.520]                 }
[15:32:20.520]             }
[15:32:20.520]         }))
[15:32:20.520]     }, error = function(ex) {
[15:32:20.520]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:20.520]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:20.520]                 ...future.rng), started = ...future.startTime, 
[15:32:20.520]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:20.520]             version = "1.8"), class = "FutureResult")
[15:32:20.520]     }, finally = {
[15:32:20.520]         if (!identical(...future.workdir, getwd())) 
[15:32:20.520]             setwd(...future.workdir)
[15:32:20.520]         {
[15:32:20.520]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:20.520]                 ...future.oldOptions$nwarnings <- NULL
[15:32:20.520]             }
[15:32:20.520]             base::options(...future.oldOptions)
[15:32:20.520]             if (.Platform$OS.type == "windows") {
[15:32:20.520]                 old_names <- names(...future.oldEnvVars)
[15:32:20.520]                 envs <- base::Sys.getenv()
[15:32:20.520]                 names <- names(envs)
[15:32:20.520]                 common <- intersect(names, old_names)
[15:32:20.520]                 added <- setdiff(names, old_names)
[15:32:20.520]                 removed <- setdiff(old_names, names)
[15:32:20.520]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:20.520]                   envs[common]]
[15:32:20.520]                 NAMES <- toupper(changed)
[15:32:20.520]                 args <- list()
[15:32:20.520]                 for (kk in seq_along(NAMES)) {
[15:32:20.520]                   name <- changed[[kk]]
[15:32:20.520]                   NAME <- NAMES[[kk]]
[15:32:20.520]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:20.520]                     next
[15:32:20.520]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:20.520]                 }
[15:32:20.520]                 NAMES <- toupper(added)
[15:32:20.520]                 for (kk in seq_along(NAMES)) {
[15:32:20.520]                   name <- added[[kk]]
[15:32:20.520]                   NAME <- NAMES[[kk]]
[15:32:20.520]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:20.520]                     next
[15:32:20.520]                   args[[name]] <- ""
[15:32:20.520]                 }
[15:32:20.520]                 NAMES <- toupper(removed)
[15:32:20.520]                 for (kk in seq_along(NAMES)) {
[15:32:20.520]                   name <- removed[[kk]]
[15:32:20.520]                   NAME <- NAMES[[kk]]
[15:32:20.520]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:20.520]                     next
[15:32:20.520]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:20.520]                 }
[15:32:20.520]                 if (length(args) > 0) 
[15:32:20.520]                   base::do.call(base::Sys.setenv, args = args)
[15:32:20.520]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:20.520]             }
[15:32:20.520]             else {
[15:32:20.520]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:20.520]             }
[15:32:20.520]             {
[15:32:20.520]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:20.520]                   0L) {
[15:32:20.520]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:20.520]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:20.520]                   base::options(opts)
[15:32:20.520]                 }
[15:32:20.520]                 {
[15:32:20.520]                   {
[15:32:20.520]                     NULL
[15:32:20.520]                     RNGkind("Mersenne-Twister")
[15:32:20.520]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:20.520]                       inherits = FALSE)
[15:32:20.520]                   }
[15:32:20.520]                   options(future.plan = NULL)
[15:32:20.520]                   if (is.na(NA_character_)) 
[15:32:20.520]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:20.520]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:20.520]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:20.520]                     .init = FALSE)
[15:32:20.520]                 }
[15:32:20.520]             }
[15:32:20.520]         }
[15:32:20.520]     })
[15:32:20.520]     if (TRUE) {
[15:32:20.520]         base::sink(type = "output", split = FALSE)
[15:32:20.520]         if (TRUE) {
[15:32:20.520]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:20.520]         }
[15:32:20.520]         else {
[15:32:20.520]             ...future.result["stdout"] <- base::list(NULL)
[15:32:20.520]         }
[15:32:20.520]         base::close(...future.stdout)
[15:32:20.520]         ...future.stdout <- NULL
[15:32:20.520]     }
[15:32:20.520]     ...future.result$conditions <- ...future.conditions
[15:32:20.520]     ...future.result$finished <- base::Sys.time()
[15:32:20.520]     ...future.result
[15:32:20.520] }
[15:32:20.526] assign_globals() ...
[15:32:20.526] List of 5
[15:32:20.526]  $ ...future.FUN            :function (x, y = 2 * 1:5)  
[15:32:20.526]  $ future.call.arguments    : list()
[15:32:20.526]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:20.526]  $ ...future.elements_ii    :List of 3
[15:32:20.526]   ..$ a: num 1
[15:32:20.526]   ..$ b: num 2
[15:32:20.526]   ..$ c: num 3
[15:32:20.526]  $ ...future.seeds_ii       : NULL
[15:32:20.526]  $ ...future.globals.maxSize: NULL
[15:32:20.526]  - attr(*, "where")=List of 5
[15:32:20.526]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:20.526]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:20.526]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:20.526]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:20.526]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:20.526]  - attr(*, "resolved")= logi FALSE
[15:32:20.526]  - attr(*, "total_size")= num 4728
[15:32:20.526]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:20.526]  - attr(*, "already-done")= logi TRUE
[15:32:20.541] - reassign environment for '...future.FUN'
[15:32:20.542] - copied '...future.FUN' to environment
[15:32:20.542] - copied 'future.call.arguments' to environment
[15:32:20.542] - copied '...future.elements_ii' to environment
[15:32:20.542] - copied '...future.seeds_ii' to environment
[15:32:20.543] - copied '...future.globals.maxSize' to environment
[15:32:20.543] assign_globals() ... done
[15:32:20.544] plan(): Setting new future strategy stack:
[15:32:20.544] List of future strategies:
[15:32:20.544] 1. sequential:
[15:32:20.544]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:20.544]    - tweaked: FALSE
[15:32:20.544]    - call: NULL
[15:32:20.545] plan(): nbrOfWorkers() = 1
[15:32:20.547] plan(): Setting new future strategy stack:
[15:32:20.547] List of future strategies:
[15:32:20.547] 1. sequential:
[15:32:20.547]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:20.547]    - tweaked: FALSE
[15:32:20.547]    - call: plan(strategy)
[15:32:20.548] plan(): nbrOfWorkers() = 1
[15:32:20.548] SequentialFuture started (and completed)
[15:32:20.549] - Launch lazy future ... done
[15:32:20.549] run() for 'SequentialFuture' ... done
[15:32:20.549] Created future:
[15:32:20.550] SequentialFuture:
[15:32:20.550] Label: 'future_sapply-1'
[15:32:20.550] Expression:
[15:32:20.550] {
[15:32:20.550]     do.call(function(...) {
[15:32:20.550]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:20.550]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:20.550]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:20.550]             on.exit(options(oopts), add = TRUE)
[15:32:20.550]         }
[15:32:20.550]         {
[15:32:20.550]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:20.550]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:20.550]                 ...future.FUN(...future.X_jj, ...)
[15:32:20.550]             })
[15:32:20.550]         }
[15:32:20.550]     }, args = future.call.arguments)
[15:32:20.550] }
[15:32:20.550] Lazy evaluation: FALSE
[15:32:20.550] Asynchronous evaluation: FALSE
[15:32:20.550] Local evaluation: TRUE
[15:32:20.550] Environment: R_GlobalEnv
[15:32:20.550] Capture standard output: TRUE
[15:32:20.550] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:20.550] Globals: 5 objects totaling 4.78 KiB (function '...future.FUN' of 4.62 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:20.550] Packages: <none>
[15:32:20.550] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:20.550] Resolved: TRUE
[15:32:20.550] Value: 1.01 KiB of class 'list'
[15:32:20.550] Early signaling: FALSE
[15:32:20.550] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:20.550] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:20.552] Chunk #1 of 1 ... DONE
[15:32:20.552] Launching 1 futures (chunks) ... DONE
[15:32:20.552] Resolving 1 futures (chunks) ...
[15:32:20.552] resolve() on list ...
[15:32:20.552]  recursive: 0
[15:32:20.553]  length: 1
[15:32:20.553] 
[15:32:20.553] resolved() for 'SequentialFuture' ...
[15:32:20.553] - state: 'finished'
[15:32:20.554] - run: TRUE
[15:32:20.554] - result: 'FutureResult'
[15:32:20.554] resolved() for 'SequentialFuture' ... done
[15:32:20.555] Future #1
[15:32:20.555] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:20.555] - nx: 1
[15:32:20.555] - relay: TRUE
[15:32:20.555] - stdout: TRUE
[15:32:20.556] - signal: TRUE
[15:32:20.556] - resignal: FALSE
[15:32:20.556] - force: TRUE
[15:32:20.556] - relayed: [n=1] FALSE
[15:32:20.556] - queued futures: [n=1] FALSE
[15:32:20.556]  - until=1
[15:32:20.557]  - relaying element #1
[15:32:20.557] - relayed: [n=1] TRUE
[15:32:20.557] - queued futures: [n=1] TRUE
[15:32:20.558] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:20.558]  length: 0 (resolved future 1)
[15:32:20.558] Relaying remaining futures
[15:32:20.558] signalConditionsASAP(NULL, pos=0) ...
[15:32:20.559] - nx: 1
[15:32:20.559] - relay: TRUE
[15:32:20.559] - stdout: TRUE
[15:32:20.559] - signal: TRUE
[15:32:20.560] - resignal: FALSE
[15:32:20.560] - force: TRUE
[15:32:20.560] - relayed: [n=1] TRUE
[15:32:20.560] - queued futures: [n=1] TRUE
 - flush all
[15:32:20.561] - relayed: [n=1] TRUE
[15:32:20.561] - queued futures: [n=1] TRUE
[15:32:20.561] signalConditionsASAP(NULL, pos=0) ... done
[15:32:20.561] resolve() on list ... DONE
[15:32:20.562]  - Number of value chunks collected: 1
[15:32:20.562] Resolving 1 futures (chunks) ... DONE
[15:32:20.562] Reducing values from 1 chunks ...
[15:32:20.562]  - Number of values collected after concatenation: 3
[15:32:20.563]  - Number of values expected: 3
[15:32:20.563] Reducing values from 1 chunks ... DONE
[15:32:20.563] future_lapply() ... DONE
List of 2
 $ y0: num [1:15, 1:3] 2 2 2 4 4 4 6 6 6 8 ...
  ..- attr(*, "dimnames")=List of 2
  .. ..$ : NULL
  .. ..$ : chr [1:3] "a" "b" "c"
 $ y1: num [1:15, 1:3] 2 2 2 4 4 4 6 6 6 8 ...
  ..- attr(*, "dimnames")=List of 2
  .. ..$ : NULL
  .. ..$ : chr [1:3] "a" "b" "c"
[15:32:20.569] future_lapply() ...
[15:32:20.570] Number of chunks: 1
[15:32:20.570] getGlobalsAndPackagesXApply() ...
[15:32:20.571]  - future.globals: TRUE
[15:32:20.571] getGlobalsAndPackages() ...
[15:32:20.571] Searching for globals...
[15:32:20.574] - globals found: [1] 'FUN'
[15:32:20.574] Searching for globals ... DONE
[15:32:20.574] Resolving globals: FALSE
[15:32:20.575] The total size of the 1 globals is 848 bytes (848 bytes)
[15:32:20.576] The total size of the 1 globals exported for future expression ('FUN()') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:32:20.576] - globals: [1] 'FUN'
[15:32:20.581] 
[15:32:20.581] getGlobalsAndPackages() ... DONE
[15:32:20.582]  - globals found/used: [n=1] 'FUN'
[15:32:20.582]  - needed namespaces: [n=0] 
[15:32:20.582] Finding globals ... DONE
[15:32:20.583]  - use_args: TRUE
[15:32:20.583]  - Getting '...' globals ...
[15:32:20.584] resolve() on list ...
[15:32:20.584]  recursive: 0
[15:32:20.585]  length: 1
[15:32:20.585]  elements: '...'
[15:32:20.586]  length: 0 (resolved future 1)
[15:32:20.586] resolve() on list ... DONE
[15:32:20.586]    - '...' content: [n=0] 
[15:32:20.586] List of 1
[15:32:20.586]  $ ...: list()
[15:32:20.586]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:20.586]  - attr(*, "where")=List of 1
[15:32:20.586]   ..$ ...:<environment: 0x00000276e2458680> 
[15:32:20.586]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:20.586]  - attr(*, "resolved")= logi TRUE
[15:32:20.586]  - attr(*, "total_size")= num NA
[15:32:20.592]  - Getting '...' globals ... DONE
[15:32:20.592] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:20.592] List of 2
[15:32:20.592]  $ ...future.FUN:function (x)  
[15:32:20.592]  $ ...          : list()
[15:32:20.592]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:20.592]  - attr(*, "where")=List of 2
[15:32:20.592]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:20.592]   ..$ ...          :<environment: 0x00000276e2458680> 
[15:32:20.592]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:20.592]  - attr(*, "resolved")= logi FALSE
[15:32:20.592]  - attr(*, "total_size")= num 848
[15:32:20.597] Packages to be attached in all futures: [n=0] 
[15:32:20.597] getGlobalsAndPackagesXApply() ... DONE
[15:32:20.598] Number of futures (= number of chunks): 1
[15:32:20.598] Launching 1 futures (chunks) ...
[15:32:20.598] Chunk #1 of 1 ...
[15:32:20.599]  - Finding globals in 'X' for chunk #1 ...
[15:32:20.599] getGlobalsAndPackages() ...
[15:32:20.599] Searching for globals...
[15:32:20.600] 
[15:32:20.600] Searching for globals ... DONE
[15:32:20.601] - globals: [0] <none>
[15:32:20.601] getGlobalsAndPackages() ... DONE
[15:32:20.601]    + additional globals found: [n=0] 
[15:32:20.601]    + additional namespaces needed: [n=0] 
[15:32:20.602]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:20.602]  - seeds: <none>
[15:32:20.602]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:20.602] getGlobalsAndPackages() ...
[15:32:20.603] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:20.603] Resolving globals: FALSE
[15:32:20.603] Tweak future expression to call with '...' arguments ...
[15:32:20.604] {
[15:32:20.604]     do.call(function(...) {
[15:32:20.604]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:20.604]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:20.604]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:20.604]             on.exit(options(oopts), add = TRUE)
[15:32:20.604]         }
[15:32:20.604]         {
[15:32:20.604]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:20.604]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:20.604]                 ...future.FUN(...future.X_jj, ...)
[15:32:20.604]             })
[15:32:20.604]         }
[15:32:20.604]     }, args = future.call.arguments)
[15:32:20.604] }
[15:32:20.605] Tweak future expression to call with '...' arguments ... DONE
[15:32:20.605] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:20.606] 
[15:32:20.606] getGlobalsAndPackages() ... DONE
[15:32:20.607] run() for 'Future' ...
[15:32:20.607] - state: 'created'
[15:32:20.607] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:20.608] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:20.609] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:20.609]   - Field: 'label'
[15:32:20.609]   - Field: 'local'
[15:32:20.609]   - Field: 'owner'
[15:32:20.610]   - Field: 'envir'
[15:32:20.610]   - Field: 'packages'
[15:32:20.610]   - Field: 'gc'
[15:32:20.611]   - Field: 'conditions'
[15:32:20.611]   - Field: 'expr'
[15:32:20.611]   - Field: 'uuid'
[15:32:20.612]   - Field: 'seed'
[15:32:20.612]   - Field: 'version'
[15:32:20.612]   - Field: 'result'
[15:32:20.613]   - Field: 'asynchronous'
[15:32:20.613]   - Field: 'calls'
[15:32:20.613]   - Field: 'globals'
[15:32:20.614]   - Field: 'stdout'
[15:32:20.614]   - Field: 'earlySignal'
[15:32:20.614]   - Field: 'lazy'
[15:32:20.615]   - Field: 'state'
[15:32:20.615] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:20.615] - Launch lazy future ...
[15:32:20.616] Packages needed by the future expression (n = 0): <none>
[15:32:20.616] Packages needed by future strategies (n = 0): <none>
[15:32:20.618] {
[15:32:20.618]     {
[15:32:20.618]         {
[15:32:20.618]             ...future.startTime <- base::Sys.time()
[15:32:20.618]             {
[15:32:20.618]                 {
[15:32:20.618]                   {
[15:32:20.618]                     base::local({
[15:32:20.618]                       has_future <- base::requireNamespace("future", 
[15:32:20.618]                         quietly = TRUE)
[15:32:20.618]                       if (has_future) {
[15:32:20.618]                         ns <- base::getNamespace("future")
[15:32:20.618]                         version <- ns[[".package"]][["version"]]
[15:32:20.618]                         if (is.null(version)) 
[15:32:20.618]                           version <- utils::packageVersion("future")
[15:32:20.618]                       }
[15:32:20.618]                       else {
[15:32:20.618]                         version <- NULL
[15:32:20.618]                       }
[15:32:20.618]                       if (!has_future || version < "1.8.0") {
[15:32:20.618]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:20.618]                           "", base::R.version$version.string), 
[15:32:20.618]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:20.618]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:20.618]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:20.618]                             "release", "version")], collapse = " "), 
[15:32:20.618]                           hostname = base::Sys.info()[["nodename"]])
[15:32:20.618]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:20.618]                           info)
[15:32:20.618]                         info <- base::paste(info, collapse = "; ")
[15:32:20.618]                         if (!has_future) {
[15:32:20.618]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:20.618]                             info)
[15:32:20.618]                         }
[15:32:20.618]                         else {
[15:32:20.618]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:20.618]                             info, version)
[15:32:20.618]                         }
[15:32:20.618]                         base::stop(msg)
[15:32:20.618]                       }
[15:32:20.618]                     })
[15:32:20.618]                   }
[15:32:20.618]                   ...future.strategy.old <- future::plan("list")
[15:32:20.618]                   options(future.plan = NULL)
[15:32:20.618]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:20.618]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:20.618]                 }
[15:32:20.618]                 ...future.workdir <- getwd()
[15:32:20.618]             }
[15:32:20.618]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:20.618]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:20.618]         }
[15:32:20.618]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:20.618]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:20.618]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:20.618]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:20.618]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:20.618]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:20.618]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:20.618]             base::names(...future.oldOptions))
[15:32:20.618]     }
[15:32:20.618]     if (FALSE) {
[15:32:20.618]     }
[15:32:20.618]     else {
[15:32:20.618]         if (TRUE) {
[15:32:20.618]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:20.618]                 open = "w")
[15:32:20.618]         }
[15:32:20.618]         else {
[15:32:20.618]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:20.618]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:20.618]         }
[15:32:20.618]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:20.618]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:20.618]             base::sink(type = "output", split = FALSE)
[15:32:20.618]             base::close(...future.stdout)
[15:32:20.618]         }, add = TRUE)
[15:32:20.618]     }
[15:32:20.618]     ...future.frame <- base::sys.nframe()
[15:32:20.618]     ...future.conditions <- base::list()
[15:32:20.618]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:20.618]     if (FALSE) {
[15:32:20.618]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:20.618]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:20.618]     }
[15:32:20.618]     ...future.result <- base::tryCatch({
[15:32:20.618]         base::withCallingHandlers({
[15:32:20.618]             ...future.value <- base::withVisible(base::local({
[15:32:20.618]                 do.call(function(...) {
[15:32:20.618]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:20.618]                   if (!identical(...future.globals.maxSize.org, 
[15:32:20.618]                     ...future.globals.maxSize)) {
[15:32:20.618]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:20.618]                     on.exit(options(oopts), add = TRUE)
[15:32:20.618]                   }
[15:32:20.618]                   {
[15:32:20.618]                     lapply(seq_along(...future.elements_ii), 
[15:32:20.618]                       FUN = function(jj) {
[15:32:20.618]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:20.618]                         ...future.FUN(...future.X_jj, ...)
[15:32:20.618]                       })
[15:32:20.618]                   }
[15:32:20.618]                 }, args = future.call.arguments)
[15:32:20.618]             }))
[15:32:20.618]             future::FutureResult(value = ...future.value$value, 
[15:32:20.618]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:20.618]                   ...future.rng), globalenv = if (FALSE) 
[15:32:20.618]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:20.618]                     ...future.globalenv.names))
[15:32:20.618]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:20.618]         }, condition = base::local({
[15:32:20.618]             c <- base::c
[15:32:20.618]             inherits <- base::inherits
[15:32:20.618]             invokeRestart <- base::invokeRestart
[15:32:20.618]             length <- base::length
[15:32:20.618]             list <- base::list
[15:32:20.618]             seq.int <- base::seq.int
[15:32:20.618]             signalCondition <- base::signalCondition
[15:32:20.618]             sys.calls <- base::sys.calls
[15:32:20.618]             `[[` <- base::`[[`
[15:32:20.618]             `+` <- base::`+`
[15:32:20.618]             `<<-` <- base::`<<-`
[15:32:20.618]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:20.618]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:20.618]                   3L)]
[15:32:20.618]             }
[15:32:20.618]             function(cond) {
[15:32:20.618]                 is_error <- inherits(cond, "error")
[15:32:20.618]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:20.618]                   NULL)
[15:32:20.618]                 if (is_error) {
[15:32:20.618]                   sessionInformation <- function() {
[15:32:20.618]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:20.618]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:20.618]                       search = base::search(), system = base::Sys.info())
[15:32:20.618]                   }
[15:32:20.618]                   ...future.conditions[[length(...future.conditions) + 
[15:32:20.618]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:20.618]                     cond$call), session = sessionInformation(), 
[15:32:20.618]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:20.618]                   signalCondition(cond)
[15:32:20.618]                 }
[15:32:20.618]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:20.618]                 "immediateCondition"))) {
[15:32:20.618]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:20.618]                   ...future.conditions[[length(...future.conditions) + 
[15:32:20.618]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:20.618]                   if (TRUE && !signal) {
[15:32:20.618]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:20.618]                     {
[15:32:20.618]                       inherits <- base::inherits
[15:32:20.618]                       invokeRestart <- base::invokeRestart
[15:32:20.618]                       is.null <- base::is.null
[15:32:20.618]                       muffled <- FALSE
[15:32:20.618]                       if (inherits(cond, "message")) {
[15:32:20.618]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:20.618]                         if (muffled) 
[15:32:20.618]                           invokeRestart("muffleMessage")
[15:32:20.618]                       }
[15:32:20.618]                       else if (inherits(cond, "warning")) {
[15:32:20.618]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:20.618]                         if (muffled) 
[15:32:20.618]                           invokeRestart("muffleWarning")
[15:32:20.618]                       }
[15:32:20.618]                       else if (inherits(cond, "condition")) {
[15:32:20.618]                         if (!is.null(pattern)) {
[15:32:20.618]                           computeRestarts <- base::computeRestarts
[15:32:20.618]                           grepl <- base::grepl
[15:32:20.618]                           restarts <- computeRestarts(cond)
[15:32:20.618]                           for (restart in restarts) {
[15:32:20.618]                             name <- restart$name
[15:32:20.618]                             if (is.null(name)) 
[15:32:20.618]                               next
[15:32:20.618]                             if (!grepl(pattern, name)) 
[15:32:20.618]                               next
[15:32:20.618]                             invokeRestart(restart)
[15:32:20.618]                             muffled <- TRUE
[15:32:20.618]                             break
[15:32:20.618]                           }
[15:32:20.618]                         }
[15:32:20.618]                       }
[15:32:20.618]                       invisible(muffled)
[15:32:20.618]                     }
[15:32:20.618]                     muffleCondition(cond, pattern = "^muffle")
[15:32:20.618]                   }
[15:32:20.618]                 }
[15:32:20.618]                 else {
[15:32:20.618]                   if (TRUE) {
[15:32:20.618]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:20.618]                     {
[15:32:20.618]                       inherits <- base::inherits
[15:32:20.618]                       invokeRestart <- base::invokeRestart
[15:32:20.618]                       is.null <- base::is.null
[15:32:20.618]                       muffled <- FALSE
[15:32:20.618]                       if (inherits(cond, "message")) {
[15:32:20.618]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:20.618]                         if (muffled) 
[15:32:20.618]                           invokeRestart("muffleMessage")
[15:32:20.618]                       }
[15:32:20.618]                       else if (inherits(cond, "warning")) {
[15:32:20.618]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:20.618]                         if (muffled) 
[15:32:20.618]                           invokeRestart("muffleWarning")
[15:32:20.618]                       }
[15:32:20.618]                       else if (inherits(cond, "condition")) {
[15:32:20.618]                         if (!is.null(pattern)) {
[15:32:20.618]                           computeRestarts <- base::computeRestarts
[15:32:20.618]                           grepl <- base::grepl
[15:32:20.618]                           restarts <- computeRestarts(cond)
[15:32:20.618]                           for (restart in restarts) {
[15:32:20.618]                             name <- restart$name
[15:32:20.618]                             if (is.null(name)) 
[15:32:20.618]                               next
[15:32:20.618]                             if (!grepl(pattern, name)) 
[15:32:20.618]                               next
[15:32:20.618]                             invokeRestart(restart)
[15:32:20.618]                             muffled <- TRUE
[15:32:20.618]                             break
[15:32:20.618]                           }
[15:32:20.618]                         }
[15:32:20.618]                       }
[15:32:20.618]                       invisible(muffled)
[15:32:20.618]                     }
[15:32:20.618]                     muffleCondition(cond, pattern = "^muffle")
[15:32:20.618]                   }
[15:32:20.618]                 }
[15:32:20.618]             }
[15:32:20.618]         }))
[15:32:20.618]     }, error = function(ex) {
[15:32:20.618]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:20.618]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:20.618]                 ...future.rng), started = ...future.startTime, 
[15:32:20.618]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:20.618]             version = "1.8"), class = "FutureResult")
[15:32:20.618]     }, finally = {
[15:32:20.618]         if (!identical(...future.workdir, getwd())) 
[15:32:20.618]             setwd(...future.workdir)
[15:32:20.618]         {
[15:32:20.618]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:20.618]                 ...future.oldOptions$nwarnings <- NULL
[15:32:20.618]             }
[15:32:20.618]             base::options(...future.oldOptions)
[15:32:20.618]             if (.Platform$OS.type == "windows") {
[15:32:20.618]                 old_names <- names(...future.oldEnvVars)
[15:32:20.618]                 envs <- base::Sys.getenv()
[15:32:20.618]                 names <- names(envs)
[15:32:20.618]                 common <- intersect(names, old_names)
[15:32:20.618]                 added <- setdiff(names, old_names)
[15:32:20.618]                 removed <- setdiff(old_names, names)
[15:32:20.618]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:20.618]                   envs[common]]
[15:32:20.618]                 NAMES <- toupper(changed)
[15:32:20.618]                 args <- list()
[15:32:20.618]                 for (kk in seq_along(NAMES)) {
[15:32:20.618]                   name <- changed[[kk]]
[15:32:20.618]                   NAME <- NAMES[[kk]]
[15:32:20.618]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:20.618]                     next
[15:32:20.618]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:20.618]                 }
[15:32:20.618]                 NAMES <- toupper(added)
[15:32:20.618]                 for (kk in seq_along(NAMES)) {
[15:32:20.618]                   name <- added[[kk]]
[15:32:20.618]                   NAME <- NAMES[[kk]]
[15:32:20.618]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:20.618]                     next
[15:32:20.618]                   args[[name]] <- ""
[15:32:20.618]                 }
[15:32:20.618]                 NAMES <- toupper(removed)
[15:32:20.618]                 for (kk in seq_along(NAMES)) {
[15:32:20.618]                   name <- removed[[kk]]
[15:32:20.618]                   NAME <- NAMES[[kk]]
[15:32:20.618]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:20.618]                     next
[15:32:20.618]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:20.618]                 }
[15:32:20.618]                 if (length(args) > 0) 
[15:32:20.618]                   base::do.call(base::Sys.setenv, args = args)
[15:32:20.618]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:20.618]             }
[15:32:20.618]             else {
[15:32:20.618]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:20.618]             }
[15:32:20.618]             {
[15:32:20.618]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:20.618]                   0L) {
[15:32:20.618]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:20.618]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:20.618]                   base::options(opts)
[15:32:20.618]                 }
[15:32:20.618]                 {
[15:32:20.618]                   {
[15:32:20.618]                     NULL
[15:32:20.618]                     RNGkind("Mersenne-Twister")
[15:32:20.618]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:20.618]                       inherits = FALSE)
[15:32:20.618]                   }
[15:32:20.618]                   options(future.plan = NULL)
[15:32:20.618]                   if (is.na(NA_character_)) 
[15:32:20.618]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:20.618]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:20.618]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:20.618]                     .init = FALSE)
[15:32:20.618]                 }
[15:32:20.618]             }
[15:32:20.618]         }
[15:32:20.618]     })
[15:32:20.618]     if (TRUE) {
[15:32:20.618]         base::sink(type = "output", split = FALSE)
[15:32:20.618]         if (TRUE) {
[15:32:20.618]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:20.618]         }
[15:32:20.618]         else {
[15:32:20.618]             ...future.result["stdout"] <- base::list(NULL)
[15:32:20.618]         }
[15:32:20.618]         base::close(...future.stdout)
[15:32:20.618]         ...future.stdout <- NULL
[15:32:20.618]     }
[15:32:20.618]     ...future.result$conditions <- ...future.conditions
[15:32:20.618]     ...future.result$finished <- base::Sys.time()
[15:32:20.618]     ...future.result
[15:32:20.618] }
[15:32:20.625] assign_globals() ...
[15:32:20.625] List of 5
[15:32:20.625]  $ ...future.FUN            :function (x)  
[15:32:20.625]  $ future.call.arguments    : list()
[15:32:20.625]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:20.625]  $ ...future.elements_ii    :List of 3
[15:32:20.625]   ..$ a: num 1
[15:32:20.625]   ..$ b: num 2
[15:32:20.625]   ..$ c: num 3
[15:32:20.625]  $ ...future.seeds_ii       : NULL
[15:32:20.625]  $ ...future.globals.maxSize: NULL
[15:32:20.625]  - attr(*, "where")=List of 5
[15:32:20.625]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:20.625]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:20.625]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:20.625]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:20.625]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:20.625]  - attr(*, "resolved")= logi FALSE
[15:32:20.625]  - attr(*, "total_size")= num 848
[15:32:20.625]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:20.625]  - attr(*, "already-done")= logi TRUE
[15:32:20.644] - copied '...future.FUN' to environment
[15:32:20.644] - copied 'future.call.arguments' to environment
[15:32:20.644] - copied '...future.elements_ii' to environment
[15:32:20.645] - copied '...future.seeds_ii' to environment
[15:32:20.645] - copied '...future.globals.maxSize' to environment
[15:32:20.645] assign_globals() ... done
[15:32:20.646] plan(): Setting new future strategy stack:
[15:32:20.646] List of future strategies:
[15:32:20.646] 1. sequential:
[15:32:20.646]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:20.646]    - tweaked: FALSE
[15:32:20.646]    - call: NULL
[15:32:20.648] plan(): nbrOfWorkers() = 1
[15:32:20.650] plan(): Setting new future strategy stack:
[15:32:20.650] List of future strategies:
[15:32:20.650] 1. sequential:
[15:32:20.650]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:20.650]    - tweaked: FALSE
[15:32:20.650]    - call: plan(strategy)
[15:32:20.651] plan(): nbrOfWorkers() = 1
[15:32:20.652] SequentialFuture started (and completed)
[15:32:20.652] - Launch lazy future ... done
[15:32:20.653] run() for 'SequentialFuture' ... done
[15:32:20.653] Created future:
[15:32:20.653] SequentialFuture:
[15:32:20.653] Label: 'future_sapply-1'
[15:32:20.653] Expression:
[15:32:20.653] {
[15:32:20.653]     do.call(function(...) {
[15:32:20.653]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:20.653]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:20.653]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:20.653]             on.exit(options(oopts), add = TRUE)
[15:32:20.653]         }
[15:32:20.653]         {
[15:32:20.653]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:20.653]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:20.653]                 ...future.FUN(...future.X_jj, ...)
[15:32:20.653]             })
[15:32:20.653]         }
[15:32:20.653]     }, args = future.call.arguments)
[15:32:20.653] }
[15:32:20.653] Lazy evaluation: FALSE
[15:32:20.653] Asynchronous evaluation: FALSE
[15:32:20.653] Local evaluation: TRUE
[15:32:20.653] Environment: R_GlobalEnv
[15:32:20.653] Capture standard output: TRUE
[15:32:20.653] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:20.653] Globals: 5 objects totaling 0.99 KiB (function '...future.FUN' of 848 bytes, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:20.653] Packages: <none>
[15:32:20.653] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:20.653] Resolved: TRUE
[15:32:20.653] Value: 168 bytes of class 'list'
[15:32:20.653] Early signaling: FALSE
[15:32:20.653] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:20.653] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:20.656] Chunk #1 of 1 ... DONE
[15:32:20.656] Launching 1 futures (chunks) ... DONE
[15:32:20.657] Resolving 1 futures (chunks) ...
[15:32:20.657] resolve() on list ...
[15:32:20.657]  recursive: 0
[15:32:20.658]  length: 1
[15:32:20.658] 
[15:32:20.658] resolved() for 'SequentialFuture' ...
[15:32:20.659] - state: 'finished'
[15:32:20.659] - run: TRUE
[15:32:20.659] - result: 'FutureResult'
[15:32:20.660] resolved() for 'SequentialFuture' ... done
[15:32:20.660] Future #1
[15:32:20.661] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:20.661] - nx: 1
[15:32:20.661] - relay: TRUE
[15:32:20.661] - stdout: TRUE
[15:32:20.662] - signal: TRUE
[15:32:20.662] - resignal: FALSE
[15:32:20.662] - force: TRUE
[15:32:20.663] - relayed: [n=1] FALSE
[15:32:20.663] - queued futures: [n=1] FALSE
[15:32:20.663]  - until=1
[15:32:20.663]  - relaying element #1
[15:32:20.664] - relayed: [n=1] TRUE
[15:32:20.664] - queued futures: [n=1] TRUE
[15:32:20.665] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:20.665]  length: 0 (resolved future 1)
[15:32:20.665] Relaying remaining futures
[15:32:20.666] signalConditionsASAP(NULL, pos=0) ...
[15:32:20.666] - nx: 1
[15:32:20.666] - relay: TRUE
[15:32:20.666] - stdout: TRUE
[15:32:20.667] - signal: TRUE
[15:32:20.667] - resignal: FALSE
[15:32:20.667] - force: TRUE
[15:32:20.668] - relayed: [n=1] TRUE
[15:32:20.668] - queued futures: [n=1] TRUE
 - flush all
[15:32:20.668] - relayed: [n=1] TRUE
[15:32:20.669] - queued futures: [n=1] TRUE
[15:32:20.669] signalConditionsASAP(NULL, pos=0) ... done
[15:32:20.669] resolve() on list ... DONE
[15:32:20.670]  - Number of value chunks collected: 1
[15:32:20.670] Resolving 1 futures (chunks) ... DONE
[15:32:20.670] Reducing values from 1 chunks ...
[15:32:20.671]  - Number of values collected after concatenation: 3
[15:32:20.671]  - Number of values expected: 3
[15:32:20.671] Reducing values from 1 chunks ... DONE
[15:32:20.672] future_lapply() ... DONE
List of 2
 $ y0: Named num [1:3] 1 2 3
  ..- attr(*, "names")= chr [1:3] "a" "b" "c"
 $ y1: Named num [1:3] 1 2 3
  ..- attr(*, "names")= chr [1:3] "a" "b" "c"
[15:32:20.676] future_lapply() ...
[15:32:20.677] Number of chunks: 1
[15:32:20.678] getGlobalsAndPackagesXApply() ...
[15:32:20.678]  - future.globals: TRUE
[15:32:20.678] getGlobalsAndPackages() ...
[15:32:20.678] Searching for globals...
[15:32:20.681] - globals found: [2] 'FUN', 'UseMethod'
[15:32:20.681] Searching for globals ... DONE
[15:32:20.682] Resolving globals: FALSE
[15:32:20.683] The total size of the 1 globals is 1.22 KiB (1248 bytes)
[15:32:20.683] The total size of the 1 globals exported for future expression ('FUN()') is 1.22 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.22 KiB of class 'function')
[15:32:20.684] - globals: [1] 'FUN'
[15:32:20.684] 
[15:32:20.684] getGlobalsAndPackages() ... DONE
[15:32:20.685]  - globals found/used: [n=1] 'FUN'
[15:32:20.685]  - needed namespaces: [n=0] 
[15:32:20.685] Finding globals ... DONE
[15:32:20.686]  - use_args: TRUE
[15:32:20.686]  - Getting '...' globals ...
[15:32:20.687] resolve() on list ...
[15:32:20.687]  recursive: 0
[15:32:20.687]  length: 1
[15:32:20.688]  elements: '...'
[15:32:20.688]  length: 0 (resolved future 1)
[15:32:20.688] resolve() on list ... DONE
[15:32:20.689]    - '...' content: [n=0] 
[15:32:20.693] List of 1
[15:32:20.693]  $ ...: list()
[15:32:20.693]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:20.693]  - attr(*, "where")=List of 1
[15:32:20.693]   ..$ ...:<environment: 0x00000276e1f2de98> 
[15:32:20.693]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:20.693]  - attr(*, "resolved")= logi TRUE
[15:32:20.693]  - attr(*, "total_size")= num NA
[15:32:20.700]  - Getting '...' globals ... DONE
[15:32:20.701] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:20.701] List of 2
[15:32:20.701]  $ ...future.FUN:function (x, ...)  
[15:32:20.701]  $ ...          : list()
[15:32:20.701]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:20.701]  - attr(*, "where")=List of 2
[15:32:20.701]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:20.701]   ..$ ...          :<environment: 0x00000276e1f2de98> 
[15:32:20.701]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:20.701]  - attr(*, "resolved")= logi FALSE
[15:32:20.701]  - attr(*, "total_size")= num 1248
[15:32:20.706] Packages to be attached in all futures: [n=0] 
[15:32:20.706] getGlobalsAndPackagesXApply() ... DONE
[15:32:20.707] Number of futures (= number of chunks): 1
[15:32:20.707] Launching 1 futures (chunks) ...
[15:32:20.707] Chunk #1 of 1 ...
[15:32:20.708]  - Finding globals in 'X' for chunk #1 ...
[15:32:20.708] getGlobalsAndPackages() ...
[15:32:20.708] Searching for globals...
[15:32:20.709] 
[15:32:20.709] Searching for globals ... DONE
[15:32:20.710] - globals: [0] <none>
[15:32:20.710] getGlobalsAndPackages() ... DONE
[15:32:20.710]    + additional globals found: [n=0] 
[15:32:20.711]    + additional namespaces needed: [n=0] 
[15:32:20.711]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:20.711]  - seeds: <none>
[15:32:20.711]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:20.712] getGlobalsAndPackages() ...
[15:32:20.712] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:20.712] Resolving globals: FALSE
[15:32:20.713] Tweak future expression to call with '...' arguments ...
[15:32:20.713] {
[15:32:20.713]     do.call(function(...) {
[15:32:20.713]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:20.713]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:20.713]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:20.713]             on.exit(options(oopts), add = TRUE)
[15:32:20.713]         }
[15:32:20.713]         {
[15:32:20.713]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:20.713]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:20.713]                 ...future.FUN(...future.X_jj, ...)
[15:32:20.713]             })
[15:32:20.713]         }
[15:32:20.713]     }, args = future.call.arguments)
[15:32:20.713] }
[15:32:20.714] Tweak future expression to call with '...' arguments ... DONE
[15:32:20.715] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:20.715] 
[15:32:20.716] getGlobalsAndPackages() ... DONE
[15:32:20.716] run() for 'Future' ...
[15:32:20.717] - state: 'created'
[15:32:20.717] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:20.717] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:20.718] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:20.718]   - Field: 'label'
[15:32:20.718]   - Field: 'local'
[15:32:20.718]   - Field: 'owner'
[15:32:20.719]   - Field: 'envir'
[15:32:20.719]   - Field: 'packages'
[15:32:20.719]   - Field: 'gc'
[15:32:20.719]   - Field: 'conditions'
[15:32:20.720]   - Field: 'expr'
[15:32:20.720]   - Field: 'uuid'
[15:32:20.720]   - Field: 'seed'
[15:32:20.721]   - Field: 'version'
[15:32:20.721]   - Field: 'result'
[15:32:20.721]   - Field: 'asynchronous'
[15:32:20.721]   - Field: 'calls'
[15:32:20.722]   - Field: 'globals'
[15:32:20.722]   - Field: 'stdout'
[15:32:20.722]   - Field: 'earlySignal'
[15:32:20.722]   - Field: 'lazy'
[15:32:20.722]   - Field: 'state'
[15:32:20.723] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:20.723] - Launch lazy future ...
[15:32:20.723] Packages needed by the future expression (n = 0): <none>
[15:32:20.723] Packages needed by future strategies (n = 0): <none>
[15:32:20.724] {
[15:32:20.724]     {
[15:32:20.724]         {
[15:32:20.724]             ...future.startTime <- base::Sys.time()
[15:32:20.724]             {
[15:32:20.724]                 {
[15:32:20.724]                   {
[15:32:20.724]                     base::local({
[15:32:20.724]                       has_future <- base::requireNamespace("future", 
[15:32:20.724]                         quietly = TRUE)
[15:32:20.724]                       if (has_future) {
[15:32:20.724]                         ns <- base::getNamespace("future")
[15:32:20.724]                         version <- ns[[".package"]][["version"]]
[15:32:20.724]                         if (is.null(version)) 
[15:32:20.724]                           version <- utils::packageVersion("future")
[15:32:20.724]                       }
[15:32:20.724]                       else {
[15:32:20.724]                         version <- NULL
[15:32:20.724]                       }
[15:32:20.724]                       if (!has_future || version < "1.8.0") {
[15:32:20.724]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:20.724]                           "", base::R.version$version.string), 
[15:32:20.724]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:20.724]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:20.724]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:20.724]                             "release", "version")], collapse = " "), 
[15:32:20.724]                           hostname = base::Sys.info()[["nodename"]])
[15:32:20.724]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:20.724]                           info)
[15:32:20.724]                         info <- base::paste(info, collapse = "; ")
[15:32:20.724]                         if (!has_future) {
[15:32:20.724]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:20.724]                             info)
[15:32:20.724]                         }
[15:32:20.724]                         else {
[15:32:20.724]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:20.724]                             info, version)
[15:32:20.724]                         }
[15:32:20.724]                         base::stop(msg)
[15:32:20.724]                       }
[15:32:20.724]                     })
[15:32:20.724]                   }
[15:32:20.724]                   ...future.strategy.old <- future::plan("list")
[15:32:20.724]                   options(future.plan = NULL)
[15:32:20.724]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:20.724]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:20.724]                 }
[15:32:20.724]                 ...future.workdir <- getwd()
[15:32:20.724]             }
[15:32:20.724]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:20.724]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:20.724]         }
[15:32:20.724]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:20.724]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:20.724]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:20.724]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:20.724]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:20.724]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:20.724]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:20.724]             base::names(...future.oldOptions))
[15:32:20.724]     }
[15:32:20.724]     if (FALSE) {
[15:32:20.724]     }
[15:32:20.724]     else {
[15:32:20.724]         if (TRUE) {
[15:32:20.724]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:20.724]                 open = "w")
[15:32:20.724]         }
[15:32:20.724]         else {
[15:32:20.724]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:20.724]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:20.724]         }
[15:32:20.724]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:20.724]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:20.724]             base::sink(type = "output", split = FALSE)
[15:32:20.724]             base::close(...future.stdout)
[15:32:20.724]         }, add = TRUE)
[15:32:20.724]     }
[15:32:20.724]     ...future.frame <- base::sys.nframe()
[15:32:20.724]     ...future.conditions <- base::list()
[15:32:20.724]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:20.724]     if (FALSE) {
[15:32:20.724]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:20.724]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:20.724]     }
[15:32:20.724]     ...future.result <- base::tryCatch({
[15:32:20.724]         base::withCallingHandlers({
[15:32:20.724]             ...future.value <- base::withVisible(base::local({
[15:32:20.724]                 do.call(function(...) {
[15:32:20.724]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:20.724]                   if (!identical(...future.globals.maxSize.org, 
[15:32:20.724]                     ...future.globals.maxSize)) {
[15:32:20.724]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:20.724]                     on.exit(options(oopts), add = TRUE)
[15:32:20.724]                   }
[15:32:20.724]                   {
[15:32:20.724]                     lapply(seq_along(...future.elements_ii), 
[15:32:20.724]                       FUN = function(jj) {
[15:32:20.724]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:20.724]                         ...future.FUN(...future.X_jj, ...)
[15:32:20.724]                       })
[15:32:20.724]                   }
[15:32:20.724]                 }, args = future.call.arguments)
[15:32:20.724]             }))
[15:32:20.724]             future::FutureResult(value = ...future.value$value, 
[15:32:20.724]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:20.724]                   ...future.rng), globalenv = if (FALSE) 
[15:32:20.724]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:20.724]                     ...future.globalenv.names))
[15:32:20.724]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:20.724]         }, condition = base::local({
[15:32:20.724]             c <- base::c
[15:32:20.724]             inherits <- base::inherits
[15:32:20.724]             invokeRestart <- base::invokeRestart
[15:32:20.724]             length <- base::length
[15:32:20.724]             list <- base::list
[15:32:20.724]             seq.int <- base::seq.int
[15:32:20.724]             signalCondition <- base::signalCondition
[15:32:20.724]             sys.calls <- base::sys.calls
[15:32:20.724]             `[[` <- base::`[[`
[15:32:20.724]             `+` <- base::`+`
[15:32:20.724]             `<<-` <- base::`<<-`
[15:32:20.724]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:20.724]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:20.724]                   3L)]
[15:32:20.724]             }
[15:32:20.724]             function(cond) {
[15:32:20.724]                 is_error <- inherits(cond, "error")
[15:32:20.724]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:20.724]                   NULL)
[15:32:20.724]                 if (is_error) {
[15:32:20.724]                   sessionInformation <- function() {
[15:32:20.724]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:20.724]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:20.724]                       search = base::search(), system = base::Sys.info())
[15:32:20.724]                   }
[15:32:20.724]                   ...future.conditions[[length(...future.conditions) + 
[15:32:20.724]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:20.724]                     cond$call), session = sessionInformation(), 
[15:32:20.724]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:20.724]                   signalCondition(cond)
[15:32:20.724]                 }
[15:32:20.724]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:20.724]                 "immediateCondition"))) {
[15:32:20.724]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:20.724]                   ...future.conditions[[length(...future.conditions) + 
[15:32:20.724]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:20.724]                   if (TRUE && !signal) {
[15:32:20.724]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:20.724]                     {
[15:32:20.724]                       inherits <- base::inherits
[15:32:20.724]                       invokeRestart <- base::invokeRestart
[15:32:20.724]                       is.null <- base::is.null
[15:32:20.724]                       muffled <- FALSE
[15:32:20.724]                       if (inherits(cond, "message")) {
[15:32:20.724]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:20.724]                         if (muffled) 
[15:32:20.724]                           invokeRestart("muffleMessage")
[15:32:20.724]                       }
[15:32:20.724]                       else if (inherits(cond, "warning")) {
[15:32:20.724]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:20.724]                         if (muffled) 
[15:32:20.724]                           invokeRestart("muffleWarning")
[15:32:20.724]                       }
[15:32:20.724]                       else if (inherits(cond, "condition")) {
[15:32:20.724]                         if (!is.null(pattern)) {
[15:32:20.724]                           computeRestarts <- base::computeRestarts
[15:32:20.724]                           grepl <- base::grepl
[15:32:20.724]                           restarts <- computeRestarts(cond)
[15:32:20.724]                           for (restart in restarts) {
[15:32:20.724]                             name <- restart$name
[15:32:20.724]                             if (is.null(name)) 
[15:32:20.724]                               next
[15:32:20.724]                             if (!grepl(pattern, name)) 
[15:32:20.724]                               next
[15:32:20.724]                             invokeRestart(restart)
[15:32:20.724]                             muffled <- TRUE
[15:32:20.724]                             break
[15:32:20.724]                           }
[15:32:20.724]                         }
[15:32:20.724]                       }
[15:32:20.724]                       invisible(muffled)
[15:32:20.724]                     }
[15:32:20.724]                     muffleCondition(cond, pattern = "^muffle")
[15:32:20.724]                   }
[15:32:20.724]                 }
[15:32:20.724]                 else {
[15:32:20.724]                   if (TRUE) {
[15:32:20.724]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:20.724]                     {
[15:32:20.724]                       inherits <- base::inherits
[15:32:20.724]                       invokeRestart <- base::invokeRestart
[15:32:20.724]                       is.null <- base::is.null
[15:32:20.724]                       muffled <- FALSE
[15:32:20.724]                       if (inherits(cond, "message")) {
[15:32:20.724]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:20.724]                         if (muffled) 
[15:32:20.724]                           invokeRestart("muffleMessage")
[15:32:20.724]                       }
[15:32:20.724]                       else if (inherits(cond, "warning")) {
[15:32:20.724]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:20.724]                         if (muffled) 
[15:32:20.724]                           invokeRestart("muffleWarning")
[15:32:20.724]                       }
[15:32:20.724]                       else if (inherits(cond, "condition")) {
[15:32:20.724]                         if (!is.null(pattern)) {
[15:32:20.724]                           computeRestarts <- base::computeRestarts
[15:32:20.724]                           grepl <- base::grepl
[15:32:20.724]                           restarts <- computeRestarts(cond)
[15:32:20.724]                           for (restart in restarts) {
[15:32:20.724]                             name <- restart$name
[15:32:20.724]                             if (is.null(name)) 
[15:32:20.724]                               next
[15:32:20.724]                             if (!grepl(pattern, name)) 
[15:32:20.724]                               next
[15:32:20.724]                             invokeRestart(restart)
[15:32:20.724]                             muffled <- TRUE
[15:32:20.724]                             break
[15:32:20.724]                           }
[15:32:20.724]                         }
[15:32:20.724]                       }
[15:32:20.724]                       invisible(muffled)
[15:32:20.724]                     }
[15:32:20.724]                     muffleCondition(cond, pattern = "^muffle")
[15:32:20.724]                   }
[15:32:20.724]                 }
[15:32:20.724]             }
[15:32:20.724]         }))
[15:32:20.724]     }, error = function(ex) {
[15:32:20.724]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:20.724]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:20.724]                 ...future.rng), started = ...future.startTime, 
[15:32:20.724]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:20.724]             version = "1.8"), class = "FutureResult")
[15:32:20.724]     }, finally = {
[15:32:20.724]         if (!identical(...future.workdir, getwd())) 
[15:32:20.724]             setwd(...future.workdir)
[15:32:20.724]         {
[15:32:20.724]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:20.724]                 ...future.oldOptions$nwarnings <- NULL
[15:32:20.724]             }
[15:32:20.724]             base::options(...future.oldOptions)
[15:32:20.724]             if (.Platform$OS.type == "windows") {
[15:32:20.724]                 old_names <- names(...future.oldEnvVars)
[15:32:20.724]                 envs <- base::Sys.getenv()
[15:32:20.724]                 names <- names(envs)
[15:32:20.724]                 common <- intersect(names, old_names)
[15:32:20.724]                 added <- setdiff(names, old_names)
[15:32:20.724]                 removed <- setdiff(old_names, names)
[15:32:20.724]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:20.724]                   envs[common]]
[15:32:20.724]                 NAMES <- toupper(changed)
[15:32:20.724]                 args <- list()
[15:32:20.724]                 for (kk in seq_along(NAMES)) {
[15:32:20.724]                   name <- changed[[kk]]
[15:32:20.724]                   NAME <- NAMES[[kk]]
[15:32:20.724]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:20.724]                     next
[15:32:20.724]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:20.724]                 }
[15:32:20.724]                 NAMES <- toupper(added)
[15:32:20.724]                 for (kk in seq_along(NAMES)) {
[15:32:20.724]                   name <- added[[kk]]
[15:32:20.724]                   NAME <- NAMES[[kk]]
[15:32:20.724]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:20.724]                     next
[15:32:20.724]                   args[[name]] <- ""
[15:32:20.724]                 }
[15:32:20.724]                 NAMES <- toupper(removed)
[15:32:20.724]                 for (kk in seq_along(NAMES)) {
[15:32:20.724]                   name <- removed[[kk]]
[15:32:20.724]                   NAME <- NAMES[[kk]]
[15:32:20.724]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:20.724]                     next
[15:32:20.724]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:20.724]                 }
[15:32:20.724]                 if (length(args) > 0) 
[15:32:20.724]                   base::do.call(base::Sys.setenv, args = args)
[15:32:20.724]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:20.724]             }
[15:32:20.724]             else {
[15:32:20.724]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:20.724]             }
[15:32:20.724]             {
[15:32:20.724]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:20.724]                   0L) {
[15:32:20.724]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:20.724]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:20.724]                   base::options(opts)
[15:32:20.724]                 }
[15:32:20.724]                 {
[15:32:20.724]                   {
[15:32:20.724]                     NULL
[15:32:20.724]                     RNGkind("Mersenne-Twister")
[15:32:20.724]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:20.724]                       inherits = FALSE)
[15:32:20.724]                   }
[15:32:20.724]                   options(future.plan = NULL)
[15:32:20.724]                   if (is.na(NA_character_)) 
[15:32:20.724]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:20.724]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:20.724]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:20.724]                     .init = FALSE)
[15:32:20.724]                 }
[15:32:20.724]             }
[15:32:20.724]         }
[15:32:20.724]     })
[15:32:20.724]     if (TRUE) {
[15:32:20.724]         base::sink(type = "output", split = FALSE)
[15:32:20.724]         if (TRUE) {
[15:32:20.724]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:20.724]         }
[15:32:20.724]         else {
[15:32:20.724]             ...future.result["stdout"] <- base::list(NULL)
[15:32:20.724]         }
[15:32:20.724]         base::close(...future.stdout)
[15:32:20.724]         ...future.stdout <- NULL
[15:32:20.724]     }
[15:32:20.724]     ...future.result$conditions <- ...future.conditions
[15:32:20.724]     ...future.result$finished <- base::Sys.time()
[15:32:20.724]     ...future.result
[15:32:20.724] }
[15:32:20.728] assign_globals() ...
[15:32:20.729] List of 5
[15:32:20.729]  $ ...future.FUN            :function (x, ...)  
[15:32:20.729]  $ future.call.arguments    : list()
[15:32:20.729]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:20.729]  $ ...future.elements_ii    :List of 3
[15:32:20.729]   ..$ a: num 1
[15:32:20.729]   ..$ b: num 2
[15:32:20.729]   ..$ c: num 3
[15:32:20.729]  $ ...future.seeds_ii       : NULL
[15:32:20.729]  $ ...future.globals.maxSize: NULL
[15:32:20.729]  - attr(*, "where")=List of 5
[15:32:20.729]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:20.729]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:20.729]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:20.729]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:20.729]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:20.729]  - attr(*, "resolved")= logi FALSE
[15:32:20.729]  - attr(*, "total_size")= num 1248
[15:32:20.729]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:20.729]  - attr(*, "already-done")= logi TRUE
[15:32:20.745] - copied '...future.FUN' to environment
[15:32:20.745] - copied 'future.call.arguments' to environment
[15:32:20.746] - copied '...future.elements_ii' to environment
[15:32:20.746] - copied '...future.seeds_ii' to environment
[15:32:20.746] - copied '...future.globals.maxSize' to environment
[15:32:20.747] assign_globals() ... done
[15:32:20.747] plan(): Setting new future strategy stack:
[15:32:20.748] List of future strategies:
[15:32:20.748] 1. sequential:
[15:32:20.748]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:20.748]    - tweaked: FALSE
[15:32:20.748]    - call: NULL
[15:32:20.749] plan(): nbrOfWorkers() = 1
[15:32:20.751] plan(): Setting new future strategy stack:
[15:32:20.751] List of future strategies:
[15:32:20.751] 1. sequential:
[15:32:20.751]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:20.751]    - tweaked: FALSE
[15:32:20.751]    - call: plan(strategy)
[15:32:20.752] plan(): nbrOfWorkers() = 1
[15:32:20.753] SequentialFuture started (and completed)
[15:32:20.753] - Launch lazy future ... done
[15:32:20.753] run() for 'SequentialFuture' ... done
[15:32:20.754] Created future:
[15:32:20.754] SequentialFuture:
[15:32:20.754] Label: 'future_sapply-1'
[15:32:20.754] Expression:
[15:32:20.754] {
[15:32:20.754]     do.call(function(...) {
[15:32:20.754]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:20.754]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:20.754]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:20.754]             on.exit(options(oopts), add = TRUE)
[15:32:20.754]         }
[15:32:20.754]         {
[15:32:20.754]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:20.754]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:20.754]                 ...future.FUN(...future.X_jj, ...)
[15:32:20.754]             })
[15:32:20.754]         }
[15:32:20.754]     }, args = future.call.arguments)
[15:32:20.754] }
[15:32:20.754] Lazy evaluation: FALSE
[15:32:20.754] Asynchronous evaluation: FALSE
[15:32:20.754] Local evaluation: TRUE
[15:32:20.754] Environment: R_GlobalEnv
[15:32:20.754] Capture standard output: TRUE
[15:32:20.754] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:20.754] Globals: 5 objects totaling 1.38 KiB (function '...future.FUN' of 1.22 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:20.754] Packages: <none>
[15:32:20.754] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:20.754] Resolved: TRUE
[15:32:20.754] Value: 672 bytes of class 'list'
[15:32:20.754] Early signaling: FALSE
[15:32:20.754] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:20.754] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:20.756] Chunk #1 of 1 ... DONE
[15:32:20.756] Launching 1 futures (chunks) ... DONE
[15:32:20.757] Resolving 1 futures (chunks) ...
[15:32:20.757] resolve() on list ...
[15:32:20.757]  recursive: 0
[15:32:20.757]  length: 1
[15:32:20.758] 
[15:32:20.758] resolved() for 'SequentialFuture' ...
[15:32:20.758] - state: 'finished'
[15:32:20.759] - run: TRUE
[15:32:20.759] - result: 'FutureResult'
[15:32:20.759] resolved() for 'SequentialFuture' ... done
[15:32:20.760] Future #1
[15:32:20.760] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:20.760] - nx: 1
[15:32:20.761] - relay: TRUE
[15:32:20.761] - stdout: TRUE
[15:32:20.761] - signal: TRUE
[15:32:20.761] - resignal: FALSE
[15:32:20.761] - force: TRUE
[15:32:20.761] - relayed: [n=1] FALSE
[15:32:20.762] - queued futures: [n=1] FALSE
[15:32:20.762]  - until=1
[15:32:20.762]  - relaying element #1
[15:32:20.762] - relayed: [n=1] TRUE
[15:32:20.763] - queued futures: [n=1] TRUE
[15:32:20.763] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:20.763]  length: 0 (resolved future 1)
[15:32:20.763] Relaying remaining futures
[15:32:20.763] signalConditionsASAP(NULL, pos=0) ...
[15:32:20.764] - nx: 1
[15:32:20.764] - relay: TRUE
[15:32:20.764] - stdout: TRUE
[15:32:20.764] - signal: TRUE
[15:32:20.764] - resignal: FALSE
[15:32:20.764] - force: TRUE
[15:32:20.765] - relayed: [n=1] TRUE
[15:32:20.765] - queued futures: [n=1] TRUE
 - flush all
[15:32:20.765] - relayed: [n=1] TRUE
[15:32:20.765] - queued futures: [n=1] TRUE
[15:32:20.765] signalConditionsASAP(NULL, pos=0) ... done
[15:32:20.766] resolve() on list ... DONE
[15:32:20.766]  - Number of value chunks collected: 1
[15:32:20.766] Resolving 1 futures (chunks) ... DONE
[15:32:20.766] Reducing values from 1 chunks ...
[15:32:20.766]  - Number of values collected after concatenation: 3
[15:32:20.767]  - Number of values expected: 3
[15:32:20.767] Reducing values from 1 chunks ... DONE
[15:32:20.767] future_lapply() ... DONE
List of 2
 $ y0: Named num [1:3] 1 2 3
  ..- attr(*, "names")= chr [1:3] "a" "b" "c"
 $ y1: Named num [1:3] 1 2 3
  ..- attr(*, "names")= chr [1:3] "a" "b" "c"
[15:32:20.770] future_lapply() ...
[15:32:20.772] Number of chunks: 1
[15:32:20.772] getGlobalsAndPackagesXApply() ...
[15:32:20.772]  - future.globals: TRUE
[15:32:20.772] getGlobalsAndPackages() ...
[15:32:20.773] Searching for globals...
[15:32:20.775] - globals found: [5] 'FUN', '*', ':', 'outer', 'rep'
[15:32:20.775] Searching for globals ... DONE
[15:32:20.776] Resolving globals: FALSE
[15:32:20.776] The total size of the 1 globals is 4.62 KiB (4728 bytes)
[15:32:20.777] The total size of the 1 globals exported for future expression ('FUN()') is 4.62 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.62 KiB of class 'function')
[15:32:20.777] - globals: [1] 'FUN'
[15:32:20.777] 
[15:32:20.778] getGlobalsAndPackages() ... DONE
[15:32:20.778]  - globals found/used: [n=1] 'FUN'
[15:32:20.778]  - needed namespaces: [n=0] 
[15:32:20.778] Finding globals ... DONE
[15:32:20.778]  - use_args: TRUE
[15:32:20.778]  - Getting '...' globals ...
[15:32:20.779] resolve() on list ...
[15:32:20.779]  recursive: 0
[15:32:20.779]  length: 1
[15:32:20.780]  elements: '...'
[15:32:20.780]  length: 0 (resolved future 1)
[15:32:20.780] resolve() on list ... DONE
[15:32:20.780]    - '...' content: [n=0] 
[15:32:20.783] List of 1
[15:32:20.783]  $ ...: list()
[15:32:20.783]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:20.783]  - attr(*, "where")=List of 1
[15:32:20.783]   ..$ ...:<environment: 0x00000276e1d5e680> 
[15:32:20.783]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:20.783]  - attr(*, "resolved")= logi TRUE
[15:32:20.783]  - attr(*, "total_size")= num NA
[15:32:20.788]  - Getting '...' globals ... DONE
[15:32:20.788] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:20.788] List of 2
[15:32:20.788]  $ ...future.FUN:function (x, y = 2 * 1:5)  
[15:32:20.788]  $ ...          : list()
[15:32:20.788]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:20.788]  - attr(*, "where")=List of 2
[15:32:20.788]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:20.788]   ..$ ...          :<environment: 0x00000276e1d5e680> 
[15:32:20.788]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:20.788]  - attr(*, "resolved")= logi FALSE
[15:32:20.788]  - attr(*, "total_size")= num 4728
[15:32:20.792] Packages to be attached in all futures: [n=0] 
[15:32:20.792] getGlobalsAndPackagesXApply() ... DONE
[15:32:20.793] Number of futures (= number of chunks): 1
[15:32:20.793] Launching 1 futures (chunks) ...
[15:32:20.793] Chunk #1 of 1 ...
[15:32:20.793]  - Finding globals in 'X' for chunk #1 ...
[15:32:20.794] getGlobalsAndPackages() ...
[15:32:20.794] Searching for globals...
[15:32:20.794] 
[15:32:20.794] Searching for globals ... DONE
[15:32:20.795] - globals: [0] <none>
[15:32:20.795] getGlobalsAndPackages() ... DONE
[15:32:20.795]    + additional globals found: [n=0] 
[15:32:20.795]    + additional namespaces needed: [n=0] 
[15:32:20.795]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:20.795]  - seeds: <none>
[15:32:20.796]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:20.796] getGlobalsAndPackages() ...
[15:32:20.796] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:20.797] Resolving globals: FALSE
[15:32:20.797] Tweak future expression to call with '...' arguments ...
[15:32:20.797] {
[15:32:20.797]     do.call(function(...) {
[15:32:20.797]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:20.797]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:20.797]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:20.797]             on.exit(options(oopts), add = TRUE)
[15:32:20.797]         }
[15:32:20.797]         {
[15:32:20.797]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:20.797]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:20.797]                 ...future.FUN(...future.X_jj, ...)
[15:32:20.797]             })
[15:32:20.797]         }
[15:32:20.797]     }, args = future.call.arguments)
[15:32:20.797] }
[15:32:20.798] Tweak future expression to call with '...' arguments ... DONE
[15:32:20.799] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:20.799] 
[15:32:20.800] getGlobalsAndPackages() ... DONE
[15:32:20.800] run() for 'Future' ...
[15:32:20.801] - state: 'created'
[15:32:20.801] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:20.802] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:20.802] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:20.803]   - Field: 'label'
[15:32:20.803]   - Field: 'local'
[15:32:20.803]   - Field: 'owner'
[15:32:20.804]   - Field: 'envir'
[15:32:20.804]   - Field: 'packages'
[15:32:20.805]   - Field: 'gc'
[15:32:20.805]   - Field: 'conditions'
[15:32:20.805]   - Field: 'expr'
[15:32:20.806]   - Field: 'uuid'
[15:32:20.806]   - Field: 'seed'
[15:32:20.806]   - Field: 'version'
[15:32:20.807]   - Field: 'result'
[15:32:20.807]   - Field: 'asynchronous'
[15:32:20.807]   - Field: 'calls'
[15:32:20.808]   - Field: 'globals'
[15:32:20.808]   - Field: 'stdout'
[15:32:20.808]   - Field: 'earlySignal'
[15:32:20.809]   - Field: 'lazy'
[15:32:20.809]   - Field: 'state'
[15:32:20.809] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:20.810] - Launch lazy future ...
[15:32:20.810] Packages needed by the future expression (n = 0): <none>
[15:32:20.811] Packages needed by future strategies (n = 0): <none>
[15:32:20.812] {
[15:32:20.812]     {
[15:32:20.812]         {
[15:32:20.812]             ...future.startTime <- base::Sys.time()
[15:32:20.812]             {
[15:32:20.812]                 {
[15:32:20.812]                   {
[15:32:20.812]                     base::local({
[15:32:20.812]                       has_future <- base::requireNamespace("future", 
[15:32:20.812]                         quietly = TRUE)
[15:32:20.812]                       if (has_future) {
[15:32:20.812]                         ns <- base::getNamespace("future")
[15:32:20.812]                         version <- ns[[".package"]][["version"]]
[15:32:20.812]                         if (is.null(version)) 
[15:32:20.812]                           version <- utils::packageVersion("future")
[15:32:20.812]                       }
[15:32:20.812]                       else {
[15:32:20.812]                         version <- NULL
[15:32:20.812]                       }
[15:32:20.812]                       if (!has_future || version < "1.8.0") {
[15:32:20.812]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:20.812]                           "", base::R.version$version.string), 
[15:32:20.812]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:20.812]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:20.812]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:20.812]                             "release", "version")], collapse = " "), 
[15:32:20.812]                           hostname = base::Sys.info()[["nodename"]])
[15:32:20.812]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:20.812]                           info)
[15:32:20.812]                         info <- base::paste(info, collapse = "; ")
[15:32:20.812]                         if (!has_future) {
[15:32:20.812]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:20.812]                             info)
[15:32:20.812]                         }
[15:32:20.812]                         else {
[15:32:20.812]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:20.812]                             info, version)
[15:32:20.812]                         }
[15:32:20.812]                         base::stop(msg)
[15:32:20.812]                       }
[15:32:20.812]                     })
[15:32:20.812]                   }
[15:32:20.812]                   ...future.strategy.old <- future::plan("list")
[15:32:20.812]                   options(future.plan = NULL)
[15:32:20.812]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:20.812]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:20.812]                 }
[15:32:20.812]                 ...future.workdir <- getwd()
[15:32:20.812]             }
[15:32:20.812]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:20.812]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:20.812]         }
[15:32:20.812]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:20.812]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:20.812]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:20.812]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:20.812]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:20.812]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:20.812]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:20.812]             base::names(...future.oldOptions))
[15:32:20.812]     }
[15:32:20.812]     if (FALSE) {
[15:32:20.812]     }
[15:32:20.812]     else {
[15:32:20.812]         if (TRUE) {
[15:32:20.812]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:20.812]                 open = "w")
[15:32:20.812]         }
[15:32:20.812]         else {
[15:32:20.812]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:20.812]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:20.812]         }
[15:32:20.812]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:20.812]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:20.812]             base::sink(type = "output", split = FALSE)
[15:32:20.812]             base::close(...future.stdout)
[15:32:20.812]         }, add = TRUE)
[15:32:20.812]     }
[15:32:20.812]     ...future.frame <- base::sys.nframe()
[15:32:20.812]     ...future.conditions <- base::list()
[15:32:20.812]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:20.812]     if (FALSE) {
[15:32:20.812]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:20.812]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:20.812]     }
[15:32:20.812]     ...future.result <- base::tryCatch({
[15:32:20.812]         base::withCallingHandlers({
[15:32:20.812]             ...future.value <- base::withVisible(base::local({
[15:32:20.812]                 do.call(function(...) {
[15:32:20.812]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:20.812]                   if (!identical(...future.globals.maxSize.org, 
[15:32:20.812]                     ...future.globals.maxSize)) {
[15:32:20.812]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:20.812]                     on.exit(options(oopts), add = TRUE)
[15:32:20.812]                   }
[15:32:20.812]                   {
[15:32:20.812]                     lapply(seq_along(...future.elements_ii), 
[15:32:20.812]                       FUN = function(jj) {
[15:32:20.812]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:20.812]                         ...future.FUN(...future.X_jj, ...)
[15:32:20.812]                       })
[15:32:20.812]                   }
[15:32:20.812]                 }, args = future.call.arguments)
[15:32:20.812]             }))
[15:32:20.812]             future::FutureResult(value = ...future.value$value, 
[15:32:20.812]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:20.812]                   ...future.rng), globalenv = if (FALSE) 
[15:32:20.812]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:20.812]                     ...future.globalenv.names))
[15:32:20.812]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:20.812]         }, condition = base::local({
[15:32:20.812]             c <- base::c
[15:32:20.812]             inherits <- base::inherits
[15:32:20.812]             invokeRestart <- base::invokeRestart
[15:32:20.812]             length <- base::length
[15:32:20.812]             list <- base::list
[15:32:20.812]             seq.int <- base::seq.int
[15:32:20.812]             signalCondition <- base::signalCondition
[15:32:20.812]             sys.calls <- base::sys.calls
[15:32:20.812]             `[[` <- base::`[[`
[15:32:20.812]             `+` <- base::`+`
[15:32:20.812]             `<<-` <- base::`<<-`
[15:32:20.812]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:20.812]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:20.812]                   3L)]
[15:32:20.812]             }
[15:32:20.812]             function(cond) {
[15:32:20.812]                 is_error <- inherits(cond, "error")
[15:32:20.812]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:20.812]                   NULL)
[15:32:20.812]                 if (is_error) {
[15:32:20.812]                   sessionInformation <- function() {
[15:32:20.812]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:20.812]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:20.812]                       search = base::search(), system = base::Sys.info())
[15:32:20.812]                   }
[15:32:20.812]                   ...future.conditions[[length(...future.conditions) + 
[15:32:20.812]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:20.812]                     cond$call), session = sessionInformation(), 
[15:32:20.812]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:20.812]                   signalCondition(cond)
[15:32:20.812]                 }
[15:32:20.812]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:20.812]                 "immediateCondition"))) {
[15:32:20.812]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:20.812]                   ...future.conditions[[length(...future.conditions) + 
[15:32:20.812]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:20.812]                   if (TRUE && !signal) {
[15:32:20.812]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:20.812]                     {
[15:32:20.812]                       inherits <- base::inherits
[15:32:20.812]                       invokeRestart <- base::invokeRestart
[15:32:20.812]                       is.null <- base::is.null
[15:32:20.812]                       muffled <- FALSE
[15:32:20.812]                       if (inherits(cond, "message")) {
[15:32:20.812]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:20.812]                         if (muffled) 
[15:32:20.812]                           invokeRestart("muffleMessage")
[15:32:20.812]                       }
[15:32:20.812]                       else if (inherits(cond, "warning")) {
[15:32:20.812]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:20.812]                         if (muffled) 
[15:32:20.812]                           invokeRestart("muffleWarning")
[15:32:20.812]                       }
[15:32:20.812]                       else if (inherits(cond, "condition")) {
[15:32:20.812]                         if (!is.null(pattern)) {
[15:32:20.812]                           computeRestarts <- base::computeRestarts
[15:32:20.812]                           grepl <- base::grepl
[15:32:20.812]                           restarts <- computeRestarts(cond)
[15:32:20.812]                           for (restart in restarts) {
[15:32:20.812]                             name <- restart$name
[15:32:20.812]                             if (is.null(name)) 
[15:32:20.812]                               next
[15:32:20.812]                             if (!grepl(pattern, name)) 
[15:32:20.812]                               next
[15:32:20.812]                             invokeRestart(restart)
[15:32:20.812]                             muffled <- TRUE
[15:32:20.812]                             break
[15:32:20.812]                           }
[15:32:20.812]                         }
[15:32:20.812]                       }
[15:32:20.812]                       invisible(muffled)
[15:32:20.812]                     }
[15:32:20.812]                     muffleCondition(cond, pattern = "^muffle")
[15:32:20.812]                   }
[15:32:20.812]                 }
[15:32:20.812]                 else {
[15:32:20.812]                   if (TRUE) {
[15:32:20.812]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:20.812]                     {
[15:32:20.812]                       inherits <- base::inherits
[15:32:20.812]                       invokeRestart <- base::invokeRestart
[15:32:20.812]                       is.null <- base::is.null
[15:32:20.812]                       muffled <- FALSE
[15:32:20.812]                       if (inherits(cond, "message")) {
[15:32:20.812]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:20.812]                         if (muffled) 
[15:32:20.812]                           invokeRestart("muffleMessage")
[15:32:20.812]                       }
[15:32:20.812]                       else if (inherits(cond, "warning")) {
[15:32:20.812]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:20.812]                         if (muffled) 
[15:32:20.812]                           invokeRestart("muffleWarning")
[15:32:20.812]                       }
[15:32:20.812]                       else if (inherits(cond, "condition")) {
[15:32:20.812]                         if (!is.null(pattern)) {
[15:32:20.812]                           computeRestarts <- base::computeRestarts
[15:32:20.812]                           grepl <- base::grepl
[15:32:20.812]                           restarts <- computeRestarts(cond)
[15:32:20.812]                           for (restart in restarts) {
[15:32:20.812]                             name <- restart$name
[15:32:20.812]                             if (is.null(name)) 
[15:32:20.812]                               next
[15:32:20.812]                             if (!grepl(pattern, name)) 
[15:32:20.812]                               next
[15:32:20.812]                             invokeRestart(restart)
[15:32:20.812]                             muffled <- TRUE
[15:32:20.812]                             break
[15:32:20.812]                           }
[15:32:20.812]                         }
[15:32:20.812]                       }
[15:32:20.812]                       invisible(muffled)
[15:32:20.812]                     }
[15:32:20.812]                     muffleCondition(cond, pattern = "^muffle")
[15:32:20.812]                   }
[15:32:20.812]                 }
[15:32:20.812]             }
[15:32:20.812]         }))
[15:32:20.812]     }, error = function(ex) {
[15:32:20.812]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:20.812]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:20.812]                 ...future.rng), started = ...future.startTime, 
[15:32:20.812]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:20.812]             version = "1.8"), class = "FutureResult")
[15:32:20.812]     }, finally = {
[15:32:20.812]         if (!identical(...future.workdir, getwd())) 
[15:32:20.812]             setwd(...future.workdir)
[15:32:20.812]         {
[15:32:20.812]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:20.812]                 ...future.oldOptions$nwarnings <- NULL
[15:32:20.812]             }
[15:32:20.812]             base::options(...future.oldOptions)
[15:32:20.812]             if (.Platform$OS.type == "windows") {
[15:32:20.812]                 old_names <- names(...future.oldEnvVars)
[15:32:20.812]                 envs <- base::Sys.getenv()
[15:32:20.812]                 names <- names(envs)
[15:32:20.812]                 common <- intersect(names, old_names)
[15:32:20.812]                 added <- setdiff(names, old_names)
[15:32:20.812]                 removed <- setdiff(old_names, names)
[15:32:20.812]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:20.812]                   envs[common]]
[15:32:20.812]                 NAMES <- toupper(changed)
[15:32:20.812]                 args <- list()
[15:32:20.812]                 for (kk in seq_along(NAMES)) {
[15:32:20.812]                   name <- changed[[kk]]
[15:32:20.812]                   NAME <- NAMES[[kk]]
[15:32:20.812]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:20.812]                     next
[15:32:20.812]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:20.812]                 }
[15:32:20.812]                 NAMES <- toupper(added)
[15:32:20.812]                 for (kk in seq_along(NAMES)) {
[15:32:20.812]                   name <- added[[kk]]
[15:32:20.812]                   NAME <- NAMES[[kk]]
[15:32:20.812]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:20.812]                     next
[15:32:20.812]                   args[[name]] <- ""
[15:32:20.812]                 }
[15:32:20.812]                 NAMES <- toupper(removed)
[15:32:20.812]                 for (kk in seq_along(NAMES)) {
[15:32:20.812]                   name <- removed[[kk]]
[15:32:20.812]                   NAME <- NAMES[[kk]]
[15:32:20.812]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:20.812]                     next
[15:32:20.812]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:20.812]                 }
[15:32:20.812]                 if (length(args) > 0) 
[15:32:20.812]                   base::do.call(base::Sys.setenv, args = args)
[15:32:20.812]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:20.812]             }
[15:32:20.812]             else {
[15:32:20.812]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:20.812]             }
[15:32:20.812]             {
[15:32:20.812]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:20.812]                   0L) {
[15:32:20.812]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:20.812]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:20.812]                   base::options(opts)
[15:32:20.812]                 }
[15:32:20.812]                 {
[15:32:20.812]                   {
[15:32:20.812]                     NULL
[15:32:20.812]                     RNGkind("Mersenne-Twister")
[15:32:20.812]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:20.812]                       inherits = FALSE)
[15:32:20.812]                   }
[15:32:20.812]                   options(future.plan = NULL)
[15:32:20.812]                   if (is.na(NA_character_)) 
[15:32:20.812]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:20.812]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:20.812]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:20.812]                     .init = FALSE)
[15:32:20.812]                 }
[15:32:20.812]             }
[15:32:20.812]         }
[15:32:20.812]     })
[15:32:20.812]     if (TRUE) {
[15:32:20.812]         base::sink(type = "output", split = FALSE)
[15:32:20.812]         if (TRUE) {
[15:32:20.812]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:20.812]         }
[15:32:20.812]         else {
[15:32:20.812]             ...future.result["stdout"] <- base::list(NULL)
[15:32:20.812]         }
[15:32:20.812]         base::close(...future.stdout)
[15:32:20.812]         ...future.stdout <- NULL
[15:32:20.812]     }
[15:32:20.812]     ...future.result$conditions <- ...future.conditions
[15:32:20.812]     ...future.result$finished <- base::Sys.time()
[15:32:20.812]     ...future.result
[15:32:20.812] }
[15:32:20.819] assign_globals() ...
[15:32:20.820] List of 5
[15:32:20.820]  $ ...future.FUN            :function (x, y = 2 * 1:5)  
[15:32:20.820]  $ future.call.arguments    : list()
[15:32:20.820]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:20.820]  $ ...future.elements_ii    :List of 3
[15:32:20.820]   ..$ a: num 1
[15:32:20.820]   ..$ b: num 2
[15:32:20.820]   ..$ c: num 3
[15:32:20.820]  $ ...future.seeds_ii       : NULL
[15:32:20.820]  $ ...future.globals.maxSize: NULL
[15:32:20.820]  - attr(*, "where")=List of 5
[15:32:20.820]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:20.820]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:20.820]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:20.820]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:20.820]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:20.820]  - attr(*, "resolved")= logi FALSE
[15:32:20.820]  - attr(*, "total_size")= num 4728
[15:32:20.820]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:20.820]  - attr(*, "already-done")= logi TRUE
[15:32:20.833] - reassign environment for '...future.FUN'
[15:32:20.833] - copied '...future.FUN' to environment
[15:32:20.833] - copied 'future.call.arguments' to environment
[15:32:20.833] - copied '...future.elements_ii' to environment
[15:32:20.833] - copied '...future.seeds_ii' to environment
[15:32:20.834] - copied '...future.globals.maxSize' to environment
[15:32:20.834] assign_globals() ... done
[15:32:20.834] plan(): Setting new future strategy stack:
[15:32:20.834] List of future strategies:
[15:32:20.834] 1. sequential:
[15:32:20.834]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:20.834]    - tweaked: FALSE
[15:32:20.834]    - call: NULL
[15:32:20.835] plan(): nbrOfWorkers() = 1
[15:32:20.837] plan(): Setting new future strategy stack:
[15:32:20.837] List of future strategies:
[15:32:20.837] 1. sequential:
[15:32:20.837]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:20.837]    - tweaked: FALSE
[15:32:20.837]    - call: plan(strategy)
[15:32:20.838] plan(): nbrOfWorkers() = 1
[15:32:20.838] SequentialFuture started (and completed)
[15:32:20.838] - Launch lazy future ... done
[15:32:20.839] run() for 'SequentialFuture' ... done
[15:32:20.839] Created future:
[15:32:20.839] SequentialFuture:
[15:32:20.839] Label: 'future_sapply-1'
[15:32:20.839] Expression:
[15:32:20.839] {
[15:32:20.839]     do.call(function(...) {
[15:32:20.839]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:20.839]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:20.839]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:20.839]             on.exit(options(oopts), add = TRUE)
[15:32:20.839]         }
[15:32:20.839]         {
[15:32:20.839]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:20.839]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:20.839]                 ...future.FUN(...future.X_jj, ...)
[15:32:20.839]             })
[15:32:20.839]         }
[15:32:20.839]     }, args = future.call.arguments)
[15:32:20.839] }
[15:32:20.839] Lazy evaluation: FALSE
[15:32:20.839] Asynchronous evaluation: FALSE
[15:32:20.839] Local evaluation: TRUE
[15:32:20.839] Environment: R_GlobalEnv
[15:32:20.839] Capture standard output: TRUE
[15:32:20.839] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:20.839] Globals: 5 objects totaling 4.78 KiB (function '...future.FUN' of 4.62 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:20.839] Packages: <none>
[15:32:20.839] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:20.839] Resolved: TRUE
[15:32:20.839] Value: 1.01 KiB of class 'list'
[15:32:20.839] Early signaling: FALSE
[15:32:20.839] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:20.839] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:20.841] Chunk #1 of 1 ... DONE
[15:32:20.841] Launching 1 futures (chunks) ... DONE
[15:32:20.841] Resolving 1 futures (chunks) ...
[15:32:20.841] resolve() on list ...
[15:32:20.842]  recursive: 0
[15:32:20.842]  length: 1
[15:32:20.842] 
[15:32:20.842] resolved() for 'SequentialFuture' ...
[15:32:20.842] - state: 'finished'
[15:32:20.843] - run: TRUE
[15:32:20.843] - result: 'FutureResult'
[15:32:20.843] resolved() for 'SequentialFuture' ... done
[15:32:20.843] Future #1
[15:32:20.844] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:20.844] - nx: 1
[15:32:20.844] - relay: TRUE
[15:32:20.844] - stdout: TRUE
[15:32:20.844] - signal: TRUE
[15:32:20.845] - resignal: FALSE
[15:32:20.845] - force: TRUE
[15:32:20.845] - relayed: [n=1] FALSE
[15:32:20.845] - queued futures: [n=1] FALSE
[15:32:20.845]  - until=1
[15:32:20.846]  - relaying element #1
[15:32:20.846] - relayed: [n=1] TRUE
[15:32:20.846] - queued futures: [n=1] TRUE
[15:32:20.846] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:20.846]  length: 0 (resolved future 1)
[15:32:20.847] Relaying remaining futures
[15:32:20.847] signalConditionsASAP(NULL, pos=0) ...
[15:32:20.847] - nx: 1
[15:32:20.847] - relay: TRUE
[15:32:20.847] - stdout: TRUE
[15:32:20.847] - signal: TRUE
[15:32:20.848] - resignal: FALSE
[15:32:20.848] - force: TRUE
[15:32:20.848] - relayed: [n=1] TRUE
[15:32:20.848] - queued futures: [n=1] TRUE
 - flush all
[15:32:20.848] - relayed: [n=1] TRUE
[15:32:20.849] - queued futures: [n=1] TRUE
[15:32:20.849] signalConditionsASAP(NULL, pos=0) ... done
[15:32:20.849] resolve() on list ... DONE
[15:32:20.849]  - Number of value chunks collected: 1
[15:32:20.849] Resolving 1 futures (chunks) ... DONE
[15:32:20.850] Reducing values from 1 chunks ...
[15:32:20.850]  - Number of values collected after concatenation: 3
[15:32:20.850]  - Number of values expected: 3
[15:32:20.850] Reducing values from 1 chunks ... DONE
[15:32:20.850] future_lapply() ... DONE
List of 2
 $ y0: num [1:3, 1:5, 1:3] 2 2 2 4 4 4 6 6 6 8 ...
  ..- attr(*, "dimnames")=List of 3
  .. ..$ : NULL
  .. ..$ : NULL
  .. ..$ : chr [1:3] "a" "b" "c"
 $ y1: num [1:3, 1:5, 1:3] 2 2 2 4 4 4 6 6 6 8 ...
  ..- attr(*, "dimnames")=List of 3
  .. ..$ : NULL
  .. ..$ : NULL
  .. ..$ : chr [1:3] "a" "b" "c"
[15:32:20.855] future_lapply() ...
[15:32:20.856] Number of chunks: 1
[15:32:20.856] getGlobalsAndPackagesXApply() ...
[15:32:20.856]  - future.globals: TRUE
[15:32:20.856] getGlobalsAndPackages() ...
[15:32:20.857] Searching for globals...
[15:32:20.858] - globals found: [1] 'FUN'
[15:32:20.858] Searching for globals ... DONE
[15:32:20.858] Resolving globals: FALSE
[15:32:20.859] The total size of the 1 globals is 848 bytes (848 bytes)
[15:32:20.860] The total size of the 1 globals exported for future expression ('FUN()') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:32:20.860] - globals: [1] 'FUN'
[15:32:20.860] 
[15:32:20.860] getGlobalsAndPackages() ... DONE
[15:32:20.860]  - globals found/used: [n=1] 'FUN'
[15:32:20.861]  - needed namespaces: [n=0] 
[15:32:20.861] Finding globals ... DONE
[15:32:20.861]  - use_args: TRUE
[15:32:20.864]  - Getting '...' globals ...
[15:32:20.865] resolve() on list ...
[15:32:20.865]  recursive: 0
[15:32:20.865]  length: 1
[15:32:20.865]  elements: '...'
[15:32:20.866]  length: 0 (resolved future 1)
[15:32:20.866] resolve() on list ... DONE
[15:32:20.866]    - '...' content: [n=0] 
[15:32:20.866] List of 1
[15:32:20.866]  $ ...: list()
[15:32:20.866]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:20.866]  - attr(*, "where")=List of 1
[15:32:20.866]   ..$ ...:<environment: 0x00000276e2349c38> 
[15:32:20.866]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:20.866]  - attr(*, "resolved")= logi TRUE
[15:32:20.866]  - attr(*, "total_size")= num NA
[15:32:20.870]  - Getting '...' globals ... DONE
[15:32:20.871] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:20.871] List of 2
[15:32:20.871]  $ ...future.FUN:function (x)  
[15:32:20.871]  $ ...          : list()
[15:32:20.871]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:20.871]  - attr(*, "where")=List of 2
[15:32:20.871]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:20.871]   ..$ ...          :<environment: 0x00000276e2349c38> 
[15:32:20.871]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:20.871]  - attr(*, "resolved")= logi FALSE
[15:32:20.871]  - attr(*, "total_size")= num 848
[15:32:20.875] Packages to be attached in all futures: [n=0] 
[15:32:20.875] getGlobalsAndPackagesXApply() ... DONE
[15:32:20.875] Number of futures (= number of chunks): 1
[15:32:20.875] Launching 1 futures (chunks) ...
[15:32:20.876] Chunk #1 of 1 ...
[15:32:20.876]  - Finding globals in 'X' for chunk #1 ...
[15:32:20.876] getGlobalsAndPackages() ...
[15:32:20.876] Searching for globals...
[15:32:20.877] 
[15:32:20.877] Searching for globals ... DONE
[15:32:20.877] - globals: [0] <none>
[15:32:20.877] getGlobalsAndPackages() ... DONE
[15:32:20.877]    + additional globals found: [n=0] 
[15:32:20.878]    + additional namespaces needed: [n=0] 
[15:32:20.878]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:20.878]  - seeds: <none>
[15:32:20.878]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:20.878] getGlobalsAndPackages() ...
[15:32:20.879] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:20.879] Resolving globals: FALSE
[15:32:20.879] Tweak future expression to call with '...' arguments ...
[15:32:20.879] {
[15:32:20.879]     do.call(function(...) {
[15:32:20.879]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:20.879]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:20.879]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:20.879]             on.exit(options(oopts), add = TRUE)
[15:32:20.879]         }
[15:32:20.879]         {
[15:32:20.879]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:20.879]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:20.879]                 ...future.FUN(...future.X_jj, ...)
[15:32:20.879]             })
[15:32:20.879]         }
[15:32:20.879]     }, args = future.call.arguments)
[15:32:20.879] }
[15:32:20.880] Tweak future expression to call with '...' arguments ... DONE
[15:32:20.880] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:20.881] 
[15:32:20.881] getGlobalsAndPackages() ... DONE
[15:32:20.881] run() for 'Future' ...
[15:32:20.882] - state: 'created'
[15:32:20.882] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:20.882] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:20.883] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:20.883]   - Field: 'label'
[15:32:20.883]   - Field: 'local'
[15:32:20.883]   - Field: 'owner'
[15:32:20.883]   - Field: 'envir'
[15:32:20.884]   - Field: 'packages'
[15:32:20.884]   - Field: 'gc'
[15:32:20.884]   - Field: 'conditions'
[15:32:20.884]   - Field: 'expr'
[15:32:20.884]   - Field: 'uuid'
[15:32:20.885]   - Field: 'seed'
[15:32:20.885]   - Field: 'version'
[15:32:20.885]   - Field: 'result'
[15:32:20.885]   - Field: 'asynchronous'
[15:32:20.885]   - Field: 'calls'
[15:32:20.886]   - Field: 'globals'
[15:32:20.886]   - Field: 'stdout'
[15:32:20.886]   - Field: 'earlySignal'
[15:32:20.886]   - Field: 'lazy'
[15:32:20.886]   - Field: 'state'
[15:32:20.886] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:20.887] - Launch lazy future ...
[15:32:20.887] Packages needed by the future expression (n = 0): <none>
[15:32:20.887] Packages needed by future strategies (n = 0): <none>
[15:32:20.888] {
[15:32:20.888]     {
[15:32:20.888]         {
[15:32:20.888]             ...future.startTime <- base::Sys.time()
[15:32:20.888]             {
[15:32:20.888]                 {
[15:32:20.888]                   {
[15:32:20.888]                     base::local({
[15:32:20.888]                       has_future <- base::requireNamespace("future", 
[15:32:20.888]                         quietly = TRUE)
[15:32:20.888]                       if (has_future) {
[15:32:20.888]                         ns <- base::getNamespace("future")
[15:32:20.888]                         version <- ns[[".package"]][["version"]]
[15:32:20.888]                         if (is.null(version)) 
[15:32:20.888]                           version <- utils::packageVersion("future")
[15:32:20.888]                       }
[15:32:20.888]                       else {
[15:32:20.888]                         version <- NULL
[15:32:20.888]                       }
[15:32:20.888]                       if (!has_future || version < "1.8.0") {
[15:32:20.888]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:20.888]                           "", base::R.version$version.string), 
[15:32:20.888]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:20.888]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:20.888]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:20.888]                             "release", "version")], collapse = " "), 
[15:32:20.888]                           hostname = base::Sys.info()[["nodename"]])
[15:32:20.888]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:20.888]                           info)
[15:32:20.888]                         info <- base::paste(info, collapse = "; ")
[15:32:20.888]                         if (!has_future) {
[15:32:20.888]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:20.888]                             info)
[15:32:20.888]                         }
[15:32:20.888]                         else {
[15:32:20.888]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:20.888]                             info, version)
[15:32:20.888]                         }
[15:32:20.888]                         base::stop(msg)
[15:32:20.888]                       }
[15:32:20.888]                     })
[15:32:20.888]                   }
[15:32:20.888]                   ...future.strategy.old <- future::plan("list")
[15:32:20.888]                   options(future.plan = NULL)
[15:32:20.888]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:20.888]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:20.888]                 }
[15:32:20.888]                 ...future.workdir <- getwd()
[15:32:20.888]             }
[15:32:20.888]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:20.888]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:20.888]         }
[15:32:20.888]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:20.888]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:20.888]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:20.888]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:20.888]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:20.888]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:20.888]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:20.888]             base::names(...future.oldOptions))
[15:32:20.888]     }
[15:32:20.888]     if (FALSE) {
[15:32:20.888]     }
[15:32:20.888]     else {
[15:32:20.888]         if (TRUE) {
[15:32:20.888]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:20.888]                 open = "w")
[15:32:20.888]         }
[15:32:20.888]         else {
[15:32:20.888]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:20.888]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:20.888]         }
[15:32:20.888]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:20.888]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:20.888]             base::sink(type = "output", split = FALSE)
[15:32:20.888]             base::close(...future.stdout)
[15:32:20.888]         }, add = TRUE)
[15:32:20.888]     }
[15:32:20.888]     ...future.frame <- base::sys.nframe()
[15:32:20.888]     ...future.conditions <- base::list()
[15:32:20.888]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:20.888]     if (FALSE) {
[15:32:20.888]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:20.888]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:20.888]     }
[15:32:20.888]     ...future.result <- base::tryCatch({
[15:32:20.888]         base::withCallingHandlers({
[15:32:20.888]             ...future.value <- base::withVisible(base::local({
[15:32:20.888]                 do.call(function(...) {
[15:32:20.888]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:20.888]                   if (!identical(...future.globals.maxSize.org, 
[15:32:20.888]                     ...future.globals.maxSize)) {
[15:32:20.888]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:20.888]                     on.exit(options(oopts), add = TRUE)
[15:32:20.888]                   }
[15:32:20.888]                   {
[15:32:20.888]                     lapply(seq_along(...future.elements_ii), 
[15:32:20.888]                       FUN = function(jj) {
[15:32:20.888]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:20.888]                         ...future.FUN(...future.X_jj, ...)
[15:32:20.888]                       })
[15:32:20.888]                   }
[15:32:20.888]                 }, args = future.call.arguments)
[15:32:20.888]             }))
[15:32:20.888]             future::FutureResult(value = ...future.value$value, 
[15:32:20.888]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:20.888]                   ...future.rng), globalenv = if (FALSE) 
[15:32:20.888]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:20.888]                     ...future.globalenv.names))
[15:32:20.888]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:20.888]         }, condition = base::local({
[15:32:20.888]             c <- base::c
[15:32:20.888]             inherits <- base::inherits
[15:32:20.888]             invokeRestart <- base::invokeRestart
[15:32:20.888]             length <- base::length
[15:32:20.888]             list <- base::list
[15:32:20.888]             seq.int <- base::seq.int
[15:32:20.888]             signalCondition <- base::signalCondition
[15:32:20.888]             sys.calls <- base::sys.calls
[15:32:20.888]             `[[` <- base::`[[`
[15:32:20.888]             `+` <- base::`+`
[15:32:20.888]             `<<-` <- base::`<<-`
[15:32:20.888]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:20.888]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:20.888]                   3L)]
[15:32:20.888]             }
[15:32:20.888]             function(cond) {
[15:32:20.888]                 is_error <- inherits(cond, "error")
[15:32:20.888]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:20.888]                   NULL)
[15:32:20.888]                 if (is_error) {
[15:32:20.888]                   sessionInformation <- function() {
[15:32:20.888]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:20.888]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:20.888]                       search = base::search(), system = base::Sys.info())
[15:32:20.888]                   }
[15:32:20.888]                   ...future.conditions[[length(...future.conditions) + 
[15:32:20.888]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:20.888]                     cond$call), session = sessionInformation(), 
[15:32:20.888]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:20.888]                   signalCondition(cond)
[15:32:20.888]                 }
[15:32:20.888]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:20.888]                 "immediateCondition"))) {
[15:32:20.888]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:20.888]                   ...future.conditions[[length(...future.conditions) + 
[15:32:20.888]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:20.888]                   if (TRUE && !signal) {
[15:32:20.888]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:20.888]                     {
[15:32:20.888]                       inherits <- base::inherits
[15:32:20.888]                       invokeRestart <- base::invokeRestart
[15:32:20.888]                       is.null <- base::is.null
[15:32:20.888]                       muffled <- FALSE
[15:32:20.888]                       if (inherits(cond, "message")) {
[15:32:20.888]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:20.888]                         if (muffled) 
[15:32:20.888]                           invokeRestart("muffleMessage")
[15:32:20.888]                       }
[15:32:20.888]                       else if (inherits(cond, "warning")) {
[15:32:20.888]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:20.888]                         if (muffled) 
[15:32:20.888]                           invokeRestart("muffleWarning")
[15:32:20.888]                       }
[15:32:20.888]                       else if (inherits(cond, "condition")) {
[15:32:20.888]                         if (!is.null(pattern)) {
[15:32:20.888]                           computeRestarts <- base::computeRestarts
[15:32:20.888]                           grepl <- base::grepl
[15:32:20.888]                           restarts <- computeRestarts(cond)
[15:32:20.888]                           for (restart in restarts) {
[15:32:20.888]                             name <- restart$name
[15:32:20.888]                             if (is.null(name)) 
[15:32:20.888]                               next
[15:32:20.888]                             if (!grepl(pattern, name)) 
[15:32:20.888]                               next
[15:32:20.888]                             invokeRestart(restart)
[15:32:20.888]                             muffled <- TRUE
[15:32:20.888]                             break
[15:32:20.888]                           }
[15:32:20.888]                         }
[15:32:20.888]                       }
[15:32:20.888]                       invisible(muffled)
[15:32:20.888]                     }
[15:32:20.888]                     muffleCondition(cond, pattern = "^muffle")
[15:32:20.888]                   }
[15:32:20.888]                 }
[15:32:20.888]                 else {
[15:32:20.888]                   if (TRUE) {
[15:32:20.888]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:20.888]                     {
[15:32:20.888]                       inherits <- base::inherits
[15:32:20.888]                       invokeRestart <- base::invokeRestart
[15:32:20.888]                       is.null <- base::is.null
[15:32:20.888]                       muffled <- FALSE
[15:32:20.888]                       if (inherits(cond, "message")) {
[15:32:20.888]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:20.888]                         if (muffled) 
[15:32:20.888]                           invokeRestart("muffleMessage")
[15:32:20.888]                       }
[15:32:20.888]                       else if (inherits(cond, "warning")) {
[15:32:20.888]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:20.888]                         if (muffled) 
[15:32:20.888]                           invokeRestart("muffleWarning")
[15:32:20.888]                       }
[15:32:20.888]                       else if (inherits(cond, "condition")) {
[15:32:20.888]                         if (!is.null(pattern)) {
[15:32:20.888]                           computeRestarts <- base::computeRestarts
[15:32:20.888]                           grepl <- base::grepl
[15:32:20.888]                           restarts <- computeRestarts(cond)
[15:32:20.888]                           for (restart in restarts) {
[15:32:20.888]                             name <- restart$name
[15:32:20.888]                             if (is.null(name)) 
[15:32:20.888]                               next
[15:32:20.888]                             if (!grepl(pattern, name)) 
[15:32:20.888]                               next
[15:32:20.888]                             invokeRestart(restart)
[15:32:20.888]                             muffled <- TRUE
[15:32:20.888]                             break
[15:32:20.888]                           }
[15:32:20.888]                         }
[15:32:20.888]                       }
[15:32:20.888]                       invisible(muffled)
[15:32:20.888]                     }
[15:32:20.888]                     muffleCondition(cond, pattern = "^muffle")
[15:32:20.888]                   }
[15:32:20.888]                 }
[15:32:20.888]             }
[15:32:20.888]         }))
[15:32:20.888]     }, error = function(ex) {
[15:32:20.888]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:20.888]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:20.888]                 ...future.rng), started = ...future.startTime, 
[15:32:20.888]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:20.888]             version = "1.8"), class = "FutureResult")
[15:32:20.888]     }, finally = {
[15:32:20.888]         if (!identical(...future.workdir, getwd())) 
[15:32:20.888]             setwd(...future.workdir)
[15:32:20.888]         {
[15:32:20.888]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:20.888]                 ...future.oldOptions$nwarnings <- NULL
[15:32:20.888]             }
[15:32:20.888]             base::options(...future.oldOptions)
[15:32:20.888]             if (.Platform$OS.type == "windows") {
[15:32:20.888]                 old_names <- names(...future.oldEnvVars)
[15:32:20.888]                 envs <- base::Sys.getenv()
[15:32:20.888]                 names <- names(envs)
[15:32:20.888]                 common <- intersect(names, old_names)
[15:32:20.888]                 added <- setdiff(names, old_names)
[15:32:20.888]                 removed <- setdiff(old_names, names)
[15:32:20.888]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:20.888]                   envs[common]]
[15:32:20.888]                 NAMES <- toupper(changed)
[15:32:20.888]                 args <- list()
[15:32:20.888]                 for (kk in seq_along(NAMES)) {
[15:32:20.888]                   name <- changed[[kk]]
[15:32:20.888]                   NAME <- NAMES[[kk]]
[15:32:20.888]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:20.888]                     next
[15:32:20.888]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:20.888]                 }
[15:32:20.888]                 NAMES <- toupper(added)
[15:32:20.888]                 for (kk in seq_along(NAMES)) {
[15:32:20.888]                   name <- added[[kk]]
[15:32:20.888]                   NAME <- NAMES[[kk]]
[15:32:20.888]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:20.888]                     next
[15:32:20.888]                   args[[name]] <- ""
[15:32:20.888]                 }
[15:32:20.888]                 NAMES <- toupper(removed)
[15:32:20.888]                 for (kk in seq_along(NAMES)) {
[15:32:20.888]                   name <- removed[[kk]]
[15:32:20.888]                   NAME <- NAMES[[kk]]
[15:32:20.888]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:20.888]                     next
[15:32:20.888]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:20.888]                 }
[15:32:20.888]                 if (length(args) > 0) 
[15:32:20.888]                   base::do.call(base::Sys.setenv, args = args)
[15:32:20.888]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:20.888]             }
[15:32:20.888]             else {
[15:32:20.888]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:20.888]             }
[15:32:20.888]             {
[15:32:20.888]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:20.888]                   0L) {
[15:32:20.888]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:20.888]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:20.888]                   base::options(opts)
[15:32:20.888]                 }
[15:32:20.888]                 {
[15:32:20.888]                   {
[15:32:20.888]                     NULL
[15:32:20.888]                     RNGkind("Mersenne-Twister")
[15:32:20.888]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:20.888]                       inherits = FALSE)
[15:32:20.888]                   }
[15:32:20.888]                   options(future.plan = NULL)
[15:32:20.888]                   if (is.na(NA_character_)) 
[15:32:20.888]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:20.888]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:20.888]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:20.888]                     .init = FALSE)
[15:32:20.888]                 }
[15:32:20.888]             }
[15:32:20.888]         }
[15:32:20.888]     })
[15:32:20.888]     if (TRUE) {
[15:32:20.888]         base::sink(type = "output", split = FALSE)
[15:32:20.888]         if (TRUE) {
[15:32:20.888]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:20.888]         }
[15:32:20.888]         else {
[15:32:20.888]             ...future.result["stdout"] <- base::list(NULL)
[15:32:20.888]         }
[15:32:20.888]         base::close(...future.stdout)
[15:32:20.888]         ...future.stdout <- NULL
[15:32:20.888]     }
[15:32:20.888]     ...future.result$conditions <- ...future.conditions
[15:32:20.888]     ...future.result$finished <- base::Sys.time()
[15:32:20.888]     ...future.result
[15:32:20.888] }
[15:32:20.892] assign_globals() ...
[15:32:20.893] List of 5
[15:32:20.893]  $ ...future.FUN            :function (x)  
[15:32:20.893]  $ future.call.arguments    : list()
[15:32:20.893]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:20.893]  $ ...future.elements_ii    :List of 6
[15:32:20.893]   ..$ a1: int 1
[15:32:20.893]   ..$ a2: int 2
[15:32:20.893]   ..$ b1: int 2
[15:32:20.893]   ..$ b2: int 3
[15:32:20.893]   ..$ c1: int 3
[15:32:20.893]   ..$ c2: int 4
[15:32:20.893]  $ ...future.seeds_ii       : NULL
[15:32:20.893]  $ ...future.globals.maxSize: NULL
[15:32:20.893]  - attr(*, "where")=List of 5
[15:32:20.893]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:20.893]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:20.893]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:20.893]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:20.893]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:20.893]  - attr(*, "resolved")= logi FALSE
[15:32:20.893]  - attr(*, "total_size")= num 848
[15:32:20.893]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:20.893]  - attr(*, "already-done")= logi TRUE
[15:32:20.906] - copied '...future.FUN' to environment
[15:32:20.906] - copied 'future.call.arguments' to environment
[15:32:20.907] - copied '...future.elements_ii' to environment
[15:32:20.907] - copied '...future.seeds_ii' to environment
[15:32:20.907] - copied '...future.globals.maxSize' to environment
[15:32:20.907] assign_globals() ... done
[15:32:20.908] plan(): Setting new future strategy stack:
[15:32:20.909] List of future strategies:
[15:32:20.909] 1. sequential:
[15:32:20.909]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:20.909]    - tweaked: FALSE
[15:32:20.909]    - call: NULL
[15:32:20.910] plan(): nbrOfWorkers() = 1
[15:32:20.912] plan(): Setting new future strategy stack:
[15:32:20.912] List of future strategies:
[15:32:20.912] 1. sequential:
[15:32:20.912]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:20.912]    - tweaked: FALSE
[15:32:20.912]    - call: plan(strategy)
[15:32:20.914] plan(): nbrOfWorkers() = 1
[15:32:20.914] SequentialFuture started (and completed)
[15:32:20.915] - Launch lazy future ... done
[15:32:20.915] run() for 'SequentialFuture' ... done
[15:32:20.915] Created future:
[15:32:20.916] SequentialFuture:
[15:32:20.916] Label: 'future_sapply-1'
[15:32:20.916] Expression:
[15:32:20.916] {
[15:32:20.916]     do.call(function(...) {
[15:32:20.916]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:20.916]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:20.916]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:20.916]             on.exit(options(oopts), add = TRUE)
[15:32:20.916]         }
[15:32:20.916]         {
[15:32:20.916]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:20.916]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:20.916]                 ...future.FUN(...future.X_jj, ...)
[15:32:20.916]             })
[15:32:20.916]         }
[15:32:20.916]     }, args = future.call.arguments)
[15:32:20.916] }
[15:32:20.916] Lazy evaluation: FALSE
[15:32:20.916] Asynchronous evaluation: FALSE
[15:32:20.916] Local evaluation: TRUE
[15:32:20.916] Environment: R_GlobalEnv
[15:32:20.916] Capture standard output: TRUE
[15:32:20.916] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:20.916] Globals: 5 objects totaling 1.16 KiB (function '...future.FUN' of 848 bytes, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 336 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:20.916] Packages: <none>
[15:32:20.916] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:20.916] Resolved: TRUE
[15:32:20.916] Value: 336 bytes of class 'list'
[15:32:20.916] Early signaling: FALSE
[15:32:20.916] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:20.916] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:20.918] Chunk #1 of 1 ... DONE
[15:32:20.919] Launching 1 futures (chunks) ... DONE
[15:32:20.919] Resolving 1 futures (chunks) ...
[15:32:20.919] resolve() on list ...
[15:32:20.920]  recursive: 0
[15:32:20.920]  length: 1
[15:32:20.920] 
[15:32:20.920] resolved() for 'SequentialFuture' ...
[15:32:20.921] - state: 'finished'
[15:32:20.921] - run: TRUE
[15:32:20.922] - result: 'FutureResult'
[15:32:20.922] resolved() for 'SequentialFuture' ... done
[15:32:20.922] Future #1
[15:32:20.923] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:20.923] - nx: 1
[15:32:20.924] - relay: TRUE
[15:32:20.924] - stdout: TRUE
[15:32:20.924] - signal: TRUE
[15:32:20.924] - resignal: FALSE
[15:32:20.925] - force: TRUE
[15:32:20.925] - relayed: [n=1] FALSE
[15:32:20.925] - queued futures: [n=1] FALSE
[15:32:20.926]  - until=1
[15:32:20.926]  - relaying element #1
[15:32:20.927] - relayed: [n=1] TRUE
[15:32:20.927] - queued futures: [n=1] TRUE
[15:32:20.927] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:20.928]  length: 0 (resolved future 1)
[15:32:20.928] Relaying remaining futures
[15:32:20.928] signalConditionsASAP(NULL, pos=0) ...
[15:32:20.929] - nx: 1
[15:32:20.929] - relay: TRUE
[15:32:20.929] - stdout: TRUE
[15:32:20.929] - signal: TRUE
[15:32:20.930] - resignal: FALSE
[15:32:20.930] - force: TRUE
[15:32:20.930] - relayed: [n=1] TRUE
[15:32:20.931] - queued futures: [n=1] TRUE
 - flush all
[15:32:20.931] - relayed: [n=1] TRUE
[15:32:20.931] - queued futures: [n=1] TRUE
[15:32:20.932] signalConditionsASAP(NULL, pos=0) ... done
[15:32:20.932] resolve() on list ... DONE
[15:32:20.933]  - Number of value chunks collected: 1
[15:32:20.933] Resolving 1 futures (chunks) ... DONE
[15:32:20.933] Reducing values from 1 chunks ...
[15:32:20.933]  - Number of values collected after concatenation: 6
[15:32:20.934]  - Number of values expected: 6
[15:32:20.934] Reducing values from 1 chunks ... DONE
[15:32:20.934] future_lapply() ... DONE
List of 2
 $ y0:List of 6
  ..$ a1: int 1
  ..$ a2: int 2
  ..$ b1: int 2
  ..$ b2: int 3
  ..$ c1: int 3
  ..$ c2: int 4
 $ y1:List of 6
  ..$ a1: int 1
  ..$ a2: int 2
  ..$ b1: int 2
  ..$ b2: int 3
  ..$ c1: int 3
  ..$ c2: int 4
List of 2
 $ y0:List of 6
  ..$ a1: int 1
  ..$ a2: int 2
  ..$ b1: int 2
  ..$ b2: int 3
  ..$ c1: int 3
  ..$ c2: int 4
 $ y2:List of 6
  ..$ a1: int 1
  ..$ a2: int 2
  ..$ b1: int 2
  ..$ b2: int 3
  ..$ c1: int 3
  ..$ c2: int 4
[15:32:20.964] future_lapply() ...
[15:32:20.966] Number of chunks: 1
[15:32:20.966] getGlobalsAndPackagesXApply() ...
[15:32:20.966]  - future.globals: TRUE
[15:32:20.967] getGlobalsAndPackages() ...
[15:32:20.967] Searching for globals...
[15:32:20.969] - globals found: [2] 'FUN', 'UseMethod'
[15:32:20.970] Searching for globals ... DONE
[15:32:20.970] Resolving globals: FALSE
[15:32:20.971] The total size of the 1 globals is 1.22 KiB (1248 bytes)
[15:32:20.972] The total size of the 1 globals exported for future expression ('FUN()') is 1.22 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.22 KiB of class 'function')
[15:32:20.972] - globals: [1] 'FUN'
[15:32:20.973] 
[15:32:20.973] getGlobalsAndPackages() ... DONE
[15:32:20.973]  - globals found/used: [n=1] 'FUN'
[15:32:20.973]  - needed namespaces: [n=0] 
[15:32:20.974] Finding globals ... DONE
[15:32:20.974]  - use_args: TRUE
[15:32:20.974]  - Getting '...' globals ...
[15:32:20.975] resolve() on list ...
[15:32:20.976]  recursive: 0
[15:32:20.976]  length: 1
[15:32:20.976]  elements: '...'
[15:32:20.977]  length: 0 (resolved future 1)
[15:32:20.977] resolve() on list ... DONE
[15:32:20.977]    - '...' content: [n=0] 
[15:32:20.977] List of 1
[15:32:20.977]  $ ...: list()
[15:32:20.977]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:20.977]  - attr(*, "where")=List of 1
[15:32:20.977]   ..$ ...:<environment: 0x00000276dee363b0> 
[15:32:20.977]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:20.977]  - attr(*, "resolved")= logi TRUE
[15:32:20.977]  - attr(*, "total_size")= num NA
[15:32:20.983]  - Getting '...' globals ... DONE
[15:32:20.984] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:20.984] List of 2
[15:32:20.984]  $ ...future.FUN:function (x, ...)  
[15:32:20.984]  $ ...          : list()
[15:32:20.984]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:20.984]  - attr(*, "where")=List of 2
[15:32:20.984]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:20.984]   ..$ ...          :<environment: 0x00000276dee363b0> 
[15:32:20.984]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:20.984]  - attr(*, "resolved")= logi FALSE
[15:32:20.984]  - attr(*, "total_size")= num 1248
[15:32:20.990] Packages to be attached in all futures: [n=0] 
[15:32:20.991] getGlobalsAndPackagesXApply() ... DONE
[15:32:20.991] Number of futures (= number of chunks): 1
[15:32:20.992] Launching 1 futures (chunks) ...
[15:32:20.992] Chunk #1 of 1 ...
[15:32:20.992]  - Finding globals in 'X' for chunk #1 ...
[15:32:20.993] getGlobalsAndPackages() ...
[15:32:20.993] Searching for globals...
[15:32:20.994] 
[15:32:20.994] Searching for globals ... DONE
[15:32:20.994] - globals: [0] <none>
[15:32:20.994] getGlobalsAndPackages() ... DONE
[15:32:20.995]    + additional globals found: [n=0] 
[15:32:20.995]    + additional namespaces needed: [n=0] 
[15:32:20.995]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:20.996]  - seeds: <none>
[15:32:20.996]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:20.996] getGlobalsAndPackages() ...
[15:32:20.997] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:20.997] Resolving globals: FALSE
[15:32:21.002] Tweak future expression to call with '...' arguments ...
[15:32:21.002] {
[15:32:21.002]     do.call(function(...) {
[15:32:21.002]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:21.002]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:21.002]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:21.002]             on.exit(options(oopts), add = TRUE)
[15:32:21.002]         }
[15:32:21.002]         {
[15:32:21.002]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:21.002]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:21.002]                 ...future.FUN(...future.X_jj, ...)
[15:32:21.002]             })
[15:32:21.002]         }
[15:32:21.002]     }, args = future.call.arguments)
[15:32:21.002] }
[15:32:21.003] Tweak future expression to call with '...' arguments ... DONE
[15:32:21.004] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:21.005] 
[15:32:21.005] getGlobalsAndPackages() ... DONE
[15:32:21.006] run() for 'Future' ...
[15:32:21.007] - state: 'created'
[15:32:21.007] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:21.008] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:21.009] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:21.009]   - Field: 'label'
[15:32:21.009]   - Field: 'local'
[15:32:21.010]   - Field: 'owner'
[15:32:21.010]   - Field: 'envir'
[15:32:21.011]   - Field: 'packages'
[15:32:21.011]   - Field: 'gc'
[15:32:21.011]   - Field: 'conditions'
[15:32:21.012]   - Field: 'expr'
[15:32:21.012]   - Field: 'uuid'
[15:32:21.013]   - Field: 'seed'
[15:32:21.013]   - Field: 'version'
[15:32:21.014]   - Field: 'result'
[15:32:21.014]   - Field: 'asynchronous'
[15:32:21.014]   - Field: 'calls'
[15:32:21.015]   - Field: 'globals'
[15:32:21.015]   - Field: 'stdout'
[15:32:21.016]   - Field: 'earlySignal'
[15:32:21.016]   - Field: 'lazy'
[15:32:21.016]   - Field: 'state'
[15:32:21.017] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:21.017] - Launch lazy future ...
[15:32:21.018] Packages needed by the future expression (n = 0): <none>
[15:32:21.018] Packages needed by future strategies (n = 0): <none>
[15:32:21.019] {
[15:32:21.019]     {
[15:32:21.019]         {
[15:32:21.019]             ...future.startTime <- base::Sys.time()
[15:32:21.019]             {
[15:32:21.019]                 {
[15:32:21.019]                   {
[15:32:21.019]                     base::local({
[15:32:21.019]                       has_future <- base::requireNamespace("future", 
[15:32:21.019]                         quietly = TRUE)
[15:32:21.019]                       if (has_future) {
[15:32:21.019]                         ns <- base::getNamespace("future")
[15:32:21.019]                         version <- ns[[".package"]][["version"]]
[15:32:21.019]                         if (is.null(version)) 
[15:32:21.019]                           version <- utils::packageVersion("future")
[15:32:21.019]                       }
[15:32:21.019]                       else {
[15:32:21.019]                         version <- NULL
[15:32:21.019]                       }
[15:32:21.019]                       if (!has_future || version < "1.8.0") {
[15:32:21.019]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:21.019]                           "", base::R.version$version.string), 
[15:32:21.019]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:21.019]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:21.019]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:21.019]                             "release", "version")], collapse = " "), 
[15:32:21.019]                           hostname = base::Sys.info()[["nodename"]])
[15:32:21.019]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:21.019]                           info)
[15:32:21.019]                         info <- base::paste(info, collapse = "; ")
[15:32:21.019]                         if (!has_future) {
[15:32:21.019]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:21.019]                             info)
[15:32:21.019]                         }
[15:32:21.019]                         else {
[15:32:21.019]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:21.019]                             info, version)
[15:32:21.019]                         }
[15:32:21.019]                         base::stop(msg)
[15:32:21.019]                       }
[15:32:21.019]                     })
[15:32:21.019]                   }
[15:32:21.019]                   ...future.strategy.old <- future::plan("list")
[15:32:21.019]                   options(future.plan = NULL)
[15:32:21.019]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:21.019]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:21.019]                 }
[15:32:21.019]                 ...future.workdir <- getwd()
[15:32:21.019]             }
[15:32:21.019]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:21.019]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:21.019]         }
[15:32:21.019]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:21.019]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:21.019]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:21.019]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:21.019]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:21.019]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:21.019]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:21.019]             base::names(...future.oldOptions))
[15:32:21.019]     }
[15:32:21.019]     if (FALSE) {
[15:32:21.019]     }
[15:32:21.019]     else {
[15:32:21.019]         if (TRUE) {
[15:32:21.019]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:21.019]                 open = "w")
[15:32:21.019]         }
[15:32:21.019]         else {
[15:32:21.019]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:21.019]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:21.019]         }
[15:32:21.019]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:21.019]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:21.019]             base::sink(type = "output", split = FALSE)
[15:32:21.019]             base::close(...future.stdout)
[15:32:21.019]         }, add = TRUE)
[15:32:21.019]     }
[15:32:21.019]     ...future.frame <- base::sys.nframe()
[15:32:21.019]     ...future.conditions <- base::list()
[15:32:21.019]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:21.019]     if (FALSE) {
[15:32:21.019]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:21.019]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:21.019]     }
[15:32:21.019]     ...future.result <- base::tryCatch({
[15:32:21.019]         base::withCallingHandlers({
[15:32:21.019]             ...future.value <- base::withVisible(base::local({
[15:32:21.019]                 do.call(function(...) {
[15:32:21.019]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:21.019]                   if (!identical(...future.globals.maxSize.org, 
[15:32:21.019]                     ...future.globals.maxSize)) {
[15:32:21.019]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:21.019]                     on.exit(options(oopts), add = TRUE)
[15:32:21.019]                   }
[15:32:21.019]                   {
[15:32:21.019]                     lapply(seq_along(...future.elements_ii), 
[15:32:21.019]                       FUN = function(jj) {
[15:32:21.019]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:21.019]                         ...future.FUN(...future.X_jj, ...)
[15:32:21.019]                       })
[15:32:21.019]                   }
[15:32:21.019]                 }, args = future.call.arguments)
[15:32:21.019]             }))
[15:32:21.019]             future::FutureResult(value = ...future.value$value, 
[15:32:21.019]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:21.019]                   ...future.rng), globalenv = if (FALSE) 
[15:32:21.019]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:21.019]                     ...future.globalenv.names))
[15:32:21.019]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:21.019]         }, condition = base::local({
[15:32:21.019]             c <- base::c
[15:32:21.019]             inherits <- base::inherits
[15:32:21.019]             invokeRestart <- base::invokeRestart
[15:32:21.019]             length <- base::length
[15:32:21.019]             list <- base::list
[15:32:21.019]             seq.int <- base::seq.int
[15:32:21.019]             signalCondition <- base::signalCondition
[15:32:21.019]             sys.calls <- base::sys.calls
[15:32:21.019]             `[[` <- base::`[[`
[15:32:21.019]             `+` <- base::`+`
[15:32:21.019]             `<<-` <- base::`<<-`
[15:32:21.019]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:21.019]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:21.019]                   3L)]
[15:32:21.019]             }
[15:32:21.019]             function(cond) {
[15:32:21.019]                 is_error <- inherits(cond, "error")
[15:32:21.019]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:21.019]                   NULL)
[15:32:21.019]                 if (is_error) {
[15:32:21.019]                   sessionInformation <- function() {
[15:32:21.019]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:21.019]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:21.019]                       search = base::search(), system = base::Sys.info())
[15:32:21.019]                   }
[15:32:21.019]                   ...future.conditions[[length(...future.conditions) + 
[15:32:21.019]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:21.019]                     cond$call), session = sessionInformation(), 
[15:32:21.019]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:21.019]                   signalCondition(cond)
[15:32:21.019]                 }
[15:32:21.019]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:21.019]                 "immediateCondition"))) {
[15:32:21.019]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:21.019]                   ...future.conditions[[length(...future.conditions) + 
[15:32:21.019]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:21.019]                   if (TRUE && !signal) {
[15:32:21.019]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:21.019]                     {
[15:32:21.019]                       inherits <- base::inherits
[15:32:21.019]                       invokeRestart <- base::invokeRestart
[15:32:21.019]                       is.null <- base::is.null
[15:32:21.019]                       muffled <- FALSE
[15:32:21.019]                       if (inherits(cond, "message")) {
[15:32:21.019]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:21.019]                         if (muffled) 
[15:32:21.019]                           invokeRestart("muffleMessage")
[15:32:21.019]                       }
[15:32:21.019]                       else if (inherits(cond, "warning")) {
[15:32:21.019]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:21.019]                         if (muffled) 
[15:32:21.019]                           invokeRestart("muffleWarning")
[15:32:21.019]                       }
[15:32:21.019]                       else if (inherits(cond, "condition")) {
[15:32:21.019]                         if (!is.null(pattern)) {
[15:32:21.019]                           computeRestarts <- base::computeRestarts
[15:32:21.019]                           grepl <- base::grepl
[15:32:21.019]                           restarts <- computeRestarts(cond)
[15:32:21.019]                           for (restart in restarts) {
[15:32:21.019]                             name <- restart$name
[15:32:21.019]                             if (is.null(name)) 
[15:32:21.019]                               next
[15:32:21.019]                             if (!grepl(pattern, name)) 
[15:32:21.019]                               next
[15:32:21.019]                             invokeRestart(restart)
[15:32:21.019]                             muffled <- TRUE
[15:32:21.019]                             break
[15:32:21.019]                           }
[15:32:21.019]                         }
[15:32:21.019]                       }
[15:32:21.019]                       invisible(muffled)
[15:32:21.019]                     }
[15:32:21.019]                     muffleCondition(cond, pattern = "^muffle")
[15:32:21.019]                   }
[15:32:21.019]                 }
[15:32:21.019]                 else {
[15:32:21.019]                   if (TRUE) {
[15:32:21.019]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:21.019]                     {
[15:32:21.019]                       inherits <- base::inherits
[15:32:21.019]                       invokeRestart <- base::invokeRestart
[15:32:21.019]                       is.null <- base::is.null
[15:32:21.019]                       muffled <- FALSE
[15:32:21.019]                       if (inherits(cond, "message")) {
[15:32:21.019]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:21.019]                         if (muffled) 
[15:32:21.019]                           invokeRestart("muffleMessage")
[15:32:21.019]                       }
[15:32:21.019]                       else if (inherits(cond, "warning")) {
[15:32:21.019]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:21.019]                         if (muffled) 
[15:32:21.019]                           invokeRestart("muffleWarning")
[15:32:21.019]                       }
[15:32:21.019]                       else if (inherits(cond, "condition")) {
[15:32:21.019]                         if (!is.null(pattern)) {
[15:32:21.019]                           computeRestarts <- base::computeRestarts
[15:32:21.019]                           grepl <- base::grepl
[15:32:21.019]                           restarts <- computeRestarts(cond)
[15:32:21.019]                           for (restart in restarts) {
[15:32:21.019]                             name <- restart$name
[15:32:21.019]                             if (is.null(name)) 
[15:32:21.019]                               next
[15:32:21.019]                             if (!grepl(pattern, name)) 
[15:32:21.019]                               next
[15:32:21.019]                             invokeRestart(restart)
[15:32:21.019]                             muffled <- TRUE
[15:32:21.019]                             break
[15:32:21.019]                           }
[15:32:21.019]                         }
[15:32:21.019]                       }
[15:32:21.019]                       invisible(muffled)
[15:32:21.019]                     }
[15:32:21.019]                     muffleCondition(cond, pattern = "^muffle")
[15:32:21.019]                   }
[15:32:21.019]                 }
[15:32:21.019]             }
[15:32:21.019]         }))
[15:32:21.019]     }, error = function(ex) {
[15:32:21.019]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:21.019]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:21.019]                 ...future.rng), started = ...future.startTime, 
[15:32:21.019]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:21.019]             version = "1.8"), class = "FutureResult")
[15:32:21.019]     }, finally = {
[15:32:21.019]         if (!identical(...future.workdir, getwd())) 
[15:32:21.019]             setwd(...future.workdir)
[15:32:21.019]         {
[15:32:21.019]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:21.019]                 ...future.oldOptions$nwarnings <- NULL
[15:32:21.019]             }
[15:32:21.019]             base::options(...future.oldOptions)
[15:32:21.019]             if (.Platform$OS.type == "windows") {
[15:32:21.019]                 old_names <- names(...future.oldEnvVars)
[15:32:21.019]                 envs <- base::Sys.getenv()
[15:32:21.019]                 names <- names(envs)
[15:32:21.019]                 common <- intersect(names, old_names)
[15:32:21.019]                 added <- setdiff(names, old_names)
[15:32:21.019]                 removed <- setdiff(old_names, names)
[15:32:21.019]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:21.019]                   envs[common]]
[15:32:21.019]                 NAMES <- toupper(changed)
[15:32:21.019]                 args <- list()
[15:32:21.019]                 for (kk in seq_along(NAMES)) {
[15:32:21.019]                   name <- changed[[kk]]
[15:32:21.019]                   NAME <- NAMES[[kk]]
[15:32:21.019]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:21.019]                     next
[15:32:21.019]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:21.019]                 }
[15:32:21.019]                 NAMES <- toupper(added)
[15:32:21.019]                 for (kk in seq_along(NAMES)) {
[15:32:21.019]                   name <- added[[kk]]
[15:32:21.019]                   NAME <- NAMES[[kk]]
[15:32:21.019]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:21.019]                     next
[15:32:21.019]                   args[[name]] <- ""
[15:32:21.019]                 }
[15:32:21.019]                 NAMES <- toupper(removed)
[15:32:21.019]                 for (kk in seq_along(NAMES)) {
[15:32:21.019]                   name <- removed[[kk]]
[15:32:21.019]                   NAME <- NAMES[[kk]]
[15:32:21.019]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:21.019]                     next
[15:32:21.019]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:21.019]                 }
[15:32:21.019]                 if (length(args) > 0) 
[15:32:21.019]                   base::do.call(base::Sys.setenv, args = args)
[15:32:21.019]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:21.019]             }
[15:32:21.019]             else {
[15:32:21.019]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:21.019]             }
[15:32:21.019]             {
[15:32:21.019]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:21.019]                   0L) {
[15:32:21.019]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:21.019]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:21.019]                   base::options(opts)
[15:32:21.019]                 }
[15:32:21.019]                 {
[15:32:21.019]                   {
[15:32:21.019]                     NULL
[15:32:21.019]                     RNGkind("Mersenne-Twister")
[15:32:21.019]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:21.019]                       inherits = FALSE)
[15:32:21.019]                   }
[15:32:21.019]                   options(future.plan = NULL)
[15:32:21.019]                   if (is.na(NA_character_)) 
[15:32:21.019]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:21.019]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:21.019]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:21.019]                     .init = FALSE)
[15:32:21.019]                 }
[15:32:21.019]             }
[15:32:21.019]         }
[15:32:21.019]     })
[15:32:21.019]     if (TRUE) {
[15:32:21.019]         base::sink(type = "output", split = FALSE)
[15:32:21.019]         if (TRUE) {
[15:32:21.019]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:21.019]         }
[15:32:21.019]         else {
[15:32:21.019]             ...future.result["stdout"] <- base::list(NULL)
[15:32:21.019]         }
[15:32:21.019]         base::close(...future.stdout)
[15:32:21.019]         ...future.stdout <- NULL
[15:32:21.019]     }
[15:32:21.019]     ...future.result$conditions <- ...future.conditions
[15:32:21.019]     ...future.result$finished <- base::Sys.time()
[15:32:21.019]     ...future.result
[15:32:21.019] }
[15:32:21.027] assign_globals() ...
[15:32:21.027] List of 5
[15:32:21.027]  $ ...future.FUN            :function (x, ...)  
[15:32:21.027]  $ future.call.arguments    : list()
[15:32:21.027]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:21.027]  $ ...future.elements_ii    :List of 6
[15:32:21.027]   ..$ a1: int 1
[15:32:21.027]   ..$ a2: int 2
[15:32:21.027]   ..$ b1: int 2
[15:32:21.027]   ..$ b2: int 3
[15:32:21.027]   ..$ c1: int 3
[15:32:21.027]   ..$ c2: int 4
[15:32:21.027]  $ ...future.seeds_ii       : NULL
[15:32:21.027]  $ ...future.globals.maxSize: NULL
[15:32:21.027]  - attr(*, "where")=List of 5
[15:32:21.027]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:21.027]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:21.027]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:21.027]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:21.027]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:21.027]  - attr(*, "resolved")= logi FALSE
[15:32:21.027]  - attr(*, "total_size")= num 1248
[15:32:21.027]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:21.027]  - attr(*, "already-done")= logi TRUE
[15:32:21.043] - copied '...future.FUN' to environment
[15:32:21.043] - copied 'future.call.arguments' to environment
[15:32:21.043] - copied '...future.elements_ii' to environment
[15:32:21.044] - copied '...future.seeds_ii' to environment
[15:32:21.044] - copied '...future.globals.maxSize' to environment
[15:32:21.044] assign_globals() ... done
[15:32:21.045] plan(): Setting new future strategy stack:
[15:32:21.045] List of future strategies:
[15:32:21.045] 1. sequential:
[15:32:21.045]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:21.045]    - tweaked: FALSE
[15:32:21.045]    - call: NULL
[15:32:21.047] plan(): nbrOfWorkers() = 1
[15:32:21.049] plan(): Setting new future strategy stack:
[15:32:21.050] List of future strategies:
[15:32:21.050] 1. sequential:
[15:32:21.050]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:21.050]    - tweaked: FALSE
[15:32:21.050]    - call: plan(strategy)
[15:32:21.051] plan(): nbrOfWorkers() = 1
[15:32:21.051] SequentialFuture started (and completed)
[15:32:21.052] - Launch lazy future ... done
[15:32:21.052] run() for 'SequentialFuture' ... done
[15:32:21.052] Created future:
[15:32:21.053] SequentialFuture:
[15:32:21.053] Label: 'future_sapply-1'
[15:32:21.053] Expression:
[15:32:21.053] {
[15:32:21.053]     do.call(function(...) {
[15:32:21.053]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:21.053]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:21.053]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:21.053]             on.exit(options(oopts), add = TRUE)
[15:32:21.053]         }
[15:32:21.053]         {
[15:32:21.053]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:21.053]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:21.053]                 ...future.FUN(...future.X_jj, ...)
[15:32:21.053]             })
[15:32:21.053]         }
[15:32:21.053]     }, args = future.call.arguments)
[15:32:21.053] }
[15:32:21.053] Lazy evaluation: FALSE
[15:32:21.053] Asynchronous evaluation: FALSE
[15:32:21.053] Local evaluation: TRUE
[15:32:21.053] Environment: R_GlobalEnv
[15:32:21.053] Capture standard output: TRUE
[15:32:21.053] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:21.053] Globals: 5 objects totaling 1.55 KiB (function '...future.FUN' of 1.22 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 336 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:21.053] Packages: <none>
[15:32:21.053] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:21.053] Resolved: TRUE
[15:32:21.053] Value: 1.31 KiB of class 'list'
[15:32:21.053] Early signaling: FALSE
[15:32:21.053] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:21.053] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:21.055] Chunk #1 of 1 ... DONE
[15:32:21.056] Launching 1 futures (chunks) ... DONE
[15:32:21.056] Resolving 1 futures (chunks) ...
[15:32:21.056] resolve() on list ...
[15:32:21.057]  recursive: 0
[15:32:21.057]  length: 1
[15:32:21.057] 
[15:32:21.058] resolved() for 'SequentialFuture' ...
[15:32:21.058] - state: 'finished'
[15:32:21.058] - run: TRUE
[15:32:21.059] - result: 'FutureResult'
[15:32:21.059] resolved() for 'SequentialFuture' ... done
[15:32:21.059] Future #1
[15:32:21.060] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:21.060] - nx: 1
[15:32:21.061] - relay: TRUE
[15:32:21.061] - stdout: TRUE
[15:32:21.061] - signal: TRUE
[15:32:21.061] - resignal: FALSE
[15:32:21.062] - force: TRUE
[15:32:21.062] - relayed: [n=1] FALSE
[15:32:21.062] - queued futures: [n=1] FALSE
[15:32:21.063]  - until=1
[15:32:21.063]  - relaying element #1
[15:32:21.064] - relayed: [n=1] TRUE
[15:32:21.064] - queued futures: [n=1] TRUE
[15:32:21.064] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:21.065]  length: 0 (resolved future 1)
[15:32:21.065] Relaying remaining futures
[15:32:21.070] signalConditionsASAP(NULL, pos=0) ...
[15:32:21.071] - nx: 1
[15:32:21.071] - relay: TRUE
[15:32:21.072] - stdout: TRUE
[15:32:21.072] - signal: TRUE
[15:32:21.072] - resignal: FALSE
[15:32:21.073] - force: TRUE
[15:32:21.073] - relayed: [n=1] TRUE
[15:32:21.073] - queued futures: [n=1] TRUE
 - flush all
[15:32:21.074] - relayed: [n=1] TRUE
[15:32:21.074] - queued futures: [n=1] TRUE
[15:32:21.075] signalConditionsASAP(NULL, pos=0) ... done
[15:32:21.075] resolve() on list ... DONE
[15:32:21.076]  - Number of value chunks collected: 1
[15:32:21.076] Resolving 1 futures (chunks) ... DONE
[15:32:21.076] Reducing values from 1 chunks ...
[15:32:21.077]  - Number of values collected after concatenation: 6
[15:32:21.077]  - Number of values expected: 6
[15:32:21.078] Reducing values from 1 chunks ... DONE
[15:32:21.078] future_lapply() ... DONE
List of 2
 $ y0:List of 6
  ..$ a1: int [1, 1] 1
  ..$ a2: int [1, 1] 2
  ..$ b1: int [1, 1] 2
  ..$ b2: int [1, 1] 3
  ..$ c1: int [1, 1] 3
  ..$ c2: int [1, 1] 4
 $ y1:List of 6
  ..$ a1: int [1, 1] 1
  ..$ a2: int [1, 1] 2
  ..$ b1: int [1, 1] 2
  ..$ b2: int [1, 1] 3
  ..$ c1: int [1, 1] 3
  ..$ c2: int [1, 1] 4
List of 2
 $ y0:List of 6
  ..$ a1: int [1, 1] 1
  ..$ a2: int [1, 1] 2
  ..$ b1: int [1, 1] 2
  ..$ b2: int [1, 1] 3
  ..$ c1: int [1, 1] 3
  ..$ c2: int [1, 1] 4
 $ y2:List of 6
  ..$ a1: int [1, 1] 1
  ..$ a2: int [1, 1] 2
  ..$ b1: int [1, 1] 2
  ..$ b2: int [1, 1] 3
  ..$ c1: int [1, 1] 3
  ..$ c2: int [1, 1] 4
[15:32:21.102] future_lapply() ...
[15:32:21.104] Number of chunks: 1
[15:32:21.104] getGlobalsAndPackagesXApply() ...
[15:32:21.104]  - future.globals: TRUE
[15:32:21.105] getGlobalsAndPackages() ...
[15:32:21.105] Searching for globals...
[15:32:21.108] - globals found: [5] 'FUN', '*', ':', 'outer', 'rep'
[15:32:21.109] Searching for globals ... DONE
[15:32:21.109] Resolving globals: FALSE
[15:32:21.110] The total size of the 1 globals is 4.62 KiB (4728 bytes)
[15:32:21.111] The total size of the 1 globals exported for future expression ('FUN()') is 4.62 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.62 KiB of class 'function')
[15:32:21.111] - globals: [1] 'FUN'
[15:32:21.111] 
[15:32:21.112] getGlobalsAndPackages() ... DONE
[15:32:21.112]  - globals found/used: [n=1] 'FUN'
[15:32:21.112]  - needed namespaces: [n=0] 
[15:32:21.113] Finding globals ... DONE
[15:32:21.113]  - use_args: TRUE
[15:32:21.113]  - Getting '...' globals ...
[15:32:21.114] resolve() on list ...
[15:32:21.114]  recursive: 0
[15:32:21.115]  length: 1
[15:32:21.115]  elements: '...'
[15:32:21.115]  length: 0 (resolved future 1)
[15:32:21.116] resolve() on list ... DONE
[15:32:21.116]    - '...' content: [n=0] 
[15:32:21.116] List of 1
[15:32:21.116]  $ ...: list()
[15:32:21.116]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:21.116]  - attr(*, "where")=List of 1
[15:32:21.116]   ..$ ...:<environment: 0x00000276e1cab258> 
[15:32:21.116]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:21.116]  - attr(*, "resolved")= logi TRUE
[15:32:21.116]  - attr(*, "total_size")= num NA
[15:32:21.127]  - Getting '...' globals ... DONE
[15:32:21.128] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:21.128] List of 2
[15:32:21.128]  $ ...future.FUN:function (x, y = 2 * 1:5)  
[15:32:21.128]  $ ...          : list()
[15:32:21.128]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:21.128]  - attr(*, "where")=List of 2
[15:32:21.128]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:21.128]   ..$ ...          :<environment: 0x00000276e1cab258> 
[15:32:21.128]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:21.128]  - attr(*, "resolved")= logi FALSE
[15:32:21.128]  - attr(*, "total_size")= num 4728
[15:32:21.134] Packages to be attached in all futures: [n=0] 
[15:32:21.135] getGlobalsAndPackagesXApply() ... DONE
[15:32:21.135] Number of futures (= number of chunks): 1
[15:32:21.136] Launching 1 futures (chunks) ...
[15:32:21.136] Chunk #1 of 1 ...
[15:32:21.136]  - Finding globals in 'X' for chunk #1 ...
[15:32:21.137] getGlobalsAndPackages() ...
[15:32:21.137] Searching for globals...
[15:32:21.138] 
[15:32:21.138] Searching for globals ... DONE
[15:32:21.138] - globals: [0] <none>
[15:32:21.138] getGlobalsAndPackages() ... DONE
[15:32:21.139]    + additional globals found: [n=0] 
[15:32:21.139]    + additional namespaces needed: [n=0] 
[15:32:21.139]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:21.140]  - seeds: <none>
[15:32:21.140]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:21.140] getGlobalsAndPackages() ...
[15:32:21.141] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:21.141] Resolving globals: FALSE
[15:32:21.141] Tweak future expression to call with '...' arguments ...
[15:32:21.142] {
[15:32:21.142]     do.call(function(...) {
[15:32:21.142]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:21.142]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:21.142]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:21.142]             on.exit(options(oopts), add = TRUE)
[15:32:21.142]         }
[15:32:21.142]         {
[15:32:21.142]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:21.142]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:21.142]                 ...future.FUN(...future.X_jj, ...)
[15:32:21.142]             })
[15:32:21.142]         }
[15:32:21.142]     }, args = future.call.arguments)
[15:32:21.142] }
[15:32:21.143] Tweak future expression to call with '...' arguments ... DONE
[15:32:21.144] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:21.144] 
[15:32:21.144] getGlobalsAndPackages() ... DONE
[15:32:21.145] run() for 'Future' ...
[15:32:21.145] - state: 'created'
[15:32:21.146] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:21.147] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:21.147] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:21.147]   - Field: 'label'
[15:32:21.148]   - Field: 'local'
[15:32:21.148]   - Field: 'owner'
[15:32:21.148]   - Field: 'envir'
[15:32:21.149]   - Field: 'packages'
[15:32:21.149]   - Field: 'gc'
[15:32:21.149]   - Field: 'conditions'
[15:32:21.150]   - Field: 'expr'
[15:32:21.150]   - Field: 'uuid'
[15:32:21.150]   - Field: 'seed'
[15:32:21.151]   - Field: 'version'
[15:32:21.151]   - Field: 'result'
[15:32:21.151]   - Field: 'asynchronous'
[15:32:21.152]   - Field: 'calls'
[15:32:21.152]   - Field: 'globals'
[15:32:21.152]   - Field: 'stdout'
[15:32:21.153]   - Field: 'earlySignal'
[15:32:21.153]   - Field: 'lazy'
[15:32:21.153]   - Field: 'state'
[15:32:21.154] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:21.154] - Launch lazy future ...
[15:32:21.155] Packages needed by the future expression (n = 0): <none>
[15:32:21.155] Packages needed by future strategies (n = 0): <none>
[15:32:21.156] {
[15:32:21.156]     {
[15:32:21.156]         {
[15:32:21.156]             ...future.startTime <- base::Sys.time()
[15:32:21.156]             {
[15:32:21.156]                 {
[15:32:21.156]                   {
[15:32:21.156]                     base::local({
[15:32:21.156]                       has_future <- base::requireNamespace("future", 
[15:32:21.156]                         quietly = TRUE)
[15:32:21.156]                       if (has_future) {
[15:32:21.156]                         ns <- base::getNamespace("future")
[15:32:21.156]                         version <- ns[[".package"]][["version"]]
[15:32:21.156]                         if (is.null(version)) 
[15:32:21.156]                           version <- utils::packageVersion("future")
[15:32:21.156]                       }
[15:32:21.156]                       else {
[15:32:21.156]                         version <- NULL
[15:32:21.156]                       }
[15:32:21.156]                       if (!has_future || version < "1.8.0") {
[15:32:21.156]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:21.156]                           "", base::R.version$version.string), 
[15:32:21.156]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:21.156]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:21.156]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:21.156]                             "release", "version")], collapse = " "), 
[15:32:21.156]                           hostname = base::Sys.info()[["nodename"]])
[15:32:21.156]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:21.156]                           info)
[15:32:21.156]                         info <- base::paste(info, collapse = "; ")
[15:32:21.156]                         if (!has_future) {
[15:32:21.156]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:21.156]                             info)
[15:32:21.156]                         }
[15:32:21.156]                         else {
[15:32:21.156]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:21.156]                             info, version)
[15:32:21.156]                         }
[15:32:21.156]                         base::stop(msg)
[15:32:21.156]                       }
[15:32:21.156]                     })
[15:32:21.156]                   }
[15:32:21.156]                   ...future.strategy.old <- future::plan("list")
[15:32:21.156]                   options(future.plan = NULL)
[15:32:21.156]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:21.156]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:21.156]                 }
[15:32:21.156]                 ...future.workdir <- getwd()
[15:32:21.156]             }
[15:32:21.156]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:21.156]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:21.156]         }
[15:32:21.156]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:21.156]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:21.156]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:21.156]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:21.156]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:21.156]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:21.156]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:21.156]             base::names(...future.oldOptions))
[15:32:21.156]     }
[15:32:21.156]     if (FALSE) {
[15:32:21.156]     }
[15:32:21.156]     else {
[15:32:21.156]         if (TRUE) {
[15:32:21.156]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:21.156]                 open = "w")
[15:32:21.156]         }
[15:32:21.156]         else {
[15:32:21.156]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:21.156]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:21.156]         }
[15:32:21.156]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:21.156]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:21.156]             base::sink(type = "output", split = FALSE)
[15:32:21.156]             base::close(...future.stdout)
[15:32:21.156]         }, add = TRUE)
[15:32:21.156]     }
[15:32:21.156]     ...future.frame <- base::sys.nframe()
[15:32:21.156]     ...future.conditions <- base::list()
[15:32:21.156]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:21.156]     if (FALSE) {
[15:32:21.156]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:21.156]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:21.156]     }
[15:32:21.156]     ...future.result <- base::tryCatch({
[15:32:21.156]         base::withCallingHandlers({
[15:32:21.156]             ...future.value <- base::withVisible(base::local({
[15:32:21.156]                 do.call(function(...) {
[15:32:21.156]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:21.156]                   if (!identical(...future.globals.maxSize.org, 
[15:32:21.156]                     ...future.globals.maxSize)) {
[15:32:21.156]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:21.156]                     on.exit(options(oopts), add = TRUE)
[15:32:21.156]                   }
[15:32:21.156]                   {
[15:32:21.156]                     lapply(seq_along(...future.elements_ii), 
[15:32:21.156]                       FUN = function(jj) {
[15:32:21.156]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:21.156]                         ...future.FUN(...future.X_jj, ...)
[15:32:21.156]                       })
[15:32:21.156]                   }
[15:32:21.156]                 }, args = future.call.arguments)
[15:32:21.156]             }))
[15:32:21.156]             future::FutureResult(value = ...future.value$value, 
[15:32:21.156]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:21.156]                   ...future.rng), globalenv = if (FALSE) 
[15:32:21.156]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:21.156]                     ...future.globalenv.names))
[15:32:21.156]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:21.156]         }, condition = base::local({
[15:32:21.156]             c <- base::c
[15:32:21.156]             inherits <- base::inherits
[15:32:21.156]             invokeRestart <- base::invokeRestart
[15:32:21.156]             length <- base::length
[15:32:21.156]             list <- base::list
[15:32:21.156]             seq.int <- base::seq.int
[15:32:21.156]             signalCondition <- base::signalCondition
[15:32:21.156]             sys.calls <- base::sys.calls
[15:32:21.156]             `[[` <- base::`[[`
[15:32:21.156]             `+` <- base::`+`
[15:32:21.156]             `<<-` <- base::`<<-`
[15:32:21.156]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:21.156]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:21.156]                   3L)]
[15:32:21.156]             }
[15:32:21.156]             function(cond) {
[15:32:21.156]                 is_error <- inherits(cond, "error")
[15:32:21.156]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:21.156]                   NULL)
[15:32:21.156]                 if (is_error) {
[15:32:21.156]                   sessionInformation <- function() {
[15:32:21.156]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:21.156]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:21.156]                       search = base::search(), system = base::Sys.info())
[15:32:21.156]                   }
[15:32:21.156]                   ...future.conditions[[length(...future.conditions) + 
[15:32:21.156]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:21.156]                     cond$call), session = sessionInformation(), 
[15:32:21.156]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:21.156]                   signalCondition(cond)
[15:32:21.156]                 }
[15:32:21.156]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:21.156]                 "immediateCondition"))) {
[15:32:21.156]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:21.156]                   ...future.conditions[[length(...future.conditions) + 
[15:32:21.156]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:21.156]                   if (TRUE && !signal) {
[15:32:21.156]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:21.156]                     {
[15:32:21.156]                       inherits <- base::inherits
[15:32:21.156]                       invokeRestart <- base::invokeRestart
[15:32:21.156]                       is.null <- base::is.null
[15:32:21.156]                       muffled <- FALSE
[15:32:21.156]                       if (inherits(cond, "message")) {
[15:32:21.156]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:21.156]                         if (muffled) 
[15:32:21.156]                           invokeRestart("muffleMessage")
[15:32:21.156]                       }
[15:32:21.156]                       else if (inherits(cond, "warning")) {
[15:32:21.156]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:21.156]                         if (muffled) 
[15:32:21.156]                           invokeRestart("muffleWarning")
[15:32:21.156]                       }
[15:32:21.156]                       else if (inherits(cond, "condition")) {
[15:32:21.156]                         if (!is.null(pattern)) {
[15:32:21.156]                           computeRestarts <- base::computeRestarts
[15:32:21.156]                           grepl <- base::grepl
[15:32:21.156]                           restarts <- computeRestarts(cond)
[15:32:21.156]                           for (restart in restarts) {
[15:32:21.156]                             name <- restart$name
[15:32:21.156]                             if (is.null(name)) 
[15:32:21.156]                               next
[15:32:21.156]                             if (!grepl(pattern, name)) 
[15:32:21.156]                               next
[15:32:21.156]                             invokeRestart(restart)
[15:32:21.156]                             muffled <- TRUE
[15:32:21.156]                             break
[15:32:21.156]                           }
[15:32:21.156]                         }
[15:32:21.156]                       }
[15:32:21.156]                       invisible(muffled)
[15:32:21.156]                     }
[15:32:21.156]                     muffleCondition(cond, pattern = "^muffle")
[15:32:21.156]                   }
[15:32:21.156]                 }
[15:32:21.156]                 else {
[15:32:21.156]                   if (TRUE) {
[15:32:21.156]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:21.156]                     {
[15:32:21.156]                       inherits <- base::inherits
[15:32:21.156]                       invokeRestart <- base::invokeRestart
[15:32:21.156]                       is.null <- base::is.null
[15:32:21.156]                       muffled <- FALSE
[15:32:21.156]                       if (inherits(cond, "message")) {
[15:32:21.156]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:21.156]                         if (muffled) 
[15:32:21.156]                           invokeRestart("muffleMessage")
[15:32:21.156]                       }
[15:32:21.156]                       else if (inherits(cond, "warning")) {
[15:32:21.156]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:21.156]                         if (muffled) 
[15:32:21.156]                           invokeRestart("muffleWarning")
[15:32:21.156]                       }
[15:32:21.156]                       else if (inherits(cond, "condition")) {
[15:32:21.156]                         if (!is.null(pattern)) {
[15:32:21.156]                           computeRestarts <- base::computeRestarts
[15:32:21.156]                           grepl <- base::grepl
[15:32:21.156]                           restarts <- computeRestarts(cond)
[15:32:21.156]                           for (restart in restarts) {
[15:32:21.156]                             name <- restart$name
[15:32:21.156]                             if (is.null(name)) 
[15:32:21.156]                               next
[15:32:21.156]                             if (!grepl(pattern, name)) 
[15:32:21.156]                               next
[15:32:21.156]                             invokeRestart(restart)
[15:32:21.156]                             muffled <- TRUE
[15:32:21.156]                             break
[15:32:21.156]                           }
[15:32:21.156]                         }
[15:32:21.156]                       }
[15:32:21.156]                       invisible(muffled)
[15:32:21.156]                     }
[15:32:21.156]                     muffleCondition(cond, pattern = "^muffle")
[15:32:21.156]                   }
[15:32:21.156]                 }
[15:32:21.156]             }
[15:32:21.156]         }))
[15:32:21.156]     }, error = function(ex) {
[15:32:21.156]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:21.156]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:21.156]                 ...future.rng), started = ...future.startTime, 
[15:32:21.156]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:21.156]             version = "1.8"), class = "FutureResult")
[15:32:21.156]     }, finally = {
[15:32:21.156]         if (!identical(...future.workdir, getwd())) 
[15:32:21.156]             setwd(...future.workdir)
[15:32:21.156]         {
[15:32:21.156]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:21.156]                 ...future.oldOptions$nwarnings <- NULL
[15:32:21.156]             }
[15:32:21.156]             base::options(...future.oldOptions)
[15:32:21.156]             if (.Platform$OS.type == "windows") {
[15:32:21.156]                 old_names <- names(...future.oldEnvVars)
[15:32:21.156]                 envs <- base::Sys.getenv()
[15:32:21.156]                 names <- names(envs)
[15:32:21.156]                 common <- intersect(names, old_names)
[15:32:21.156]                 added <- setdiff(names, old_names)
[15:32:21.156]                 removed <- setdiff(old_names, names)
[15:32:21.156]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:21.156]                   envs[common]]
[15:32:21.156]                 NAMES <- toupper(changed)
[15:32:21.156]                 args <- list()
[15:32:21.156]                 for (kk in seq_along(NAMES)) {
[15:32:21.156]                   name <- changed[[kk]]
[15:32:21.156]                   NAME <- NAMES[[kk]]
[15:32:21.156]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:21.156]                     next
[15:32:21.156]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:21.156]                 }
[15:32:21.156]                 NAMES <- toupper(added)
[15:32:21.156]                 for (kk in seq_along(NAMES)) {
[15:32:21.156]                   name <- added[[kk]]
[15:32:21.156]                   NAME <- NAMES[[kk]]
[15:32:21.156]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:21.156]                     next
[15:32:21.156]                   args[[name]] <- ""
[15:32:21.156]                 }
[15:32:21.156]                 NAMES <- toupper(removed)
[15:32:21.156]                 for (kk in seq_along(NAMES)) {
[15:32:21.156]                   name <- removed[[kk]]
[15:32:21.156]                   NAME <- NAMES[[kk]]
[15:32:21.156]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:21.156]                     next
[15:32:21.156]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:21.156]                 }
[15:32:21.156]                 if (length(args) > 0) 
[15:32:21.156]                   base::do.call(base::Sys.setenv, args = args)
[15:32:21.156]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:21.156]             }
[15:32:21.156]             else {
[15:32:21.156]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:21.156]             }
[15:32:21.156]             {
[15:32:21.156]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:21.156]                   0L) {
[15:32:21.156]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:21.156]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:21.156]                   base::options(opts)
[15:32:21.156]                 }
[15:32:21.156]                 {
[15:32:21.156]                   {
[15:32:21.156]                     NULL
[15:32:21.156]                     RNGkind("Mersenne-Twister")
[15:32:21.156]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:21.156]                       inherits = FALSE)
[15:32:21.156]                   }
[15:32:21.156]                   options(future.plan = NULL)
[15:32:21.156]                   if (is.na(NA_character_)) 
[15:32:21.156]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:21.156]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:21.156]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:21.156]                     .init = FALSE)
[15:32:21.156]                 }
[15:32:21.156]             }
[15:32:21.156]         }
[15:32:21.156]     })
[15:32:21.156]     if (TRUE) {
[15:32:21.156]         base::sink(type = "output", split = FALSE)
[15:32:21.156]         if (TRUE) {
[15:32:21.156]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:21.156]         }
[15:32:21.156]         else {
[15:32:21.156]             ...future.result["stdout"] <- base::list(NULL)
[15:32:21.156]         }
[15:32:21.156]         base::close(...future.stdout)
[15:32:21.156]         ...future.stdout <- NULL
[15:32:21.156]     }
[15:32:21.156]     ...future.result$conditions <- ...future.conditions
[15:32:21.156]     ...future.result$finished <- base::Sys.time()
[15:32:21.156]     ...future.result
[15:32:21.156] }
[15:32:21.163] assign_globals() ...
[15:32:21.164] List of 5
[15:32:21.164]  $ ...future.FUN            :function (x, y = 2 * 1:5)  
[15:32:21.164]  $ future.call.arguments    : list()
[15:32:21.164]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:21.164]  $ ...future.elements_ii    :List of 6
[15:32:21.164]   ..$ a1: int 1
[15:32:21.164]   ..$ a2: int 2
[15:32:21.164]   ..$ b1: int 2
[15:32:21.164]   ..$ b2: int 3
[15:32:21.164]   ..$ c1: int 3
[15:32:21.164]   ..$ c2: int 4
[15:32:21.164]  $ ...future.seeds_ii       : NULL
[15:32:21.164]  $ ...future.globals.maxSize: NULL
[15:32:21.164]  - attr(*, "where")=List of 5
[15:32:21.164]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:21.164]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:21.164]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:21.164]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:21.164]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:21.164]  - attr(*, "resolved")= logi FALSE
[15:32:21.164]  - attr(*, "total_size")= num 4728
[15:32:21.164]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:21.164]  - attr(*, "already-done")= logi TRUE
[15:32:21.183] - reassign environment for '...future.FUN'
[15:32:21.183] - copied '...future.FUN' to environment
[15:32:21.184] - copied 'future.call.arguments' to environment
[15:32:21.184] - copied '...future.elements_ii' to environment
[15:32:21.184] - copied '...future.seeds_ii' to environment
[15:32:21.185] - copied '...future.globals.maxSize' to environment
[15:32:21.185] assign_globals() ... done
[15:32:21.186] plan(): Setting new future strategy stack:
[15:32:21.186] List of future strategies:
[15:32:21.186] 1. sequential:
[15:32:21.186]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:21.186]    - tweaked: FALSE
[15:32:21.186]    - call: NULL
[15:32:21.187] plan(): nbrOfWorkers() = 1
[15:32:21.190] plan(): Setting new future strategy stack:
[15:32:21.190] List of future strategies:
[15:32:21.190] 1. sequential:
[15:32:21.190]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:21.190]    - tweaked: FALSE
[15:32:21.190]    - call: plan(strategy)
[15:32:21.192] plan(): nbrOfWorkers() = 1
[15:32:21.192] SequentialFuture started (and completed)
[15:32:21.193] - Launch lazy future ... done
[15:32:21.193] run() for 'SequentialFuture' ... done
[15:32:21.193] Created future:
[15:32:21.194] SequentialFuture:
[15:32:21.194] Label: 'future_sapply-1'
[15:32:21.194] Expression:
[15:32:21.194] {
[15:32:21.194]     do.call(function(...) {
[15:32:21.194]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:21.194]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:21.194]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:21.194]             on.exit(options(oopts), add = TRUE)
[15:32:21.194]         }
[15:32:21.194]         {
[15:32:21.194]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:21.194]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:21.194]                 ...future.FUN(...future.X_jj, ...)
[15:32:21.194]             })
[15:32:21.194]         }
[15:32:21.194]     }, args = future.call.arguments)
[15:32:21.194] }
[15:32:21.194] Lazy evaluation: FALSE
[15:32:21.194] Asynchronous evaluation: FALSE
[15:32:21.194] Local evaluation: TRUE
[15:32:21.194] Environment: R_GlobalEnv
[15:32:21.194] Capture standard output: TRUE
[15:32:21.194] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:21.194] Globals: 5 objects totaling 4.95 KiB (function '...future.FUN' of 4.62 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 336 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:21.194] Packages: <none>
[15:32:21.194] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:21.194] Resolved: TRUE
[15:32:21.194] Value: 2.02 KiB of class 'list'
[15:32:21.194] Early signaling: FALSE
[15:32:21.194] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:21.194] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:21.196] Chunk #1 of 1 ... DONE
[15:32:21.196] Launching 1 futures (chunks) ... DONE
[15:32:21.197] Resolving 1 futures (chunks) ...
[15:32:21.197] resolve() on list ...
[15:32:21.197]  recursive: 0
[15:32:21.198]  length: 1
[15:32:21.198] 
[15:32:21.198] resolved() for 'SequentialFuture' ...
[15:32:21.199] - state: 'finished'
[15:32:21.199] - run: TRUE
[15:32:21.199] - result: 'FutureResult'
[15:32:21.200] resolved() for 'SequentialFuture' ... done
[15:32:21.200] Future #1
[15:32:21.200] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:21.201] - nx: 1
[15:32:21.201] - relay: TRUE
[15:32:21.201] - stdout: TRUE
[15:32:21.202] - signal: TRUE
[15:32:21.202] - resignal: FALSE
[15:32:21.202] - force: TRUE
[15:32:21.202] - relayed: [n=1] FALSE
[15:32:21.203] - queued futures: [n=1] FALSE
[15:32:21.203]  - until=1
[15:32:21.203]  - relaying element #1
[15:32:21.204] - relayed: [n=1] TRUE
[15:32:21.204] - queued futures: [n=1] TRUE
[15:32:21.204] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:21.205]  length: 0 (resolved future 1)
[15:32:21.205] Relaying remaining futures
[15:32:21.205] signalConditionsASAP(NULL, pos=0) ...
[15:32:21.206] - nx: 1
[15:32:21.206] - relay: TRUE
[15:32:21.206] - stdout: TRUE
[15:32:21.206] - signal: TRUE
[15:32:21.207] - resignal: FALSE
[15:32:21.207] - force: TRUE
[15:32:21.207] - relayed: [n=1] TRUE
[15:32:21.208] - queued futures: [n=1] TRUE
 - flush all
[15:32:21.208] - relayed: [n=1] TRUE
[15:32:21.208] - queued futures: [n=1] TRUE
[15:32:21.209] signalConditionsASAP(NULL, pos=0) ... done
[15:32:21.209] resolve() on list ... DONE
[15:32:21.209]  - Number of value chunks collected: 1
[15:32:21.210] Resolving 1 futures (chunks) ... DONE
[15:32:21.210] Reducing values from 1 chunks ...
[15:32:21.210]  - Number of values collected after concatenation: 6
[15:32:21.210]  - Number of values expected: 6
[15:32:21.211] Reducing values from 1 chunks ... DONE
[15:32:21.211] future_lapply() ... DONE
List of 2
 $ y0:List of 6
  ..$ a1: num [1:3, 1:5] 2 2 2 4 4 4 6 6 6 8 ...
  ..$ a2: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
  ..$ b1: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
  ..$ b2: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
  ..$ c1: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
  ..$ c2: num [1:3, 1:5] 8 8 8 16 16 16 24 24 24 32 ...
 $ y1:List of 6
  ..$ a1: num [1:3, 1:5] 2 2 2 4 4 4 6 6 6 8 ...
  ..$ a2: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
  ..$ b1: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
  ..$ b2: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
  ..$ c1: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
  ..$ c2: num [1:3, 1:5] 8 8 8 16 16 16 24 24 24 32 ...
List of 2
 $ y0:List of 6
  ..$ a1: num [1:3, 1:5] 2 2 2 4 4 4 6 6 6 8 ...
  ..$ a2: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
  ..$ b1: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
  ..$ b2: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
  ..$ c1: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
  ..$ c2: num [1:3, 1:5] 8 8 8 16 16 16 24 24 24 32 ...
 $ y2:List of 6
  ..$ a1: num [1:3, 1:5] 2 2 2 4 4 4 6 6 6 8 ...
  ..$ a2: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
  ..$ b1: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
  ..$ b2: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
  ..$ c1: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
  ..$ c2: num [1:3, 1:5] 8 8 8 16 16 16 24 24 24 32 ...
[15:32:21.241] future_lapply() ...
[15:32:21.243] Number of chunks: 1
[15:32:21.243] getGlobalsAndPackagesXApply() ...
[15:32:21.243]  - future.globals: TRUE
[15:32:21.244] getGlobalsAndPackages() ...
[15:32:21.244] Searching for globals...
[15:32:21.246] - globals found: [1] 'FUN'
[15:32:21.247] Searching for globals ... DONE
[15:32:21.247] Resolving globals: FALSE
[15:32:21.248] The total size of the 1 globals is 848 bytes (848 bytes)
[15:32:21.249] The total size of the 1 globals exported for future expression ('FUN()') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:32:21.249] - globals: [1] 'FUN'
[15:32:21.249] 
[15:32:21.249] getGlobalsAndPackages() ... DONE
[15:32:21.250]  - globals found/used: [n=1] 'FUN'
[15:32:21.250]  - needed namespaces: [n=0] 
[15:32:21.250] Finding globals ... DONE
[15:32:21.251]  - use_args: TRUE
[15:32:21.251]  - Getting '...' globals ...
[15:32:21.252] resolve() on list ...
[15:32:21.252]  recursive: 0
[15:32:21.252]  length: 1
[15:32:21.253]  elements: '...'
[15:32:21.253]  length: 0 (resolved future 1)
[15:32:21.253] resolve() on list ... DONE
[15:32:21.254]    - '...' content: [n=0] 
[15:32:21.254] List of 1
[15:32:21.254]  $ ...: list()
[15:32:21.254]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:21.254]  - attr(*, "where")=List of 1
[15:32:21.254]   ..$ ...:<environment: 0x00000276e2744450> 
[15:32:21.254]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:21.254]  - attr(*, "resolved")= logi TRUE
[15:32:21.254]  - attr(*, "total_size")= num NA
[15:32:21.260]  - Getting '...' globals ... DONE
[15:32:21.260] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:21.261] List of 2
[15:32:21.261]  $ ...future.FUN:function (x)  
[15:32:21.261]  $ ...          : list()
[15:32:21.261]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:21.261]  - attr(*, "where")=List of 2
[15:32:21.261]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:21.261]   ..$ ...          :<environment: 0x00000276e2744450> 
[15:32:21.261]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:21.261]  - attr(*, "resolved")= logi FALSE
[15:32:21.261]  - attr(*, "total_size")= num 848
[15:32:21.266] Packages to be attached in all futures: [n=0] 
[15:32:21.267] getGlobalsAndPackagesXApply() ... DONE
[15:32:21.267] Number of futures (= number of chunks): 1
[15:32:21.268] Launching 1 futures (chunks) ...
[15:32:21.268] Chunk #1 of 1 ...
[15:32:21.268]  - Finding globals in 'X' for chunk #1 ...
[15:32:21.269] getGlobalsAndPackages() ...
[15:32:21.269] Searching for globals...
[15:32:21.270] 
[15:32:21.270] Searching for globals ... DONE
[15:32:21.270] - globals: [0] <none>
[15:32:21.271] getGlobalsAndPackages() ... DONE
[15:32:21.271]    + additional globals found: [n=0] 
[15:32:21.271]    + additional namespaces needed: [n=0] 
[15:32:21.272]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:21.272]  - seeds: <none>
[15:32:21.272]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:21.273] getGlobalsAndPackages() ...
[15:32:21.273] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:21.273] Resolving globals: FALSE
[15:32:21.274] Tweak future expression to call with '...' arguments ...
[15:32:21.274] {
[15:32:21.274]     do.call(function(...) {
[15:32:21.274]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:21.274]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:21.274]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:21.274]             on.exit(options(oopts), add = TRUE)
[15:32:21.274]         }
[15:32:21.274]         {
[15:32:21.274]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:21.274]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:21.274]                 ...future.FUN(...future.X_jj, ...)
[15:32:21.274]             })
[15:32:21.274]         }
[15:32:21.274]     }, args = future.call.arguments)
[15:32:21.274] }
[15:32:21.275] Tweak future expression to call with '...' arguments ... DONE
[15:32:21.276] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:21.276] 
[15:32:21.276] getGlobalsAndPackages() ... DONE
[15:32:21.277] run() for 'Future' ...
[15:32:21.277] - state: 'created'
[15:32:21.278] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:21.279] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:21.279] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:21.279]   - Field: 'label'
[15:32:21.280]   - Field: 'local'
[15:32:21.280]   - Field: 'owner'
[15:32:21.280]   - Field: 'envir'
[15:32:21.281]   - Field: 'packages'
[15:32:21.281]   - Field: 'gc'
[15:32:21.281]   - Field: 'conditions'
[15:32:21.282]   - Field: 'expr'
[15:32:21.287]   - Field: 'uuid'
[15:32:21.287]   - Field: 'seed'
[15:32:21.287]   - Field: 'version'
[15:32:21.288]   - Field: 'result'
[15:32:21.288]   - Field: 'asynchronous'
[15:32:21.289]   - Field: 'calls'
[15:32:21.289]   - Field: 'globals'
[15:32:21.289]   - Field: 'stdout'
[15:32:21.290]   - Field: 'earlySignal'
[15:32:21.290]   - Field: 'lazy'
[15:32:21.290]   - Field: 'state'
[15:32:21.291] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:21.291] - Launch lazy future ...
[15:32:21.292] Packages needed by the future expression (n = 0): <none>
[15:32:21.292] Packages needed by future strategies (n = 0): <none>
[15:32:21.294] {
[15:32:21.294]     {
[15:32:21.294]         {
[15:32:21.294]             ...future.startTime <- base::Sys.time()
[15:32:21.294]             {
[15:32:21.294]                 {
[15:32:21.294]                   {
[15:32:21.294]                     base::local({
[15:32:21.294]                       has_future <- base::requireNamespace("future", 
[15:32:21.294]                         quietly = TRUE)
[15:32:21.294]                       if (has_future) {
[15:32:21.294]                         ns <- base::getNamespace("future")
[15:32:21.294]                         version <- ns[[".package"]][["version"]]
[15:32:21.294]                         if (is.null(version)) 
[15:32:21.294]                           version <- utils::packageVersion("future")
[15:32:21.294]                       }
[15:32:21.294]                       else {
[15:32:21.294]                         version <- NULL
[15:32:21.294]                       }
[15:32:21.294]                       if (!has_future || version < "1.8.0") {
[15:32:21.294]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:21.294]                           "", base::R.version$version.string), 
[15:32:21.294]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:21.294]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:21.294]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:21.294]                             "release", "version")], collapse = " "), 
[15:32:21.294]                           hostname = base::Sys.info()[["nodename"]])
[15:32:21.294]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:21.294]                           info)
[15:32:21.294]                         info <- base::paste(info, collapse = "; ")
[15:32:21.294]                         if (!has_future) {
[15:32:21.294]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:21.294]                             info)
[15:32:21.294]                         }
[15:32:21.294]                         else {
[15:32:21.294]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:21.294]                             info, version)
[15:32:21.294]                         }
[15:32:21.294]                         base::stop(msg)
[15:32:21.294]                       }
[15:32:21.294]                     })
[15:32:21.294]                   }
[15:32:21.294]                   ...future.strategy.old <- future::plan("list")
[15:32:21.294]                   options(future.plan = NULL)
[15:32:21.294]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:21.294]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:21.294]                 }
[15:32:21.294]                 ...future.workdir <- getwd()
[15:32:21.294]             }
[15:32:21.294]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:21.294]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:21.294]         }
[15:32:21.294]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:21.294]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:21.294]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:21.294]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:21.294]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:21.294]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:21.294]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:21.294]             base::names(...future.oldOptions))
[15:32:21.294]     }
[15:32:21.294]     if (FALSE) {
[15:32:21.294]     }
[15:32:21.294]     else {
[15:32:21.294]         if (TRUE) {
[15:32:21.294]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:21.294]                 open = "w")
[15:32:21.294]         }
[15:32:21.294]         else {
[15:32:21.294]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:21.294]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:21.294]         }
[15:32:21.294]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:21.294]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:21.294]             base::sink(type = "output", split = FALSE)
[15:32:21.294]             base::close(...future.stdout)
[15:32:21.294]         }, add = TRUE)
[15:32:21.294]     }
[15:32:21.294]     ...future.frame <- base::sys.nframe()
[15:32:21.294]     ...future.conditions <- base::list()
[15:32:21.294]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:21.294]     if (FALSE) {
[15:32:21.294]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:21.294]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:21.294]     }
[15:32:21.294]     ...future.result <- base::tryCatch({
[15:32:21.294]         base::withCallingHandlers({
[15:32:21.294]             ...future.value <- base::withVisible(base::local({
[15:32:21.294]                 do.call(function(...) {
[15:32:21.294]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:21.294]                   if (!identical(...future.globals.maxSize.org, 
[15:32:21.294]                     ...future.globals.maxSize)) {
[15:32:21.294]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:21.294]                     on.exit(options(oopts), add = TRUE)
[15:32:21.294]                   }
[15:32:21.294]                   {
[15:32:21.294]                     lapply(seq_along(...future.elements_ii), 
[15:32:21.294]                       FUN = function(jj) {
[15:32:21.294]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:21.294]                         ...future.FUN(...future.X_jj, ...)
[15:32:21.294]                       })
[15:32:21.294]                   }
[15:32:21.294]                 }, args = future.call.arguments)
[15:32:21.294]             }))
[15:32:21.294]             future::FutureResult(value = ...future.value$value, 
[15:32:21.294]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:21.294]                   ...future.rng), globalenv = if (FALSE) 
[15:32:21.294]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:21.294]                     ...future.globalenv.names))
[15:32:21.294]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:21.294]         }, condition = base::local({
[15:32:21.294]             c <- base::c
[15:32:21.294]             inherits <- base::inherits
[15:32:21.294]             invokeRestart <- base::invokeRestart
[15:32:21.294]             length <- base::length
[15:32:21.294]             list <- base::list
[15:32:21.294]             seq.int <- base::seq.int
[15:32:21.294]             signalCondition <- base::signalCondition
[15:32:21.294]             sys.calls <- base::sys.calls
[15:32:21.294]             `[[` <- base::`[[`
[15:32:21.294]             `+` <- base::`+`
[15:32:21.294]             `<<-` <- base::`<<-`
[15:32:21.294]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:21.294]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:21.294]                   3L)]
[15:32:21.294]             }
[15:32:21.294]             function(cond) {
[15:32:21.294]                 is_error <- inherits(cond, "error")
[15:32:21.294]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:21.294]                   NULL)
[15:32:21.294]                 if (is_error) {
[15:32:21.294]                   sessionInformation <- function() {
[15:32:21.294]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:21.294]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:21.294]                       search = base::search(), system = base::Sys.info())
[15:32:21.294]                   }
[15:32:21.294]                   ...future.conditions[[length(...future.conditions) + 
[15:32:21.294]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:21.294]                     cond$call), session = sessionInformation(), 
[15:32:21.294]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:21.294]                   signalCondition(cond)
[15:32:21.294]                 }
[15:32:21.294]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:21.294]                 "immediateCondition"))) {
[15:32:21.294]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:21.294]                   ...future.conditions[[length(...future.conditions) + 
[15:32:21.294]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:21.294]                   if (TRUE && !signal) {
[15:32:21.294]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:21.294]                     {
[15:32:21.294]                       inherits <- base::inherits
[15:32:21.294]                       invokeRestart <- base::invokeRestart
[15:32:21.294]                       is.null <- base::is.null
[15:32:21.294]                       muffled <- FALSE
[15:32:21.294]                       if (inherits(cond, "message")) {
[15:32:21.294]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:21.294]                         if (muffled) 
[15:32:21.294]                           invokeRestart("muffleMessage")
[15:32:21.294]                       }
[15:32:21.294]                       else if (inherits(cond, "warning")) {
[15:32:21.294]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:21.294]                         if (muffled) 
[15:32:21.294]                           invokeRestart("muffleWarning")
[15:32:21.294]                       }
[15:32:21.294]                       else if (inherits(cond, "condition")) {
[15:32:21.294]                         if (!is.null(pattern)) {
[15:32:21.294]                           computeRestarts <- base::computeRestarts
[15:32:21.294]                           grepl <- base::grepl
[15:32:21.294]                           restarts <- computeRestarts(cond)
[15:32:21.294]                           for (restart in restarts) {
[15:32:21.294]                             name <- restart$name
[15:32:21.294]                             if (is.null(name)) 
[15:32:21.294]                               next
[15:32:21.294]                             if (!grepl(pattern, name)) 
[15:32:21.294]                               next
[15:32:21.294]                             invokeRestart(restart)
[15:32:21.294]                             muffled <- TRUE
[15:32:21.294]                             break
[15:32:21.294]                           }
[15:32:21.294]                         }
[15:32:21.294]                       }
[15:32:21.294]                       invisible(muffled)
[15:32:21.294]                     }
[15:32:21.294]                     muffleCondition(cond, pattern = "^muffle")
[15:32:21.294]                   }
[15:32:21.294]                 }
[15:32:21.294]                 else {
[15:32:21.294]                   if (TRUE) {
[15:32:21.294]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:21.294]                     {
[15:32:21.294]                       inherits <- base::inherits
[15:32:21.294]                       invokeRestart <- base::invokeRestart
[15:32:21.294]                       is.null <- base::is.null
[15:32:21.294]                       muffled <- FALSE
[15:32:21.294]                       if (inherits(cond, "message")) {
[15:32:21.294]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:21.294]                         if (muffled) 
[15:32:21.294]                           invokeRestart("muffleMessage")
[15:32:21.294]                       }
[15:32:21.294]                       else if (inherits(cond, "warning")) {
[15:32:21.294]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:21.294]                         if (muffled) 
[15:32:21.294]                           invokeRestart("muffleWarning")
[15:32:21.294]                       }
[15:32:21.294]                       else if (inherits(cond, "condition")) {
[15:32:21.294]                         if (!is.null(pattern)) {
[15:32:21.294]                           computeRestarts <- base::computeRestarts
[15:32:21.294]                           grepl <- base::grepl
[15:32:21.294]                           restarts <- computeRestarts(cond)
[15:32:21.294]                           for (restart in restarts) {
[15:32:21.294]                             name <- restart$name
[15:32:21.294]                             if (is.null(name)) 
[15:32:21.294]                               next
[15:32:21.294]                             if (!grepl(pattern, name)) 
[15:32:21.294]                               next
[15:32:21.294]                             invokeRestart(restart)
[15:32:21.294]                             muffled <- TRUE
[15:32:21.294]                             break
[15:32:21.294]                           }
[15:32:21.294]                         }
[15:32:21.294]                       }
[15:32:21.294]                       invisible(muffled)
[15:32:21.294]                     }
[15:32:21.294]                     muffleCondition(cond, pattern = "^muffle")
[15:32:21.294]                   }
[15:32:21.294]                 }
[15:32:21.294]             }
[15:32:21.294]         }))
[15:32:21.294]     }, error = function(ex) {
[15:32:21.294]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:21.294]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:21.294]                 ...future.rng), started = ...future.startTime, 
[15:32:21.294]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:21.294]             version = "1.8"), class = "FutureResult")
[15:32:21.294]     }, finally = {
[15:32:21.294]         if (!identical(...future.workdir, getwd())) 
[15:32:21.294]             setwd(...future.workdir)
[15:32:21.294]         {
[15:32:21.294]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:21.294]                 ...future.oldOptions$nwarnings <- NULL
[15:32:21.294]             }
[15:32:21.294]             base::options(...future.oldOptions)
[15:32:21.294]             if (.Platform$OS.type == "windows") {
[15:32:21.294]                 old_names <- names(...future.oldEnvVars)
[15:32:21.294]                 envs <- base::Sys.getenv()
[15:32:21.294]                 names <- names(envs)
[15:32:21.294]                 common <- intersect(names, old_names)
[15:32:21.294]                 added <- setdiff(names, old_names)
[15:32:21.294]                 removed <- setdiff(old_names, names)
[15:32:21.294]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:21.294]                   envs[common]]
[15:32:21.294]                 NAMES <- toupper(changed)
[15:32:21.294]                 args <- list()
[15:32:21.294]                 for (kk in seq_along(NAMES)) {
[15:32:21.294]                   name <- changed[[kk]]
[15:32:21.294]                   NAME <- NAMES[[kk]]
[15:32:21.294]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:21.294]                     next
[15:32:21.294]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:21.294]                 }
[15:32:21.294]                 NAMES <- toupper(added)
[15:32:21.294]                 for (kk in seq_along(NAMES)) {
[15:32:21.294]                   name <- added[[kk]]
[15:32:21.294]                   NAME <- NAMES[[kk]]
[15:32:21.294]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:21.294]                     next
[15:32:21.294]                   args[[name]] <- ""
[15:32:21.294]                 }
[15:32:21.294]                 NAMES <- toupper(removed)
[15:32:21.294]                 for (kk in seq_along(NAMES)) {
[15:32:21.294]                   name <- removed[[kk]]
[15:32:21.294]                   NAME <- NAMES[[kk]]
[15:32:21.294]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:21.294]                     next
[15:32:21.294]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:21.294]                 }
[15:32:21.294]                 if (length(args) > 0) 
[15:32:21.294]                   base::do.call(base::Sys.setenv, args = args)
[15:32:21.294]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:21.294]             }
[15:32:21.294]             else {
[15:32:21.294]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:21.294]             }
[15:32:21.294]             {
[15:32:21.294]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:21.294]                   0L) {
[15:32:21.294]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:21.294]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:21.294]                   base::options(opts)
[15:32:21.294]                 }
[15:32:21.294]                 {
[15:32:21.294]                   {
[15:32:21.294]                     NULL
[15:32:21.294]                     RNGkind("Mersenne-Twister")
[15:32:21.294]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:21.294]                       inherits = FALSE)
[15:32:21.294]                   }
[15:32:21.294]                   options(future.plan = NULL)
[15:32:21.294]                   if (is.na(NA_character_)) 
[15:32:21.294]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:21.294]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:21.294]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:21.294]                     .init = FALSE)
[15:32:21.294]                 }
[15:32:21.294]             }
[15:32:21.294]         }
[15:32:21.294]     })
[15:32:21.294]     if (TRUE) {
[15:32:21.294]         base::sink(type = "output", split = FALSE)
[15:32:21.294]         if (TRUE) {
[15:32:21.294]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:21.294]         }
[15:32:21.294]         else {
[15:32:21.294]             ...future.result["stdout"] <- base::list(NULL)
[15:32:21.294]         }
[15:32:21.294]         base::close(...future.stdout)
[15:32:21.294]         ...future.stdout <- NULL
[15:32:21.294]     }
[15:32:21.294]     ...future.result$conditions <- ...future.conditions
[15:32:21.294]     ...future.result$finished <- base::Sys.time()
[15:32:21.294]     ...future.result
[15:32:21.294] }
[15:32:21.301] assign_globals() ...
[15:32:21.301] List of 5
[15:32:21.301]  $ ...future.FUN            :function (x)  
[15:32:21.301]  $ future.call.arguments    : list()
[15:32:21.301]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:21.301]  $ ...future.elements_ii    :List of 6
[15:32:21.301]   ..$ a1: int 1
[15:32:21.301]   ..$ a2: int 2
[15:32:21.301]   ..$ b1: int 2
[15:32:21.301]   ..$ b2: int 3
[15:32:21.301]   ..$ c1: int 3
[15:32:21.301]   ..$ c2: int 4
[15:32:21.301]  $ ...future.seeds_ii       : NULL
[15:32:21.301]  $ ...future.globals.maxSize: NULL
[15:32:21.301]  - attr(*, "where")=List of 5
[15:32:21.301]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:21.301]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:21.301]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:21.301]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:21.301]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:21.301]  - attr(*, "resolved")= logi FALSE
[15:32:21.301]  - attr(*, "total_size")= num 848
[15:32:21.301]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:21.301]  - attr(*, "already-done")= logi TRUE
[15:32:21.316] - copied '...future.FUN' to environment
[15:32:21.317] - copied 'future.call.arguments' to environment
[15:32:21.317] - copied '...future.elements_ii' to environment
[15:32:21.317] - copied '...future.seeds_ii' to environment
[15:32:21.318] - copied '...future.globals.maxSize' to environment
[15:32:21.318] assign_globals() ... done
[15:32:21.319] plan(): Setting new future strategy stack:
[15:32:21.319] List of future strategies:
[15:32:21.319] 1. sequential:
[15:32:21.319]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:21.319]    - tweaked: FALSE
[15:32:21.319]    - call: NULL
[15:32:21.320] plan(): nbrOfWorkers() = 1
[15:32:21.323] plan(): Setting new future strategy stack:
[15:32:21.323] List of future strategies:
[15:32:21.323] 1. sequential:
[15:32:21.323]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:21.323]    - tweaked: FALSE
[15:32:21.323]    - call: plan(strategy)
[15:32:21.324] plan(): nbrOfWorkers() = 1
[15:32:21.325] SequentialFuture started (and completed)
[15:32:21.325] - Launch lazy future ... done
[15:32:21.325] run() for 'SequentialFuture' ... done
[15:32:21.326] Created future:
[15:32:21.326] SequentialFuture:
[15:32:21.326] Label: 'future_sapply-1'
[15:32:21.326] Expression:
[15:32:21.326] {
[15:32:21.326]     do.call(function(...) {
[15:32:21.326]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:21.326]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:21.326]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:21.326]             on.exit(options(oopts), add = TRUE)
[15:32:21.326]         }
[15:32:21.326]         {
[15:32:21.326]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:21.326]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:21.326]                 ...future.FUN(...future.X_jj, ...)
[15:32:21.326]             })
[15:32:21.326]         }
[15:32:21.326]     }, args = future.call.arguments)
[15:32:21.326] }
[15:32:21.326] Lazy evaluation: FALSE
[15:32:21.326] Asynchronous evaluation: FALSE
[15:32:21.326] Local evaluation: TRUE
[15:32:21.326] Environment: R_GlobalEnv
[15:32:21.326] Capture standard output: TRUE
[15:32:21.326] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:21.326] Globals: 5 objects totaling 1.16 KiB (function '...future.FUN' of 848 bytes, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 336 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:21.326] Packages: <none>
[15:32:21.326] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:21.326] Resolved: TRUE
[15:32:21.326] Value: 336 bytes of class 'list'
[15:32:21.326] Early signaling: FALSE
[15:32:21.326] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:21.326] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:21.329] Chunk #1 of 1 ... DONE
[15:32:21.329] Launching 1 futures (chunks) ... DONE
[15:32:21.329] Resolving 1 futures (chunks) ...
[15:32:21.330] resolve() on list ...
[15:32:21.330]  recursive: 0
[15:32:21.330]  length: 1
[15:32:21.331] 
[15:32:21.331] resolved() for 'SequentialFuture' ...
[15:32:21.331] - state: 'finished'
[15:32:21.332] - run: TRUE
[15:32:21.332] - result: 'FutureResult'
[15:32:21.332] resolved() for 'SequentialFuture' ... done
[15:32:21.333] Future #1
[15:32:21.333] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:21.333] - nx: 1
[15:32:21.334] - relay: TRUE
[15:32:21.334] - stdout: TRUE
[15:32:21.334] - signal: TRUE
[15:32:21.334] - resignal: FALSE
[15:32:21.335] - force: TRUE
[15:32:21.335] - relayed: [n=1] FALSE
[15:32:21.335] - queued futures: [n=1] FALSE
[15:32:21.336]  - until=1
[15:32:21.336]  - relaying element #1
[15:32:21.336] - relayed: [n=1] TRUE
[15:32:21.337] - queued futures: [n=1] TRUE
[15:32:21.337] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:21.337]  length: 0 (resolved future 1)
[15:32:21.338] Relaying remaining futures
[15:32:21.338] signalConditionsASAP(NULL, pos=0) ...
[15:32:21.338] - nx: 1
[15:32:21.339] - relay: TRUE
[15:32:21.339] - stdout: TRUE
[15:32:21.339] - signal: TRUE
[15:32:21.339] - resignal: FALSE
[15:32:21.340] - force: TRUE
[15:32:21.340] - relayed: [n=1] TRUE
[15:32:21.340] - queued futures: [n=1] TRUE
 - flush all
[15:32:21.341] - relayed: [n=1] TRUE
[15:32:21.341] - queued futures: [n=1] TRUE
[15:32:21.341] signalConditionsASAP(NULL, pos=0) ... done
[15:32:21.342] resolve() on list ... DONE
[15:32:21.342]  - Number of value chunks collected: 1
[15:32:21.343] Resolving 1 futures (chunks) ... DONE
[15:32:21.343] Reducing values from 1 chunks ...
[15:32:21.343]  - Number of values collected after concatenation: 6
[15:32:21.343]  - Number of values expected: 6
[15:32:21.344] Reducing values from 1 chunks ... DONE
[15:32:21.349] future_lapply() ... DONE
List of 2
 $ y0: Named int [1:6] 1 2 2 3 3 4
  ..- attr(*, "names")= chr [1:6] "a1" "a2" "b1" "b2" ...
 $ y1: Named int [1:6] 1 2 2 3 3 4
  ..- attr(*, "names")= chr [1:6] "a1" "a2" "b1" "b2" ...
[15:32:21.353] future_lapply() ...
[15:32:21.355] Number of chunks: 1
[15:32:21.355] getGlobalsAndPackagesXApply() ...
[15:32:21.355]  - future.globals: TRUE
[15:32:21.356] getGlobalsAndPackages() ...
[15:32:21.356] Searching for globals...
[15:32:21.359] - globals found: [2] 'FUN', 'UseMethod'
[15:32:21.359] Searching for globals ... DONE
[15:32:21.360] Resolving globals: FALSE
[15:32:21.361] The total size of the 1 globals is 1.22 KiB (1248 bytes)
[15:32:21.361] The total size of the 1 globals exported for future expression ('FUN()') is 1.22 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.22 KiB of class 'function')
[15:32:21.362] - globals: [1] 'FUN'
[15:32:21.362] 
[15:32:21.362] getGlobalsAndPackages() ... DONE
[15:32:21.363]  - globals found/used: [n=1] 'FUN'
[15:32:21.363]  - needed namespaces: [n=0] 
[15:32:21.363] Finding globals ... DONE
[15:32:21.364]  - use_args: TRUE
[15:32:21.364]  - Getting '...' globals ...
[15:32:21.365] resolve() on list ...
[15:32:21.365]  recursive: 0
[15:32:21.365]  length: 1
[15:32:21.365]  elements: '...'
[15:32:21.366]  length: 0 (resolved future 1)
[15:32:21.366] resolve() on list ... DONE
[15:32:21.366]    - '...' content: [n=0] 
[15:32:21.367] List of 1
[15:32:21.367]  $ ...: list()
[15:32:21.367]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:21.367]  - attr(*, "where")=List of 1
[15:32:21.367]   ..$ ...:<environment: 0x00000276e256e728> 
[15:32:21.367]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:21.367]  - attr(*, "resolved")= logi TRUE
[15:32:21.367]  - attr(*, "total_size")= num NA
[15:32:21.372]  - Getting '...' globals ... DONE
[15:32:21.373] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:21.373] List of 2
[15:32:21.373]  $ ...future.FUN:function (x, ...)  
[15:32:21.373]  $ ...          : list()
[15:32:21.373]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:21.373]  - attr(*, "where")=List of 2
[15:32:21.373]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:21.373]   ..$ ...          :<environment: 0x00000276e256e728> 
[15:32:21.373]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:21.373]  - attr(*, "resolved")= logi FALSE
[15:32:21.373]  - attr(*, "total_size")= num 1248
[15:32:21.379] Packages to be attached in all futures: [n=0] 
[15:32:21.379] getGlobalsAndPackagesXApply() ... DONE
[15:32:21.380] Number of futures (= number of chunks): 1
[15:32:21.380] Launching 1 futures (chunks) ...
[15:32:21.381] Chunk #1 of 1 ...
[15:32:21.381]  - Finding globals in 'X' for chunk #1 ...
[15:32:21.381] getGlobalsAndPackages() ...
[15:32:21.382] Searching for globals...
[15:32:21.382] 
[15:32:21.383] Searching for globals ... DONE
[15:32:21.383] - globals: [0] <none>
[15:32:21.383] getGlobalsAndPackages() ... DONE
[15:32:21.384]    + additional globals found: [n=0] 
[15:32:21.384]    + additional namespaces needed: [n=0] 
[15:32:21.384]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:21.384]  - seeds: <none>
[15:32:21.385]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:21.385] getGlobalsAndPackages() ...
[15:32:21.385] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:21.386] Resolving globals: FALSE
[15:32:21.386] Tweak future expression to call with '...' arguments ...
[15:32:21.386] {
[15:32:21.386]     do.call(function(...) {
[15:32:21.386]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:21.386]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:21.386]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:21.386]             on.exit(options(oopts), add = TRUE)
[15:32:21.386]         }
[15:32:21.386]         {
[15:32:21.386]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:21.386]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:21.386]                 ...future.FUN(...future.X_jj, ...)
[15:32:21.386]             })
[15:32:21.386]         }
[15:32:21.386]     }, args = future.call.arguments)
[15:32:21.386] }
[15:32:21.387] Tweak future expression to call with '...' arguments ... DONE
[15:32:21.388] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:21.389] 
[15:32:21.389] getGlobalsAndPackages() ... DONE
[15:32:21.390] run() for 'Future' ...
[15:32:21.390] - state: 'created'
[15:32:21.390] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:21.391] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:21.392] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:21.392]   - Field: 'label'
[15:32:21.392]   - Field: 'local'
[15:32:21.393]   - Field: 'owner'
[15:32:21.393]   - Field: 'envir'
[15:32:21.393]   - Field: 'packages'
[15:32:21.394]   - Field: 'gc'
[15:32:21.394]   - Field: 'conditions'
[15:32:21.394]   - Field: 'expr'
[15:32:21.395]   - Field: 'uuid'
[15:32:21.395]   - Field: 'seed'
[15:32:21.395]   - Field: 'version'
[15:32:21.396]   - Field: 'result'
[15:32:21.396]   - Field: 'asynchronous'
[15:32:21.396]   - Field: 'calls'
[15:32:21.397]   - Field: 'globals'
[15:32:21.397]   - Field: 'stdout'
[15:32:21.397]   - Field: 'earlySignal'
[15:32:21.398]   - Field: 'lazy'
[15:32:21.402]   - Field: 'state'
[15:32:21.402] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:21.403] - Launch lazy future ...
[15:32:21.403] Packages needed by the future expression (n = 0): <none>
[15:32:21.404] Packages needed by future strategies (n = 0): <none>
[15:32:21.405] {
[15:32:21.405]     {
[15:32:21.405]         {
[15:32:21.405]             ...future.startTime <- base::Sys.time()
[15:32:21.405]             {
[15:32:21.405]                 {
[15:32:21.405]                   {
[15:32:21.405]                     base::local({
[15:32:21.405]                       has_future <- base::requireNamespace("future", 
[15:32:21.405]                         quietly = TRUE)
[15:32:21.405]                       if (has_future) {
[15:32:21.405]                         ns <- base::getNamespace("future")
[15:32:21.405]                         version <- ns[[".package"]][["version"]]
[15:32:21.405]                         if (is.null(version)) 
[15:32:21.405]                           version <- utils::packageVersion("future")
[15:32:21.405]                       }
[15:32:21.405]                       else {
[15:32:21.405]                         version <- NULL
[15:32:21.405]                       }
[15:32:21.405]                       if (!has_future || version < "1.8.0") {
[15:32:21.405]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:21.405]                           "", base::R.version$version.string), 
[15:32:21.405]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:21.405]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:21.405]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:21.405]                             "release", "version")], collapse = " "), 
[15:32:21.405]                           hostname = base::Sys.info()[["nodename"]])
[15:32:21.405]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:21.405]                           info)
[15:32:21.405]                         info <- base::paste(info, collapse = "; ")
[15:32:21.405]                         if (!has_future) {
[15:32:21.405]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:21.405]                             info)
[15:32:21.405]                         }
[15:32:21.405]                         else {
[15:32:21.405]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:21.405]                             info, version)
[15:32:21.405]                         }
[15:32:21.405]                         base::stop(msg)
[15:32:21.405]                       }
[15:32:21.405]                     })
[15:32:21.405]                   }
[15:32:21.405]                   ...future.strategy.old <- future::plan("list")
[15:32:21.405]                   options(future.plan = NULL)
[15:32:21.405]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:21.405]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:21.405]                 }
[15:32:21.405]                 ...future.workdir <- getwd()
[15:32:21.405]             }
[15:32:21.405]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:21.405]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:21.405]         }
[15:32:21.405]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:21.405]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:21.405]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:21.405]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:21.405]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:21.405]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:21.405]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:21.405]             base::names(...future.oldOptions))
[15:32:21.405]     }
[15:32:21.405]     if (FALSE) {
[15:32:21.405]     }
[15:32:21.405]     else {
[15:32:21.405]         if (TRUE) {
[15:32:21.405]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:21.405]                 open = "w")
[15:32:21.405]         }
[15:32:21.405]         else {
[15:32:21.405]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:21.405]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:21.405]         }
[15:32:21.405]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:21.405]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:21.405]             base::sink(type = "output", split = FALSE)
[15:32:21.405]             base::close(...future.stdout)
[15:32:21.405]         }, add = TRUE)
[15:32:21.405]     }
[15:32:21.405]     ...future.frame <- base::sys.nframe()
[15:32:21.405]     ...future.conditions <- base::list()
[15:32:21.405]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:21.405]     if (FALSE) {
[15:32:21.405]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:21.405]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:21.405]     }
[15:32:21.405]     ...future.result <- base::tryCatch({
[15:32:21.405]         base::withCallingHandlers({
[15:32:21.405]             ...future.value <- base::withVisible(base::local({
[15:32:21.405]                 do.call(function(...) {
[15:32:21.405]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:21.405]                   if (!identical(...future.globals.maxSize.org, 
[15:32:21.405]                     ...future.globals.maxSize)) {
[15:32:21.405]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:21.405]                     on.exit(options(oopts), add = TRUE)
[15:32:21.405]                   }
[15:32:21.405]                   {
[15:32:21.405]                     lapply(seq_along(...future.elements_ii), 
[15:32:21.405]                       FUN = function(jj) {
[15:32:21.405]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:21.405]                         ...future.FUN(...future.X_jj, ...)
[15:32:21.405]                       })
[15:32:21.405]                   }
[15:32:21.405]                 }, args = future.call.arguments)
[15:32:21.405]             }))
[15:32:21.405]             future::FutureResult(value = ...future.value$value, 
[15:32:21.405]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:21.405]                   ...future.rng), globalenv = if (FALSE) 
[15:32:21.405]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:21.405]                     ...future.globalenv.names))
[15:32:21.405]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:21.405]         }, condition = base::local({
[15:32:21.405]             c <- base::c
[15:32:21.405]             inherits <- base::inherits
[15:32:21.405]             invokeRestart <- base::invokeRestart
[15:32:21.405]             length <- base::length
[15:32:21.405]             list <- base::list
[15:32:21.405]             seq.int <- base::seq.int
[15:32:21.405]             signalCondition <- base::signalCondition
[15:32:21.405]             sys.calls <- base::sys.calls
[15:32:21.405]             `[[` <- base::`[[`
[15:32:21.405]             `+` <- base::`+`
[15:32:21.405]             `<<-` <- base::`<<-`
[15:32:21.405]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:21.405]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:21.405]                   3L)]
[15:32:21.405]             }
[15:32:21.405]             function(cond) {
[15:32:21.405]                 is_error <- inherits(cond, "error")
[15:32:21.405]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:21.405]                   NULL)
[15:32:21.405]                 if (is_error) {
[15:32:21.405]                   sessionInformation <- function() {
[15:32:21.405]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:21.405]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:21.405]                       search = base::search(), system = base::Sys.info())
[15:32:21.405]                   }
[15:32:21.405]                   ...future.conditions[[length(...future.conditions) + 
[15:32:21.405]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:21.405]                     cond$call), session = sessionInformation(), 
[15:32:21.405]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:21.405]                   signalCondition(cond)
[15:32:21.405]                 }
[15:32:21.405]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:21.405]                 "immediateCondition"))) {
[15:32:21.405]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:21.405]                   ...future.conditions[[length(...future.conditions) + 
[15:32:21.405]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:21.405]                   if (TRUE && !signal) {
[15:32:21.405]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:21.405]                     {
[15:32:21.405]                       inherits <- base::inherits
[15:32:21.405]                       invokeRestart <- base::invokeRestart
[15:32:21.405]                       is.null <- base::is.null
[15:32:21.405]                       muffled <- FALSE
[15:32:21.405]                       if (inherits(cond, "message")) {
[15:32:21.405]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:21.405]                         if (muffled) 
[15:32:21.405]                           invokeRestart("muffleMessage")
[15:32:21.405]                       }
[15:32:21.405]                       else if (inherits(cond, "warning")) {
[15:32:21.405]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:21.405]                         if (muffled) 
[15:32:21.405]                           invokeRestart("muffleWarning")
[15:32:21.405]                       }
[15:32:21.405]                       else if (inherits(cond, "condition")) {
[15:32:21.405]                         if (!is.null(pattern)) {
[15:32:21.405]                           computeRestarts <- base::computeRestarts
[15:32:21.405]                           grepl <- base::grepl
[15:32:21.405]                           restarts <- computeRestarts(cond)
[15:32:21.405]                           for (restart in restarts) {
[15:32:21.405]                             name <- restart$name
[15:32:21.405]                             if (is.null(name)) 
[15:32:21.405]                               next
[15:32:21.405]                             if (!grepl(pattern, name)) 
[15:32:21.405]                               next
[15:32:21.405]                             invokeRestart(restart)
[15:32:21.405]                             muffled <- TRUE
[15:32:21.405]                             break
[15:32:21.405]                           }
[15:32:21.405]                         }
[15:32:21.405]                       }
[15:32:21.405]                       invisible(muffled)
[15:32:21.405]                     }
[15:32:21.405]                     muffleCondition(cond, pattern = "^muffle")
[15:32:21.405]                   }
[15:32:21.405]                 }
[15:32:21.405]                 else {
[15:32:21.405]                   if (TRUE) {
[15:32:21.405]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:21.405]                     {
[15:32:21.405]                       inherits <- base::inherits
[15:32:21.405]                       invokeRestart <- base::invokeRestart
[15:32:21.405]                       is.null <- base::is.null
[15:32:21.405]                       muffled <- FALSE
[15:32:21.405]                       if (inherits(cond, "message")) {
[15:32:21.405]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:21.405]                         if (muffled) 
[15:32:21.405]                           invokeRestart("muffleMessage")
[15:32:21.405]                       }
[15:32:21.405]                       else if (inherits(cond, "warning")) {
[15:32:21.405]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:21.405]                         if (muffled) 
[15:32:21.405]                           invokeRestart("muffleWarning")
[15:32:21.405]                       }
[15:32:21.405]                       else if (inherits(cond, "condition")) {
[15:32:21.405]                         if (!is.null(pattern)) {
[15:32:21.405]                           computeRestarts <- base::computeRestarts
[15:32:21.405]                           grepl <- base::grepl
[15:32:21.405]                           restarts <- computeRestarts(cond)
[15:32:21.405]                           for (restart in restarts) {
[15:32:21.405]                             name <- restart$name
[15:32:21.405]                             if (is.null(name)) 
[15:32:21.405]                               next
[15:32:21.405]                             if (!grepl(pattern, name)) 
[15:32:21.405]                               next
[15:32:21.405]                             invokeRestart(restart)
[15:32:21.405]                             muffled <- TRUE
[15:32:21.405]                             break
[15:32:21.405]                           }
[15:32:21.405]                         }
[15:32:21.405]                       }
[15:32:21.405]                       invisible(muffled)
[15:32:21.405]                     }
[15:32:21.405]                     muffleCondition(cond, pattern = "^muffle")
[15:32:21.405]                   }
[15:32:21.405]                 }
[15:32:21.405]             }
[15:32:21.405]         }))
[15:32:21.405]     }, error = function(ex) {
[15:32:21.405]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:21.405]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:21.405]                 ...future.rng), started = ...future.startTime, 
[15:32:21.405]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:21.405]             version = "1.8"), class = "FutureResult")
[15:32:21.405]     }, finally = {
[15:32:21.405]         if (!identical(...future.workdir, getwd())) 
[15:32:21.405]             setwd(...future.workdir)
[15:32:21.405]         {
[15:32:21.405]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:21.405]                 ...future.oldOptions$nwarnings <- NULL
[15:32:21.405]             }
[15:32:21.405]             base::options(...future.oldOptions)
[15:32:21.405]             if (.Platform$OS.type == "windows") {
[15:32:21.405]                 old_names <- names(...future.oldEnvVars)
[15:32:21.405]                 envs <- base::Sys.getenv()
[15:32:21.405]                 names <- names(envs)
[15:32:21.405]                 common <- intersect(names, old_names)
[15:32:21.405]                 added <- setdiff(names, old_names)
[15:32:21.405]                 removed <- setdiff(old_names, names)
[15:32:21.405]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:21.405]                   envs[common]]
[15:32:21.405]                 NAMES <- toupper(changed)
[15:32:21.405]                 args <- list()
[15:32:21.405]                 for (kk in seq_along(NAMES)) {
[15:32:21.405]                   name <- changed[[kk]]
[15:32:21.405]                   NAME <- NAMES[[kk]]
[15:32:21.405]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:21.405]                     next
[15:32:21.405]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:21.405]                 }
[15:32:21.405]                 NAMES <- toupper(added)
[15:32:21.405]                 for (kk in seq_along(NAMES)) {
[15:32:21.405]                   name <- added[[kk]]
[15:32:21.405]                   NAME <- NAMES[[kk]]
[15:32:21.405]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:21.405]                     next
[15:32:21.405]                   args[[name]] <- ""
[15:32:21.405]                 }
[15:32:21.405]                 NAMES <- toupper(removed)
[15:32:21.405]                 for (kk in seq_along(NAMES)) {
[15:32:21.405]                   name <- removed[[kk]]
[15:32:21.405]                   NAME <- NAMES[[kk]]
[15:32:21.405]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:21.405]                     next
[15:32:21.405]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:21.405]                 }
[15:32:21.405]                 if (length(args) > 0) 
[15:32:21.405]                   base::do.call(base::Sys.setenv, args = args)
[15:32:21.405]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:21.405]             }
[15:32:21.405]             else {
[15:32:21.405]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:21.405]             }
[15:32:21.405]             {
[15:32:21.405]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:21.405]                   0L) {
[15:32:21.405]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:21.405]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:21.405]                   base::options(opts)
[15:32:21.405]                 }
[15:32:21.405]                 {
[15:32:21.405]                   {
[15:32:21.405]                     NULL
[15:32:21.405]                     RNGkind("Mersenne-Twister")
[15:32:21.405]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:21.405]                       inherits = FALSE)
[15:32:21.405]                   }
[15:32:21.405]                   options(future.plan = NULL)
[15:32:21.405]                   if (is.na(NA_character_)) 
[15:32:21.405]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:21.405]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:21.405]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:21.405]                     .init = FALSE)
[15:32:21.405]                 }
[15:32:21.405]             }
[15:32:21.405]         }
[15:32:21.405]     })
[15:32:21.405]     if (TRUE) {
[15:32:21.405]         base::sink(type = "output", split = FALSE)
[15:32:21.405]         if (TRUE) {
[15:32:21.405]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:21.405]         }
[15:32:21.405]         else {
[15:32:21.405]             ...future.result["stdout"] <- base::list(NULL)
[15:32:21.405]         }
[15:32:21.405]         base::close(...future.stdout)
[15:32:21.405]         ...future.stdout <- NULL
[15:32:21.405]     }
[15:32:21.405]     ...future.result$conditions <- ...future.conditions
[15:32:21.405]     ...future.result$finished <- base::Sys.time()
[15:32:21.405]     ...future.result
[15:32:21.405] }
[15:32:21.413] assign_globals() ...
[15:32:21.413] List of 5
[15:32:21.413]  $ ...future.FUN            :function (x, ...)  
[15:32:21.413]  $ future.call.arguments    : list()
[15:32:21.413]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:21.413]  $ ...future.elements_ii    :List of 6
[15:32:21.413]   ..$ a1: int 1
[15:32:21.413]   ..$ a2: int 2
[15:32:21.413]   ..$ b1: int 2
[15:32:21.413]   ..$ b2: int 3
[15:32:21.413]   ..$ c1: int 3
[15:32:21.413]   ..$ c2: int 4
[15:32:21.413]  $ ...future.seeds_ii       : NULL
[15:32:21.413]  $ ...future.globals.maxSize: NULL
[15:32:21.413]  - attr(*, "where")=List of 5
[15:32:21.413]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:21.413]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:21.413]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:21.413]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:21.413]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:21.413]  - attr(*, "resolved")= logi FALSE
[15:32:21.413]  - attr(*, "total_size")= num 1248
[15:32:21.413]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:21.413]  - attr(*, "already-done")= logi TRUE
[15:32:21.428] - copied '...future.FUN' to environment
[15:32:21.428] - copied 'future.call.arguments' to environment
[15:32:21.429] - copied '...future.elements_ii' to environment
[15:32:21.429] - copied '...future.seeds_ii' to environment
[15:32:21.429] - copied '...future.globals.maxSize' to environment
[15:32:21.430] assign_globals() ... done
[15:32:21.430] plan(): Setting new future strategy stack:
[15:32:21.431] List of future strategies:
[15:32:21.431] 1. sequential:
[15:32:21.431]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:21.431]    - tweaked: FALSE
[15:32:21.431]    - call: NULL
[15:32:21.432] plan(): nbrOfWorkers() = 1
[15:32:21.434] plan(): Setting new future strategy stack:
[15:32:21.435] List of future strategies:
[15:32:21.435] 1. sequential:
[15:32:21.435]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:21.435]    - tweaked: FALSE
[15:32:21.435]    - call: plan(strategy)
[15:32:21.436] plan(): nbrOfWorkers() = 1
[15:32:21.436] SequentialFuture started (and completed)
[15:32:21.436] - Launch lazy future ... done
[15:32:21.437] run() for 'SequentialFuture' ... done
[15:32:21.437] Created future:
[15:32:21.437] SequentialFuture:
[15:32:21.437] Label: 'future_sapply-1'
[15:32:21.437] Expression:
[15:32:21.437] {
[15:32:21.437]     do.call(function(...) {
[15:32:21.437]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:21.437]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:21.437]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:21.437]             on.exit(options(oopts), add = TRUE)
[15:32:21.437]         }
[15:32:21.437]         {
[15:32:21.437]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:21.437]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:21.437]                 ...future.FUN(...future.X_jj, ...)
[15:32:21.437]             })
[15:32:21.437]         }
[15:32:21.437]     }, args = future.call.arguments)
[15:32:21.437] }
[15:32:21.437] Lazy evaluation: FALSE
[15:32:21.437] Asynchronous evaluation: FALSE
[15:32:21.437] Local evaluation: TRUE
[15:32:21.437] Environment: R_GlobalEnv
[15:32:21.437] Capture standard output: TRUE
[15:32:21.437] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:21.437] Globals: 5 objects totaling 1.55 KiB (function '...future.FUN' of 1.22 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 336 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:21.437] Packages: <none>
[15:32:21.437] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:21.437] Resolved: TRUE
[15:32:21.437] Value: 1.31 KiB of class 'list'
[15:32:21.437] Early signaling: FALSE
[15:32:21.437] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:21.437] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:21.440] Chunk #1 of 1 ... DONE
[15:32:21.440] Launching 1 futures (chunks) ... DONE
[15:32:21.441] Resolving 1 futures (chunks) ...
[15:32:21.441] resolve() on list ...
[15:32:21.441]  recursive: 0
[15:32:21.442]  length: 1
[15:32:21.442] 
[15:32:21.442] resolved() for 'SequentialFuture' ...
[15:32:21.443] - state: 'finished'
[15:32:21.443] - run: TRUE
[15:32:21.443] - result: 'FutureResult'
[15:32:21.444] resolved() for 'SequentialFuture' ... done
[15:32:21.444] Future #1
[15:32:21.444] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:21.445] - nx: 1
[15:32:21.445] - relay: TRUE
[15:32:21.445] - stdout: TRUE
[15:32:21.446] - signal: TRUE
[15:32:21.446] - resignal: FALSE
[15:32:21.446] - force: TRUE
[15:32:21.446] - relayed: [n=1] FALSE
[15:32:21.447] - queued futures: [n=1] FALSE
[15:32:21.447]  - until=1
[15:32:21.447]  - relaying element #1
[15:32:21.448] - relayed: [n=1] TRUE
[15:32:21.448] - queued futures: [n=1] TRUE
[15:32:21.449] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:21.449]  length: 0 (resolved future 1)
[15:32:21.449] Relaying remaining futures
[15:32:21.450] signalConditionsASAP(NULL, pos=0) ...
[15:32:21.450] - nx: 1
[15:32:21.450] - relay: TRUE
[15:32:21.450] - stdout: TRUE
[15:32:21.451] - signal: TRUE
[15:32:21.451] - resignal: FALSE
[15:32:21.451] - force: TRUE
[15:32:21.452] - relayed: [n=1] TRUE
[15:32:21.452] - queued futures: [n=1] TRUE
 - flush all
[15:32:21.452] - relayed: [n=1] TRUE
[15:32:21.453] - queued futures: [n=1] TRUE
[15:32:21.453] signalConditionsASAP(NULL, pos=0) ... done
[15:32:21.453] resolve() on list ... DONE
[15:32:21.454]  - Number of value chunks collected: 1
[15:32:21.454] Resolving 1 futures (chunks) ... DONE
[15:32:21.454] Reducing values from 1 chunks ...
[15:32:21.455]  - Number of values collected after concatenation: 6
[15:32:21.455]  - Number of values expected: 6
[15:32:21.455] Reducing values from 1 chunks ... DONE
[15:32:21.456] future_lapply() ... DONE
List of 2
 $ y0: Named int [1:6] 1 2 2 3 3 4
  ..- attr(*, "names")= chr [1:6] "a1" "a2" "b1" "b2" ...
 $ y1: Named int [1:6] 1 2 2 3 3 4
  ..- attr(*, "names")= chr [1:6] "a1" "a2" "b1" "b2" ...
[15:32:21.464] future_lapply() ...
[15:32:21.466] Number of chunks: 1
[15:32:21.467] getGlobalsAndPackagesXApply() ...
[15:32:21.467]  - future.globals: TRUE
[15:32:21.467] getGlobalsAndPackages() ...
[15:32:21.468] Searching for globals...
[15:32:21.472] - globals found: [5] 'FUN', '*', ':', 'outer', 'rep'
[15:32:21.472] Searching for globals ... DONE
[15:32:21.472] Resolving globals: FALSE
[15:32:21.473] The total size of the 1 globals is 4.62 KiB (4728 bytes)
[15:32:21.474] The total size of the 1 globals exported for future expression ('FUN()') is 4.62 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.62 KiB of class 'function')
[15:32:21.474] - globals: [1] 'FUN'
[15:32:21.475] 
[15:32:21.475] getGlobalsAndPackages() ... DONE
[15:32:21.475]  - globals found/used: [n=1] 'FUN'
[15:32:21.476]  - needed namespaces: [n=0] 
[15:32:21.476] Finding globals ... DONE
[15:32:21.476]  - use_args: TRUE
[15:32:21.476]  - Getting '...' globals ...
[15:32:21.477] resolve() on list ...
[15:32:21.477]  recursive: 0
[15:32:21.478]  length: 1
[15:32:21.478]  elements: '...'
[15:32:21.478]  length: 0 (resolved future 1)
[15:32:21.479] resolve() on list ... DONE
[15:32:21.479]    - '...' content: [n=0] 
[15:32:21.479] List of 1
[15:32:21.479]  $ ...: list()
[15:32:21.479]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:21.479]  - attr(*, "where")=List of 1
[15:32:21.479]   ..$ ...:<environment: 0x00000276e1c187a0> 
[15:32:21.479]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:21.479]  - attr(*, "resolved")= logi TRUE
[15:32:21.479]  - attr(*, "total_size")= num NA
[15:32:21.485]  - Getting '...' globals ... DONE
[15:32:21.485] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:21.486] List of 2
[15:32:21.486]  $ ...future.FUN:function (x, y = 2 * 1:5)  
[15:32:21.486]  $ ...          : list()
[15:32:21.486]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:21.486]  - attr(*, "where")=List of 2
[15:32:21.486]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:21.486]   ..$ ...          :<environment: 0x00000276e1c187a0> 
[15:32:21.486]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:21.486]  - attr(*, "resolved")= logi FALSE
[15:32:21.486]  - attr(*, "total_size")= num 4728
[15:32:21.492] Packages to be attached in all futures: [n=0] 
[15:32:21.492] getGlobalsAndPackagesXApply() ... DONE
[15:32:21.492] Number of futures (= number of chunks): 1
[15:32:21.493] Launching 1 futures (chunks) ...
[15:32:21.493] Chunk #1 of 1 ...
[15:32:21.494]  - Finding globals in 'X' for chunk #1 ...
[15:32:21.494] getGlobalsAndPackages() ...
[15:32:21.494] Searching for globals...
[15:32:21.495] 
[15:32:21.495] Searching for globals ... DONE
[15:32:21.495] - globals: [0] <none>
[15:32:21.496] getGlobalsAndPackages() ... DONE
[15:32:21.496]    + additional globals found: [n=0] 
[15:32:21.496]    + additional namespaces needed: [n=0] 
[15:32:21.497]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:21.497]  - seeds: <none>
[15:32:21.497]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:21.498] getGlobalsAndPackages() ...
[15:32:21.498] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:21.498] Resolving globals: FALSE
[15:32:21.499] Tweak future expression to call with '...' arguments ...
[15:32:21.499] {
[15:32:21.499]     do.call(function(...) {
[15:32:21.499]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:21.499]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:21.499]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:21.499]             on.exit(options(oopts), add = TRUE)
[15:32:21.499]         }
[15:32:21.499]         {
[15:32:21.499]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:21.499]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:21.499]                 ...future.FUN(...future.X_jj, ...)
[15:32:21.499]             })
[15:32:21.499]         }
[15:32:21.499]     }, args = future.call.arguments)
[15:32:21.499] }
[15:32:21.500] Tweak future expression to call with '...' arguments ... DONE
[15:32:21.501] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:21.501] 
[15:32:21.501] getGlobalsAndPackages() ... DONE
[15:32:21.502] run() for 'Future' ...
[15:32:21.503] - state: 'created'
[15:32:21.503] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:21.504] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:21.504] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:21.504]   - Field: 'label'
[15:32:21.505]   - Field: 'local'
[15:32:21.505]   - Field: 'owner'
[15:32:21.505]   - Field: 'envir'
[15:32:21.506]   - Field: 'packages'
[15:32:21.506]   - Field: 'gc'
[15:32:21.506]   - Field: 'conditions'
[15:32:21.507]   - Field: 'expr'
[15:32:21.507]   - Field: 'uuid'
[15:32:21.507]   - Field: 'seed'
[15:32:21.508]   - Field: 'version'
[15:32:21.508]   - Field: 'result'
[15:32:21.508]   - Field: 'asynchronous'
[15:32:21.513]   - Field: 'calls'
[15:32:21.514]   - Field: 'globals'
[15:32:21.514]   - Field: 'stdout'
[15:32:21.515]   - Field: 'earlySignal'
[15:32:21.515]   - Field: 'lazy'
[15:32:21.515]   - Field: 'state'
[15:32:21.516] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:21.516] - Launch lazy future ...
[15:32:21.517] Packages needed by the future expression (n = 0): <none>
[15:32:21.517] Packages needed by future strategies (n = 0): <none>
[15:32:21.518] {
[15:32:21.518]     {
[15:32:21.518]         {
[15:32:21.518]             ...future.startTime <- base::Sys.time()
[15:32:21.518]             {
[15:32:21.518]                 {
[15:32:21.518]                   {
[15:32:21.518]                     base::local({
[15:32:21.518]                       has_future <- base::requireNamespace("future", 
[15:32:21.518]                         quietly = TRUE)
[15:32:21.518]                       if (has_future) {
[15:32:21.518]                         ns <- base::getNamespace("future")
[15:32:21.518]                         version <- ns[[".package"]][["version"]]
[15:32:21.518]                         if (is.null(version)) 
[15:32:21.518]                           version <- utils::packageVersion("future")
[15:32:21.518]                       }
[15:32:21.518]                       else {
[15:32:21.518]                         version <- NULL
[15:32:21.518]                       }
[15:32:21.518]                       if (!has_future || version < "1.8.0") {
[15:32:21.518]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:21.518]                           "", base::R.version$version.string), 
[15:32:21.518]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:21.518]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:21.518]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:21.518]                             "release", "version")], collapse = " "), 
[15:32:21.518]                           hostname = base::Sys.info()[["nodename"]])
[15:32:21.518]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:21.518]                           info)
[15:32:21.518]                         info <- base::paste(info, collapse = "; ")
[15:32:21.518]                         if (!has_future) {
[15:32:21.518]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:21.518]                             info)
[15:32:21.518]                         }
[15:32:21.518]                         else {
[15:32:21.518]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:21.518]                             info, version)
[15:32:21.518]                         }
[15:32:21.518]                         base::stop(msg)
[15:32:21.518]                       }
[15:32:21.518]                     })
[15:32:21.518]                   }
[15:32:21.518]                   ...future.strategy.old <- future::plan("list")
[15:32:21.518]                   options(future.plan = NULL)
[15:32:21.518]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:21.518]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:21.518]                 }
[15:32:21.518]                 ...future.workdir <- getwd()
[15:32:21.518]             }
[15:32:21.518]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:21.518]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:21.518]         }
[15:32:21.518]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:21.518]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:21.518]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:21.518]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:21.518]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:21.518]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:21.518]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:21.518]             base::names(...future.oldOptions))
[15:32:21.518]     }
[15:32:21.518]     if (FALSE) {
[15:32:21.518]     }
[15:32:21.518]     else {
[15:32:21.518]         if (TRUE) {
[15:32:21.518]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:21.518]                 open = "w")
[15:32:21.518]         }
[15:32:21.518]         else {
[15:32:21.518]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:21.518]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:21.518]         }
[15:32:21.518]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:21.518]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:21.518]             base::sink(type = "output", split = FALSE)
[15:32:21.518]             base::close(...future.stdout)
[15:32:21.518]         }, add = TRUE)
[15:32:21.518]     }
[15:32:21.518]     ...future.frame <- base::sys.nframe()
[15:32:21.518]     ...future.conditions <- base::list()
[15:32:21.518]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:21.518]     if (FALSE) {
[15:32:21.518]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:21.518]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:21.518]     }
[15:32:21.518]     ...future.result <- base::tryCatch({
[15:32:21.518]         base::withCallingHandlers({
[15:32:21.518]             ...future.value <- base::withVisible(base::local({
[15:32:21.518]                 do.call(function(...) {
[15:32:21.518]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:21.518]                   if (!identical(...future.globals.maxSize.org, 
[15:32:21.518]                     ...future.globals.maxSize)) {
[15:32:21.518]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:21.518]                     on.exit(options(oopts), add = TRUE)
[15:32:21.518]                   }
[15:32:21.518]                   {
[15:32:21.518]                     lapply(seq_along(...future.elements_ii), 
[15:32:21.518]                       FUN = function(jj) {
[15:32:21.518]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:21.518]                         ...future.FUN(...future.X_jj, ...)
[15:32:21.518]                       })
[15:32:21.518]                   }
[15:32:21.518]                 }, args = future.call.arguments)
[15:32:21.518]             }))
[15:32:21.518]             future::FutureResult(value = ...future.value$value, 
[15:32:21.518]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:21.518]                   ...future.rng), globalenv = if (FALSE) 
[15:32:21.518]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:21.518]                     ...future.globalenv.names))
[15:32:21.518]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:21.518]         }, condition = base::local({
[15:32:21.518]             c <- base::c
[15:32:21.518]             inherits <- base::inherits
[15:32:21.518]             invokeRestart <- base::invokeRestart
[15:32:21.518]             length <- base::length
[15:32:21.518]             list <- base::list
[15:32:21.518]             seq.int <- base::seq.int
[15:32:21.518]             signalCondition <- base::signalCondition
[15:32:21.518]             sys.calls <- base::sys.calls
[15:32:21.518]             `[[` <- base::`[[`
[15:32:21.518]             `+` <- base::`+`
[15:32:21.518]             `<<-` <- base::`<<-`
[15:32:21.518]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:21.518]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:21.518]                   3L)]
[15:32:21.518]             }
[15:32:21.518]             function(cond) {
[15:32:21.518]                 is_error <- inherits(cond, "error")
[15:32:21.518]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:21.518]                   NULL)
[15:32:21.518]                 if (is_error) {
[15:32:21.518]                   sessionInformation <- function() {
[15:32:21.518]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:21.518]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:21.518]                       search = base::search(), system = base::Sys.info())
[15:32:21.518]                   }
[15:32:21.518]                   ...future.conditions[[length(...future.conditions) + 
[15:32:21.518]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:21.518]                     cond$call), session = sessionInformation(), 
[15:32:21.518]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:21.518]                   signalCondition(cond)
[15:32:21.518]                 }
[15:32:21.518]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:21.518]                 "immediateCondition"))) {
[15:32:21.518]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:21.518]                   ...future.conditions[[length(...future.conditions) + 
[15:32:21.518]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:21.518]                   if (TRUE && !signal) {
[15:32:21.518]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:21.518]                     {
[15:32:21.518]                       inherits <- base::inherits
[15:32:21.518]                       invokeRestart <- base::invokeRestart
[15:32:21.518]                       is.null <- base::is.null
[15:32:21.518]                       muffled <- FALSE
[15:32:21.518]                       if (inherits(cond, "message")) {
[15:32:21.518]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:21.518]                         if (muffled) 
[15:32:21.518]                           invokeRestart("muffleMessage")
[15:32:21.518]                       }
[15:32:21.518]                       else if (inherits(cond, "warning")) {
[15:32:21.518]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:21.518]                         if (muffled) 
[15:32:21.518]                           invokeRestart("muffleWarning")
[15:32:21.518]                       }
[15:32:21.518]                       else if (inherits(cond, "condition")) {
[15:32:21.518]                         if (!is.null(pattern)) {
[15:32:21.518]                           computeRestarts <- base::computeRestarts
[15:32:21.518]                           grepl <- base::grepl
[15:32:21.518]                           restarts <- computeRestarts(cond)
[15:32:21.518]                           for (restart in restarts) {
[15:32:21.518]                             name <- restart$name
[15:32:21.518]                             if (is.null(name)) 
[15:32:21.518]                               next
[15:32:21.518]                             if (!grepl(pattern, name)) 
[15:32:21.518]                               next
[15:32:21.518]                             invokeRestart(restart)
[15:32:21.518]                             muffled <- TRUE
[15:32:21.518]                             break
[15:32:21.518]                           }
[15:32:21.518]                         }
[15:32:21.518]                       }
[15:32:21.518]                       invisible(muffled)
[15:32:21.518]                     }
[15:32:21.518]                     muffleCondition(cond, pattern = "^muffle")
[15:32:21.518]                   }
[15:32:21.518]                 }
[15:32:21.518]                 else {
[15:32:21.518]                   if (TRUE) {
[15:32:21.518]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:21.518]                     {
[15:32:21.518]                       inherits <- base::inherits
[15:32:21.518]                       invokeRestart <- base::invokeRestart
[15:32:21.518]                       is.null <- base::is.null
[15:32:21.518]                       muffled <- FALSE
[15:32:21.518]                       if (inherits(cond, "message")) {
[15:32:21.518]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:21.518]                         if (muffled) 
[15:32:21.518]                           invokeRestart("muffleMessage")
[15:32:21.518]                       }
[15:32:21.518]                       else if (inherits(cond, "warning")) {
[15:32:21.518]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:21.518]                         if (muffled) 
[15:32:21.518]                           invokeRestart("muffleWarning")
[15:32:21.518]                       }
[15:32:21.518]                       else if (inherits(cond, "condition")) {
[15:32:21.518]                         if (!is.null(pattern)) {
[15:32:21.518]                           computeRestarts <- base::computeRestarts
[15:32:21.518]                           grepl <- base::grepl
[15:32:21.518]                           restarts <- computeRestarts(cond)
[15:32:21.518]                           for (restart in restarts) {
[15:32:21.518]                             name <- restart$name
[15:32:21.518]                             if (is.null(name)) 
[15:32:21.518]                               next
[15:32:21.518]                             if (!grepl(pattern, name)) 
[15:32:21.518]                               next
[15:32:21.518]                             invokeRestart(restart)
[15:32:21.518]                             muffled <- TRUE
[15:32:21.518]                             break
[15:32:21.518]                           }
[15:32:21.518]                         }
[15:32:21.518]                       }
[15:32:21.518]                       invisible(muffled)
[15:32:21.518]                     }
[15:32:21.518]                     muffleCondition(cond, pattern = "^muffle")
[15:32:21.518]                   }
[15:32:21.518]                 }
[15:32:21.518]             }
[15:32:21.518]         }))
[15:32:21.518]     }, error = function(ex) {
[15:32:21.518]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:21.518]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:21.518]                 ...future.rng), started = ...future.startTime, 
[15:32:21.518]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:21.518]             version = "1.8"), class = "FutureResult")
[15:32:21.518]     }, finally = {
[15:32:21.518]         if (!identical(...future.workdir, getwd())) 
[15:32:21.518]             setwd(...future.workdir)
[15:32:21.518]         {
[15:32:21.518]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:21.518]                 ...future.oldOptions$nwarnings <- NULL
[15:32:21.518]             }
[15:32:21.518]             base::options(...future.oldOptions)
[15:32:21.518]             if (.Platform$OS.type == "windows") {
[15:32:21.518]                 old_names <- names(...future.oldEnvVars)
[15:32:21.518]                 envs <- base::Sys.getenv()
[15:32:21.518]                 names <- names(envs)
[15:32:21.518]                 common <- intersect(names, old_names)
[15:32:21.518]                 added <- setdiff(names, old_names)
[15:32:21.518]                 removed <- setdiff(old_names, names)
[15:32:21.518]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:21.518]                   envs[common]]
[15:32:21.518]                 NAMES <- toupper(changed)
[15:32:21.518]                 args <- list()
[15:32:21.518]                 for (kk in seq_along(NAMES)) {
[15:32:21.518]                   name <- changed[[kk]]
[15:32:21.518]                   NAME <- NAMES[[kk]]
[15:32:21.518]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:21.518]                     next
[15:32:21.518]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:21.518]                 }
[15:32:21.518]                 NAMES <- toupper(added)
[15:32:21.518]                 for (kk in seq_along(NAMES)) {
[15:32:21.518]                   name <- added[[kk]]
[15:32:21.518]                   NAME <- NAMES[[kk]]
[15:32:21.518]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:21.518]                     next
[15:32:21.518]                   args[[name]] <- ""
[15:32:21.518]                 }
[15:32:21.518]                 NAMES <- toupper(removed)
[15:32:21.518]                 for (kk in seq_along(NAMES)) {
[15:32:21.518]                   name <- removed[[kk]]
[15:32:21.518]                   NAME <- NAMES[[kk]]
[15:32:21.518]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:21.518]                     next
[15:32:21.518]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:21.518]                 }
[15:32:21.518]                 if (length(args) > 0) 
[15:32:21.518]                   base::do.call(base::Sys.setenv, args = args)
[15:32:21.518]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:21.518]             }
[15:32:21.518]             else {
[15:32:21.518]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:21.518]             }
[15:32:21.518]             {
[15:32:21.518]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:21.518]                   0L) {
[15:32:21.518]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:21.518]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:21.518]                   base::options(opts)
[15:32:21.518]                 }
[15:32:21.518]                 {
[15:32:21.518]                   {
[15:32:21.518]                     NULL
[15:32:21.518]                     RNGkind("Mersenne-Twister")
[15:32:21.518]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:21.518]                       inherits = FALSE)
[15:32:21.518]                   }
[15:32:21.518]                   options(future.plan = NULL)
[15:32:21.518]                   if (is.na(NA_character_)) 
[15:32:21.518]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:21.518]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:21.518]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:21.518]                     .init = FALSE)
[15:32:21.518]                 }
[15:32:21.518]             }
[15:32:21.518]         }
[15:32:21.518]     })
[15:32:21.518]     if (TRUE) {
[15:32:21.518]         base::sink(type = "output", split = FALSE)
[15:32:21.518]         if (TRUE) {
[15:32:21.518]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:21.518]         }
[15:32:21.518]         else {
[15:32:21.518]             ...future.result["stdout"] <- base::list(NULL)
[15:32:21.518]         }
[15:32:21.518]         base::close(...future.stdout)
[15:32:21.518]         ...future.stdout <- NULL
[15:32:21.518]     }
[15:32:21.518]     ...future.result$conditions <- ...future.conditions
[15:32:21.518]     ...future.result$finished <- base::Sys.time()
[15:32:21.518]     ...future.result
[15:32:21.518] }
[15:32:21.525] assign_globals() ...
[15:32:21.526] List of 5
[15:32:21.526]  $ ...future.FUN            :function (x, y = 2 * 1:5)  
[15:32:21.526]  $ future.call.arguments    : list()
[15:32:21.526]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:21.526]  $ ...future.elements_ii    :List of 6
[15:32:21.526]   ..$ a1: int 1
[15:32:21.526]   ..$ a2: int 2
[15:32:21.526]   ..$ b1: int 2
[15:32:21.526]   ..$ b2: int 3
[15:32:21.526]   ..$ c1: int 3
[15:32:21.526]   ..$ c2: int 4
[15:32:21.526]  $ ...future.seeds_ii       : NULL
[15:32:21.526]  $ ...future.globals.maxSize: NULL
[15:32:21.526]  - attr(*, "where")=List of 5
[15:32:21.526]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:21.526]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:21.526]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:21.526]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:21.526]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:21.526]  - attr(*, "resolved")= logi FALSE
[15:32:21.526]  - attr(*, "total_size")= num 4728
[15:32:21.526]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:21.526]  - attr(*, "already-done")= logi TRUE
[15:32:21.540] - reassign environment for '...future.FUN'
[15:32:21.541] - copied '...future.FUN' to environment
[15:32:21.541] - copied 'future.call.arguments' to environment
[15:32:21.541] - copied '...future.elements_ii' to environment
[15:32:21.542] - copied '...future.seeds_ii' to environment
[15:32:21.542] - copied '...future.globals.maxSize' to environment
[15:32:21.542] assign_globals() ... done
[15:32:21.543] plan(): Setting new future strategy stack:
[15:32:21.543] List of future strategies:
[15:32:21.543] 1. sequential:
[15:32:21.543]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:21.543]    - tweaked: FALSE
[15:32:21.543]    - call: NULL
[15:32:21.545] plan(): nbrOfWorkers() = 1
[15:32:21.547] plan(): Setting new future strategy stack:
[15:32:21.547] List of future strategies:
[15:32:21.547] 1. sequential:
[15:32:21.547]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:21.547]    - tweaked: FALSE
[15:32:21.547]    - call: plan(strategy)
[15:32:21.548] plan(): nbrOfWorkers() = 1
[15:32:21.549] SequentialFuture started (and completed)
[15:32:21.549] - Launch lazy future ... done
[15:32:21.550] run() for 'SequentialFuture' ... done
[15:32:21.550] Created future:
[15:32:21.550] SequentialFuture:
[15:32:21.550] Label: 'future_sapply-1'
[15:32:21.550] Expression:
[15:32:21.550] {
[15:32:21.550]     do.call(function(...) {
[15:32:21.550]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:21.550]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:21.550]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:21.550]             on.exit(options(oopts), add = TRUE)
[15:32:21.550]         }
[15:32:21.550]         {
[15:32:21.550]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:21.550]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:21.550]                 ...future.FUN(...future.X_jj, ...)
[15:32:21.550]             })
[15:32:21.550]         }
[15:32:21.550]     }, args = future.call.arguments)
[15:32:21.550] }
[15:32:21.550] Lazy evaluation: FALSE
[15:32:21.550] Asynchronous evaluation: FALSE
[15:32:21.550] Local evaluation: TRUE
[15:32:21.550] Environment: R_GlobalEnv
[15:32:21.550] Capture standard output: TRUE
[15:32:21.550] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:21.550] Globals: 5 objects totaling 4.95 KiB (function '...future.FUN' of 4.62 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 336 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:21.550] Packages: <none>
[15:32:21.550] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:21.550] Resolved: TRUE
[15:32:21.550] Value: 2.02 KiB of class 'list'
[15:32:21.550] Early signaling: FALSE
[15:32:21.550] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:21.550] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:21.553] Chunk #1 of 1 ... DONE
[15:32:21.553] Launching 1 futures (chunks) ... DONE
[15:32:21.553] Resolving 1 futures (chunks) ...
[15:32:21.554] resolve() on list ...
[15:32:21.554]  recursive: 0
[15:32:21.554]  length: 1
[15:32:21.555] 
[15:32:21.555] resolved() for 'SequentialFuture' ...
[15:32:21.555] - state: 'finished'
[15:32:21.556] - run: TRUE
[15:32:21.556] - result: 'FutureResult'
[15:32:21.556] resolved() for 'SequentialFuture' ... done
[15:32:21.556] Future #1
[15:32:21.557] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:21.557] - nx: 1
[15:32:21.557] - relay: TRUE
[15:32:21.558] - stdout: TRUE
[15:32:21.558] - signal: TRUE
[15:32:21.558] - resignal: FALSE
[15:32:21.559] - force: TRUE
[15:32:21.559] - relayed: [n=1] FALSE
[15:32:21.559] - queued futures: [n=1] FALSE
[15:32:21.559]  - until=1
[15:32:21.560]  - relaying element #1
[15:32:21.560] - relayed: [n=1] TRUE
[15:32:21.560] - queued futures: [n=1] TRUE
[15:32:21.561] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:21.561]  length: 0 (resolved future 1)
[15:32:21.562] Relaying remaining futures
[15:32:21.562] signalConditionsASAP(NULL, pos=0) ...
[15:32:21.562] - nx: 1
[15:32:21.562] - relay: TRUE
[15:32:21.563] - stdout: TRUE
[15:32:21.563] - signal: TRUE
[15:32:21.563] - resignal: FALSE
[15:32:21.563] - force: TRUE
[15:32:21.564] - relayed: [n=1] TRUE
[15:32:21.564] - queued futures: [n=1] TRUE
 - flush all
[15:32:21.565] - relayed: [n=1] TRUE
[15:32:21.565] - queued futures: [n=1] TRUE
[15:32:21.565] signalConditionsASAP(NULL, pos=0) ... done
[15:32:21.565] resolve() on list ... DONE
[15:32:21.566]  - Number of value chunks collected: 1
[15:32:21.566] Resolving 1 futures (chunks) ... DONE
[15:32:21.566] Reducing values from 1 chunks ...
[15:32:21.567]  - Number of values collected after concatenation: 6
[15:32:21.567]  - Number of values expected: 6
[15:32:21.567] Reducing values from 1 chunks ... DONE
[15:32:21.573] future_lapply() ... DONE
List of 2
 $ y0: num [1:15, 1:6] 2 2 2 4 4 4 6 6 6 8 ...
  ..- attr(*, "dimnames")=List of 2
  .. ..$ : NULL
  .. ..$ : chr [1:6] "a1" "a2" "b1" "b2" ...
 $ y1: num [1:15, 1:6] 2 2 2 4 4 4 6 6 6 8 ...
  ..- attr(*, "dimnames")=List of 2
  .. ..$ : NULL
  .. ..$ : chr [1:6] "a1" "a2" "b1" "b2" ...
[15:32:21.580] future_lapply() ...
[15:32:21.582] Number of chunks: 1
[15:32:21.582] getGlobalsAndPackagesXApply() ...
[15:32:21.582]  - future.globals: TRUE
[15:32:21.583] getGlobalsAndPackages() ...
[15:32:21.583] Searching for globals...
[15:32:21.585] - globals found: [1] 'FUN'
[15:32:21.586] Searching for globals ... DONE
[15:32:21.586] Resolving globals: FALSE
[15:32:21.587] The total size of the 1 globals is 848 bytes (848 bytes)
[15:32:21.587] The total size of the 1 globals exported for future expression ('FUN()') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:32:21.588] - globals: [1] 'FUN'
[15:32:21.588] 
[15:32:21.588] getGlobalsAndPackages() ... DONE
[15:32:21.589]  - globals found/used: [n=1] 'FUN'
[15:32:21.589]  - needed namespaces: [n=0] 
[15:32:21.589] Finding globals ... DONE
[15:32:21.590]  - use_args: TRUE
[15:32:21.590]  - Getting '...' globals ...
[15:32:21.591] resolve() on list ...
[15:32:21.591]  recursive: 0
[15:32:21.591]  length: 1
[15:32:21.592]  elements: '...'
[15:32:21.592]  length: 0 (resolved future 1)
[15:32:21.592] resolve() on list ... DONE
[15:32:21.593]    - '...' content: [n=0] 
[15:32:21.593] List of 1
[15:32:21.593]  $ ...: list()
[15:32:21.593]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:21.593]  - attr(*, "where")=List of 1
[15:32:21.593]   ..$ ...:<environment: 0x00000276e23666f0> 
[15:32:21.593]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:21.593]  - attr(*, "resolved")= logi TRUE
[15:32:21.593]  - attr(*, "total_size")= num NA
[15:32:21.599]  - Getting '...' globals ... DONE
[15:32:21.599] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:21.600] List of 2
[15:32:21.600]  $ ...future.FUN:function (x)  
[15:32:21.600]  $ ...          : list()
[15:32:21.600]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:21.600]  - attr(*, "where")=List of 2
[15:32:21.600]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:21.600]   ..$ ...          :<environment: 0x00000276e23666f0> 
[15:32:21.600]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:21.600]  - attr(*, "resolved")= logi FALSE
[15:32:21.600]  - attr(*, "total_size")= num 848
[15:32:21.606] Packages to be attached in all futures: [n=0] 
[15:32:21.606] getGlobalsAndPackagesXApply() ... DONE
[15:32:21.606] Number of futures (= number of chunks): 1
[15:32:21.607] Launching 1 futures (chunks) ...
[15:32:21.607] Chunk #1 of 1 ...
[15:32:21.607]  - Finding globals in 'X' for chunk #1 ...
[15:32:21.608] getGlobalsAndPackages() ...
[15:32:21.608] Searching for globals...
[15:32:21.609] 
[15:32:21.609] Searching for globals ... DONE
[15:32:21.609] - globals: [0] <none>
[15:32:21.610] getGlobalsAndPackages() ... DONE
[15:32:21.610]    + additional globals found: [n=0] 
[15:32:21.610]    + additional namespaces needed: [n=0] 
[15:32:21.611]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:21.611]  - seeds: <none>
[15:32:21.611]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:21.612] getGlobalsAndPackages() ...
[15:32:21.612] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:21.612] Resolving globals: FALSE
[15:32:21.613] Tweak future expression to call with '...' arguments ...
[15:32:21.613] {
[15:32:21.613]     do.call(function(...) {
[15:32:21.613]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:21.613]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:21.613]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:21.613]             on.exit(options(oopts), add = TRUE)
[15:32:21.613]         }
[15:32:21.613]         {
[15:32:21.613]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:21.613]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:21.613]                 ...future.FUN(...future.X_jj, ...)
[15:32:21.613]             })
[15:32:21.613]         }
[15:32:21.613]     }, args = future.call.arguments)
[15:32:21.613] }
[15:32:21.614] Tweak future expression to call with '...' arguments ... DONE
[15:32:21.615] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:21.615] 
[15:32:21.615] getGlobalsAndPackages() ... DONE
[15:32:21.616] run() for 'Future' ...
[15:32:21.617] - state: 'created'
[15:32:21.617] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:21.618] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:21.618] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:21.618]   - Field: 'label'
[15:32:21.619]   - Field: 'local'
[15:32:21.619]   - Field: 'owner'
[15:32:21.620]   - Field: 'envir'
[15:32:21.620]   - Field: 'packages'
[15:32:21.625]   - Field: 'gc'
[15:32:21.626]   - Field: 'conditions'
[15:32:21.626]   - Field: 'expr'
[15:32:21.626]   - Field: 'uuid'
[15:32:21.627]   - Field: 'seed'
[15:32:21.627]   - Field: 'version'
[15:32:21.628]   - Field: 'result'
[15:32:21.628]   - Field: 'asynchronous'
[15:32:21.628]   - Field: 'calls'
[15:32:21.629]   - Field: 'globals'
[15:32:21.629]   - Field: 'stdout'
[15:32:21.630]   - Field: 'earlySignal'
[15:32:21.630]   - Field: 'lazy'
[15:32:21.630]   - Field: 'state'
[15:32:21.631] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:21.631] - Launch lazy future ...
[15:32:21.632] Packages needed by the future expression (n = 0): <none>
[15:32:21.632] Packages needed by future strategies (n = 0): <none>
[15:32:21.634] {
[15:32:21.634]     {
[15:32:21.634]         {
[15:32:21.634]             ...future.startTime <- base::Sys.time()
[15:32:21.634]             {
[15:32:21.634]                 {
[15:32:21.634]                   {
[15:32:21.634]                     base::local({
[15:32:21.634]                       has_future <- base::requireNamespace("future", 
[15:32:21.634]                         quietly = TRUE)
[15:32:21.634]                       if (has_future) {
[15:32:21.634]                         ns <- base::getNamespace("future")
[15:32:21.634]                         version <- ns[[".package"]][["version"]]
[15:32:21.634]                         if (is.null(version)) 
[15:32:21.634]                           version <- utils::packageVersion("future")
[15:32:21.634]                       }
[15:32:21.634]                       else {
[15:32:21.634]                         version <- NULL
[15:32:21.634]                       }
[15:32:21.634]                       if (!has_future || version < "1.8.0") {
[15:32:21.634]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:21.634]                           "", base::R.version$version.string), 
[15:32:21.634]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:21.634]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:21.634]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:21.634]                             "release", "version")], collapse = " "), 
[15:32:21.634]                           hostname = base::Sys.info()[["nodename"]])
[15:32:21.634]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:21.634]                           info)
[15:32:21.634]                         info <- base::paste(info, collapse = "; ")
[15:32:21.634]                         if (!has_future) {
[15:32:21.634]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:21.634]                             info)
[15:32:21.634]                         }
[15:32:21.634]                         else {
[15:32:21.634]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:21.634]                             info, version)
[15:32:21.634]                         }
[15:32:21.634]                         base::stop(msg)
[15:32:21.634]                       }
[15:32:21.634]                     })
[15:32:21.634]                   }
[15:32:21.634]                   ...future.strategy.old <- future::plan("list")
[15:32:21.634]                   options(future.plan = NULL)
[15:32:21.634]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:21.634]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:21.634]                 }
[15:32:21.634]                 ...future.workdir <- getwd()
[15:32:21.634]             }
[15:32:21.634]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:21.634]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:21.634]         }
[15:32:21.634]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:21.634]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:21.634]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:21.634]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:21.634]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:21.634]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:21.634]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:21.634]             base::names(...future.oldOptions))
[15:32:21.634]     }
[15:32:21.634]     if (FALSE) {
[15:32:21.634]     }
[15:32:21.634]     else {
[15:32:21.634]         if (TRUE) {
[15:32:21.634]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:21.634]                 open = "w")
[15:32:21.634]         }
[15:32:21.634]         else {
[15:32:21.634]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:21.634]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:21.634]         }
[15:32:21.634]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:21.634]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:21.634]             base::sink(type = "output", split = FALSE)
[15:32:21.634]             base::close(...future.stdout)
[15:32:21.634]         }, add = TRUE)
[15:32:21.634]     }
[15:32:21.634]     ...future.frame <- base::sys.nframe()
[15:32:21.634]     ...future.conditions <- base::list()
[15:32:21.634]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:21.634]     if (FALSE) {
[15:32:21.634]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:21.634]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:21.634]     }
[15:32:21.634]     ...future.result <- base::tryCatch({
[15:32:21.634]         base::withCallingHandlers({
[15:32:21.634]             ...future.value <- base::withVisible(base::local({
[15:32:21.634]                 do.call(function(...) {
[15:32:21.634]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:21.634]                   if (!identical(...future.globals.maxSize.org, 
[15:32:21.634]                     ...future.globals.maxSize)) {
[15:32:21.634]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:21.634]                     on.exit(options(oopts), add = TRUE)
[15:32:21.634]                   }
[15:32:21.634]                   {
[15:32:21.634]                     lapply(seq_along(...future.elements_ii), 
[15:32:21.634]                       FUN = function(jj) {
[15:32:21.634]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:21.634]                         ...future.FUN(...future.X_jj, ...)
[15:32:21.634]                       })
[15:32:21.634]                   }
[15:32:21.634]                 }, args = future.call.arguments)
[15:32:21.634]             }))
[15:32:21.634]             future::FutureResult(value = ...future.value$value, 
[15:32:21.634]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:21.634]                   ...future.rng), globalenv = if (FALSE) 
[15:32:21.634]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:21.634]                     ...future.globalenv.names))
[15:32:21.634]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:21.634]         }, condition = base::local({
[15:32:21.634]             c <- base::c
[15:32:21.634]             inherits <- base::inherits
[15:32:21.634]             invokeRestart <- base::invokeRestart
[15:32:21.634]             length <- base::length
[15:32:21.634]             list <- base::list
[15:32:21.634]             seq.int <- base::seq.int
[15:32:21.634]             signalCondition <- base::signalCondition
[15:32:21.634]             sys.calls <- base::sys.calls
[15:32:21.634]             `[[` <- base::`[[`
[15:32:21.634]             `+` <- base::`+`
[15:32:21.634]             `<<-` <- base::`<<-`
[15:32:21.634]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:21.634]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:21.634]                   3L)]
[15:32:21.634]             }
[15:32:21.634]             function(cond) {
[15:32:21.634]                 is_error <- inherits(cond, "error")
[15:32:21.634]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:21.634]                   NULL)
[15:32:21.634]                 if (is_error) {
[15:32:21.634]                   sessionInformation <- function() {
[15:32:21.634]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:21.634]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:21.634]                       search = base::search(), system = base::Sys.info())
[15:32:21.634]                   }
[15:32:21.634]                   ...future.conditions[[length(...future.conditions) + 
[15:32:21.634]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:21.634]                     cond$call), session = sessionInformation(), 
[15:32:21.634]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:21.634]                   signalCondition(cond)
[15:32:21.634]                 }
[15:32:21.634]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:21.634]                 "immediateCondition"))) {
[15:32:21.634]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:21.634]                   ...future.conditions[[length(...future.conditions) + 
[15:32:21.634]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:21.634]                   if (TRUE && !signal) {
[15:32:21.634]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:21.634]                     {
[15:32:21.634]                       inherits <- base::inherits
[15:32:21.634]                       invokeRestart <- base::invokeRestart
[15:32:21.634]                       is.null <- base::is.null
[15:32:21.634]                       muffled <- FALSE
[15:32:21.634]                       if (inherits(cond, "message")) {
[15:32:21.634]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:21.634]                         if (muffled) 
[15:32:21.634]                           invokeRestart("muffleMessage")
[15:32:21.634]                       }
[15:32:21.634]                       else if (inherits(cond, "warning")) {
[15:32:21.634]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:21.634]                         if (muffled) 
[15:32:21.634]                           invokeRestart("muffleWarning")
[15:32:21.634]                       }
[15:32:21.634]                       else if (inherits(cond, "condition")) {
[15:32:21.634]                         if (!is.null(pattern)) {
[15:32:21.634]                           computeRestarts <- base::computeRestarts
[15:32:21.634]                           grepl <- base::grepl
[15:32:21.634]                           restarts <- computeRestarts(cond)
[15:32:21.634]                           for (restart in restarts) {
[15:32:21.634]                             name <- restart$name
[15:32:21.634]                             if (is.null(name)) 
[15:32:21.634]                               next
[15:32:21.634]                             if (!grepl(pattern, name)) 
[15:32:21.634]                               next
[15:32:21.634]                             invokeRestart(restart)
[15:32:21.634]                             muffled <- TRUE
[15:32:21.634]                             break
[15:32:21.634]                           }
[15:32:21.634]                         }
[15:32:21.634]                       }
[15:32:21.634]                       invisible(muffled)
[15:32:21.634]                     }
[15:32:21.634]                     muffleCondition(cond, pattern = "^muffle")
[15:32:21.634]                   }
[15:32:21.634]                 }
[15:32:21.634]                 else {
[15:32:21.634]                   if (TRUE) {
[15:32:21.634]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:21.634]                     {
[15:32:21.634]                       inherits <- base::inherits
[15:32:21.634]                       invokeRestart <- base::invokeRestart
[15:32:21.634]                       is.null <- base::is.null
[15:32:21.634]                       muffled <- FALSE
[15:32:21.634]                       if (inherits(cond, "message")) {
[15:32:21.634]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:21.634]                         if (muffled) 
[15:32:21.634]                           invokeRestart("muffleMessage")
[15:32:21.634]                       }
[15:32:21.634]                       else if (inherits(cond, "warning")) {
[15:32:21.634]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:21.634]                         if (muffled) 
[15:32:21.634]                           invokeRestart("muffleWarning")
[15:32:21.634]                       }
[15:32:21.634]                       else if (inherits(cond, "condition")) {
[15:32:21.634]                         if (!is.null(pattern)) {
[15:32:21.634]                           computeRestarts <- base::computeRestarts
[15:32:21.634]                           grepl <- base::grepl
[15:32:21.634]                           restarts <- computeRestarts(cond)
[15:32:21.634]                           for (restart in restarts) {
[15:32:21.634]                             name <- restart$name
[15:32:21.634]                             if (is.null(name)) 
[15:32:21.634]                               next
[15:32:21.634]                             if (!grepl(pattern, name)) 
[15:32:21.634]                               next
[15:32:21.634]                             invokeRestart(restart)
[15:32:21.634]                             muffled <- TRUE
[15:32:21.634]                             break
[15:32:21.634]                           }
[15:32:21.634]                         }
[15:32:21.634]                       }
[15:32:21.634]                       invisible(muffled)
[15:32:21.634]                     }
[15:32:21.634]                     muffleCondition(cond, pattern = "^muffle")
[15:32:21.634]                   }
[15:32:21.634]                 }
[15:32:21.634]             }
[15:32:21.634]         }))
[15:32:21.634]     }, error = function(ex) {
[15:32:21.634]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:21.634]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:21.634]                 ...future.rng), started = ...future.startTime, 
[15:32:21.634]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:21.634]             version = "1.8"), class = "FutureResult")
[15:32:21.634]     }, finally = {
[15:32:21.634]         if (!identical(...future.workdir, getwd())) 
[15:32:21.634]             setwd(...future.workdir)
[15:32:21.634]         {
[15:32:21.634]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:21.634]                 ...future.oldOptions$nwarnings <- NULL
[15:32:21.634]             }
[15:32:21.634]             base::options(...future.oldOptions)
[15:32:21.634]             if (.Platform$OS.type == "windows") {
[15:32:21.634]                 old_names <- names(...future.oldEnvVars)
[15:32:21.634]                 envs <- base::Sys.getenv()
[15:32:21.634]                 names <- names(envs)
[15:32:21.634]                 common <- intersect(names, old_names)
[15:32:21.634]                 added <- setdiff(names, old_names)
[15:32:21.634]                 removed <- setdiff(old_names, names)
[15:32:21.634]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:21.634]                   envs[common]]
[15:32:21.634]                 NAMES <- toupper(changed)
[15:32:21.634]                 args <- list()
[15:32:21.634]                 for (kk in seq_along(NAMES)) {
[15:32:21.634]                   name <- changed[[kk]]
[15:32:21.634]                   NAME <- NAMES[[kk]]
[15:32:21.634]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:21.634]                     next
[15:32:21.634]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:21.634]                 }
[15:32:21.634]                 NAMES <- toupper(added)
[15:32:21.634]                 for (kk in seq_along(NAMES)) {
[15:32:21.634]                   name <- added[[kk]]
[15:32:21.634]                   NAME <- NAMES[[kk]]
[15:32:21.634]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:21.634]                     next
[15:32:21.634]                   args[[name]] <- ""
[15:32:21.634]                 }
[15:32:21.634]                 NAMES <- toupper(removed)
[15:32:21.634]                 for (kk in seq_along(NAMES)) {
[15:32:21.634]                   name <- removed[[kk]]
[15:32:21.634]                   NAME <- NAMES[[kk]]
[15:32:21.634]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:21.634]                     next
[15:32:21.634]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:21.634]                 }
[15:32:21.634]                 if (length(args) > 0) 
[15:32:21.634]                   base::do.call(base::Sys.setenv, args = args)
[15:32:21.634]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:21.634]             }
[15:32:21.634]             else {
[15:32:21.634]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:21.634]             }
[15:32:21.634]             {
[15:32:21.634]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:21.634]                   0L) {
[15:32:21.634]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:21.634]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:21.634]                   base::options(opts)
[15:32:21.634]                 }
[15:32:21.634]                 {
[15:32:21.634]                   {
[15:32:21.634]                     NULL
[15:32:21.634]                     RNGkind("Mersenne-Twister")
[15:32:21.634]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:21.634]                       inherits = FALSE)
[15:32:21.634]                   }
[15:32:21.634]                   options(future.plan = NULL)
[15:32:21.634]                   if (is.na(NA_character_)) 
[15:32:21.634]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:21.634]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:21.634]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:21.634]                     .init = FALSE)
[15:32:21.634]                 }
[15:32:21.634]             }
[15:32:21.634]         }
[15:32:21.634]     })
[15:32:21.634]     if (TRUE) {
[15:32:21.634]         base::sink(type = "output", split = FALSE)
[15:32:21.634]         if (TRUE) {
[15:32:21.634]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:21.634]         }
[15:32:21.634]         else {
[15:32:21.634]             ...future.result["stdout"] <- base::list(NULL)
[15:32:21.634]         }
[15:32:21.634]         base::close(...future.stdout)
[15:32:21.634]         ...future.stdout <- NULL
[15:32:21.634]     }
[15:32:21.634]     ...future.result$conditions <- ...future.conditions
[15:32:21.634]     ...future.result$finished <- base::Sys.time()
[15:32:21.634]     ...future.result
[15:32:21.634] }
[15:32:21.642] assign_globals() ...
[15:32:21.642] List of 5
[15:32:21.642]  $ ...future.FUN            :function (x)  
[15:32:21.642]  $ future.call.arguments    : list()
[15:32:21.642]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:21.642]  $ ...future.elements_ii    :List of 6
[15:32:21.642]   ..$ a1: int 1
[15:32:21.642]   ..$ a2: int 2
[15:32:21.642]   ..$ b1: int 2
[15:32:21.642]   ..$ b2: int 3
[15:32:21.642]   ..$ c1: int 3
[15:32:21.642]   ..$ c2: int 4
[15:32:21.642]  $ ...future.seeds_ii       : NULL
[15:32:21.642]  $ ...future.globals.maxSize: NULL
[15:32:21.642]  - attr(*, "where")=List of 5
[15:32:21.642]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:21.642]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:21.642]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:21.642]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:21.642]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:21.642]  - attr(*, "resolved")= logi FALSE
[15:32:21.642]  - attr(*, "total_size")= num 848
[15:32:21.642]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:21.642]  - attr(*, "already-done")= logi TRUE
[15:32:21.658] - copied '...future.FUN' to environment
[15:32:21.658] - copied 'future.call.arguments' to environment
[15:32:21.658] - copied '...future.elements_ii' to environment
[15:32:21.659] - copied '...future.seeds_ii' to environment
[15:32:21.659] - copied '...future.globals.maxSize' to environment
[15:32:21.659] assign_globals() ... done
[15:32:21.660] plan(): Setting new future strategy stack:
[15:32:21.660] List of future strategies:
[15:32:21.660] 1. sequential:
[15:32:21.660]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:21.660]    - tweaked: FALSE
[15:32:21.660]    - call: NULL
[15:32:21.662] plan(): nbrOfWorkers() = 1
[15:32:21.664] plan(): Setting new future strategy stack:
[15:32:21.664] List of future strategies:
[15:32:21.664] 1. sequential:
[15:32:21.664]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:21.664]    - tweaked: FALSE
[15:32:21.664]    - call: plan(strategy)
[15:32:21.666] plan(): nbrOfWorkers() = 1
[15:32:21.666] SequentialFuture started (and completed)
[15:32:21.666] - Launch lazy future ... done
[15:32:21.667] run() for 'SequentialFuture' ... done
[15:32:21.667] Created future:
[15:32:21.667] SequentialFuture:
[15:32:21.667] Label: 'future_sapply-1'
[15:32:21.667] Expression:
[15:32:21.667] {
[15:32:21.667]     do.call(function(...) {
[15:32:21.667]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:21.667]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:21.667]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:21.667]             on.exit(options(oopts), add = TRUE)
[15:32:21.667]         }
[15:32:21.667]         {
[15:32:21.667]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:21.667]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:21.667]                 ...future.FUN(...future.X_jj, ...)
[15:32:21.667]             })
[15:32:21.667]         }
[15:32:21.667]     }, args = future.call.arguments)
[15:32:21.667] }
[15:32:21.667] Lazy evaluation: FALSE
[15:32:21.667] Asynchronous evaluation: FALSE
[15:32:21.667] Local evaluation: TRUE
[15:32:21.667] Environment: R_GlobalEnv
[15:32:21.667] Capture standard output: TRUE
[15:32:21.667] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:21.667] Globals: 5 objects totaling 1.16 KiB (function '...future.FUN' of 848 bytes, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 336 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:21.667] Packages: <none>
[15:32:21.667] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:21.667] Resolved: TRUE
[15:32:21.667] Value: 336 bytes of class 'list'
[15:32:21.667] Early signaling: FALSE
[15:32:21.667] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:21.667] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:21.670] Chunk #1 of 1 ... DONE
[15:32:21.670] Launching 1 futures (chunks) ... DONE
[15:32:21.671] Resolving 1 futures (chunks) ...
[15:32:21.671] resolve() on list ...
[15:32:21.671]  recursive: 0
[15:32:21.672]  length: 1
[15:32:21.672] 
[15:32:21.672] resolved() for 'SequentialFuture' ...
[15:32:21.673] - state: 'finished'
[15:32:21.673] - run: TRUE
[15:32:21.673] - result: 'FutureResult'
[15:32:21.674] resolved() for 'SequentialFuture' ... done
[15:32:21.674] Future #1
[15:32:21.674] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:21.675] - nx: 1
[15:32:21.675] - relay: TRUE
[15:32:21.675] - stdout: TRUE
[15:32:21.676] - signal: TRUE
[15:32:21.676] - resignal: FALSE
[15:32:21.676] - force: TRUE
[15:32:21.677] - relayed: [n=1] FALSE
[15:32:21.677] - queued futures: [n=1] FALSE
[15:32:21.677]  - until=1
[15:32:21.677]  - relaying element #1
[15:32:21.678] - relayed: [n=1] TRUE
[15:32:21.678] - queued futures: [n=1] TRUE
[15:32:21.679] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:21.679]  length: 0 (resolved future 1)
[15:32:21.679] Relaying remaining futures
[15:32:21.680] signalConditionsASAP(NULL, pos=0) ...
[15:32:21.680] - nx: 1
[15:32:21.680] - relay: TRUE
[15:32:21.680] - stdout: TRUE
[15:32:21.681] - signal: TRUE
[15:32:21.681] - resignal: FALSE
[15:32:21.681] - force: TRUE
[15:32:21.682] - relayed: [n=1] TRUE
[15:32:21.682] - queued futures: [n=1] TRUE
 - flush all
[15:32:21.682] - relayed: [n=1] TRUE
[15:32:21.688] - queued futures: [n=1] TRUE
[15:32:21.688] signalConditionsASAP(NULL, pos=0) ... done
[15:32:21.688] resolve() on list ... DONE
[15:32:21.689]  - Number of value chunks collected: 1
[15:32:21.689] Resolving 1 futures (chunks) ... DONE
[15:32:21.690] Reducing values from 1 chunks ...
[15:32:21.690]  - Number of values collected after concatenation: 6
[15:32:21.690]  - Number of values expected: 6
[15:32:21.691] Reducing values from 1 chunks ... DONE
[15:32:21.691] future_lapply() ... DONE
List of 2
 $ y0: Named int [1:6] 1 2 2 3 3 4
  ..- attr(*, "names")= chr [1:6] "a1" "a2" "b1" "b2" ...
 $ y1: Named int [1:6] 1 2 2 3 3 4
  ..- attr(*, "names")= chr [1:6] "a1" "a2" "b1" "b2" ...
[15:32:21.696] future_lapply() ...
[15:32:21.697] Number of chunks: 1
[15:32:21.698] getGlobalsAndPackagesXApply() ...
[15:32:21.698]  - future.globals: TRUE
[15:32:21.698] getGlobalsAndPackages() ...
[15:32:21.699] Searching for globals...
[15:32:21.701] - globals found: [2] 'FUN', 'UseMethod'
[15:32:21.701] Searching for globals ... DONE
[15:32:21.702] Resolving globals: FALSE
[15:32:21.703] The total size of the 1 globals is 1.22 KiB (1248 bytes)
[15:32:21.703] The total size of the 1 globals exported for future expression ('FUN()') is 1.22 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.22 KiB of class 'function')
[15:32:21.704] - globals: [1] 'FUN'
[15:32:21.704] 
[15:32:21.704] getGlobalsAndPackages() ... DONE
[15:32:21.704]  - globals found/used: [n=1] 'FUN'
[15:32:21.705]  - needed namespaces: [n=0] 
[15:32:21.705] Finding globals ... DONE
[15:32:21.705]  - use_args: TRUE
[15:32:21.706]  - Getting '...' globals ...
[15:32:21.707] resolve() on list ...
[15:32:21.707]  recursive: 0
[15:32:21.707]  length: 1
[15:32:21.708]  elements: '...'
[15:32:21.708]  length: 0 (resolved future 1)
[15:32:21.708] resolve() on list ... DONE
[15:32:21.709]    - '...' content: [n=0] 
[15:32:21.709] List of 1
[15:32:21.709]  $ ...: list()
[15:32:21.709]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:21.709]  - attr(*, "where")=List of 1
[15:32:21.709]   ..$ ...:<environment: 0x00000276def46840> 
[15:32:21.709]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:21.709]  - attr(*, "resolved")= logi TRUE
[15:32:21.709]  - attr(*, "total_size")= num NA
[15:32:21.715]  - Getting '...' globals ... DONE
[15:32:21.715] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:21.716] List of 2
[15:32:21.716]  $ ...future.FUN:function (x, ...)  
[15:32:21.716]  $ ...          : list()
[15:32:21.716]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:21.716]  - attr(*, "where")=List of 2
[15:32:21.716]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:21.716]   ..$ ...          :<environment: 0x00000276def46840> 
[15:32:21.716]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:21.716]  - attr(*, "resolved")= logi FALSE
[15:32:21.716]  - attr(*, "total_size")= num 1248
[15:32:21.722] Packages to be attached in all futures: [n=0] 
[15:32:21.722] getGlobalsAndPackagesXApply() ... DONE
[15:32:21.722] Number of futures (= number of chunks): 1
[15:32:21.723] Launching 1 futures (chunks) ...
[15:32:21.723] Chunk #1 of 1 ...
[15:32:21.723]  - Finding globals in 'X' for chunk #1 ...
[15:32:21.724] getGlobalsAndPackages() ...
[15:32:21.724] Searching for globals...
[15:32:21.725] 
[15:32:21.725] Searching for globals ... DONE
[15:32:21.725] - globals: [0] <none>
[15:32:21.726] getGlobalsAndPackages() ... DONE
[15:32:21.726]    + additional globals found: [n=0] 
[15:32:21.726]    + additional namespaces needed: [n=0] 
[15:32:21.727]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:21.727]  - seeds: <none>
[15:32:21.727]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:21.728] getGlobalsAndPackages() ...
[15:32:21.728] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:21.728] Resolving globals: FALSE
[15:32:21.729] Tweak future expression to call with '...' arguments ...
[15:32:21.729] {
[15:32:21.729]     do.call(function(...) {
[15:32:21.729]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:21.729]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:21.729]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:21.729]             on.exit(options(oopts), add = TRUE)
[15:32:21.729]         }
[15:32:21.729]         {
[15:32:21.729]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:21.729]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:21.729]                 ...future.FUN(...future.X_jj, ...)
[15:32:21.729]             })
[15:32:21.729]         }
[15:32:21.729]     }, args = future.call.arguments)
[15:32:21.729] }
[15:32:21.730] Tweak future expression to call with '...' arguments ... DONE
[15:32:21.731] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:21.731] 
[15:32:21.731] getGlobalsAndPackages() ... DONE
[15:32:21.732] run() for 'Future' ...
[15:32:21.733] - state: 'created'
[15:32:21.733] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:21.734] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:21.734] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:21.734]   - Field: 'label'
[15:32:21.735]   - Field: 'local'
[15:32:21.740]   - Field: 'owner'
[15:32:21.740]   - Field: 'envir'
[15:32:21.741]   - Field: 'packages'
[15:32:21.741]   - Field: 'gc'
[15:32:21.742]   - Field: 'conditions'
[15:32:21.742]   - Field: 'expr'
[15:32:21.742]   - Field: 'uuid'
[15:32:21.743]   - Field: 'seed'
[15:32:21.743]   - Field: 'version'
[15:32:21.743]   - Field: 'result'
[15:32:21.744]   - Field: 'asynchronous'
[15:32:21.744]   - Field: 'calls'
[15:32:21.745]   - Field: 'globals'
[15:32:21.745]   - Field: 'stdout'
[15:32:21.745]   - Field: 'earlySignal'
[15:32:21.746]   - Field: 'lazy'
[15:32:21.746]   - Field: 'state'
[15:32:21.747] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:21.747] - Launch lazy future ...
[15:32:21.748] Packages needed by the future expression (n = 0): <none>
[15:32:21.748] Packages needed by future strategies (n = 0): <none>
[15:32:21.749] {
[15:32:21.749]     {
[15:32:21.749]         {
[15:32:21.749]             ...future.startTime <- base::Sys.time()
[15:32:21.749]             {
[15:32:21.749]                 {
[15:32:21.749]                   {
[15:32:21.749]                     base::local({
[15:32:21.749]                       has_future <- base::requireNamespace("future", 
[15:32:21.749]                         quietly = TRUE)
[15:32:21.749]                       if (has_future) {
[15:32:21.749]                         ns <- base::getNamespace("future")
[15:32:21.749]                         version <- ns[[".package"]][["version"]]
[15:32:21.749]                         if (is.null(version)) 
[15:32:21.749]                           version <- utils::packageVersion("future")
[15:32:21.749]                       }
[15:32:21.749]                       else {
[15:32:21.749]                         version <- NULL
[15:32:21.749]                       }
[15:32:21.749]                       if (!has_future || version < "1.8.0") {
[15:32:21.749]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:21.749]                           "", base::R.version$version.string), 
[15:32:21.749]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:21.749]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:21.749]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:21.749]                             "release", "version")], collapse = " "), 
[15:32:21.749]                           hostname = base::Sys.info()[["nodename"]])
[15:32:21.749]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:21.749]                           info)
[15:32:21.749]                         info <- base::paste(info, collapse = "; ")
[15:32:21.749]                         if (!has_future) {
[15:32:21.749]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:21.749]                             info)
[15:32:21.749]                         }
[15:32:21.749]                         else {
[15:32:21.749]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:21.749]                             info, version)
[15:32:21.749]                         }
[15:32:21.749]                         base::stop(msg)
[15:32:21.749]                       }
[15:32:21.749]                     })
[15:32:21.749]                   }
[15:32:21.749]                   ...future.strategy.old <- future::plan("list")
[15:32:21.749]                   options(future.plan = NULL)
[15:32:21.749]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:21.749]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:21.749]                 }
[15:32:21.749]                 ...future.workdir <- getwd()
[15:32:21.749]             }
[15:32:21.749]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:21.749]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:21.749]         }
[15:32:21.749]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:21.749]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:21.749]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:21.749]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:21.749]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:21.749]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:21.749]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:21.749]             base::names(...future.oldOptions))
[15:32:21.749]     }
[15:32:21.749]     if (FALSE) {
[15:32:21.749]     }
[15:32:21.749]     else {
[15:32:21.749]         if (TRUE) {
[15:32:21.749]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:21.749]                 open = "w")
[15:32:21.749]         }
[15:32:21.749]         else {
[15:32:21.749]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:21.749]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:21.749]         }
[15:32:21.749]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:21.749]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:21.749]             base::sink(type = "output", split = FALSE)
[15:32:21.749]             base::close(...future.stdout)
[15:32:21.749]         }, add = TRUE)
[15:32:21.749]     }
[15:32:21.749]     ...future.frame <- base::sys.nframe()
[15:32:21.749]     ...future.conditions <- base::list()
[15:32:21.749]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:21.749]     if (FALSE) {
[15:32:21.749]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:21.749]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:21.749]     }
[15:32:21.749]     ...future.result <- base::tryCatch({
[15:32:21.749]         base::withCallingHandlers({
[15:32:21.749]             ...future.value <- base::withVisible(base::local({
[15:32:21.749]                 do.call(function(...) {
[15:32:21.749]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:21.749]                   if (!identical(...future.globals.maxSize.org, 
[15:32:21.749]                     ...future.globals.maxSize)) {
[15:32:21.749]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:21.749]                     on.exit(options(oopts), add = TRUE)
[15:32:21.749]                   }
[15:32:21.749]                   {
[15:32:21.749]                     lapply(seq_along(...future.elements_ii), 
[15:32:21.749]                       FUN = function(jj) {
[15:32:21.749]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:21.749]                         ...future.FUN(...future.X_jj, ...)
[15:32:21.749]                       })
[15:32:21.749]                   }
[15:32:21.749]                 }, args = future.call.arguments)
[15:32:21.749]             }))
[15:32:21.749]             future::FutureResult(value = ...future.value$value, 
[15:32:21.749]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:21.749]                   ...future.rng), globalenv = if (FALSE) 
[15:32:21.749]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:21.749]                     ...future.globalenv.names))
[15:32:21.749]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:21.749]         }, condition = base::local({
[15:32:21.749]             c <- base::c
[15:32:21.749]             inherits <- base::inherits
[15:32:21.749]             invokeRestart <- base::invokeRestart
[15:32:21.749]             length <- base::length
[15:32:21.749]             list <- base::list
[15:32:21.749]             seq.int <- base::seq.int
[15:32:21.749]             signalCondition <- base::signalCondition
[15:32:21.749]             sys.calls <- base::sys.calls
[15:32:21.749]             `[[` <- base::`[[`
[15:32:21.749]             `+` <- base::`+`
[15:32:21.749]             `<<-` <- base::`<<-`
[15:32:21.749]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:21.749]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:21.749]                   3L)]
[15:32:21.749]             }
[15:32:21.749]             function(cond) {
[15:32:21.749]                 is_error <- inherits(cond, "error")
[15:32:21.749]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:21.749]                   NULL)
[15:32:21.749]                 if (is_error) {
[15:32:21.749]                   sessionInformation <- function() {
[15:32:21.749]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:21.749]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:21.749]                       search = base::search(), system = base::Sys.info())
[15:32:21.749]                   }
[15:32:21.749]                   ...future.conditions[[length(...future.conditions) + 
[15:32:21.749]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:21.749]                     cond$call), session = sessionInformation(), 
[15:32:21.749]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:21.749]                   signalCondition(cond)
[15:32:21.749]                 }
[15:32:21.749]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:21.749]                 "immediateCondition"))) {
[15:32:21.749]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:21.749]                   ...future.conditions[[length(...future.conditions) + 
[15:32:21.749]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:21.749]                   if (TRUE && !signal) {
[15:32:21.749]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:21.749]                     {
[15:32:21.749]                       inherits <- base::inherits
[15:32:21.749]                       invokeRestart <- base::invokeRestart
[15:32:21.749]                       is.null <- base::is.null
[15:32:21.749]                       muffled <- FALSE
[15:32:21.749]                       if (inherits(cond, "message")) {
[15:32:21.749]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:21.749]                         if (muffled) 
[15:32:21.749]                           invokeRestart("muffleMessage")
[15:32:21.749]                       }
[15:32:21.749]                       else if (inherits(cond, "warning")) {
[15:32:21.749]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:21.749]                         if (muffled) 
[15:32:21.749]                           invokeRestart("muffleWarning")
[15:32:21.749]                       }
[15:32:21.749]                       else if (inherits(cond, "condition")) {
[15:32:21.749]                         if (!is.null(pattern)) {
[15:32:21.749]                           computeRestarts <- base::computeRestarts
[15:32:21.749]                           grepl <- base::grepl
[15:32:21.749]                           restarts <- computeRestarts(cond)
[15:32:21.749]                           for (restart in restarts) {
[15:32:21.749]                             name <- restart$name
[15:32:21.749]                             if (is.null(name)) 
[15:32:21.749]                               next
[15:32:21.749]                             if (!grepl(pattern, name)) 
[15:32:21.749]                               next
[15:32:21.749]                             invokeRestart(restart)
[15:32:21.749]                             muffled <- TRUE
[15:32:21.749]                             break
[15:32:21.749]                           }
[15:32:21.749]                         }
[15:32:21.749]                       }
[15:32:21.749]                       invisible(muffled)
[15:32:21.749]                     }
[15:32:21.749]                     muffleCondition(cond, pattern = "^muffle")
[15:32:21.749]                   }
[15:32:21.749]                 }
[15:32:21.749]                 else {
[15:32:21.749]                   if (TRUE) {
[15:32:21.749]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:21.749]                     {
[15:32:21.749]                       inherits <- base::inherits
[15:32:21.749]                       invokeRestart <- base::invokeRestart
[15:32:21.749]                       is.null <- base::is.null
[15:32:21.749]                       muffled <- FALSE
[15:32:21.749]                       if (inherits(cond, "message")) {
[15:32:21.749]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:21.749]                         if (muffled) 
[15:32:21.749]                           invokeRestart("muffleMessage")
[15:32:21.749]                       }
[15:32:21.749]                       else if (inherits(cond, "warning")) {
[15:32:21.749]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:21.749]                         if (muffled) 
[15:32:21.749]                           invokeRestart("muffleWarning")
[15:32:21.749]                       }
[15:32:21.749]                       else if (inherits(cond, "condition")) {
[15:32:21.749]                         if (!is.null(pattern)) {
[15:32:21.749]                           computeRestarts <- base::computeRestarts
[15:32:21.749]                           grepl <- base::grepl
[15:32:21.749]                           restarts <- computeRestarts(cond)
[15:32:21.749]                           for (restart in restarts) {
[15:32:21.749]                             name <- restart$name
[15:32:21.749]                             if (is.null(name)) 
[15:32:21.749]                               next
[15:32:21.749]                             if (!grepl(pattern, name)) 
[15:32:21.749]                               next
[15:32:21.749]                             invokeRestart(restart)
[15:32:21.749]                             muffled <- TRUE
[15:32:21.749]                             break
[15:32:21.749]                           }
[15:32:21.749]                         }
[15:32:21.749]                       }
[15:32:21.749]                       invisible(muffled)
[15:32:21.749]                     }
[15:32:21.749]                     muffleCondition(cond, pattern = "^muffle")
[15:32:21.749]                   }
[15:32:21.749]                 }
[15:32:21.749]             }
[15:32:21.749]         }))
[15:32:21.749]     }, error = function(ex) {
[15:32:21.749]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:21.749]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:21.749]                 ...future.rng), started = ...future.startTime, 
[15:32:21.749]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:21.749]             version = "1.8"), class = "FutureResult")
[15:32:21.749]     }, finally = {
[15:32:21.749]         if (!identical(...future.workdir, getwd())) 
[15:32:21.749]             setwd(...future.workdir)
[15:32:21.749]         {
[15:32:21.749]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:21.749]                 ...future.oldOptions$nwarnings <- NULL
[15:32:21.749]             }
[15:32:21.749]             base::options(...future.oldOptions)
[15:32:21.749]             if (.Platform$OS.type == "windows") {
[15:32:21.749]                 old_names <- names(...future.oldEnvVars)
[15:32:21.749]                 envs <- base::Sys.getenv()
[15:32:21.749]                 names <- names(envs)
[15:32:21.749]                 common <- intersect(names, old_names)
[15:32:21.749]                 added <- setdiff(names, old_names)
[15:32:21.749]                 removed <- setdiff(old_names, names)
[15:32:21.749]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:21.749]                   envs[common]]
[15:32:21.749]                 NAMES <- toupper(changed)
[15:32:21.749]                 args <- list()
[15:32:21.749]                 for (kk in seq_along(NAMES)) {
[15:32:21.749]                   name <- changed[[kk]]
[15:32:21.749]                   NAME <- NAMES[[kk]]
[15:32:21.749]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:21.749]                     next
[15:32:21.749]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:21.749]                 }
[15:32:21.749]                 NAMES <- toupper(added)
[15:32:21.749]                 for (kk in seq_along(NAMES)) {
[15:32:21.749]                   name <- added[[kk]]
[15:32:21.749]                   NAME <- NAMES[[kk]]
[15:32:21.749]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:21.749]                     next
[15:32:21.749]                   args[[name]] <- ""
[15:32:21.749]                 }
[15:32:21.749]                 NAMES <- toupper(removed)
[15:32:21.749]                 for (kk in seq_along(NAMES)) {
[15:32:21.749]                   name <- removed[[kk]]
[15:32:21.749]                   NAME <- NAMES[[kk]]
[15:32:21.749]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:21.749]                     next
[15:32:21.749]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:21.749]                 }
[15:32:21.749]                 if (length(args) > 0) 
[15:32:21.749]                   base::do.call(base::Sys.setenv, args = args)
[15:32:21.749]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:21.749]             }
[15:32:21.749]             else {
[15:32:21.749]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:21.749]             }
[15:32:21.749]             {
[15:32:21.749]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:21.749]                   0L) {
[15:32:21.749]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:21.749]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:21.749]                   base::options(opts)
[15:32:21.749]                 }
[15:32:21.749]                 {
[15:32:21.749]                   {
[15:32:21.749]                     NULL
[15:32:21.749]                     RNGkind("Mersenne-Twister")
[15:32:21.749]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:21.749]                       inherits = FALSE)
[15:32:21.749]                   }
[15:32:21.749]                   options(future.plan = NULL)
[15:32:21.749]                   if (is.na(NA_character_)) 
[15:32:21.749]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:21.749]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:21.749]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:21.749]                     .init = FALSE)
[15:32:21.749]                 }
[15:32:21.749]             }
[15:32:21.749]         }
[15:32:21.749]     })
[15:32:21.749]     if (TRUE) {
[15:32:21.749]         base::sink(type = "output", split = FALSE)
[15:32:21.749]         if (TRUE) {
[15:32:21.749]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:21.749]         }
[15:32:21.749]         else {
[15:32:21.749]             ...future.result["stdout"] <- base::list(NULL)
[15:32:21.749]         }
[15:32:21.749]         base::close(...future.stdout)
[15:32:21.749]         ...future.stdout <- NULL
[15:32:21.749]     }
[15:32:21.749]     ...future.result$conditions <- ...future.conditions
[15:32:21.749]     ...future.result$finished <- base::Sys.time()
[15:32:21.749]     ...future.result
[15:32:21.749] }
[15:32:21.757] assign_globals() ...
[15:32:21.757] List of 5
[15:32:21.757]  $ ...future.FUN            :function (x, ...)  
[15:32:21.757]  $ future.call.arguments    : list()
[15:32:21.757]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:21.757]  $ ...future.elements_ii    :List of 6
[15:32:21.757]   ..$ a1: int 1
[15:32:21.757]   ..$ a2: int 2
[15:32:21.757]   ..$ b1: int 2
[15:32:21.757]   ..$ b2: int 3
[15:32:21.757]   ..$ c1: int 3
[15:32:21.757]   ..$ c2: int 4
[15:32:21.757]  $ ...future.seeds_ii       : NULL
[15:32:21.757]  $ ...future.globals.maxSize: NULL
[15:32:21.757]  - attr(*, "where")=List of 5
[15:32:21.757]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:21.757]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:21.757]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:21.757]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:21.757]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:21.757]  - attr(*, "resolved")= logi FALSE
[15:32:21.757]  - attr(*, "total_size")= num 1248
[15:32:21.757]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:21.757]  - attr(*, "already-done")= logi TRUE
[15:32:21.772] - copied '...future.FUN' to environment
[15:32:21.772] - copied 'future.call.arguments' to environment
[15:32:21.773] - copied '...future.elements_ii' to environment
[15:32:21.773] - copied '...future.seeds_ii' to environment
[15:32:21.773] - copied '...future.globals.maxSize' to environment
[15:32:21.774] assign_globals() ... done
[15:32:21.774] plan(): Setting new future strategy stack:
[15:32:21.775] List of future strategies:
[15:32:21.775] 1. sequential:
[15:32:21.775]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:21.775]    - tweaked: FALSE
[15:32:21.775]    - call: NULL
[15:32:21.776] plan(): nbrOfWorkers() = 1
[15:32:21.778] plan(): Setting new future strategy stack:
[15:32:21.779] List of future strategies:
[15:32:21.779] 1. sequential:
[15:32:21.779]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:21.779]    - tweaked: FALSE
[15:32:21.779]    - call: plan(strategy)
[15:32:21.780] plan(): nbrOfWorkers() = 1
[15:32:21.780] SequentialFuture started (and completed)
[15:32:21.781] - Launch lazy future ... done
[15:32:21.781] run() for 'SequentialFuture' ... done
[15:32:21.782] Created future:
[15:32:21.782] SequentialFuture:
[15:32:21.782] Label: 'future_sapply-1'
[15:32:21.782] Expression:
[15:32:21.782] {
[15:32:21.782]     do.call(function(...) {
[15:32:21.782]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:21.782]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:21.782]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:21.782]             on.exit(options(oopts), add = TRUE)
[15:32:21.782]         }
[15:32:21.782]         {
[15:32:21.782]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:21.782]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:21.782]                 ...future.FUN(...future.X_jj, ...)
[15:32:21.782]             })
[15:32:21.782]         }
[15:32:21.782]     }, args = future.call.arguments)
[15:32:21.782] }
[15:32:21.782] Lazy evaluation: FALSE
[15:32:21.782] Asynchronous evaluation: FALSE
[15:32:21.782] Local evaluation: TRUE
[15:32:21.782] Environment: R_GlobalEnv
[15:32:21.782] Capture standard output: TRUE
[15:32:21.782] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:21.782] Globals: 5 objects totaling 1.55 KiB (function '...future.FUN' of 1.22 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 336 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:21.782] Packages: <none>
[15:32:21.782] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:21.782] Resolved: TRUE
[15:32:21.782] Value: 1.31 KiB of class 'list'
[15:32:21.782] Early signaling: FALSE
[15:32:21.782] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:21.782] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:21.784] Chunk #1 of 1 ... DONE
[15:32:21.785] Launching 1 futures (chunks) ... DONE
[15:32:21.785] Resolving 1 futures (chunks) ...
[15:32:21.785] resolve() on list ...
[15:32:21.786]  recursive: 0
[15:32:21.786]  length: 1
[15:32:21.786] 
[15:32:21.787] resolved() for 'SequentialFuture' ...
[15:32:21.787] - state: 'finished'
[15:32:21.787] - run: TRUE
[15:32:21.788] - result: 'FutureResult'
[15:32:21.788] resolved() for 'SequentialFuture' ... done
[15:32:21.788] Future #1
[15:32:21.789] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:21.789] - nx: 1
[15:32:21.790] - relay: TRUE
[15:32:21.790] - stdout: TRUE
[15:32:21.790] - signal: TRUE
[15:32:21.791] - resignal: FALSE
[15:32:21.791] - force: TRUE
[15:32:21.791] - relayed: [n=1] FALSE
[15:32:21.791] - queued futures: [n=1] FALSE
[15:32:21.792]  - until=1
[15:32:21.792]  - relaying element #1
[15:32:21.793] - relayed: [n=1] TRUE
[15:32:21.793] - queued futures: [n=1] TRUE
[15:32:21.793] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:21.794]  length: 0 (resolved future 1)
[15:32:21.794] Relaying remaining futures
[15:32:21.794] signalConditionsASAP(NULL, pos=0) ...
[15:32:21.795] - nx: 1
[15:32:21.795] - relay: TRUE
[15:32:21.795] - stdout: TRUE
[15:32:21.796] - signal: TRUE
[15:32:21.801] - resignal: FALSE
[15:32:21.801] - force: TRUE
[15:32:21.802] - relayed: [n=1] TRUE
[15:32:21.802] - queued futures: [n=1] TRUE
 - flush all
[15:32:21.803] - relayed: [n=1] TRUE
[15:32:21.803] - queued futures: [n=1] TRUE
[15:32:21.803] signalConditionsASAP(NULL, pos=0) ... done
[15:32:21.804] resolve() on list ... DONE
[15:32:21.804]  - Number of value chunks collected: 1
[15:32:21.805] Resolving 1 futures (chunks) ... DONE
[15:32:21.805] Reducing values from 1 chunks ...
[15:32:21.805]  - Number of values collected after concatenation: 6
[15:32:21.806]  - Number of values expected: 6
[15:32:21.806] Reducing values from 1 chunks ... DONE
[15:32:21.807] future_lapply() ... DONE
List of 2
 $ y0: Named int [1:6] 1 2 2 3 3 4
  ..- attr(*, "names")= chr [1:6] "a1" "a2" "b1" "b2" ...
 $ y1: Named int [1:6] 1 2 2 3 3 4
  ..- attr(*, "names")= chr [1:6] "a1" "a2" "b1" "b2" ...
[15:32:21.812] future_lapply() ...
[15:32:21.814] Number of chunks: 1
[15:32:21.814] getGlobalsAndPackagesXApply() ...
[15:32:21.815]  - future.globals: TRUE
[15:32:21.815] getGlobalsAndPackages() ...
[15:32:21.815] Searching for globals...
[15:32:21.819] - globals found: [5] 'FUN', '*', ':', 'outer', 'rep'
[15:32:21.819] Searching for globals ... DONE
[15:32:21.820] Resolving globals: FALSE
[15:32:21.821] The total size of the 1 globals is 4.62 KiB (4728 bytes)
[15:32:21.822] The total size of the 1 globals exported for future expression ('FUN()') is 4.62 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.62 KiB of class 'function')
[15:32:21.822] - globals: [1] 'FUN'
[15:32:21.822] 
[15:32:21.823] getGlobalsAndPackages() ... DONE
[15:32:21.823]  - globals found/used: [n=1] 'FUN'
[15:32:21.823]  - needed namespaces: [n=0] 
[15:32:21.824] Finding globals ... DONE
[15:32:21.824]  - use_args: TRUE
[15:32:21.824]  - Getting '...' globals ...
[15:32:21.825] resolve() on list ...
[15:32:21.825]  recursive: 0
[15:32:21.826]  length: 1
[15:32:21.826]  elements: '...'
[15:32:21.826]  length: 0 (resolved future 1)
[15:32:21.827] resolve() on list ... DONE
[15:32:21.827]    - '...' content: [n=0] 
[15:32:21.827] List of 1
[15:32:21.827]  $ ...: list()
[15:32:21.827]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:21.827]  - attr(*, "where")=List of 1
[15:32:21.827]   ..$ ...:<environment: 0x00000276e0793bf8> 
[15:32:21.827]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:21.827]  - attr(*, "resolved")= logi TRUE
[15:32:21.827]  - attr(*, "total_size")= num NA
[15:32:21.833]  - Getting '...' globals ... DONE
[15:32:21.833] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:21.834] List of 2
[15:32:21.834]  $ ...future.FUN:function (x, y = 2 * 1:5)  
[15:32:21.834]  $ ...          : list()
[15:32:21.834]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:21.834]  - attr(*, "where")=List of 2
[15:32:21.834]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:21.834]   ..$ ...          :<environment: 0x00000276e0793bf8> 
[15:32:21.834]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:21.834]  - attr(*, "resolved")= logi FALSE
[15:32:21.834]  - attr(*, "total_size")= num 4728
[15:32:21.840] Packages to be attached in all futures: [n=0] 
[15:32:21.840] getGlobalsAndPackagesXApply() ... DONE
[15:32:21.841] Number of futures (= number of chunks): 1
[15:32:21.841] Launching 1 futures (chunks) ...
[15:32:21.842] Chunk #1 of 1 ...
[15:32:21.842]  - Finding globals in 'X' for chunk #1 ...
[15:32:21.842] getGlobalsAndPackages() ...
[15:32:21.843] Searching for globals...
[15:32:21.843] 
[15:32:21.844] Searching for globals ... DONE
[15:32:21.844] - globals: [0] <none>
[15:32:21.844] getGlobalsAndPackages() ... DONE
[15:32:21.845]    + additional globals found: [n=0] 
[15:32:21.845]    + additional namespaces needed: [n=0] 
[15:32:21.845]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:21.846]  - seeds: <none>
[15:32:21.846]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:21.846] getGlobalsAndPackages() ...
[15:32:21.847] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:21.847] Resolving globals: FALSE
[15:32:21.847] Tweak future expression to call with '...' arguments ...
[15:32:21.848] {
[15:32:21.848]     do.call(function(...) {
[15:32:21.848]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:21.848]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:21.848]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:21.848]             on.exit(options(oopts), add = TRUE)
[15:32:21.848]         }
[15:32:21.848]         {
[15:32:21.848]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:21.848]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:21.848]                 ...future.FUN(...future.X_jj, ...)
[15:32:21.848]             })
[15:32:21.848]         }
[15:32:21.848]     }, args = future.call.arguments)
[15:32:21.848] }
[15:32:21.853] Tweak future expression to call with '...' arguments ... DONE
[15:32:21.855] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:21.855] 
[15:32:21.855] getGlobalsAndPackages() ... DONE
[15:32:21.856] run() for 'Future' ...
[15:32:21.857] - state: 'created'
[15:32:21.857] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:21.858] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:21.859] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:21.859]   - Field: 'label'
[15:32:21.859]   - Field: 'local'
[15:32:21.860]   - Field: 'owner'
[15:32:21.860]   - Field: 'envir'
[15:32:21.861]   - Field: 'packages'
[15:32:21.861]   - Field: 'gc'
[15:32:21.861]   - Field: 'conditions'
[15:32:21.862]   - Field: 'expr'
[15:32:21.862]   - Field: 'uuid'
[15:32:21.863]   - Field: 'seed'
[15:32:21.863]   - Field: 'version'
[15:32:21.863]   - Field: 'result'
[15:32:21.864]   - Field: 'asynchronous'
[15:32:21.864]   - Field: 'calls'
[15:32:21.865]   - Field: 'globals'
[15:32:21.865]   - Field: 'stdout'
[15:32:21.865]   - Field: 'earlySignal'
[15:32:21.866]   - Field: 'lazy'
[15:32:21.866]   - Field: 'state'
[15:32:21.866] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:21.867] - Launch lazy future ...
[15:32:21.867] Packages needed by the future expression (n = 0): <none>
[15:32:21.868] Packages needed by future strategies (n = 0): <none>
[15:32:21.869] {
[15:32:21.869]     {
[15:32:21.869]         {
[15:32:21.869]             ...future.startTime <- base::Sys.time()
[15:32:21.869]             {
[15:32:21.869]                 {
[15:32:21.869]                   {
[15:32:21.869]                     base::local({
[15:32:21.869]                       has_future <- base::requireNamespace("future", 
[15:32:21.869]                         quietly = TRUE)
[15:32:21.869]                       if (has_future) {
[15:32:21.869]                         ns <- base::getNamespace("future")
[15:32:21.869]                         version <- ns[[".package"]][["version"]]
[15:32:21.869]                         if (is.null(version)) 
[15:32:21.869]                           version <- utils::packageVersion("future")
[15:32:21.869]                       }
[15:32:21.869]                       else {
[15:32:21.869]                         version <- NULL
[15:32:21.869]                       }
[15:32:21.869]                       if (!has_future || version < "1.8.0") {
[15:32:21.869]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:21.869]                           "", base::R.version$version.string), 
[15:32:21.869]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:21.869]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:21.869]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:21.869]                             "release", "version")], collapse = " "), 
[15:32:21.869]                           hostname = base::Sys.info()[["nodename"]])
[15:32:21.869]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:21.869]                           info)
[15:32:21.869]                         info <- base::paste(info, collapse = "; ")
[15:32:21.869]                         if (!has_future) {
[15:32:21.869]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:21.869]                             info)
[15:32:21.869]                         }
[15:32:21.869]                         else {
[15:32:21.869]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:21.869]                             info, version)
[15:32:21.869]                         }
[15:32:21.869]                         base::stop(msg)
[15:32:21.869]                       }
[15:32:21.869]                     })
[15:32:21.869]                   }
[15:32:21.869]                   ...future.strategy.old <- future::plan("list")
[15:32:21.869]                   options(future.plan = NULL)
[15:32:21.869]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:21.869]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:21.869]                 }
[15:32:21.869]                 ...future.workdir <- getwd()
[15:32:21.869]             }
[15:32:21.869]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:21.869]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:21.869]         }
[15:32:21.869]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:21.869]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:21.869]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:21.869]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:21.869]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:21.869]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:21.869]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:21.869]             base::names(...future.oldOptions))
[15:32:21.869]     }
[15:32:21.869]     if (FALSE) {
[15:32:21.869]     }
[15:32:21.869]     else {
[15:32:21.869]         if (TRUE) {
[15:32:21.869]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:21.869]                 open = "w")
[15:32:21.869]         }
[15:32:21.869]         else {
[15:32:21.869]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:21.869]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:21.869]         }
[15:32:21.869]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:21.869]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:21.869]             base::sink(type = "output", split = FALSE)
[15:32:21.869]             base::close(...future.stdout)
[15:32:21.869]         }, add = TRUE)
[15:32:21.869]     }
[15:32:21.869]     ...future.frame <- base::sys.nframe()
[15:32:21.869]     ...future.conditions <- base::list()
[15:32:21.869]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:21.869]     if (FALSE) {
[15:32:21.869]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:21.869]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:21.869]     }
[15:32:21.869]     ...future.result <- base::tryCatch({
[15:32:21.869]         base::withCallingHandlers({
[15:32:21.869]             ...future.value <- base::withVisible(base::local({
[15:32:21.869]                 do.call(function(...) {
[15:32:21.869]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:21.869]                   if (!identical(...future.globals.maxSize.org, 
[15:32:21.869]                     ...future.globals.maxSize)) {
[15:32:21.869]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:21.869]                     on.exit(options(oopts), add = TRUE)
[15:32:21.869]                   }
[15:32:21.869]                   {
[15:32:21.869]                     lapply(seq_along(...future.elements_ii), 
[15:32:21.869]                       FUN = function(jj) {
[15:32:21.869]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:21.869]                         ...future.FUN(...future.X_jj, ...)
[15:32:21.869]                       })
[15:32:21.869]                   }
[15:32:21.869]                 }, args = future.call.arguments)
[15:32:21.869]             }))
[15:32:21.869]             future::FutureResult(value = ...future.value$value, 
[15:32:21.869]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:21.869]                   ...future.rng), globalenv = if (FALSE) 
[15:32:21.869]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:21.869]                     ...future.globalenv.names))
[15:32:21.869]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:21.869]         }, condition = base::local({
[15:32:21.869]             c <- base::c
[15:32:21.869]             inherits <- base::inherits
[15:32:21.869]             invokeRestart <- base::invokeRestart
[15:32:21.869]             length <- base::length
[15:32:21.869]             list <- base::list
[15:32:21.869]             seq.int <- base::seq.int
[15:32:21.869]             signalCondition <- base::signalCondition
[15:32:21.869]             sys.calls <- base::sys.calls
[15:32:21.869]             `[[` <- base::`[[`
[15:32:21.869]             `+` <- base::`+`
[15:32:21.869]             `<<-` <- base::`<<-`
[15:32:21.869]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:21.869]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:21.869]                   3L)]
[15:32:21.869]             }
[15:32:21.869]             function(cond) {
[15:32:21.869]                 is_error <- inherits(cond, "error")
[15:32:21.869]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:21.869]                   NULL)
[15:32:21.869]                 if (is_error) {
[15:32:21.869]                   sessionInformation <- function() {
[15:32:21.869]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:21.869]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:21.869]                       search = base::search(), system = base::Sys.info())
[15:32:21.869]                   }
[15:32:21.869]                   ...future.conditions[[length(...future.conditions) + 
[15:32:21.869]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:21.869]                     cond$call), session = sessionInformation(), 
[15:32:21.869]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:21.869]                   signalCondition(cond)
[15:32:21.869]                 }
[15:32:21.869]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:21.869]                 "immediateCondition"))) {
[15:32:21.869]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:21.869]                   ...future.conditions[[length(...future.conditions) + 
[15:32:21.869]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:21.869]                   if (TRUE && !signal) {
[15:32:21.869]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:21.869]                     {
[15:32:21.869]                       inherits <- base::inherits
[15:32:21.869]                       invokeRestart <- base::invokeRestart
[15:32:21.869]                       is.null <- base::is.null
[15:32:21.869]                       muffled <- FALSE
[15:32:21.869]                       if (inherits(cond, "message")) {
[15:32:21.869]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:21.869]                         if (muffled) 
[15:32:21.869]                           invokeRestart("muffleMessage")
[15:32:21.869]                       }
[15:32:21.869]                       else if (inherits(cond, "warning")) {
[15:32:21.869]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:21.869]                         if (muffled) 
[15:32:21.869]                           invokeRestart("muffleWarning")
[15:32:21.869]                       }
[15:32:21.869]                       else if (inherits(cond, "condition")) {
[15:32:21.869]                         if (!is.null(pattern)) {
[15:32:21.869]                           computeRestarts <- base::computeRestarts
[15:32:21.869]                           grepl <- base::grepl
[15:32:21.869]                           restarts <- computeRestarts(cond)
[15:32:21.869]                           for (restart in restarts) {
[15:32:21.869]                             name <- restart$name
[15:32:21.869]                             if (is.null(name)) 
[15:32:21.869]                               next
[15:32:21.869]                             if (!grepl(pattern, name)) 
[15:32:21.869]                               next
[15:32:21.869]                             invokeRestart(restart)
[15:32:21.869]                             muffled <- TRUE
[15:32:21.869]                             break
[15:32:21.869]                           }
[15:32:21.869]                         }
[15:32:21.869]                       }
[15:32:21.869]                       invisible(muffled)
[15:32:21.869]                     }
[15:32:21.869]                     muffleCondition(cond, pattern = "^muffle")
[15:32:21.869]                   }
[15:32:21.869]                 }
[15:32:21.869]                 else {
[15:32:21.869]                   if (TRUE) {
[15:32:21.869]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:21.869]                     {
[15:32:21.869]                       inherits <- base::inherits
[15:32:21.869]                       invokeRestart <- base::invokeRestart
[15:32:21.869]                       is.null <- base::is.null
[15:32:21.869]                       muffled <- FALSE
[15:32:21.869]                       if (inherits(cond, "message")) {
[15:32:21.869]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:21.869]                         if (muffled) 
[15:32:21.869]                           invokeRestart("muffleMessage")
[15:32:21.869]                       }
[15:32:21.869]                       else if (inherits(cond, "warning")) {
[15:32:21.869]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:21.869]                         if (muffled) 
[15:32:21.869]                           invokeRestart("muffleWarning")
[15:32:21.869]                       }
[15:32:21.869]                       else if (inherits(cond, "condition")) {
[15:32:21.869]                         if (!is.null(pattern)) {
[15:32:21.869]                           computeRestarts <- base::computeRestarts
[15:32:21.869]                           grepl <- base::grepl
[15:32:21.869]                           restarts <- computeRestarts(cond)
[15:32:21.869]                           for (restart in restarts) {
[15:32:21.869]                             name <- restart$name
[15:32:21.869]                             if (is.null(name)) 
[15:32:21.869]                               next
[15:32:21.869]                             if (!grepl(pattern, name)) 
[15:32:21.869]                               next
[15:32:21.869]                             invokeRestart(restart)
[15:32:21.869]                             muffled <- TRUE
[15:32:21.869]                             break
[15:32:21.869]                           }
[15:32:21.869]                         }
[15:32:21.869]                       }
[15:32:21.869]                       invisible(muffled)
[15:32:21.869]                     }
[15:32:21.869]                     muffleCondition(cond, pattern = "^muffle")
[15:32:21.869]                   }
[15:32:21.869]                 }
[15:32:21.869]             }
[15:32:21.869]         }))
[15:32:21.869]     }, error = function(ex) {
[15:32:21.869]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:21.869]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:21.869]                 ...future.rng), started = ...future.startTime, 
[15:32:21.869]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:21.869]             version = "1.8"), class = "FutureResult")
[15:32:21.869]     }, finally = {
[15:32:21.869]         if (!identical(...future.workdir, getwd())) 
[15:32:21.869]             setwd(...future.workdir)
[15:32:21.869]         {
[15:32:21.869]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:21.869]                 ...future.oldOptions$nwarnings <- NULL
[15:32:21.869]             }
[15:32:21.869]             base::options(...future.oldOptions)
[15:32:21.869]             if (.Platform$OS.type == "windows") {
[15:32:21.869]                 old_names <- names(...future.oldEnvVars)
[15:32:21.869]                 envs <- base::Sys.getenv()
[15:32:21.869]                 names <- names(envs)
[15:32:21.869]                 common <- intersect(names, old_names)
[15:32:21.869]                 added <- setdiff(names, old_names)
[15:32:21.869]                 removed <- setdiff(old_names, names)
[15:32:21.869]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:21.869]                   envs[common]]
[15:32:21.869]                 NAMES <- toupper(changed)
[15:32:21.869]                 args <- list()
[15:32:21.869]                 for (kk in seq_along(NAMES)) {
[15:32:21.869]                   name <- changed[[kk]]
[15:32:21.869]                   NAME <- NAMES[[kk]]
[15:32:21.869]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:21.869]                     next
[15:32:21.869]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:21.869]                 }
[15:32:21.869]                 NAMES <- toupper(added)
[15:32:21.869]                 for (kk in seq_along(NAMES)) {
[15:32:21.869]                   name <- added[[kk]]
[15:32:21.869]                   NAME <- NAMES[[kk]]
[15:32:21.869]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:21.869]                     next
[15:32:21.869]                   args[[name]] <- ""
[15:32:21.869]                 }
[15:32:21.869]                 NAMES <- toupper(removed)
[15:32:21.869]                 for (kk in seq_along(NAMES)) {
[15:32:21.869]                   name <- removed[[kk]]
[15:32:21.869]                   NAME <- NAMES[[kk]]
[15:32:21.869]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:21.869]                     next
[15:32:21.869]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:21.869]                 }
[15:32:21.869]                 if (length(args) > 0) 
[15:32:21.869]                   base::do.call(base::Sys.setenv, args = args)
[15:32:21.869]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:21.869]             }
[15:32:21.869]             else {
[15:32:21.869]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:21.869]             }
[15:32:21.869]             {
[15:32:21.869]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:21.869]                   0L) {
[15:32:21.869]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:21.869]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:21.869]                   base::options(opts)
[15:32:21.869]                 }
[15:32:21.869]                 {
[15:32:21.869]                   {
[15:32:21.869]                     NULL
[15:32:21.869]                     RNGkind("Mersenne-Twister")
[15:32:21.869]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:21.869]                       inherits = FALSE)
[15:32:21.869]                   }
[15:32:21.869]                   options(future.plan = NULL)
[15:32:21.869]                   if (is.na(NA_character_)) 
[15:32:21.869]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:21.869]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:21.869]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:21.869]                     .init = FALSE)
[15:32:21.869]                 }
[15:32:21.869]             }
[15:32:21.869]         }
[15:32:21.869]     })
[15:32:21.869]     if (TRUE) {
[15:32:21.869]         base::sink(type = "output", split = FALSE)
[15:32:21.869]         if (TRUE) {
[15:32:21.869]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:21.869]         }
[15:32:21.869]         else {
[15:32:21.869]             ...future.result["stdout"] <- base::list(NULL)
[15:32:21.869]         }
[15:32:21.869]         base::close(...future.stdout)
[15:32:21.869]         ...future.stdout <- NULL
[15:32:21.869]     }
[15:32:21.869]     ...future.result$conditions <- ...future.conditions
[15:32:21.869]     ...future.result$finished <- base::Sys.time()
[15:32:21.869]     ...future.result
[15:32:21.869] }
[15:32:21.877] assign_globals() ...
[15:32:21.877] List of 5
[15:32:21.877]  $ ...future.FUN            :function (x, y = 2 * 1:5)  
[15:32:21.877]  $ future.call.arguments    : list()
[15:32:21.877]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:21.877]  $ ...future.elements_ii    :List of 6
[15:32:21.877]   ..$ a1: int 1
[15:32:21.877]   ..$ a2: int 2
[15:32:21.877]   ..$ b1: int 2
[15:32:21.877]   ..$ b2: int 3
[15:32:21.877]   ..$ c1: int 3
[15:32:21.877]   ..$ c2: int 4
[15:32:21.877]  $ ...future.seeds_ii       : NULL
[15:32:21.877]  $ ...future.globals.maxSize: NULL
[15:32:21.877]  - attr(*, "where")=List of 5
[15:32:21.877]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:21.877]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:21.877]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:21.877]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:21.877]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:21.877]  - attr(*, "resolved")= logi FALSE
[15:32:21.877]  - attr(*, "total_size")= num 4728
[15:32:21.877]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:21.877]  - attr(*, "already-done")= logi TRUE
[15:32:21.892] - reassign environment for '...future.FUN'
[15:32:21.892] - copied '...future.FUN' to environment
[15:32:21.892] - copied 'future.call.arguments' to environment
[15:32:21.893] - copied '...future.elements_ii' to environment
[15:32:21.893] - copied '...future.seeds_ii' to environment
[15:32:21.893] - copied '...future.globals.maxSize' to environment
[15:32:21.894] assign_globals() ... done
[15:32:21.894] plan(): Setting new future strategy stack:
[15:32:21.895] List of future strategies:
[15:32:21.895] 1. sequential:
[15:32:21.895]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:21.895]    - tweaked: FALSE
[15:32:21.895]    - call: NULL
[15:32:21.896] plan(): nbrOfWorkers() = 1
[15:32:21.899] plan(): Setting new future strategy stack:
[15:32:21.899] List of future strategies:
[15:32:21.899] 1. sequential:
[15:32:21.899]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:21.899]    - tweaked: FALSE
[15:32:21.899]    - call: plan(strategy)
[15:32:21.900] plan(): nbrOfWorkers() = 1
[15:32:21.900] SequentialFuture started (and completed)
[15:32:21.901] - Launch lazy future ... done
[15:32:21.901] run() for 'SequentialFuture' ... done
[15:32:21.902] Created future:
[15:32:21.902] SequentialFuture:
[15:32:21.902] Label: 'future_sapply-1'
[15:32:21.902] Expression:
[15:32:21.902] {
[15:32:21.902]     do.call(function(...) {
[15:32:21.902]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:21.902]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:21.902]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:21.902]             on.exit(options(oopts), add = TRUE)
[15:32:21.902]         }
[15:32:21.902]         {
[15:32:21.902]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:21.902]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:21.902]                 ...future.FUN(...future.X_jj, ...)
[15:32:21.902]             })
[15:32:21.902]         }
[15:32:21.902]     }, args = future.call.arguments)
[15:32:21.902] }
[15:32:21.902] Lazy evaluation: FALSE
[15:32:21.902] Asynchronous evaluation: FALSE
[15:32:21.902] Local evaluation: TRUE
[15:32:21.902] Environment: R_GlobalEnv
[15:32:21.902] Capture standard output: TRUE
[15:32:21.902] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:21.902] Globals: 5 objects totaling 4.95 KiB (function '...future.FUN' of 4.62 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 336 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:21.902] Packages: <none>
[15:32:21.902] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:21.902] Resolved: TRUE
[15:32:21.902] Value: 2.02 KiB of class 'list'
[15:32:21.902] Early signaling: FALSE
[15:32:21.902] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:21.902] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:21.905] Chunk #1 of 1 ... DONE
[15:32:21.905] Launching 1 futures (chunks) ... DONE
[15:32:21.905] Resolving 1 futures (chunks) ...
[15:32:21.906] resolve() on list ...
[15:32:21.906]  recursive: 0
[15:32:21.906]  length: 1
[15:32:21.907] 
[15:32:21.907] resolved() for 'SequentialFuture' ...
[15:32:21.907] - state: 'finished'
[15:32:21.908] - run: TRUE
[15:32:21.908] - result: 'FutureResult'
[15:32:21.908] resolved() for 'SequentialFuture' ... done
[15:32:21.909] Future #1
[15:32:21.914] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:21.914] - nx: 1
[15:32:21.915] - relay: TRUE
[15:32:21.915] - stdout: TRUE
[15:32:21.915] - signal: TRUE
[15:32:21.916] - resignal: FALSE
[15:32:21.916] - force: TRUE
[15:32:21.916] - relayed: [n=1] FALSE
[15:32:21.917] - queued futures: [n=1] FALSE
[15:32:21.917]  - until=1
[15:32:21.918]  - relaying element #1
[15:32:21.918] - relayed: [n=1] TRUE
[15:32:21.919] - queued futures: [n=1] TRUE
[15:32:21.919] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:21.919]  length: 0 (resolved future 1)
[15:32:21.920] Relaying remaining futures
[15:32:21.920] signalConditionsASAP(NULL, pos=0) ...
[15:32:21.920] - nx: 1
[15:32:21.921] - relay: TRUE
[15:32:21.921] - stdout: TRUE
[15:32:21.921] - signal: TRUE
[15:32:21.922] - resignal: FALSE
[15:32:21.922] - force: TRUE
[15:32:21.922] - relayed: [n=1] TRUE
[15:32:21.923] - queued futures: [n=1] TRUE
 - flush all
[15:32:21.923] - relayed: [n=1] TRUE
[15:32:21.924] - queued futures: [n=1] TRUE
[15:32:21.924] signalConditionsASAP(NULL, pos=0) ... done
[15:32:21.924] resolve() on list ... DONE
[15:32:21.925]  - Number of value chunks collected: 1
[15:32:21.925] Resolving 1 futures (chunks) ... DONE
[15:32:21.926] Reducing values from 1 chunks ...
[15:32:21.926]  - Number of values collected after concatenation: 6
[15:32:21.926]  - Number of values expected: 6
[15:32:21.927] Reducing values from 1 chunks ... DONE
[15:32:21.927] future_lapply() ... DONE
List of 2
 $ y0: num [1:3, 1:5, 1:6] 2 2 2 4 4 4 6 6 6 8 ...
  ..- attr(*, "dimnames")=List of 3
  .. ..$ : NULL
  .. ..$ : NULL
  .. ..$ : chr [1:6] "a1" "a2" "b1" "b2" ...
 $ y1: num [1:3, 1:5, 1:6] 2 2 2 4 4 4 6 6 6 8 ...
  ..- attr(*, "dimnames")=List of 3
  .. ..$ : NULL
  .. ..$ : NULL
  .. ..$ : chr [1:6] "a1" "a2" "b1" "b2" ...
[15:32:21.934] future_lapply() ...
[15:32:21.935] Number of chunks: 1
[15:32:21.935] getGlobalsAndPackagesXApply() ...
[15:32:21.936]  - future.globals: TRUE
[15:32:21.936] getGlobalsAndPackages() ...
[15:32:21.936] Searching for globals...
[15:32:21.938] - globals found: [1] 'FUN'
[15:32:21.938] Searching for globals ... DONE
[15:32:21.938] Resolving globals: FALSE
[15:32:21.939] The total size of the 1 globals is 848 bytes (848 bytes)
[15:32:21.939] The total size of the 1 globals exported for future expression ('FUN()') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:32:21.940] - globals: [1] 'FUN'
[15:32:21.940] 
[15:32:21.940] getGlobalsAndPackages() ... DONE
[15:32:21.940]  - globals found/used: [n=1] 'FUN'
[15:32:21.940]  - needed namespaces: [n=0] 
[15:32:21.940] Finding globals ... DONE
[15:32:21.941]  - use_args: TRUE
[15:32:21.941]  - Getting '...' globals ...
[15:32:21.941] resolve() on list ...
[15:32:21.942]  recursive: 0
[15:32:21.942]  length: 1
[15:32:21.942]  elements: '...'
[15:32:21.942]  length: 0 (resolved future 1)
[15:32:21.942] resolve() on list ... DONE
[15:32:21.943]    - '...' content: [n=0] 
[15:32:21.943] List of 1
[15:32:21.943]  $ ...: list()
[15:32:21.943]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:21.943]  - attr(*, "where")=List of 1
[15:32:21.943]   ..$ ...:<environment: 0x00000276de892f98> 
[15:32:21.943]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:21.943]  - attr(*, "resolved")= logi TRUE
[15:32:21.943]  - attr(*, "total_size")= num NA
[15:32:21.946]  - Getting '...' globals ... DONE
[15:32:21.947] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:21.947] List of 2
[15:32:21.947]  $ ...future.FUN:function (x)  
[15:32:21.947]  $ ...          : list()
[15:32:21.947]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:21.947]  - attr(*, "where")=List of 2
[15:32:21.947]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:21.947]   ..$ ...          :<environment: 0x00000276de892f98> 
[15:32:21.947]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:21.947]  - attr(*, "resolved")= logi FALSE
[15:32:21.947]  - attr(*, "total_size")= num 848
[15:32:21.954] Packages to be attached in all futures: [n=0] 
[15:32:21.955] getGlobalsAndPackagesXApply() ... DONE
[15:32:21.955] Number of futures (= number of chunks): 1
[15:32:21.956] Launching 1 futures (chunks) ...
[15:32:21.956] Chunk #1 of 1 ...
[15:32:21.956]  - Finding globals in 'X' for chunk #1 ...
[15:32:21.957] getGlobalsAndPackages() ...
[15:32:21.957] Searching for globals...
[15:32:21.958] 
[15:32:21.958] Searching for globals ... DONE
[15:32:21.959] - globals: [0] <none>
[15:32:21.959] getGlobalsAndPackages() ... DONE
[15:32:21.959]    + additional globals found: [n=0] 
[15:32:21.960]    + additional namespaces needed: [n=0] 
[15:32:21.960]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:21.960]  - seeds: <none>
[15:32:21.961]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:21.961] getGlobalsAndPackages() ...
[15:32:21.961] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:21.962] Resolving globals: FALSE
[15:32:21.962] Tweak future expression to call with '...' arguments ...
[15:32:21.963] {
[15:32:21.963]     do.call(function(...) {
[15:32:21.963]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:21.963]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:21.963]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:21.963]             on.exit(options(oopts), add = TRUE)
[15:32:21.963]         }
[15:32:21.963]         {
[15:32:21.963]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:21.963]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:21.963]                 ...future.FUN(...future.X_jj, ...)
[15:32:21.963]             })
[15:32:21.963]         }
[15:32:21.963]     }, args = future.call.arguments)
[15:32:21.963] }
[15:32:21.964] Tweak future expression to call with '...' arguments ... DONE
[15:32:21.965] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:21.965] 
[15:32:21.965] getGlobalsAndPackages() ... DONE
[15:32:21.966] run() for 'Future' ...
[15:32:21.966] - state: 'created'
[15:32:21.967] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:21.968] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:21.968] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:21.968]   - Field: 'label'
[15:32:21.969]   - Field: 'local'
[15:32:21.969]   - Field: 'owner'
[15:32:21.970]   - Field: 'envir'
[15:32:21.970]   - Field: 'packages'
[15:32:21.970]   - Field: 'gc'
[15:32:21.971]   - Field: 'conditions'
[15:32:21.971]   - Field: 'expr'
[15:32:21.971]   - Field: 'uuid'
[15:32:21.972]   - Field: 'seed'
[15:32:21.972]   - Field: 'version'
[15:32:21.972]   - Field: 'result'
[15:32:21.973]   - Field: 'asynchronous'
[15:32:21.973]   - Field: 'calls'
[15:32:21.973]   - Field: 'globals'
[15:32:21.974]   - Field: 'stdout'
[15:32:21.974]   - Field: 'earlySignal'
[15:32:21.974]   - Field: 'lazy'
[15:32:21.975]   - Field: 'state'
[15:32:21.975] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:21.976] - Launch lazy future ...
[15:32:21.976] Packages needed by the future expression (n = 0): <none>
[15:32:21.976] Packages needed by future strategies (n = 0): <none>
[15:32:21.978] {
[15:32:21.978]     {
[15:32:21.978]         {
[15:32:21.978]             ...future.startTime <- base::Sys.time()
[15:32:21.978]             {
[15:32:21.978]                 {
[15:32:21.978]                   {
[15:32:21.978]                     base::local({
[15:32:21.978]                       has_future <- base::requireNamespace("future", 
[15:32:21.978]                         quietly = TRUE)
[15:32:21.978]                       if (has_future) {
[15:32:21.978]                         ns <- base::getNamespace("future")
[15:32:21.978]                         version <- ns[[".package"]][["version"]]
[15:32:21.978]                         if (is.null(version)) 
[15:32:21.978]                           version <- utils::packageVersion("future")
[15:32:21.978]                       }
[15:32:21.978]                       else {
[15:32:21.978]                         version <- NULL
[15:32:21.978]                       }
[15:32:21.978]                       if (!has_future || version < "1.8.0") {
[15:32:21.978]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:21.978]                           "", base::R.version$version.string), 
[15:32:21.978]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:21.978]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:21.978]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:21.978]                             "release", "version")], collapse = " "), 
[15:32:21.978]                           hostname = base::Sys.info()[["nodename"]])
[15:32:21.978]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:21.978]                           info)
[15:32:21.978]                         info <- base::paste(info, collapse = "; ")
[15:32:21.978]                         if (!has_future) {
[15:32:21.978]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:21.978]                             info)
[15:32:21.978]                         }
[15:32:21.978]                         else {
[15:32:21.978]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:21.978]                             info, version)
[15:32:21.978]                         }
[15:32:21.978]                         base::stop(msg)
[15:32:21.978]                       }
[15:32:21.978]                     })
[15:32:21.978]                   }
[15:32:21.978]                   ...future.strategy.old <- future::plan("list")
[15:32:21.978]                   options(future.plan = NULL)
[15:32:21.978]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:21.978]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:21.978]                 }
[15:32:21.978]                 ...future.workdir <- getwd()
[15:32:21.978]             }
[15:32:21.978]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:21.978]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:21.978]         }
[15:32:21.978]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:21.978]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:21.978]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:21.978]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:21.978]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:21.978]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:21.978]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:21.978]             base::names(...future.oldOptions))
[15:32:21.978]     }
[15:32:21.978]     if (FALSE) {
[15:32:21.978]     }
[15:32:21.978]     else {
[15:32:21.978]         if (TRUE) {
[15:32:21.978]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:21.978]                 open = "w")
[15:32:21.978]         }
[15:32:21.978]         else {
[15:32:21.978]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:21.978]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:21.978]         }
[15:32:21.978]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:21.978]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:21.978]             base::sink(type = "output", split = FALSE)
[15:32:21.978]             base::close(...future.stdout)
[15:32:21.978]         }, add = TRUE)
[15:32:21.978]     }
[15:32:21.978]     ...future.frame <- base::sys.nframe()
[15:32:21.978]     ...future.conditions <- base::list()
[15:32:21.978]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:21.978]     if (FALSE) {
[15:32:21.978]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:21.978]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:21.978]     }
[15:32:21.978]     ...future.result <- base::tryCatch({
[15:32:21.978]         base::withCallingHandlers({
[15:32:21.978]             ...future.value <- base::withVisible(base::local({
[15:32:21.978]                 do.call(function(...) {
[15:32:21.978]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:21.978]                   if (!identical(...future.globals.maxSize.org, 
[15:32:21.978]                     ...future.globals.maxSize)) {
[15:32:21.978]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:21.978]                     on.exit(options(oopts), add = TRUE)
[15:32:21.978]                   }
[15:32:21.978]                   {
[15:32:21.978]                     lapply(seq_along(...future.elements_ii), 
[15:32:21.978]                       FUN = function(jj) {
[15:32:21.978]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:21.978]                         ...future.FUN(...future.X_jj, ...)
[15:32:21.978]                       })
[15:32:21.978]                   }
[15:32:21.978]                 }, args = future.call.arguments)
[15:32:21.978]             }))
[15:32:21.978]             future::FutureResult(value = ...future.value$value, 
[15:32:21.978]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:21.978]                   ...future.rng), globalenv = if (FALSE) 
[15:32:21.978]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:21.978]                     ...future.globalenv.names))
[15:32:21.978]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:21.978]         }, condition = base::local({
[15:32:21.978]             c <- base::c
[15:32:21.978]             inherits <- base::inherits
[15:32:21.978]             invokeRestart <- base::invokeRestart
[15:32:21.978]             length <- base::length
[15:32:21.978]             list <- base::list
[15:32:21.978]             seq.int <- base::seq.int
[15:32:21.978]             signalCondition <- base::signalCondition
[15:32:21.978]             sys.calls <- base::sys.calls
[15:32:21.978]             `[[` <- base::`[[`
[15:32:21.978]             `+` <- base::`+`
[15:32:21.978]             `<<-` <- base::`<<-`
[15:32:21.978]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:21.978]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:21.978]                   3L)]
[15:32:21.978]             }
[15:32:21.978]             function(cond) {
[15:32:21.978]                 is_error <- inherits(cond, "error")
[15:32:21.978]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:21.978]                   NULL)
[15:32:21.978]                 if (is_error) {
[15:32:21.978]                   sessionInformation <- function() {
[15:32:21.978]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:21.978]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:21.978]                       search = base::search(), system = base::Sys.info())
[15:32:21.978]                   }
[15:32:21.978]                   ...future.conditions[[length(...future.conditions) + 
[15:32:21.978]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:21.978]                     cond$call), session = sessionInformation(), 
[15:32:21.978]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:21.978]                   signalCondition(cond)
[15:32:21.978]                 }
[15:32:21.978]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:21.978]                 "immediateCondition"))) {
[15:32:21.978]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:21.978]                   ...future.conditions[[length(...future.conditions) + 
[15:32:21.978]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:21.978]                   if (TRUE && !signal) {
[15:32:21.978]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:21.978]                     {
[15:32:21.978]                       inherits <- base::inherits
[15:32:21.978]                       invokeRestart <- base::invokeRestart
[15:32:21.978]                       is.null <- base::is.null
[15:32:21.978]                       muffled <- FALSE
[15:32:21.978]                       if (inherits(cond, "message")) {
[15:32:21.978]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:21.978]                         if (muffled) 
[15:32:21.978]                           invokeRestart("muffleMessage")
[15:32:21.978]                       }
[15:32:21.978]                       else if (inherits(cond, "warning")) {
[15:32:21.978]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:21.978]                         if (muffled) 
[15:32:21.978]                           invokeRestart("muffleWarning")
[15:32:21.978]                       }
[15:32:21.978]                       else if (inherits(cond, "condition")) {
[15:32:21.978]                         if (!is.null(pattern)) {
[15:32:21.978]                           computeRestarts <- base::computeRestarts
[15:32:21.978]                           grepl <- base::grepl
[15:32:21.978]                           restarts <- computeRestarts(cond)
[15:32:21.978]                           for (restart in restarts) {
[15:32:21.978]                             name <- restart$name
[15:32:21.978]                             if (is.null(name)) 
[15:32:21.978]                               next
[15:32:21.978]                             if (!grepl(pattern, name)) 
[15:32:21.978]                               next
[15:32:21.978]                             invokeRestart(restart)
[15:32:21.978]                             muffled <- TRUE
[15:32:21.978]                             break
[15:32:21.978]                           }
[15:32:21.978]                         }
[15:32:21.978]                       }
[15:32:21.978]                       invisible(muffled)
[15:32:21.978]                     }
[15:32:21.978]                     muffleCondition(cond, pattern = "^muffle")
[15:32:21.978]                   }
[15:32:21.978]                 }
[15:32:21.978]                 else {
[15:32:21.978]                   if (TRUE) {
[15:32:21.978]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:21.978]                     {
[15:32:21.978]                       inherits <- base::inherits
[15:32:21.978]                       invokeRestart <- base::invokeRestart
[15:32:21.978]                       is.null <- base::is.null
[15:32:21.978]                       muffled <- FALSE
[15:32:21.978]                       if (inherits(cond, "message")) {
[15:32:21.978]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:21.978]                         if (muffled) 
[15:32:21.978]                           invokeRestart("muffleMessage")
[15:32:21.978]                       }
[15:32:21.978]                       else if (inherits(cond, "warning")) {
[15:32:21.978]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:21.978]                         if (muffled) 
[15:32:21.978]                           invokeRestart("muffleWarning")
[15:32:21.978]                       }
[15:32:21.978]                       else if (inherits(cond, "condition")) {
[15:32:21.978]                         if (!is.null(pattern)) {
[15:32:21.978]                           computeRestarts <- base::computeRestarts
[15:32:21.978]                           grepl <- base::grepl
[15:32:21.978]                           restarts <- computeRestarts(cond)
[15:32:21.978]                           for (restart in restarts) {
[15:32:21.978]                             name <- restart$name
[15:32:21.978]                             if (is.null(name)) 
[15:32:21.978]                               next
[15:32:21.978]                             if (!grepl(pattern, name)) 
[15:32:21.978]                               next
[15:32:21.978]                             invokeRestart(restart)
[15:32:21.978]                             muffled <- TRUE
[15:32:21.978]                             break
[15:32:21.978]                           }
[15:32:21.978]                         }
[15:32:21.978]                       }
[15:32:21.978]                       invisible(muffled)
[15:32:21.978]                     }
[15:32:21.978]                     muffleCondition(cond, pattern = "^muffle")
[15:32:21.978]                   }
[15:32:21.978]                 }
[15:32:21.978]             }
[15:32:21.978]         }))
[15:32:21.978]     }, error = function(ex) {
[15:32:21.978]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:21.978]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:21.978]                 ...future.rng), started = ...future.startTime, 
[15:32:21.978]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:21.978]             version = "1.8"), class = "FutureResult")
[15:32:21.978]     }, finally = {
[15:32:21.978]         if (!identical(...future.workdir, getwd())) 
[15:32:21.978]             setwd(...future.workdir)
[15:32:21.978]         {
[15:32:21.978]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:21.978]                 ...future.oldOptions$nwarnings <- NULL
[15:32:21.978]             }
[15:32:21.978]             base::options(...future.oldOptions)
[15:32:21.978]             if (.Platform$OS.type == "windows") {
[15:32:21.978]                 old_names <- names(...future.oldEnvVars)
[15:32:21.978]                 envs <- base::Sys.getenv()
[15:32:21.978]                 names <- names(envs)
[15:32:21.978]                 common <- intersect(names, old_names)
[15:32:21.978]                 added <- setdiff(names, old_names)
[15:32:21.978]                 removed <- setdiff(old_names, names)
[15:32:21.978]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:21.978]                   envs[common]]
[15:32:21.978]                 NAMES <- toupper(changed)
[15:32:21.978]                 args <- list()
[15:32:21.978]                 for (kk in seq_along(NAMES)) {
[15:32:21.978]                   name <- changed[[kk]]
[15:32:21.978]                   NAME <- NAMES[[kk]]
[15:32:21.978]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:21.978]                     next
[15:32:21.978]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:21.978]                 }
[15:32:21.978]                 NAMES <- toupper(added)
[15:32:21.978]                 for (kk in seq_along(NAMES)) {
[15:32:21.978]                   name <- added[[kk]]
[15:32:21.978]                   NAME <- NAMES[[kk]]
[15:32:21.978]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:21.978]                     next
[15:32:21.978]                   args[[name]] <- ""
[15:32:21.978]                 }
[15:32:21.978]                 NAMES <- toupper(removed)
[15:32:21.978]                 for (kk in seq_along(NAMES)) {
[15:32:21.978]                   name <- removed[[kk]]
[15:32:21.978]                   NAME <- NAMES[[kk]]
[15:32:21.978]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:21.978]                     next
[15:32:21.978]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:21.978]                 }
[15:32:21.978]                 if (length(args) > 0) 
[15:32:21.978]                   base::do.call(base::Sys.setenv, args = args)
[15:32:21.978]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:21.978]             }
[15:32:21.978]             else {
[15:32:21.978]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:21.978]             }
[15:32:21.978]             {
[15:32:21.978]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:21.978]                   0L) {
[15:32:21.978]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:21.978]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:21.978]                   base::options(opts)
[15:32:21.978]                 }
[15:32:21.978]                 {
[15:32:21.978]                   {
[15:32:21.978]                     NULL
[15:32:21.978]                     RNGkind("Mersenne-Twister")
[15:32:21.978]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:21.978]                       inherits = FALSE)
[15:32:21.978]                   }
[15:32:21.978]                   options(future.plan = NULL)
[15:32:21.978]                   if (is.na(NA_character_)) 
[15:32:21.978]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:21.978]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:21.978]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:21.978]                     .init = FALSE)
[15:32:21.978]                 }
[15:32:21.978]             }
[15:32:21.978]         }
[15:32:21.978]     })
[15:32:21.978]     if (TRUE) {
[15:32:21.978]         base::sink(type = "output", split = FALSE)
[15:32:21.978]         if (TRUE) {
[15:32:21.978]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:21.978]         }
[15:32:21.978]         else {
[15:32:21.978]             ...future.result["stdout"] <- base::list(NULL)
[15:32:21.978]         }
[15:32:21.978]         base::close(...future.stdout)
[15:32:21.978]         ...future.stdout <- NULL
[15:32:21.978]     }
[15:32:21.978]     ...future.result$conditions <- ...future.conditions
[15:32:21.978]     ...future.result$finished <- base::Sys.time()
[15:32:21.978]     ...future.result
[15:32:21.978] }
[15:32:21.985] assign_globals() ...
[15:32:21.985] List of 5
[15:32:21.985]  $ ...future.FUN            :function (x)  
[15:32:21.985]  $ future.call.arguments    : list()
[15:32:21.985]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:21.985]  $ ...future.elements_ii    :List of 6
[15:32:21.985]   ..$ a1: int 1
[15:32:21.985]   ..$ a2: int 2
[15:32:21.985]   ..$ b1: int 2
[15:32:21.985]   ..$ b2: int 3
[15:32:21.985]   ..$ c1: int 3
[15:32:21.985]   ..$ c2: int 4
[15:32:21.985]  $ ...future.seeds_ii       : NULL
[15:32:21.985]  $ ...future.globals.maxSize: NULL
[15:32:21.985]  - attr(*, "where")=List of 5
[15:32:21.985]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:21.985]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:21.985]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:21.985]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:21.985]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:21.985]  - attr(*, "resolved")= logi FALSE
[15:32:21.985]  - attr(*, "total_size")= num 848
[15:32:21.985]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:21.985]  - attr(*, "already-done")= logi TRUE
[15:32:22.000] - copied '...future.FUN' to environment
[15:32:22.000] - copied 'future.call.arguments' to environment
[15:32:22.000] - copied '...future.elements_ii' to environment
[15:32:22.001] - copied '...future.seeds_ii' to environment
[15:32:22.001] - copied '...future.globals.maxSize' to environment
[15:32:22.001] assign_globals() ... done
[15:32:22.002] plan(): Setting new future strategy stack:
[15:32:22.002] List of future strategies:
[15:32:22.002] 1. sequential:
[15:32:22.002]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:22.002]    - tweaked: FALSE
[15:32:22.002]    - call: NULL
[15:32:22.004] plan(): nbrOfWorkers() = 1
[15:32:22.006] plan(): Setting new future strategy stack:
[15:32:22.006] List of future strategies:
[15:32:22.006] 1. sequential:
[15:32:22.006]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:22.006]    - tweaked: FALSE
[15:32:22.006]    - call: plan(strategy)
[15:32:22.008] plan(): nbrOfWorkers() = 1
[15:32:22.008] SequentialFuture started (and completed)
[15:32:22.014] - Launch lazy future ... done
[15:32:22.014] run() for 'SequentialFuture' ... done
[15:32:22.014] Created future:
[15:32:22.015] SequentialFuture:
[15:32:22.015] Label: 'future_sapply-1'
[15:32:22.015] Expression:
[15:32:22.015] {
[15:32:22.015]     do.call(function(...) {
[15:32:22.015]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:22.015]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:22.015]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:22.015]             on.exit(options(oopts), add = TRUE)
[15:32:22.015]         }
[15:32:22.015]         {
[15:32:22.015]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:22.015]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:22.015]                 ...future.FUN(...future.X_jj, ...)
[15:32:22.015]             })
[15:32:22.015]         }
[15:32:22.015]     }, args = future.call.arguments)
[15:32:22.015] }
[15:32:22.015] Lazy evaluation: FALSE
[15:32:22.015] Asynchronous evaluation: FALSE
[15:32:22.015] Local evaluation: TRUE
[15:32:22.015] Environment: R_GlobalEnv
[15:32:22.015] Capture standard output: TRUE
[15:32:22.015] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:22.015] Globals: 5 objects totaling 1.16 KiB (function '...future.FUN' of 848 bytes, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 336 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:22.015] Packages: <none>
[15:32:22.015] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:22.015] Resolved: TRUE
[15:32:22.015] Value: 336 bytes of class 'list'
[15:32:22.015] Early signaling: FALSE
[15:32:22.015] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:22.015] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:22.018] Chunk #1 of 1 ... DONE
[15:32:22.018] Launching 1 futures (chunks) ... DONE
[15:32:22.018] Resolving 1 futures (chunks) ...
[15:32:22.019] resolve() on list ...
[15:32:22.019]  recursive: 0
[15:32:22.019]  length: 1
[15:32:22.020] 
[15:32:22.020] resolved() for 'SequentialFuture' ...
[15:32:22.020] - state: 'finished'
[15:32:22.021] - run: TRUE
[15:32:22.021] - result: 'FutureResult'
[15:32:22.021] resolved() for 'SequentialFuture' ... done
[15:32:22.022] Future #1
[15:32:22.022] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:22.022] - nx: 1
[15:32:22.023] - relay: TRUE
[15:32:22.023] - stdout: TRUE
[15:32:22.023] - signal: TRUE
[15:32:22.024] - resignal: FALSE
[15:32:22.024] - force: TRUE
[15:32:22.024] - relayed: [n=1] FALSE
[15:32:22.025] - queued futures: [n=1] FALSE
[15:32:22.025]  - until=1
[15:32:22.025]  - relaying element #1
[15:32:22.026] - relayed: [n=1] TRUE
[15:32:22.026] - queued futures: [n=1] TRUE
[15:32:22.026] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:22.026]  length: 0 (resolved future 1)
[15:32:22.027] Relaying remaining futures
[15:32:22.027] signalConditionsASAP(NULL, pos=0) ...
[15:32:22.027] - nx: 1
[15:32:22.027] - relay: TRUE
[15:32:22.028] - stdout: TRUE
[15:32:22.028] - signal: TRUE
[15:32:22.028] - resignal: FALSE
[15:32:22.028] - force: TRUE
[15:32:22.029] - relayed: [n=1] TRUE
[15:32:22.029] - queued futures: [n=1] TRUE
 - flush all
[15:32:22.029] - relayed: [n=1] TRUE
[15:32:22.030] - queued futures: [n=1] TRUE
[15:32:22.030] signalConditionsASAP(NULL, pos=0) ... done
[15:32:22.030] resolve() on list ... DONE
[15:32:22.030]  - Number of value chunks collected: 1
[15:32:22.031] Resolving 1 futures (chunks) ... DONE
[15:32:22.031] Reducing values from 1 chunks ...
[15:32:22.031]  - Number of values collected after concatenation: 6
[15:32:22.031]  - Number of values expected: 6
[15:32:22.031] Reducing values from 1 chunks ... DONE
[15:32:22.032] future_lapply() ... DONE
List of 2
 $ y0:List of 6
  ..$ a1: int 1
  ..$ a2: int 2
  ..$ b1: int 2
  ..$ b2: int 3
  ..$ c1: int 3
  ..$ c2: int 4
 $ y1:List of 6
  ..$ a1: int 1
  ..$ a2: int 2
  ..$ b1: int 2
  ..$ b2: int 3
  ..$ c1: int 3
  ..$ c2: int 4
List of 2
 $ y0:List of 6
  ..$ a1: int 1
  ..$ a2: int 2
  ..$ b1: int 2
  ..$ b2: int 3
  ..$ c1: int 3
  ..$ c2: int 4
 $ y2:List of 6
  ..$ a1: int 1
  ..$ a2: int 2
  ..$ b1: int 2
  ..$ b2: int 3
  ..$ c1: int 3
  ..$ c2: int 4
[15:32:22.044] future_lapply() ...
[15:32:22.046] Number of chunks: 1
[15:32:22.046] getGlobalsAndPackagesXApply() ...
[15:32:22.049]  - future.globals: TRUE
[15:32:22.050] getGlobalsAndPackages() ...
[15:32:22.050] Searching for globals...
[15:32:22.052] - globals found: [2] 'FUN', 'UseMethod'
[15:32:22.052] Searching for globals ... DONE
[15:32:22.053] Resolving globals: FALSE
[15:32:22.053] The total size of the 1 globals is 1.22 KiB (1248 bytes)
[15:32:22.054] The total size of the 1 globals exported for future expression ('FUN()') is 1.22 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.22 KiB of class 'function')
[15:32:22.054] - globals: [1] 'FUN'
[15:32:22.055] 
[15:32:22.055] getGlobalsAndPackages() ... DONE
[15:32:22.055]  - globals found/used: [n=1] 'FUN'
[15:32:22.055]  - needed namespaces: [n=0] 
[15:32:22.056] Finding globals ... DONE
[15:32:22.056]  - use_args: TRUE
[15:32:22.056]  - Getting '...' globals ...
[15:32:22.057] resolve() on list ...
[15:32:22.057]  recursive: 0
[15:32:22.057]  length: 1
[15:32:22.057]  elements: '...'
[15:32:22.058]  length: 0 (resolved future 1)
[15:32:22.058] resolve() on list ... DONE
[15:32:22.058]    - '...' content: [n=0] 
[15:32:22.058] List of 1
[15:32:22.058]  $ ...: list()
[15:32:22.058]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:22.058]  - attr(*, "where")=List of 1
[15:32:22.058]   ..$ ...:<environment: 0x00000276e246c728> 
[15:32:22.058]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:22.058]  - attr(*, "resolved")= logi TRUE
[15:32:22.058]  - attr(*, "total_size")= num NA
[15:32:22.063]  - Getting '...' globals ... DONE
[15:32:22.064] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:22.064] List of 2
[15:32:22.064]  $ ...future.FUN:function (x, ...)  
[15:32:22.064]  $ ...          : list()
[15:32:22.064]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:22.064]  - attr(*, "where")=List of 2
[15:32:22.064]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:22.064]   ..$ ...          :<environment: 0x00000276e246c728> 
[15:32:22.064]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:22.064]  - attr(*, "resolved")= logi FALSE
[15:32:22.064]  - attr(*, "total_size")= num 1248
[15:32:22.069] Packages to be attached in all futures: [n=0] 
[15:32:22.069] getGlobalsAndPackagesXApply() ... DONE
[15:32:22.070] Number of futures (= number of chunks): 1
[15:32:22.070] Launching 1 futures (chunks) ...
[15:32:22.070] Chunk #1 of 1 ...
[15:32:22.071]  - Finding globals in 'X' for chunk #1 ...
[15:32:22.071] getGlobalsAndPackages() ...
[15:32:22.071] Searching for globals...
[15:32:22.072] 
[15:32:22.072] Searching for globals ... DONE
[15:32:22.073] - globals: [0] <none>
[15:32:22.073] getGlobalsAndPackages() ... DONE
[15:32:22.073]    + additional globals found: [n=0] 
[15:32:22.074]    + additional namespaces needed: [n=0] 
[15:32:22.074]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:22.074]  - seeds: <none>
[15:32:22.075]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:22.075] getGlobalsAndPackages() ...
[15:32:22.075] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:22.076] Resolving globals: FALSE
[15:32:22.076] Tweak future expression to call with '...' arguments ...
[15:32:22.076] {
[15:32:22.076]     do.call(function(...) {
[15:32:22.076]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:22.076]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:22.076]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:22.076]             on.exit(options(oopts), add = TRUE)
[15:32:22.076]         }
[15:32:22.076]         {
[15:32:22.076]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:22.076]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:22.076]                 ...future.FUN(...future.X_jj, ...)
[15:32:22.076]             })
[15:32:22.076]         }
[15:32:22.076]     }, args = future.call.arguments)
[15:32:22.076] }
[15:32:22.077] Tweak future expression to call with '...' arguments ... DONE
[15:32:22.078] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:22.079] 
[15:32:22.079] getGlobalsAndPackages() ... DONE
[15:32:22.080] run() for 'Future' ...
[15:32:22.080] - state: 'created'
[15:32:22.081] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:22.082] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:22.082] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:22.082]   - Field: 'label'
[15:32:22.083]   - Field: 'local'
[15:32:22.083]   - Field: 'owner'
[15:32:22.083]   - Field: 'envir'
[15:32:22.084]   - Field: 'packages'
[15:32:22.084]   - Field: 'gc'
[15:32:22.084]   - Field: 'conditions'
[15:32:22.085]   - Field: 'expr'
[15:32:22.085]   - Field: 'uuid'
[15:32:22.085]   - Field: 'seed'
[15:32:22.086]   - Field: 'version'
[15:32:22.086]   - Field: 'result'
[15:32:22.086]   - Field: 'asynchronous'
[15:32:22.087]   - Field: 'calls'
[15:32:22.087]   - Field: 'globals'
[15:32:22.087]   - Field: 'stdout'
[15:32:22.088]   - Field: 'earlySignal'
[15:32:22.088]   - Field: 'lazy'
[15:32:22.088]   - Field: 'state'
[15:32:22.089] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:22.089] - Launch lazy future ...
[15:32:22.090] Packages needed by the future expression (n = 0): <none>
[15:32:22.090] Packages needed by future strategies (n = 0): <none>
[15:32:22.100] {
[15:32:22.100]     {
[15:32:22.100]         {
[15:32:22.100]             ...future.startTime <- base::Sys.time()
[15:32:22.100]             {
[15:32:22.100]                 {
[15:32:22.100]                   {
[15:32:22.100]                     base::local({
[15:32:22.100]                       has_future <- base::requireNamespace("future", 
[15:32:22.100]                         quietly = TRUE)
[15:32:22.100]                       if (has_future) {
[15:32:22.100]                         ns <- base::getNamespace("future")
[15:32:22.100]                         version <- ns[[".package"]][["version"]]
[15:32:22.100]                         if (is.null(version)) 
[15:32:22.100]                           version <- utils::packageVersion("future")
[15:32:22.100]                       }
[15:32:22.100]                       else {
[15:32:22.100]                         version <- NULL
[15:32:22.100]                       }
[15:32:22.100]                       if (!has_future || version < "1.8.0") {
[15:32:22.100]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:22.100]                           "", base::R.version$version.string), 
[15:32:22.100]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:22.100]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:22.100]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:22.100]                             "release", "version")], collapse = " "), 
[15:32:22.100]                           hostname = base::Sys.info()[["nodename"]])
[15:32:22.100]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:22.100]                           info)
[15:32:22.100]                         info <- base::paste(info, collapse = "; ")
[15:32:22.100]                         if (!has_future) {
[15:32:22.100]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:22.100]                             info)
[15:32:22.100]                         }
[15:32:22.100]                         else {
[15:32:22.100]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:22.100]                             info, version)
[15:32:22.100]                         }
[15:32:22.100]                         base::stop(msg)
[15:32:22.100]                       }
[15:32:22.100]                     })
[15:32:22.100]                   }
[15:32:22.100]                   ...future.strategy.old <- future::plan("list")
[15:32:22.100]                   options(future.plan = NULL)
[15:32:22.100]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:22.100]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:22.100]                 }
[15:32:22.100]                 ...future.workdir <- getwd()
[15:32:22.100]             }
[15:32:22.100]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:22.100]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:22.100]         }
[15:32:22.100]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:22.100]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:22.100]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:22.100]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:22.100]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:22.100]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:22.100]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:22.100]             base::names(...future.oldOptions))
[15:32:22.100]     }
[15:32:22.100]     if (FALSE) {
[15:32:22.100]     }
[15:32:22.100]     else {
[15:32:22.100]         if (TRUE) {
[15:32:22.100]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:22.100]                 open = "w")
[15:32:22.100]         }
[15:32:22.100]         else {
[15:32:22.100]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:22.100]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:22.100]         }
[15:32:22.100]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:22.100]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:22.100]             base::sink(type = "output", split = FALSE)
[15:32:22.100]             base::close(...future.stdout)
[15:32:22.100]         }, add = TRUE)
[15:32:22.100]     }
[15:32:22.100]     ...future.frame <- base::sys.nframe()
[15:32:22.100]     ...future.conditions <- base::list()
[15:32:22.100]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:22.100]     if (FALSE) {
[15:32:22.100]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:22.100]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:22.100]     }
[15:32:22.100]     ...future.result <- base::tryCatch({
[15:32:22.100]         base::withCallingHandlers({
[15:32:22.100]             ...future.value <- base::withVisible(base::local({
[15:32:22.100]                 do.call(function(...) {
[15:32:22.100]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:22.100]                   if (!identical(...future.globals.maxSize.org, 
[15:32:22.100]                     ...future.globals.maxSize)) {
[15:32:22.100]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:22.100]                     on.exit(options(oopts), add = TRUE)
[15:32:22.100]                   }
[15:32:22.100]                   {
[15:32:22.100]                     lapply(seq_along(...future.elements_ii), 
[15:32:22.100]                       FUN = function(jj) {
[15:32:22.100]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:22.100]                         ...future.FUN(...future.X_jj, ...)
[15:32:22.100]                       })
[15:32:22.100]                   }
[15:32:22.100]                 }, args = future.call.arguments)
[15:32:22.100]             }))
[15:32:22.100]             future::FutureResult(value = ...future.value$value, 
[15:32:22.100]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:22.100]                   ...future.rng), globalenv = if (FALSE) 
[15:32:22.100]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:22.100]                     ...future.globalenv.names))
[15:32:22.100]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:22.100]         }, condition = base::local({
[15:32:22.100]             c <- base::c
[15:32:22.100]             inherits <- base::inherits
[15:32:22.100]             invokeRestart <- base::invokeRestart
[15:32:22.100]             length <- base::length
[15:32:22.100]             list <- base::list
[15:32:22.100]             seq.int <- base::seq.int
[15:32:22.100]             signalCondition <- base::signalCondition
[15:32:22.100]             sys.calls <- base::sys.calls
[15:32:22.100]             `[[` <- base::`[[`
[15:32:22.100]             `+` <- base::`+`
[15:32:22.100]             `<<-` <- base::`<<-`
[15:32:22.100]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:22.100]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:22.100]                   3L)]
[15:32:22.100]             }
[15:32:22.100]             function(cond) {
[15:32:22.100]                 is_error <- inherits(cond, "error")
[15:32:22.100]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:22.100]                   NULL)
[15:32:22.100]                 if (is_error) {
[15:32:22.100]                   sessionInformation <- function() {
[15:32:22.100]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:22.100]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:22.100]                       search = base::search(), system = base::Sys.info())
[15:32:22.100]                   }
[15:32:22.100]                   ...future.conditions[[length(...future.conditions) + 
[15:32:22.100]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:22.100]                     cond$call), session = sessionInformation(), 
[15:32:22.100]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:22.100]                   signalCondition(cond)
[15:32:22.100]                 }
[15:32:22.100]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:22.100]                 "immediateCondition"))) {
[15:32:22.100]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:22.100]                   ...future.conditions[[length(...future.conditions) + 
[15:32:22.100]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:22.100]                   if (TRUE && !signal) {
[15:32:22.100]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:22.100]                     {
[15:32:22.100]                       inherits <- base::inherits
[15:32:22.100]                       invokeRestart <- base::invokeRestart
[15:32:22.100]                       is.null <- base::is.null
[15:32:22.100]                       muffled <- FALSE
[15:32:22.100]                       if (inherits(cond, "message")) {
[15:32:22.100]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:22.100]                         if (muffled) 
[15:32:22.100]                           invokeRestart("muffleMessage")
[15:32:22.100]                       }
[15:32:22.100]                       else if (inherits(cond, "warning")) {
[15:32:22.100]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:22.100]                         if (muffled) 
[15:32:22.100]                           invokeRestart("muffleWarning")
[15:32:22.100]                       }
[15:32:22.100]                       else if (inherits(cond, "condition")) {
[15:32:22.100]                         if (!is.null(pattern)) {
[15:32:22.100]                           computeRestarts <- base::computeRestarts
[15:32:22.100]                           grepl <- base::grepl
[15:32:22.100]                           restarts <- computeRestarts(cond)
[15:32:22.100]                           for (restart in restarts) {
[15:32:22.100]                             name <- restart$name
[15:32:22.100]                             if (is.null(name)) 
[15:32:22.100]                               next
[15:32:22.100]                             if (!grepl(pattern, name)) 
[15:32:22.100]                               next
[15:32:22.100]                             invokeRestart(restart)
[15:32:22.100]                             muffled <- TRUE
[15:32:22.100]                             break
[15:32:22.100]                           }
[15:32:22.100]                         }
[15:32:22.100]                       }
[15:32:22.100]                       invisible(muffled)
[15:32:22.100]                     }
[15:32:22.100]                     muffleCondition(cond, pattern = "^muffle")
[15:32:22.100]                   }
[15:32:22.100]                 }
[15:32:22.100]                 else {
[15:32:22.100]                   if (TRUE) {
[15:32:22.100]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:22.100]                     {
[15:32:22.100]                       inherits <- base::inherits
[15:32:22.100]                       invokeRestart <- base::invokeRestart
[15:32:22.100]                       is.null <- base::is.null
[15:32:22.100]                       muffled <- FALSE
[15:32:22.100]                       if (inherits(cond, "message")) {
[15:32:22.100]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:22.100]                         if (muffled) 
[15:32:22.100]                           invokeRestart("muffleMessage")
[15:32:22.100]                       }
[15:32:22.100]                       else if (inherits(cond, "warning")) {
[15:32:22.100]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:22.100]                         if (muffled) 
[15:32:22.100]                           invokeRestart("muffleWarning")
[15:32:22.100]                       }
[15:32:22.100]                       else if (inherits(cond, "condition")) {
[15:32:22.100]                         if (!is.null(pattern)) {
[15:32:22.100]                           computeRestarts <- base::computeRestarts
[15:32:22.100]                           grepl <- base::grepl
[15:32:22.100]                           restarts <- computeRestarts(cond)
[15:32:22.100]                           for (restart in restarts) {
[15:32:22.100]                             name <- restart$name
[15:32:22.100]                             if (is.null(name)) 
[15:32:22.100]                               next
[15:32:22.100]                             if (!grepl(pattern, name)) 
[15:32:22.100]                               next
[15:32:22.100]                             invokeRestart(restart)
[15:32:22.100]                             muffled <- TRUE
[15:32:22.100]                             break
[15:32:22.100]                           }
[15:32:22.100]                         }
[15:32:22.100]                       }
[15:32:22.100]                       invisible(muffled)
[15:32:22.100]                     }
[15:32:22.100]                     muffleCondition(cond, pattern = "^muffle")
[15:32:22.100]                   }
[15:32:22.100]                 }
[15:32:22.100]             }
[15:32:22.100]         }))
[15:32:22.100]     }, error = function(ex) {
[15:32:22.100]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:22.100]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:22.100]                 ...future.rng), started = ...future.startTime, 
[15:32:22.100]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:22.100]             version = "1.8"), class = "FutureResult")
[15:32:22.100]     }, finally = {
[15:32:22.100]         if (!identical(...future.workdir, getwd())) 
[15:32:22.100]             setwd(...future.workdir)
[15:32:22.100]         {
[15:32:22.100]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:22.100]                 ...future.oldOptions$nwarnings <- NULL
[15:32:22.100]             }
[15:32:22.100]             base::options(...future.oldOptions)
[15:32:22.100]             if (.Platform$OS.type == "windows") {
[15:32:22.100]                 old_names <- names(...future.oldEnvVars)
[15:32:22.100]                 envs <- base::Sys.getenv()
[15:32:22.100]                 names <- names(envs)
[15:32:22.100]                 common <- intersect(names, old_names)
[15:32:22.100]                 added <- setdiff(names, old_names)
[15:32:22.100]                 removed <- setdiff(old_names, names)
[15:32:22.100]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:22.100]                   envs[common]]
[15:32:22.100]                 NAMES <- toupper(changed)
[15:32:22.100]                 args <- list()
[15:32:22.100]                 for (kk in seq_along(NAMES)) {
[15:32:22.100]                   name <- changed[[kk]]
[15:32:22.100]                   NAME <- NAMES[[kk]]
[15:32:22.100]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:22.100]                     next
[15:32:22.100]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:22.100]                 }
[15:32:22.100]                 NAMES <- toupper(added)
[15:32:22.100]                 for (kk in seq_along(NAMES)) {
[15:32:22.100]                   name <- added[[kk]]
[15:32:22.100]                   NAME <- NAMES[[kk]]
[15:32:22.100]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:22.100]                     next
[15:32:22.100]                   args[[name]] <- ""
[15:32:22.100]                 }
[15:32:22.100]                 NAMES <- toupper(removed)
[15:32:22.100]                 for (kk in seq_along(NAMES)) {
[15:32:22.100]                   name <- removed[[kk]]
[15:32:22.100]                   NAME <- NAMES[[kk]]
[15:32:22.100]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:22.100]                     next
[15:32:22.100]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:22.100]                 }
[15:32:22.100]                 if (length(args) > 0) 
[15:32:22.100]                   base::do.call(base::Sys.setenv, args = args)
[15:32:22.100]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:22.100]             }
[15:32:22.100]             else {
[15:32:22.100]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:22.100]             }
[15:32:22.100]             {
[15:32:22.100]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:22.100]                   0L) {
[15:32:22.100]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:22.100]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:22.100]                   base::options(opts)
[15:32:22.100]                 }
[15:32:22.100]                 {
[15:32:22.100]                   {
[15:32:22.100]                     NULL
[15:32:22.100]                     RNGkind("Mersenne-Twister")
[15:32:22.100]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:22.100]                       inherits = FALSE)
[15:32:22.100]                   }
[15:32:22.100]                   options(future.plan = NULL)
[15:32:22.100]                   if (is.na(NA_character_)) 
[15:32:22.100]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:22.100]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:22.100]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:22.100]                     .init = FALSE)
[15:32:22.100]                 }
[15:32:22.100]             }
[15:32:22.100]         }
[15:32:22.100]     })
[15:32:22.100]     if (TRUE) {
[15:32:22.100]         base::sink(type = "output", split = FALSE)
[15:32:22.100]         if (TRUE) {
[15:32:22.100]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:22.100]         }
[15:32:22.100]         else {
[15:32:22.100]             ...future.result["stdout"] <- base::list(NULL)
[15:32:22.100]         }
[15:32:22.100]         base::close(...future.stdout)
[15:32:22.100]         ...future.stdout <- NULL
[15:32:22.100]     }
[15:32:22.100]     ...future.result$conditions <- ...future.conditions
[15:32:22.100]     ...future.result$finished <- base::Sys.time()
[15:32:22.100]     ...future.result
[15:32:22.100] }
[15:32:22.108] assign_globals() ...
[15:32:22.108] List of 5
[15:32:22.108]  $ ...future.FUN            :function (x, ...)  
[15:32:22.108]  $ future.call.arguments    : list()
[15:32:22.108]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:22.108]  $ ...future.elements_ii    :List of 6
[15:32:22.108]   ..$ a1: int 1
[15:32:22.108]   ..$ a2: int 2
[15:32:22.108]   ..$ b1: int 2
[15:32:22.108]   ..$ b2: int 3
[15:32:22.108]   ..$ c1: int 3
[15:32:22.108]   ..$ c2: int 4
[15:32:22.108]  $ ...future.seeds_ii       : NULL
[15:32:22.108]  $ ...future.globals.maxSize: NULL
[15:32:22.108]  - attr(*, "where")=List of 5
[15:32:22.108]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:22.108]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:22.108]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:22.108]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:22.108]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:22.108]  - attr(*, "resolved")= logi FALSE
[15:32:22.108]  - attr(*, "total_size")= num 1248
[15:32:22.108]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:22.108]  - attr(*, "already-done")= logi TRUE
[15:32:22.124] - copied '...future.FUN' to environment
[15:32:22.124] - copied 'future.call.arguments' to environment
[15:32:22.125] - copied '...future.elements_ii' to environment
[15:32:22.125] - copied '...future.seeds_ii' to environment
[15:32:22.126] - copied '...future.globals.maxSize' to environment
[15:32:22.126] assign_globals() ... done
[15:32:22.127] plan(): Setting new future strategy stack:
[15:32:22.127] List of future strategies:
[15:32:22.127] 1. sequential:
[15:32:22.127]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:22.127]    - tweaked: FALSE
[15:32:22.127]    - call: NULL
[15:32:22.128] plan(): nbrOfWorkers() = 1
[15:32:22.131] plan(): Setting new future strategy stack:
[15:32:22.131] List of future strategies:
[15:32:22.131] 1. sequential:
[15:32:22.131]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:22.131]    - tweaked: FALSE
[15:32:22.131]    - call: plan(strategy)
[15:32:22.132] plan(): nbrOfWorkers() = 1
[15:32:22.133] SequentialFuture started (and completed)
[15:32:22.133] - Launch lazy future ... done
[15:32:22.133] run() for 'SequentialFuture' ... done
[15:32:22.134] Created future:
[15:32:22.134] SequentialFuture:
[15:32:22.134] Label: 'future_sapply-1'
[15:32:22.134] Expression:
[15:32:22.134] {
[15:32:22.134]     do.call(function(...) {
[15:32:22.134]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:22.134]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:22.134]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:22.134]             on.exit(options(oopts), add = TRUE)
[15:32:22.134]         }
[15:32:22.134]         {
[15:32:22.134]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:22.134]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:22.134]                 ...future.FUN(...future.X_jj, ...)
[15:32:22.134]             })
[15:32:22.134]         }
[15:32:22.134]     }, args = future.call.arguments)
[15:32:22.134] }
[15:32:22.134] Lazy evaluation: FALSE
[15:32:22.134] Asynchronous evaluation: FALSE
[15:32:22.134] Local evaluation: TRUE
[15:32:22.134] Environment: R_GlobalEnv
[15:32:22.134] Capture standard output: TRUE
[15:32:22.134] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:22.134] Globals: 5 objects totaling 1.55 KiB (function '...future.FUN' of 1.22 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 336 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:22.134] Packages: <none>
[15:32:22.134] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:22.134] Resolved: TRUE
[15:32:22.134] Value: 1.31 KiB of class 'list'
[15:32:22.134] Early signaling: FALSE
[15:32:22.134] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:22.134] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:22.136] Chunk #1 of 1 ... DONE
[15:32:22.137] Launching 1 futures (chunks) ... DONE
[15:32:22.137] Resolving 1 futures (chunks) ...
[15:32:22.137] resolve() on list ...
[15:32:22.138]  recursive: 0
[15:32:22.138]  length: 1
[15:32:22.138] 
[15:32:22.139] resolved() for 'SequentialFuture' ...
[15:32:22.139] - state: 'finished'
[15:32:22.139] - run: TRUE
[15:32:22.140] - result: 'FutureResult'
[15:32:22.140] resolved() for 'SequentialFuture' ... done
[15:32:22.140] Future #1
[15:32:22.141] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:22.141] - nx: 1
[15:32:22.141] - relay: TRUE
[15:32:22.142] - stdout: TRUE
[15:32:22.142] - signal: TRUE
[15:32:22.142] - resignal: FALSE
[15:32:22.142] - force: TRUE
[15:32:22.143] - relayed: [n=1] FALSE
[15:32:22.143] - queued futures: [n=1] FALSE
[15:32:22.143]  - until=1
[15:32:22.144]  - relaying element #1
[15:32:22.144] - relayed: [n=1] TRUE
[15:32:22.144] - queued futures: [n=1] TRUE
[15:32:22.145] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:22.145]  length: 0 (resolved future 1)
[15:32:22.145] Relaying remaining futures
[15:32:22.146] signalConditionsASAP(NULL, pos=0) ...
[15:32:22.146] - nx: 1
[15:32:22.146] - relay: TRUE
[15:32:22.146] - stdout: TRUE
[15:32:22.147] - signal: TRUE
[15:32:22.147] - resignal: FALSE
[15:32:22.147] - force: TRUE
[15:32:22.148] - relayed: [n=1] TRUE
[15:32:22.148] - queued futures: [n=1] TRUE
 - flush all
[15:32:22.148] - relayed: [n=1] TRUE
[15:32:22.149] - queued futures: [n=1] TRUE
[15:32:22.149] signalConditionsASAP(NULL, pos=0) ... done
[15:32:22.149] resolve() on list ... DONE
[15:32:22.150]  - Number of value chunks collected: 1
[15:32:22.150] Resolving 1 futures (chunks) ... DONE
[15:32:22.150] Reducing values from 1 chunks ...
[15:32:22.151]  - Number of values collected after concatenation: 6
[15:32:22.151]  - Number of values expected: 6
[15:32:22.151] Reducing values from 1 chunks ... DONE
[15:32:22.151] future_lapply() ... DONE
List of 2
 $ y0:List of 6
  ..$ a1: int [1, 1] 1
  ..$ a2: int [1, 1] 2
  ..$ b1: int [1, 1] 2
  ..$ b2: int [1, 1] 3
  ..$ c1: int [1, 1] 3
  ..$ c2: int [1, 1] 4
 $ y1:List of 6
  ..$ a1: int [1, 1] 1
  ..$ a2: int [1, 1] 2
  ..$ b1: int [1, 1] 2
  ..$ b2: int [1, 1] 3
  ..$ c1: int [1, 1] 3
  ..$ c2: int [1, 1] 4
List of 2
 $ y0:List of 6
  ..$ a1: int [1, 1] 1
  ..$ a2: int [1, 1] 2
  ..$ b1: int [1, 1] 2
  ..$ b2: int [1, 1] 3
  ..$ c1: int [1, 1] 3
  ..$ c2: int [1, 1] 4
 $ y2:List of 6
  ..$ a1: int [1, 1] 1
  ..$ a2: int [1, 1] 2
  ..$ b1: int [1, 1] 2
  ..$ b2: int [1, 1] 3
  ..$ c1: int [1, 1] 3
  ..$ c2: int [1, 1] 4
[15:32:22.175] future_lapply() ...
[15:32:22.177] Number of chunks: 1
[15:32:22.177] getGlobalsAndPackagesXApply() ...
[15:32:22.177]  - future.globals: TRUE
[15:32:22.178] getGlobalsAndPackages() ...
[15:32:22.178] Searching for globals...
[15:32:22.181] - globals found: [5] 'FUN', '*', ':', 'outer', 'rep'
[15:32:22.181] Searching for globals ... DONE
[15:32:22.181] Resolving globals: FALSE
[15:32:22.182] The total size of the 1 globals is 4.62 KiB (4728 bytes)
[15:32:22.183] The total size of the 1 globals exported for future expression ('FUN()') is 4.62 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.62 KiB of class 'function')
[15:32:22.183] - globals: [1] 'FUN'
[15:32:22.183] 
[15:32:22.184] getGlobalsAndPackages() ... DONE
[15:32:22.184]  - globals found/used: [n=1] 'FUN'
[15:32:22.184]  - needed namespaces: [n=0] 
[15:32:22.184] Finding globals ... DONE
[15:32:22.185]  - use_args: TRUE
[15:32:22.185]  - Getting '...' globals ...
[15:32:22.185] resolve() on list ...
[15:32:22.186]  recursive: 0
[15:32:22.186]  length: 1
[15:32:22.186]  elements: '...'
[15:32:22.186]  length: 0 (resolved future 1)
[15:32:22.187] resolve() on list ... DONE
[15:32:22.187]    - '...' content: [n=0] 
[15:32:22.187] List of 1
[15:32:22.187]  $ ...: list()
[15:32:22.187]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:22.187]  - attr(*, "where")=List of 1
[15:32:22.187]   ..$ ...:<environment: 0x00000276e1276c68> 
[15:32:22.187]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:22.187]  - attr(*, "resolved")= logi TRUE
[15:32:22.187]  - attr(*, "total_size")= num NA
[15:32:22.192]  - Getting '...' globals ... DONE
[15:32:22.192] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:22.192] List of 2
[15:32:22.192]  $ ...future.FUN:function (x, y = 2 * 1:5)  
[15:32:22.192]  $ ...          : list()
[15:32:22.192]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:22.192]  - attr(*, "where")=List of 2
[15:32:22.192]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:22.192]   ..$ ...          :<environment: 0x00000276e1276c68> 
[15:32:22.192]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:22.192]  - attr(*, "resolved")= logi FALSE
[15:32:22.192]  - attr(*, "total_size")= num 4728
[15:32:22.202] Packages to be attached in all futures: [n=0] 
[15:32:22.203] getGlobalsAndPackagesXApply() ... DONE
[15:32:22.203] Number of futures (= number of chunks): 1
[15:32:22.204] Launching 1 futures (chunks) ...
[15:32:22.204] Chunk #1 of 1 ...
[15:32:22.204]  - Finding globals in 'X' for chunk #1 ...
[15:32:22.205] getGlobalsAndPackages() ...
[15:32:22.205] Searching for globals...
[15:32:22.206] 
[15:32:22.206] Searching for globals ... DONE
[15:32:22.206] - globals: [0] <none>
[15:32:22.206] getGlobalsAndPackages() ... DONE
[15:32:22.207]    + additional globals found: [n=0] 
[15:32:22.207]    + additional namespaces needed: [n=0] 
[15:32:22.207]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:22.207]  - seeds: <none>
[15:32:22.208]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:22.208] getGlobalsAndPackages() ...
[15:32:22.208] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:22.209] Resolving globals: FALSE
[15:32:22.209] Tweak future expression to call with '...' arguments ...
[15:32:22.209] {
[15:32:22.209]     do.call(function(...) {
[15:32:22.209]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:22.209]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:22.209]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:22.209]             on.exit(options(oopts), add = TRUE)
[15:32:22.209]         }
[15:32:22.209]         {
[15:32:22.209]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:22.209]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:22.209]                 ...future.FUN(...future.X_jj, ...)
[15:32:22.209]             })
[15:32:22.209]         }
[15:32:22.209]     }, args = future.call.arguments)
[15:32:22.209] }
[15:32:22.210] Tweak future expression to call with '...' arguments ... DONE
[15:32:22.211] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:22.211] 
[15:32:22.211] getGlobalsAndPackages() ... DONE
[15:32:22.212] run() for 'Future' ...
[15:32:22.212] - state: 'created'
[15:32:22.212] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:22.213] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:22.213] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:22.213]   - Field: 'label'
[15:32:22.214]   - Field: 'local'
[15:32:22.214]   - Field: 'owner'
[15:32:22.214]   - Field: 'envir'
[15:32:22.215]   - Field: 'packages'
[15:32:22.215]   - Field: 'gc'
[15:32:22.215]   - Field: 'conditions'
[15:32:22.215]   - Field: 'expr'
[15:32:22.216]   - Field: 'uuid'
[15:32:22.216]   - Field: 'seed'
[15:32:22.216]   - Field: 'version'
[15:32:22.216]   - Field: 'result'
[15:32:22.217]   - Field: 'asynchronous'
[15:32:22.217]   - Field: 'calls'
[15:32:22.217]   - Field: 'globals'
[15:32:22.217]   - Field: 'stdout'
[15:32:22.218]   - Field: 'earlySignal'
[15:32:22.218]   - Field: 'lazy'
[15:32:22.218]   - Field: 'state'
[15:32:22.218] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:22.219] - Launch lazy future ...
[15:32:22.219] Packages needed by the future expression (n = 0): <none>
[15:32:22.219] Packages needed by future strategies (n = 0): <none>
[15:32:22.220] {
[15:32:22.220]     {
[15:32:22.220]         {
[15:32:22.220]             ...future.startTime <- base::Sys.time()
[15:32:22.220]             {
[15:32:22.220]                 {
[15:32:22.220]                   {
[15:32:22.220]                     base::local({
[15:32:22.220]                       has_future <- base::requireNamespace("future", 
[15:32:22.220]                         quietly = TRUE)
[15:32:22.220]                       if (has_future) {
[15:32:22.220]                         ns <- base::getNamespace("future")
[15:32:22.220]                         version <- ns[[".package"]][["version"]]
[15:32:22.220]                         if (is.null(version)) 
[15:32:22.220]                           version <- utils::packageVersion("future")
[15:32:22.220]                       }
[15:32:22.220]                       else {
[15:32:22.220]                         version <- NULL
[15:32:22.220]                       }
[15:32:22.220]                       if (!has_future || version < "1.8.0") {
[15:32:22.220]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:22.220]                           "", base::R.version$version.string), 
[15:32:22.220]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:22.220]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:22.220]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:22.220]                             "release", "version")], collapse = " "), 
[15:32:22.220]                           hostname = base::Sys.info()[["nodename"]])
[15:32:22.220]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:22.220]                           info)
[15:32:22.220]                         info <- base::paste(info, collapse = "; ")
[15:32:22.220]                         if (!has_future) {
[15:32:22.220]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:22.220]                             info)
[15:32:22.220]                         }
[15:32:22.220]                         else {
[15:32:22.220]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:22.220]                             info, version)
[15:32:22.220]                         }
[15:32:22.220]                         base::stop(msg)
[15:32:22.220]                       }
[15:32:22.220]                     })
[15:32:22.220]                   }
[15:32:22.220]                   ...future.strategy.old <- future::plan("list")
[15:32:22.220]                   options(future.plan = NULL)
[15:32:22.220]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:22.220]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:22.220]                 }
[15:32:22.220]                 ...future.workdir <- getwd()
[15:32:22.220]             }
[15:32:22.220]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:22.220]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:22.220]         }
[15:32:22.220]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:22.220]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:22.220]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:22.220]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:22.220]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:22.220]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:22.220]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:22.220]             base::names(...future.oldOptions))
[15:32:22.220]     }
[15:32:22.220]     if (FALSE) {
[15:32:22.220]     }
[15:32:22.220]     else {
[15:32:22.220]         if (TRUE) {
[15:32:22.220]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:22.220]                 open = "w")
[15:32:22.220]         }
[15:32:22.220]         else {
[15:32:22.220]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:22.220]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:22.220]         }
[15:32:22.220]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:22.220]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:22.220]             base::sink(type = "output", split = FALSE)
[15:32:22.220]             base::close(...future.stdout)
[15:32:22.220]         }, add = TRUE)
[15:32:22.220]     }
[15:32:22.220]     ...future.frame <- base::sys.nframe()
[15:32:22.220]     ...future.conditions <- base::list()
[15:32:22.220]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:22.220]     if (FALSE) {
[15:32:22.220]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:22.220]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:22.220]     }
[15:32:22.220]     ...future.result <- base::tryCatch({
[15:32:22.220]         base::withCallingHandlers({
[15:32:22.220]             ...future.value <- base::withVisible(base::local({
[15:32:22.220]                 do.call(function(...) {
[15:32:22.220]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:22.220]                   if (!identical(...future.globals.maxSize.org, 
[15:32:22.220]                     ...future.globals.maxSize)) {
[15:32:22.220]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:22.220]                     on.exit(options(oopts), add = TRUE)
[15:32:22.220]                   }
[15:32:22.220]                   {
[15:32:22.220]                     lapply(seq_along(...future.elements_ii), 
[15:32:22.220]                       FUN = function(jj) {
[15:32:22.220]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:22.220]                         ...future.FUN(...future.X_jj, ...)
[15:32:22.220]                       })
[15:32:22.220]                   }
[15:32:22.220]                 }, args = future.call.arguments)
[15:32:22.220]             }))
[15:32:22.220]             future::FutureResult(value = ...future.value$value, 
[15:32:22.220]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:22.220]                   ...future.rng), globalenv = if (FALSE) 
[15:32:22.220]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:22.220]                     ...future.globalenv.names))
[15:32:22.220]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:22.220]         }, condition = base::local({
[15:32:22.220]             c <- base::c
[15:32:22.220]             inherits <- base::inherits
[15:32:22.220]             invokeRestart <- base::invokeRestart
[15:32:22.220]             length <- base::length
[15:32:22.220]             list <- base::list
[15:32:22.220]             seq.int <- base::seq.int
[15:32:22.220]             signalCondition <- base::signalCondition
[15:32:22.220]             sys.calls <- base::sys.calls
[15:32:22.220]             `[[` <- base::`[[`
[15:32:22.220]             `+` <- base::`+`
[15:32:22.220]             `<<-` <- base::`<<-`
[15:32:22.220]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:22.220]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:22.220]                   3L)]
[15:32:22.220]             }
[15:32:22.220]             function(cond) {
[15:32:22.220]                 is_error <- inherits(cond, "error")
[15:32:22.220]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:22.220]                   NULL)
[15:32:22.220]                 if (is_error) {
[15:32:22.220]                   sessionInformation <- function() {
[15:32:22.220]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:22.220]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:22.220]                       search = base::search(), system = base::Sys.info())
[15:32:22.220]                   }
[15:32:22.220]                   ...future.conditions[[length(...future.conditions) + 
[15:32:22.220]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:22.220]                     cond$call), session = sessionInformation(), 
[15:32:22.220]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:22.220]                   signalCondition(cond)
[15:32:22.220]                 }
[15:32:22.220]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:22.220]                 "immediateCondition"))) {
[15:32:22.220]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:22.220]                   ...future.conditions[[length(...future.conditions) + 
[15:32:22.220]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:22.220]                   if (TRUE && !signal) {
[15:32:22.220]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:22.220]                     {
[15:32:22.220]                       inherits <- base::inherits
[15:32:22.220]                       invokeRestart <- base::invokeRestart
[15:32:22.220]                       is.null <- base::is.null
[15:32:22.220]                       muffled <- FALSE
[15:32:22.220]                       if (inherits(cond, "message")) {
[15:32:22.220]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:22.220]                         if (muffled) 
[15:32:22.220]                           invokeRestart("muffleMessage")
[15:32:22.220]                       }
[15:32:22.220]                       else if (inherits(cond, "warning")) {
[15:32:22.220]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:22.220]                         if (muffled) 
[15:32:22.220]                           invokeRestart("muffleWarning")
[15:32:22.220]                       }
[15:32:22.220]                       else if (inherits(cond, "condition")) {
[15:32:22.220]                         if (!is.null(pattern)) {
[15:32:22.220]                           computeRestarts <- base::computeRestarts
[15:32:22.220]                           grepl <- base::grepl
[15:32:22.220]                           restarts <- computeRestarts(cond)
[15:32:22.220]                           for (restart in restarts) {
[15:32:22.220]                             name <- restart$name
[15:32:22.220]                             if (is.null(name)) 
[15:32:22.220]                               next
[15:32:22.220]                             if (!grepl(pattern, name)) 
[15:32:22.220]                               next
[15:32:22.220]                             invokeRestart(restart)
[15:32:22.220]                             muffled <- TRUE
[15:32:22.220]                             break
[15:32:22.220]                           }
[15:32:22.220]                         }
[15:32:22.220]                       }
[15:32:22.220]                       invisible(muffled)
[15:32:22.220]                     }
[15:32:22.220]                     muffleCondition(cond, pattern = "^muffle")
[15:32:22.220]                   }
[15:32:22.220]                 }
[15:32:22.220]                 else {
[15:32:22.220]                   if (TRUE) {
[15:32:22.220]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:22.220]                     {
[15:32:22.220]                       inherits <- base::inherits
[15:32:22.220]                       invokeRestart <- base::invokeRestart
[15:32:22.220]                       is.null <- base::is.null
[15:32:22.220]                       muffled <- FALSE
[15:32:22.220]                       if (inherits(cond, "message")) {
[15:32:22.220]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:22.220]                         if (muffled) 
[15:32:22.220]                           invokeRestart("muffleMessage")
[15:32:22.220]                       }
[15:32:22.220]                       else if (inherits(cond, "warning")) {
[15:32:22.220]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:22.220]                         if (muffled) 
[15:32:22.220]                           invokeRestart("muffleWarning")
[15:32:22.220]                       }
[15:32:22.220]                       else if (inherits(cond, "condition")) {
[15:32:22.220]                         if (!is.null(pattern)) {
[15:32:22.220]                           computeRestarts <- base::computeRestarts
[15:32:22.220]                           grepl <- base::grepl
[15:32:22.220]                           restarts <- computeRestarts(cond)
[15:32:22.220]                           for (restart in restarts) {
[15:32:22.220]                             name <- restart$name
[15:32:22.220]                             if (is.null(name)) 
[15:32:22.220]                               next
[15:32:22.220]                             if (!grepl(pattern, name)) 
[15:32:22.220]                               next
[15:32:22.220]                             invokeRestart(restart)
[15:32:22.220]                             muffled <- TRUE
[15:32:22.220]                             break
[15:32:22.220]                           }
[15:32:22.220]                         }
[15:32:22.220]                       }
[15:32:22.220]                       invisible(muffled)
[15:32:22.220]                     }
[15:32:22.220]                     muffleCondition(cond, pattern = "^muffle")
[15:32:22.220]                   }
[15:32:22.220]                 }
[15:32:22.220]             }
[15:32:22.220]         }))
[15:32:22.220]     }, error = function(ex) {
[15:32:22.220]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:22.220]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:22.220]                 ...future.rng), started = ...future.startTime, 
[15:32:22.220]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:22.220]             version = "1.8"), class = "FutureResult")
[15:32:22.220]     }, finally = {
[15:32:22.220]         if (!identical(...future.workdir, getwd())) 
[15:32:22.220]             setwd(...future.workdir)
[15:32:22.220]         {
[15:32:22.220]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:22.220]                 ...future.oldOptions$nwarnings <- NULL
[15:32:22.220]             }
[15:32:22.220]             base::options(...future.oldOptions)
[15:32:22.220]             if (.Platform$OS.type == "windows") {
[15:32:22.220]                 old_names <- names(...future.oldEnvVars)
[15:32:22.220]                 envs <- base::Sys.getenv()
[15:32:22.220]                 names <- names(envs)
[15:32:22.220]                 common <- intersect(names, old_names)
[15:32:22.220]                 added <- setdiff(names, old_names)
[15:32:22.220]                 removed <- setdiff(old_names, names)
[15:32:22.220]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:22.220]                   envs[common]]
[15:32:22.220]                 NAMES <- toupper(changed)
[15:32:22.220]                 args <- list()
[15:32:22.220]                 for (kk in seq_along(NAMES)) {
[15:32:22.220]                   name <- changed[[kk]]
[15:32:22.220]                   NAME <- NAMES[[kk]]
[15:32:22.220]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:22.220]                     next
[15:32:22.220]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:22.220]                 }
[15:32:22.220]                 NAMES <- toupper(added)
[15:32:22.220]                 for (kk in seq_along(NAMES)) {
[15:32:22.220]                   name <- added[[kk]]
[15:32:22.220]                   NAME <- NAMES[[kk]]
[15:32:22.220]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:22.220]                     next
[15:32:22.220]                   args[[name]] <- ""
[15:32:22.220]                 }
[15:32:22.220]                 NAMES <- toupper(removed)
[15:32:22.220]                 for (kk in seq_along(NAMES)) {
[15:32:22.220]                   name <- removed[[kk]]
[15:32:22.220]                   NAME <- NAMES[[kk]]
[15:32:22.220]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:22.220]                     next
[15:32:22.220]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:22.220]                 }
[15:32:22.220]                 if (length(args) > 0) 
[15:32:22.220]                   base::do.call(base::Sys.setenv, args = args)
[15:32:22.220]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:22.220]             }
[15:32:22.220]             else {
[15:32:22.220]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:22.220]             }
[15:32:22.220]             {
[15:32:22.220]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:22.220]                   0L) {
[15:32:22.220]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:22.220]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:22.220]                   base::options(opts)
[15:32:22.220]                 }
[15:32:22.220]                 {
[15:32:22.220]                   {
[15:32:22.220]                     NULL
[15:32:22.220]                     RNGkind("Mersenne-Twister")
[15:32:22.220]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:22.220]                       inherits = FALSE)
[15:32:22.220]                   }
[15:32:22.220]                   options(future.plan = NULL)
[15:32:22.220]                   if (is.na(NA_character_)) 
[15:32:22.220]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:22.220]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:22.220]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:22.220]                     .init = FALSE)
[15:32:22.220]                 }
[15:32:22.220]             }
[15:32:22.220]         }
[15:32:22.220]     })
[15:32:22.220]     if (TRUE) {
[15:32:22.220]         base::sink(type = "output", split = FALSE)
[15:32:22.220]         if (TRUE) {
[15:32:22.220]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:22.220]         }
[15:32:22.220]         else {
[15:32:22.220]             ...future.result["stdout"] <- base::list(NULL)
[15:32:22.220]         }
[15:32:22.220]         base::close(...future.stdout)
[15:32:22.220]         ...future.stdout <- NULL
[15:32:22.220]     }
[15:32:22.220]     ...future.result$conditions <- ...future.conditions
[15:32:22.220]     ...future.result$finished <- base::Sys.time()
[15:32:22.220]     ...future.result
[15:32:22.220] }
[15:32:22.227] assign_globals() ...
[15:32:22.228] List of 5
[15:32:22.228]  $ ...future.FUN            :function (x, y = 2 * 1:5)  
[15:32:22.228]  $ future.call.arguments    : list()
[15:32:22.228]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:22.228]  $ ...future.elements_ii    :List of 6
[15:32:22.228]   ..$ a1: int 1
[15:32:22.228]   ..$ a2: int 2
[15:32:22.228]   ..$ b1: int 2
[15:32:22.228]   ..$ b2: int 3
[15:32:22.228]   ..$ c1: int 3
[15:32:22.228]   ..$ c2: int 4
[15:32:22.228]  $ ...future.seeds_ii       : NULL
[15:32:22.228]  $ ...future.globals.maxSize: NULL
[15:32:22.228]  - attr(*, "where")=List of 5
[15:32:22.228]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:22.228]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:22.228]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:22.228]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:22.228]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:22.228]  - attr(*, "resolved")= logi FALSE
[15:32:22.228]  - attr(*, "total_size")= num 4728
[15:32:22.228]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:22.228]  - attr(*, "already-done")= logi TRUE
[15:32:22.240] - reassign environment for '...future.FUN'
[15:32:22.240] - copied '...future.FUN' to environment
[15:32:22.240] - copied 'future.call.arguments' to environment
[15:32:22.241] - copied '...future.elements_ii' to environment
[15:32:22.241] - copied '...future.seeds_ii' to environment
[15:32:22.241] - copied '...future.globals.maxSize' to environment
[15:32:22.242] assign_globals() ... done
[15:32:22.242] plan(): Setting new future strategy stack:
[15:32:22.243] List of future strategies:
[15:32:22.243] 1. sequential:
[15:32:22.243]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:22.243]    - tweaked: FALSE
[15:32:22.243]    - call: NULL
[15:32:22.247] plan(): nbrOfWorkers() = 1
[15:32:22.249] plan(): Setting new future strategy stack:
[15:32:22.249] List of future strategies:
[15:32:22.249] 1. sequential:
[15:32:22.249]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:22.249]    - tweaked: FALSE
[15:32:22.249]    - call: plan(strategy)
[15:32:22.250] plan(): nbrOfWorkers() = 1
[15:32:22.251] SequentialFuture started (and completed)
[15:32:22.251] - Launch lazy future ... done
[15:32:22.251] run() for 'SequentialFuture' ... done
[15:32:22.252] Created future:
[15:32:22.252] SequentialFuture:
[15:32:22.252] Label: 'future_sapply-1'
[15:32:22.252] Expression:
[15:32:22.252] {
[15:32:22.252]     do.call(function(...) {
[15:32:22.252]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:22.252]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:22.252]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:22.252]             on.exit(options(oopts), add = TRUE)
[15:32:22.252]         }
[15:32:22.252]         {
[15:32:22.252]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:22.252]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:22.252]                 ...future.FUN(...future.X_jj, ...)
[15:32:22.252]             })
[15:32:22.252]         }
[15:32:22.252]     }, args = future.call.arguments)
[15:32:22.252] }
[15:32:22.252] Lazy evaluation: FALSE
[15:32:22.252] Asynchronous evaluation: FALSE
[15:32:22.252] Local evaluation: TRUE
[15:32:22.252] Environment: R_GlobalEnv
[15:32:22.252] Capture standard output: TRUE
[15:32:22.252] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:22.252] Globals: 5 objects totaling 4.95 KiB (function '...future.FUN' of 4.62 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 336 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:22.252] Packages: <none>
[15:32:22.252] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:22.252] Resolved: TRUE
[15:32:22.252] Value: 2.02 KiB of class 'list'
[15:32:22.252] Early signaling: FALSE
[15:32:22.252] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:22.252] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:22.254] Chunk #1 of 1 ... DONE
[15:32:22.254] Launching 1 futures (chunks) ... DONE
[15:32:22.255] Resolving 1 futures (chunks) ...
[15:32:22.255] resolve() on list ...
[15:32:22.255]  recursive: 0
[15:32:22.256]  length: 1
[15:32:22.256] 
[15:32:22.256] resolved() for 'SequentialFuture' ...
[15:32:22.257] - state: 'finished'
[15:32:22.257] - run: TRUE
[15:32:22.258] - result: 'FutureResult'
[15:32:22.258] resolved() for 'SequentialFuture' ... done
[15:32:22.258] Future #1
[15:32:22.259] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:22.259] - nx: 1
[15:32:22.259] - relay: TRUE
[15:32:22.260] - stdout: TRUE
[15:32:22.260] - signal: TRUE
[15:32:22.260] - resignal: FALSE
[15:32:22.260] - force: TRUE
[15:32:22.261] - relayed: [n=1] FALSE
[15:32:22.261] - queued futures: [n=1] FALSE
[15:32:22.261]  - until=1
[15:32:22.262]  - relaying element #1
[15:32:22.262] - relayed: [n=1] TRUE
[15:32:22.262] - queued futures: [n=1] TRUE
[15:32:22.263] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:22.263]  length: 0 (resolved future 1)
[15:32:22.263] Relaying remaining futures
[15:32:22.263] signalConditionsASAP(NULL, pos=0) ...
[15:32:22.264] - nx: 1
[15:32:22.264] - relay: TRUE
[15:32:22.264] - stdout: TRUE
[15:32:22.265] - signal: TRUE
[15:32:22.265] - resignal: FALSE
[15:32:22.265] - force: TRUE
[15:32:22.266] - relayed: [n=1] TRUE
[15:32:22.266] - queued futures: [n=1] TRUE
 - flush all
[15:32:22.267] - relayed: [n=1] TRUE
[15:32:22.267] - queued futures: [n=1] TRUE
[15:32:22.267] signalConditionsASAP(NULL, pos=0) ... done
[15:32:22.267] resolve() on list ... DONE
[15:32:22.268]  - Number of value chunks collected: 1
[15:32:22.268] Resolving 1 futures (chunks) ... DONE
[15:32:22.269] Reducing values from 1 chunks ...
[15:32:22.269]  - Number of values collected after concatenation: 6
[15:32:22.269]  - Number of values expected: 6
[15:32:22.270] Reducing values from 1 chunks ... DONE
[15:32:22.270] future_lapply() ... DONE
List of 2
 $ y0:List of 6
  ..$ a1: num [1:3, 1:5] 2 2 2 4 4 4 6 6 6 8 ...
  ..$ a2: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
  ..$ b1: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
  ..$ b2: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
  ..$ c1: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
  ..$ c2: num [1:3, 1:5] 8 8 8 16 16 16 24 24 24 32 ...
 $ y1:List of 6
  ..$ a1: num [1:3, 1:5] 2 2 2 4 4 4 6 6 6 8 ...
  ..$ a2: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
  ..$ b1: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
  ..$ b2: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
  ..$ c1: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
  ..$ c2: num [1:3, 1:5] 8 8 8 16 16 16 24 24 24 32 ...
List of 2
 $ y0:List of 6
  ..$ a1: num [1:3, 1:5] 2 2 2 4 4 4 6 6 6 8 ...
  ..$ a2: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
  ..$ b1: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
  ..$ b2: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
  ..$ c1: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
  ..$ c2: num [1:3, 1:5] 8 8 8 16 16 16 24 24 24 32 ...
 $ y2:List of 6
  ..$ a1: num [1:3, 1:5] 2 2 2 4 4 4 6 6 6 8 ...
  ..$ a2: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
  ..$ b1: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
  ..$ b2: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
  ..$ c1: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
  ..$ c2: num [1:3, 1:5] 8 8 8 16 16 16 24 24 24 32 ...
[15:32:22.296] future_lapply() ...
[15:32:22.298] Number of chunks: 1
[15:32:22.298] getGlobalsAndPackagesXApply() ...
[15:32:22.298]  - future.globals: TRUE
[15:32:22.299] getGlobalsAndPackages() ...
[15:32:22.299] Searching for globals...
[15:32:22.301] - globals found: [1] 'FUN'
[15:32:22.302] Searching for globals ... DONE
[15:32:22.302] Resolving globals: FALSE
[15:32:22.303] The total size of the 1 globals is 848 bytes (848 bytes)
[15:32:22.304] The total size of the 1 globals exported for future expression ('FUN()') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:32:22.304] - globals: [1] 'FUN'
[15:32:22.304] 
[15:32:22.305] getGlobalsAndPackages() ... DONE
[15:32:22.305]  - globals found/used: [n=1] 'FUN'
[15:32:22.305]  - needed namespaces: [n=0] 
[15:32:22.306] Finding globals ... DONE
[15:32:22.306]  - use_args: TRUE
[15:32:22.306]  - Getting '...' globals ...
[15:32:22.307] resolve() on list ...
[15:32:22.307]  recursive: 0
[15:32:22.308]  length: 1
[15:32:22.308]  elements: '...'
[15:32:22.308]  length: 0 (resolved future 1)
[15:32:22.309] resolve() on list ... DONE
[15:32:22.309]    - '...' content: [n=0] 
[15:32:22.309] List of 1
[15:32:22.309]  $ ...: list()
[15:32:22.309]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:22.309]  - attr(*, "where")=List of 1
[15:32:22.309]   ..$ ...:<environment: 0x00000276e24ba0d8> 
[15:32:22.309]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:22.309]  - attr(*, "resolved")= logi TRUE
[15:32:22.309]  - attr(*, "total_size")= num NA
[15:32:22.315]  - Getting '...' globals ... DONE
[15:32:22.315] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:22.316] List of 2
[15:32:22.316]  $ ...future.FUN:function (x)  
[15:32:22.316]  $ ...          : list()
[15:32:22.316]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:22.316]  - attr(*, "where")=List of 2
[15:32:22.316]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:22.316]   ..$ ...          :<environment: 0x00000276e24ba0d8> 
[15:32:22.316]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:22.316]  - attr(*, "resolved")= logi FALSE
[15:32:22.316]  - attr(*, "total_size")= num 848
[15:32:22.321] Packages to be attached in all futures: [n=0] 
[15:32:22.322] getGlobalsAndPackagesXApply() ... DONE
[15:32:22.322] Number of futures (= number of chunks): 1
[15:32:22.322] Launching 1 futures (chunks) ...
[15:32:22.323] Chunk #1 of 1 ...
[15:32:22.323]  - Finding globals in 'X' for chunk #1 ...
[15:32:22.323] getGlobalsAndPackages() ...
[15:32:22.324] Searching for globals...
[15:32:22.324] 
[15:32:22.325] Searching for globals ... DONE
[15:32:22.325] - globals: [0] <none>
[15:32:22.325] getGlobalsAndPackages() ... DONE
[15:32:22.325]    + additional globals found: [n=0] 
[15:32:22.326]    + additional namespaces needed: [n=0] 
[15:32:22.326]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:22.326]  - seeds: <none>
[15:32:22.327]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:22.327] getGlobalsAndPackages() ...
[15:32:22.327] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:22.328] Resolving globals: FALSE
[15:32:22.328] Tweak future expression to call with '...' arguments ...
[15:32:22.328] {
[15:32:22.328]     do.call(function(...) {
[15:32:22.328]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:22.328]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:22.328]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:22.328]             on.exit(options(oopts), add = TRUE)
[15:32:22.328]         }
[15:32:22.328]         {
[15:32:22.328]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:22.328]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:22.328]                 ...future.FUN(...future.X_jj, ...)
[15:32:22.328]             })
[15:32:22.328]         }
[15:32:22.328]     }, args = future.call.arguments)
[15:32:22.328] }
[15:32:22.329] Tweak future expression to call with '...' arguments ... DONE
[15:32:22.330] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:22.330] 
[15:32:22.330] getGlobalsAndPackages() ... DONE
[15:32:22.331] run() for 'Future' ...
[15:32:22.332] - state: 'created'
[15:32:22.332] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:22.333] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:22.333] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:22.333]   - Field: 'label'
[15:32:22.334]   - Field: 'local'
[15:32:22.334]   - Field: 'owner'
[15:32:22.334]   - Field: 'envir'
[15:32:22.335]   - Field: 'packages'
[15:32:22.335]   - Field: 'gc'
[15:32:22.335]   - Field: 'conditions'
[15:32:22.336]   - Field: 'expr'
[15:32:22.336]   - Field: 'uuid'
[15:32:22.336]   - Field: 'seed'
[15:32:22.337]   - Field: 'version'
[15:32:22.337]   - Field: 'result'
[15:32:22.337]   - Field: 'asynchronous'
[15:32:22.338]   - Field: 'calls'
[15:32:22.338]   - Field: 'globals'
[15:32:22.341]   - Field: 'stdout'
[15:32:22.342]   - Field: 'earlySignal'
[15:32:22.342]   - Field: 'lazy'
[15:32:22.343]   - Field: 'state'
[15:32:22.343] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:22.343] - Launch lazy future ...
[15:32:22.344] Packages needed by the future expression (n = 0): <none>
[15:32:22.344] Packages needed by future strategies (n = 0): <none>
[15:32:22.345] {
[15:32:22.345]     {
[15:32:22.345]         {
[15:32:22.345]             ...future.startTime <- base::Sys.time()
[15:32:22.345]             {
[15:32:22.345]                 {
[15:32:22.345]                   {
[15:32:22.345]                     base::local({
[15:32:22.345]                       has_future <- base::requireNamespace("future", 
[15:32:22.345]                         quietly = TRUE)
[15:32:22.345]                       if (has_future) {
[15:32:22.345]                         ns <- base::getNamespace("future")
[15:32:22.345]                         version <- ns[[".package"]][["version"]]
[15:32:22.345]                         if (is.null(version)) 
[15:32:22.345]                           version <- utils::packageVersion("future")
[15:32:22.345]                       }
[15:32:22.345]                       else {
[15:32:22.345]                         version <- NULL
[15:32:22.345]                       }
[15:32:22.345]                       if (!has_future || version < "1.8.0") {
[15:32:22.345]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:22.345]                           "", base::R.version$version.string), 
[15:32:22.345]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:22.345]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:22.345]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:22.345]                             "release", "version")], collapse = " "), 
[15:32:22.345]                           hostname = base::Sys.info()[["nodename"]])
[15:32:22.345]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:22.345]                           info)
[15:32:22.345]                         info <- base::paste(info, collapse = "; ")
[15:32:22.345]                         if (!has_future) {
[15:32:22.345]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:22.345]                             info)
[15:32:22.345]                         }
[15:32:22.345]                         else {
[15:32:22.345]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:22.345]                             info, version)
[15:32:22.345]                         }
[15:32:22.345]                         base::stop(msg)
[15:32:22.345]                       }
[15:32:22.345]                     })
[15:32:22.345]                   }
[15:32:22.345]                   ...future.strategy.old <- future::plan("list")
[15:32:22.345]                   options(future.plan = NULL)
[15:32:22.345]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:22.345]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:22.345]                 }
[15:32:22.345]                 ...future.workdir <- getwd()
[15:32:22.345]             }
[15:32:22.345]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:22.345]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:22.345]         }
[15:32:22.345]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:22.345]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:22.345]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:22.345]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:22.345]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:22.345]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:22.345]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:22.345]             base::names(...future.oldOptions))
[15:32:22.345]     }
[15:32:22.345]     if (FALSE) {
[15:32:22.345]     }
[15:32:22.345]     else {
[15:32:22.345]         if (TRUE) {
[15:32:22.345]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:22.345]                 open = "w")
[15:32:22.345]         }
[15:32:22.345]         else {
[15:32:22.345]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:22.345]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:22.345]         }
[15:32:22.345]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:22.345]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:22.345]             base::sink(type = "output", split = FALSE)
[15:32:22.345]             base::close(...future.stdout)
[15:32:22.345]         }, add = TRUE)
[15:32:22.345]     }
[15:32:22.345]     ...future.frame <- base::sys.nframe()
[15:32:22.345]     ...future.conditions <- base::list()
[15:32:22.345]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:22.345]     if (FALSE) {
[15:32:22.345]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:22.345]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:22.345]     }
[15:32:22.345]     ...future.result <- base::tryCatch({
[15:32:22.345]         base::withCallingHandlers({
[15:32:22.345]             ...future.value <- base::withVisible(base::local({
[15:32:22.345]                 do.call(function(...) {
[15:32:22.345]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:22.345]                   if (!identical(...future.globals.maxSize.org, 
[15:32:22.345]                     ...future.globals.maxSize)) {
[15:32:22.345]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:22.345]                     on.exit(options(oopts), add = TRUE)
[15:32:22.345]                   }
[15:32:22.345]                   {
[15:32:22.345]                     lapply(seq_along(...future.elements_ii), 
[15:32:22.345]                       FUN = function(jj) {
[15:32:22.345]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:22.345]                         ...future.FUN(...future.X_jj, ...)
[15:32:22.345]                       })
[15:32:22.345]                   }
[15:32:22.345]                 }, args = future.call.arguments)
[15:32:22.345]             }))
[15:32:22.345]             future::FutureResult(value = ...future.value$value, 
[15:32:22.345]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:22.345]                   ...future.rng), globalenv = if (FALSE) 
[15:32:22.345]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:22.345]                     ...future.globalenv.names))
[15:32:22.345]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:22.345]         }, condition = base::local({
[15:32:22.345]             c <- base::c
[15:32:22.345]             inherits <- base::inherits
[15:32:22.345]             invokeRestart <- base::invokeRestart
[15:32:22.345]             length <- base::length
[15:32:22.345]             list <- base::list
[15:32:22.345]             seq.int <- base::seq.int
[15:32:22.345]             signalCondition <- base::signalCondition
[15:32:22.345]             sys.calls <- base::sys.calls
[15:32:22.345]             `[[` <- base::`[[`
[15:32:22.345]             `+` <- base::`+`
[15:32:22.345]             `<<-` <- base::`<<-`
[15:32:22.345]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:22.345]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:22.345]                   3L)]
[15:32:22.345]             }
[15:32:22.345]             function(cond) {
[15:32:22.345]                 is_error <- inherits(cond, "error")
[15:32:22.345]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:22.345]                   NULL)
[15:32:22.345]                 if (is_error) {
[15:32:22.345]                   sessionInformation <- function() {
[15:32:22.345]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:22.345]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:22.345]                       search = base::search(), system = base::Sys.info())
[15:32:22.345]                   }
[15:32:22.345]                   ...future.conditions[[length(...future.conditions) + 
[15:32:22.345]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:22.345]                     cond$call), session = sessionInformation(), 
[15:32:22.345]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:22.345]                   signalCondition(cond)
[15:32:22.345]                 }
[15:32:22.345]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:22.345]                 "immediateCondition"))) {
[15:32:22.345]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:22.345]                   ...future.conditions[[length(...future.conditions) + 
[15:32:22.345]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:22.345]                   if (TRUE && !signal) {
[15:32:22.345]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:22.345]                     {
[15:32:22.345]                       inherits <- base::inherits
[15:32:22.345]                       invokeRestart <- base::invokeRestart
[15:32:22.345]                       is.null <- base::is.null
[15:32:22.345]                       muffled <- FALSE
[15:32:22.345]                       if (inherits(cond, "message")) {
[15:32:22.345]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:22.345]                         if (muffled) 
[15:32:22.345]                           invokeRestart("muffleMessage")
[15:32:22.345]                       }
[15:32:22.345]                       else if (inherits(cond, "warning")) {
[15:32:22.345]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:22.345]                         if (muffled) 
[15:32:22.345]                           invokeRestart("muffleWarning")
[15:32:22.345]                       }
[15:32:22.345]                       else if (inherits(cond, "condition")) {
[15:32:22.345]                         if (!is.null(pattern)) {
[15:32:22.345]                           computeRestarts <- base::computeRestarts
[15:32:22.345]                           grepl <- base::grepl
[15:32:22.345]                           restarts <- computeRestarts(cond)
[15:32:22.345]                           for (restart in restarts) {
[15:32:22.345]                             name <- restart$name
[15:32:22.345]                             if (is.null(name)) 
[15:32:22.345]                               next
[15:32:22.345]                             if (!grepl(pattern, name)) 
[15:32:22.345]                               next
[15:32:22.345]                             invokeRestart(restart)
[15:32:22.345]                             muffled <- TRUE
[15:32:22.345]                             break
[15:32:22.345]                           }
[15:32:22.345]                         }
[15:32:22.345]                       }
[15:32:22.345]                       invisible(muffled)
[15:32:22.345]                     }
[15:32:22.345]                     muffleCondition(cond, pattern = "^muffle")
[15:32:22.345]                   }
[15:32:22.345]                 }
[15:32:22.345]                 else {
[15:32:22.345]                   if (TRUE) {
[15:32:22.345]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:22.345]                     {
[15:32:22.345]                       inherits <- base::inherits
[15:32:22.345]                       invokeRestart <- base::invokeRestart
[15:32:22.345]                       is.null <- base::is.null
[15:32:22.345]                       muffled <- FALSE
[15:32:22.345]                       if (inherits(cond, "message")) {
[15:32:22.345]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:22.345]                         if (muffled) 
[15:32:22.345]                           invokeRestart("muffleMessage")
[15:32:22.345]                       }
[15:32:22.345]                       else if (inherits(cond, "warning")) {
[15:32:22.345]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:22.345]                         if (muffled) 
[15:32:22.345]                           invokeRestart("muffleWarning")
[15:32:22.345]                       }
[15:32:22.345]                       else if (inherits(cond, "condition")) {
[15:32:22.345]                         if (!is.null(pattern)) {
[15:32:22.345]                           computeRestarts <- base::computeRestarts
[15:32:22.345]                           grepl <- base::grepl
[15:32:22.345]                           restarts <- computeRestarts(cond)
[15:32:22.345]                           for (restart in restarts) {
[15:32:22.345]                             name <- restart$name
[15:32:22.345]                             if (is.null(name)) 
[15:32:22.345]                               next
[15:32:22.345]                             if (!grepl(pattern, name)) 
[15:32:22.345]                               next
[15:32:22.345]                             invokeRestart(restart)
[15:32:22.345]                             muffled <- TRUE
[15:32:22.345]                             break
[15:32:22.345]                           }
[15:32:22.345]                         }
[15:32:22.345]                       }
[15:32:22.345]                       invisible(muffled)
[15:32:22.345]                     }
[15:32:22.345]                     muffleCondition(cond, pattern = "^muffle")
[15:32:22.345]                   }
[15:32:22.345]                 }
[15:32:22.345]             }
[15:32:22.345]         }))
[15:32:22.345]     }, error = function(ex) {
[15:32:22.345]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:22.345]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:22.345]                 ...future.rng), started = ...future.startTime, 
[15:32:22.345]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:22.345]             version = "1.8"), class = "FutureResult")
[15:32:22.345]     }, finally = {
[15:32:22.345]         if (!identical(...future.workdir, getwd())) 
[15:32:22.345]             setwd(...future.workdir)
[15:32:22.345]         {
[15:32:22.345]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:22.345]                 ...future.oldOptions$nwarnings <- NULL
[15:32:22.345]             }
[15:32:22.345]             base::options(...future.oldOptions)
[15:32:22.345]             if (.Platform$OS.type == "windows") {
[15:32:22.345]                 old_names <- names(...future.oldEnvVars)
[15:32:22.345]                 envs <- base::Sys.getenv()
[15:32:22.345]                 names <- names(envs)
[15:32:22.345]                 common <- intersect(names, old_names)
[15:32:22.345]                 added <- setdiff(names, old_names)
[15:32:22.345]                 removed <- setdiff(old_names, names)
[15:32:22.345]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:22.345]                   envs[common]]
[15:32:22.345]                 NAMES <- toupper(changed)
[15:32:22.345]                 args <- list()
[15:32:22.345]                 for (kk in seq_along(NAMES)) {
[15:32:22.345]                   name <- changed[[kk]]
[15:32:22.345]                   NAME <- NAMES[[kk]]
[15:32:22.345]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:22.345]                     next
[15:32:22.345]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:22.345]                 }
[15:32:22.345]                 NAMES <- toupper(added)
[15:32:22.345]                 for (kk in seq_along(NAMES)) {
[15:32:22.345]                   name <- added[[kk]]
[15:32:22.345]                   NAME <- NAMES[[kk]]
[15:32:22.345]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:22.345]                     next
[15:32:22.345]                   args[[name]] <- ""
[15:32:22.345]                 }
[15:32:22.345]                 NAMES <- toupper(removed)
[15:32:22.345]                 for (kk in seq_along(NAMES)) {
[15:32:22.345]                   name <- removed[[kk]]
[15:32:22.345]                   NAME <- NAMES[[kk]]
[15:32:22.345]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:22.345]                     next
[15:32:22.345]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:22.345]                 }
[15:32:22.345]                 if (length(args) > 0) 
[15:32:22.345]                   base::do.call(base::Sys.setenv, args = args)
[15:32:22.345]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:22.345]             }
[15:32:22.345]             else {
[15:32:22.345]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:22.345]             }
[15:32:22.345]             {
[15:32:22.345]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:22.345]                   0L) {
[15:32:22.345]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:22.345]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:22.345]                   base::options(opts)
[15:32:22.345]                 }
[15:32:22.345]                 {
[15:32:22.345]                   {
[15:32:22.345]                     NULL
[15:32:22.345]                     RNGkind("Mersenne-Twister")
[15:32:22.345]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:22.345]                       inherits = FALSE)
[15:32:22.345]                   }
[15:32:22.345]                   options(future.plan = NULL)
[15:32:22.345]                   if (is.na(NA_character_)) 
[15:32:22.345]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:22.345]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:22.345]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:22.345]                     .init = FALSE)
[15:32:22.345]                 }
[15:32:22.345]             }
[15:32:22.345]         }
[15:32:22.345]     })
[15:32:22.345]     if (TRUE) {
[15:32:22.345]         base::sink(type = "output", split = FALSE)
[15:32:22.345]         if (TRUE) {
[15:32:22.345]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:22.345]         }
[15:32:22.345]         else {
[15:32:22.345]             ...future.result["stdout"] <- base::list(NULL)
[15:32:22.345]         }
[15:32:22.345]         base::close(...future.stdout)
[15:32:22.345]         ...future.stdout <- NULL
[15:32:22.345]     }
[15:32:22.345]     ...future.result$conditions <- ...future.conditions
[15:32:22.345]     ...future.result$finished <- base::Sys.time()
[15:32:22.345]     ...future.result
[15:32:22.345] }
[15:32:22.352] assign_globals() ...
[15:32:22.353] List of 5
[15:32:22.353]  $ ...future.FUN            :function (x)  
[15:32:22.353]  $ future.call.arguments    : list()
[15:32:22.353]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:22.353]  $ ...future.elements_ii    :List of 6
[15:32:22.353]   ..$ a1: int 1
[15:32:22.353]   ..$ a2: int 2
[15:32:22.353]   ..$ b1: int 2
[15:32:22.353]   ..$ b2: int 3
[15:32:22.353]   ..$ c1: int 3
[15:32:22.353]   ..$ c2: int 4
[15:32:22.353]  $ ...future.seeds_ii       : NULL
[15:32:22.353]  $ ...future.globals.maxSize: NULL
[15:32:22.353]  - attr(*, "where")=List of 5
[15:32:22.353]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:22.353]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:22.353]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:22.353]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:22.353]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:22.353]  - attr(*, "resolved")= logi FALSE
[15:32:22.353]  - attr(*, "total_size")= num 848
[15:32:22.353]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:22.353]  - attr(*, "already-done")= logi TRUE
[15:32:22.367] - copied '...future.FUN' to environment
[15:32:22.367] - copied 'future.call.arguments' to environment
[15:32:22.367] - copied '...future.elements_ii' to environment
[15:32:22.368] - copied '...future.seeds_ii' to environment
[15:32:22.368] - copied '...future.globals.maxSize' to environment
[15:32:22.368] assign_globals() ... done
[15:32:22.369] plan(): Setting new future strategy stack:
[15:32:22.369] List of future strategies:
[15:32:22.369] 1. sequential:
[15:32:22.369]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:22.369]    - tweaked: FALSE
[15:32:22.369]    - call: NULL
[15:32:22.370] plan(): nbrOfWorkers() = 1
[15:32:22.372] plan(): Setting new future strategy stack:
[15:32:22.373] List of future strategies:
[15:32:22.373] 1. sequential:
[15:32:22.373]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:22.373]    - tweaked: FALSE
[15:32:22.373]    - call: plan(strategy)
[15:32:22.374] plan(): nbrOfWorkers() = 1
[15:32:22.374] SequentialFuture started (and completed)
[15:32:22.375] - Launch lazy future ... done
[15:32:22.375] run() for 'SequentialFuture' ... done
[15:32:22.375] Created future:
[15:32:22.376] SequentialFuture:
[15:32:22.376] Label: 'future_sapply-1'
[15:32:22.376] Expression:
[15:32:22.376] {
[15:32:22.376]     do.call(function(...) {
[15:32:22.376]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:22.376]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:22.376]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:22.376]             on.exit(options(oopts), add = TRUE)
[15:32:22.376]         }
[15:32:22.376]         {
[15:32:22.376]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:22.376]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:22.376]                 ...future.FUN(...future.X_jj, ...)
[15:32:22.376]             })
[15:32:22.376]         }
[15:32:22.376]     }, args = future.call.arguments)
[15:32:22.376] }
[15:32:22.376] Lazy evaluation: FALSE
[15:32:22.376] Asynchronous evaluation: FALSE
[15:32:22.376] Local evaluation: TRUE
[15:32:22.376] Environment: R_GlobalEnv
[15:32:22.376] Capture standard output: TRUE
[15:32:22.376] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:22.376] Globals: 5 objects totaling 1.16 KiB (function '...future.FUN' of 848 bytes, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 336 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:22.376] Packages: <none>
[15:32:22.376] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:22.376] Resolved: TRUE
[15:32:22.376] Value: 336 bytes of class 'list'
[15:32:22.376] Early signaling: FALSE
[15:32:22.376] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:22.376] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:22.378] Chunk #1 of 1 ... DONE
[15:32:22.378] Launching 1 futures (chunks) ... DONE
[15:32:22.379] Resolving 1 futures (chunks) ...
[15:32:22.379] resolve() on list ...
[15:32:22.379]  recursive: 0
[15:32:22.380]  length: 1
[15:32:22.380] 
[15:32:22.380] resolved() for 'SequentialFuture' ...
[15:32:22.381] - state: 'finished'
[15:32:22.381] - run: TRUE
[15:32:22.381] - result: 'FutureResult'
[15:32:22.382] resolved() for 'SequentialFuture' ... done
[15:32:22.382] Future #1
[15:32:22.382] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:22.383] - nx: 1
[15:32:22.383] - relay: TRUE
[15:32:22.383] - stdout: TRUE
[15:32:22.384] - signal: TRUE
[15:32:22.384] - resignal: FALSE
[15:32:22.384] - force: TRUE
[15:32:22.384] - relayed: [n=1] FALSE
[15:32:22.385] - queued futures: [n=1] FALSE
[15:32:22.385]  - until=1
[15:32:22.385]  - relaying element #1
[15:32:22.386] - relayed: [n=1] TRUE
[15:32:22.386] - queued futures: [n=1] TRUE
[15:32:22.386] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:22.387]  length: 0 (resolved future 1)
[15:32:22.387] Relaying remaining futures
[15:32:22.387] signalConditionsASAP(NULL, pos=0) ...
[15:32:22.388] - nx: 1
[15:32:22.388] - relay: TRUE
[15:32:22.388] - stdout: TRUE
[15:32:22.388] - signal: TRUE
[15:32:22.389] - resignal: FALSE
[15:32:22.389] - force: TRUE
[15:32:22.389] - relayed: [n=1] TRUE
[15:32:22.390] - queued futures: [n=1] TRUE
 - flush all
[15:32:22.390] - relayed: [n=1] TRUE
[15:32:22.390] - queued futures: [n=1] TRUE
[15:32:22.391] signalConditionsASAP(NULL, pos=0) ... done
[15:32:22.391] resolve() on list ... DONE
[15:32:22.391]  - Number of value chunks collected: 1
[15:32:22.392] Resolving 1 futures (chunks) ... DONE
[15:32:22.392] Reducing values from 1 chunks ...
[15:32:22.392]  - Number of values collected after concatenation: 6
[15:32:22.393]  - Number of values expected: 6
[15:32:22.393] Reducing values from 1 chunks ... DONE
[15:32:22.393] future_lapply() ... DONE
List of 2
 $ y0: Named int [1:6] 1 2 2 3 3 4
  ..- attr(*, "names")= chr [1:6] "a1" "a2" "b1" "b2" ...
 $ y1: Named int [1:6] 1 2 2 3 3 4
  ..- attr(*, "names")= chr [1:6] "a1" "a2" "b1" "b2" ...
[15:32:22.400] future_lapply() ...
[15:32:22.401] Number of chunks: 1
[15:32:22.402] getGlobalsAndPackagesXApply() ...
[15:32:22.402]  - future.globals: TRUE
[15:32:22.402] getGlobalsAndPackages() ...
[15:32:22.402] Searching for globals...
[15:32:22.405] - globals found: [2] 'FUN', 'UseMethod'
[15:32:22.405] Searching for globals ... DONE
[15:32:22.406] Resolving globals: FALSE
[15:32:22.406] The total size of the 1 globals is 1.22 KiB (1248 bytes)
[15:32:22.407] The total size of the 1 globals exported for future expression ('FUN()') is 1.22 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.22 KiB of class 'function')
[15:32:22.408] - globals: [1] 'FUN'
[15:32:22.408] 
[15:32:22.408] getGlobalsAndPackages() ... DONE
[15:32:22.408]  - globals found/used: [n=1] 'FUN'
[15:32:22.409]  - needed namespaces: [n=0] 
[15:32:22.409] Finding globals ... DONE
[15:32:22.409]  - use_args: TRUE
[15:32:22.410]  - Getting '...' globals ...
[15:32:22.410] resolve() on list ...
[15:32:22.411]  recursive: 0
[15:32:22.411]  length: 1
[15:32:22.411]  elements: '...'
[15:32:22.412]  length: 0 (resolved future 1)
[15:32:22.412] resolve() on list ... DONE
[15:32:22.412]    - '...' content: [n=0] 
[15:32:22.413] List of 1
[15:32:22.413]  $ ...: list()
[15:32:22.413]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:22.413]  - attr(*, "where")=List of 1
[15:32:22.413]   ..$ ...:<environment: 0x00000276e28998b0> 
[15:32:22.413]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:22.413]  - attr(*, "resolved")= logi TRUE
[15:32:22.413]  - attr(*, "total_size")= num NA
[15:32:22.418]  - Getting '...' globals ... DONE
[15:32:22.418] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:22.419] List of 2
[15:32:22.419]  $ ...future.FUN:function (x, ...)  
[15:32:22.419]  $ ...          : list()
[15:32:22.419]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:22.419]  - attr(*, "where")=List of 2
[15:32:22.419]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:22.419]   ..$ ...          :<environment: 0x00000276e28998b0> 
[15:32:22.419]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:22.419]  - attr(*, "resolved")= logi FALSE
[15:32:22.419]  - attr(*, "total_size")= num 1248
[15:32:22.424] Packages to be attached in all futures: [n=0] 
[15:32:22.424] getGlobalsAndPackagesXApply() ... DONE
[15:32:22.425] Number of futures (= number of chunks): 1
[15:32:22.425] Launching 1 futures (chunks) ...
[15:32:22.425] Chunk #1 of 1 ...
[15:32:22.426]  - Finding globals in 'X' for chunk #1 ...
[15:32:22.426] getGlobalsAndPackages() ...
[15:32:22.426] Searching for globals...
[15:32:22.427] 
[15:32:22.427] Searching for globals ... DONE
[15:32:22.427] - globals: [0] <none>
[15:32:22.428] getGlobalsAndPackages() ... DONE
[15:32:22.428]    + additional globals found: [n=0] 
[15:32:22.428]    + additional namespaces needed: [n=0] 
[15:32:22.428]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:22.429]  - seeds: <none>
[15:32:22.429]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:22.429] getGlobalsAndPackages() ...
[15:32:22.429] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:22.430] Resolving globals: FALSE
[15:32:22.430] Tweak future expression to call with '...' arguments ...
[15:32:22.430] {
[15:32:22.430]     do.call(function(...) {
[15:32:22.430]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:22.430]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:22.430]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:22.430]             on.exit(options(oopts), add = TRUE)
[15:32:22.430]         }
[15:32:22.430]         {
[15:32:22.430]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:22.430]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:22.430]                 ...future.FUN(...future.X_jj, ...)
[15:32:22.430]             })
[15:32:22.430]         }
[15:32:22.430]     }, args = future.call.arguments)
[15:32:22.430] }
[15:32:22.431] Tweak future expression to call with '...' arguments ... DONE
[15:32:22.432] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:22.432] 
[15:32:22.432] getGlobalsAndPackages() ... DONE
[15:32:22.433] run() for 'Future' ...
[15:32:22.433] - state: 'created'
[15:32:22.434] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:22.434] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:22.435] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:22.435]   - Field: 'label'
[15:32:22.435]   - Field: 'local'
[15:32:22.435]   - Field: 'owner'
[15:32:22.436]   - Field: 'envir'
[15:32:22.436]   - Field: 'packages'
[15:32:22.436]   - Field: 'gc'
[15:32:22.437]   - Field: 'conditions'
[15:32:22.437]   - Field: 'expr'
[15:32:22.437]   - Field: 'uuid'
[15:32:22.437]   - Field: 'seed'
[15:32:22.438]   - Field: 'version'
[15:32:22.441]   - Field: 'result'
[15:32:22.441]   - Field: 'asynchronous'
[15:32:22.442]   - Field: 'calls'
[15:32:22.442]   - Field: 'globals'
[15:32:22.442]   - Field: 'stdout'
[15:32:22.443]   - Field: 'earlySignal'
[15:32:22.443]   - Field: 'lazy'
[15:32:22.443]   - Field: 'state'
[15:32:22.443] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:22.444] - Launch lazy future ...
[15:32:22.444] Packages needed by the future expression (n = 0): <none>
[15:32:22.445] Packages needed by future strategies (n = 0): <none>
[15:32:22.446] {
[15:32:22.446]     {
[15:32:22.446]         {
[15:32:22.446]             ...future.startTime <- base::Sys.time()
[15:32:22.446]             {
[15:32:22.446]                 {
[15:32:22.446]                   {
[15:32:22.446]                     base::local({
[15:32:22.446]                       has_future <- base::requireNamespace("future", 
[15:32:22.446]                         quietly = TRUE)
[15:32:22.446]                       if (has_future) {
[15:32:22.446]                         ns <- base::getNamespace("future")
[15:32:22.446]                         version <- ns[[".package"]][["version"]]
[15:32:22.446]                         if (is.null(version)) 
[15:32:22.446]                           version <- utils::packageVersion("future")
[15:32:22.446]                       }
[15:32:22.446]                       else {
[15:32:22.446]                         version <- NULL
[15:32:22.446]                       }
[15:32:22.446]                       if (!has_future || version < "1.8.0") {
[15:32:22.446]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:22.446]                           "", base::R.version$version.string), 
[15:32:22.446]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:22.446]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:22.446]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:22.446]                             "release", "version")], collapse = " "), 
[15:32:22.446]                           hostname = base::Sys.info()[["nodename"]])
[15:32:22.446]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:22.446]                           info)
[15:32:22.446]                         info <- base::paste(info, collapse = "; ")
[15:32:22.446]                         if (!has_future) {
[15:32:22.446]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:22.446]                             info)
[15:32:22.446]                         }
[15:32:22.446]                         else {
[15:32:22.446]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:22.446]                             info, version)
[15:32:22.446]                         }
[15:32:22.446]                         base::stop(msg)
[15:32:22.446]                       }
[15:32:22.446]                     })
[15:32:22.446]                   }
[15:32:22.446]                   ...future.strategy.old <- future::plan("list")
[15:32:22.446]                   options(future.plan = NULL)
[15:32:22.446]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:22.446]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:22.446]                 }
[15:32:22.446]                 ...future.workdir <- getwd()
[15:32:22.446]             }
[15:32:22.446]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:22.446]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:22.446]         }
[15:32:22.446]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:22.446]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:22.446]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:22.446]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:22.446]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:22.446]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:22.446]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:22.446]             base::names(...future.oldOptions))
[15:32:22.446]     }
[15:32:22.446]     if (FALSE) {
[15:32:22.446]     }
[15:32:22.446]     else {
[15:32:22.446]         if (TRUE) {
[15:32:22.446]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:22.446]                 open = "w")
[15:32:22.446]         }
[15:32:22.446]         else {
[15:32:22.446]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:22.446]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:22.446]         }
[15:32:22.446]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:22.446]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:22.446]             base::sink(type = "output", split = FALSE)
[15:32:22.446]             base::close(...future.stdout)
[15:32:22.446]         }, add = TRUE)
[15:32:22.446]     }
[15:32:22.446]     ...future.frame <- base::sys.nframe()
[15:32:22.446]     ...future.conditions <- base::list()
[15:32:22.446]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:22.446]     if (FALSE) {
[15:32:22.446]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:22.446]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:22.446]     }
[15:32:22.446]     ...future.result <- base::tryCatch({
[15:32:22.446]         base::withCallingHandlers({
[15:32:22.446]             ...future.value <- base::withVisible(base::local({
[15:32:22.446]                 do.call(function(...) {
[15:32:22.446]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:22.446]                   if (!identical(...future.globals.maxSize.org, 
[15:32:22.446]                     ...future.globals.maxSize)) {
[15:32:22.446]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:22.446]                     on.exit(options(oopts), add = TRUE)
[15:32:22.446]                   }
[15:32:22.446]                   {
[15:32:22.446]                     lapply(seq_along(...future.elements_ii), 
[15:32:22.446]                       FUN = function(jj) {
[15:32:22.446]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:22.446]                         ...future.FUN(...future.X_jj, ...)
[15:32:22.446]                       })
[15:32:22.446]                   }
[15:32:22.446]                 }, args = future.call.arguments)
[15:32:22.446]             }))
[15:32:22.446]             future::FutureResult(value = ...future.value$value, 
[15:32:22.446]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:22.446]                   ...future.rng), globalenv = if (FALSE) 
[15:32:22.446]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:22.446]                     ...future.globalenv.names))
[15:32:22.446]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:22.446]         }, condition = base::local({
[15:32:22.446]             c <- base::c
[15:32:22.446]             inherits <- base::inherits
[15:32:22.446]             invokeRestart <- base::invokeRestart
[15:32:22.446]             length <- base::length
[15:32:22.446]             list <- base::list
[15:32:22.446]             seq.int <- base::seq.int
[15:32:22.446]             signalCondition <- base::signalCondition
[15:32:22.446]             sys.calls <- base::sys.calls
[15:32:22.446]             `[[` <- base::`[[`
[15:32:22.446]             `+` <- base::`+`
[15:32:22.446]             `<<-` <- base::`<<-`
[15:32:22.446]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:22.446]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:22.446]                   3L)]
[15:32:22.446]             }
[15:32:22.446]             function(cond) {
[15:32:22.446]                 is_error <- inherits(cond, "error")
[15:32:22.446]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:22.446]                   NULL)
[15:32:22.446]                 if (is_error) {
[15:32:22.446]                   sessionInformation <- function() {
[15:32:22.446]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:22.446]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:22.446]                       search = base::search(), system = base::Sys.info())
[15:32:22.446]                   }
[15:32:22.446]                   ...future.conditions[[length(...future.conditions) + 
[15:32:22.446]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:22.446]                     cond$call), session = sessionInformation(), 
[15:32:22.446]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:22.446]                   signalCondition(cond)
[15:32:22.446]                 }
[15:32:22.446]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:22.446]                 "immediateCondition"))) {
[15:32:22.446]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:22.446]                   ...future.conditions[[length(...future.conditions) + 
[15:32:22.446]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:22.446]                   if (TRUE && !signal) {
[15:32:22.446]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:22.446]                     {
[15:32:22.446]                       inherits <- base::inherits
[15:32:22.446]                       invokeRestart <- base::invokeRestart
[15:32:22.446]                       is.null <- base::is.null
[15:32:22.446]                       muffled <- FALSE
[15:32:22.446]                       if (inherits(cond, "message")) {
[15:32:22.446]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:22.446]                         if (muffled) 
[15:32:22.446]                           invokeRestart("muffleMessage")
[15:32:22.446]                       }
[15:32:22.446]                       else if (inherits(cond, "warning")) {
[15:32:22.446]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:22.446]                         if (muffled) 
[15:32:22.446]                           invokeRestart("muffleWarning")
[15:32:22.446]                       }
[15:32:22.446]                       else if (inherits(cond, "condition")) {
[15:32:22.446]                         if (!is.null(pattern)) {
[15:32:22.446]                           computeRestarts <- base::computeRestarts
[15:32:22.446]                           grepl <- base::grepl
[15:32:22.446]                           restarts <- computeRestarts(cond)
[15:32:22.446]                           for (restart in restarts) {
[15:32:22.446]                             name <- restart$name
[15:32:22.446]                             if (is.null(name)) 
[15:32:22.446]                               next
[15:32:22.446]                             if (!grepl(pattern, name)) 
[15:32:22.446]                               next
[15:32:22.446]                             invokeRestart(restart)
[15:32:22.446]                             muffled <- TRUE
[15:32:22.446]                             break
[15:32:22.446]                           }
[15:32:22.446]                         }
[15:32:22.446]                       }
[15:32:22.446]                       invisible(muffled)
[15:32:22.446]                     }
[15:32:22.446]                     muffleCondition(cond, pattern = "^muffle")
[15:32:22.446]                   }
[15:32:22.446]                 }
[15:32:22.446]                 else {
[15:32:22.446]                   if (TRUE) {
[15:32:22.446]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:22.446]                     {
[15:32:22.446]                       inherits <- base::inherits
[15:32:22.446]                       invokeRestart <- base::invokeRestart
[15:32:22.446]                       is.null <- base::is.null
[15:32:22.446]                       muffled <- FALSE
[15:32:22.446]                       if (inherits(cond, "message")) {
[15:32:22.446]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:22.446]                         if (muffled) 
[15:32:22.446]                           invokeRestart("muffleMessage")
[15:32:22.446]                       }
[15:32:22.446]                       else if (inherits(cond, "warning")) {
[15:32:22.446]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:22.446]                         if (muffled) 
[15:32:22.446]                           invokeRestart("muffleWarning")
[15:32:22.446]                       }
[15:32:22.446]                       else if (inherits(cond, "condition")) {
[15:32:22.446]                         if (!is.null(pattern)) {
[15:32:22.446]                           computeRestarts <- base::computeRestarts
[15:32:22.446]                           grepl <- base::grepl
[15:32:22.446]                           restarts <- computeRestarts(cond)
[15:32:22.446]                           for (restart in restarts) {
[15:32:22.446]                             name <- restart$name
[15:32:22.446]                             if (is.null(name)) 
[15:32:22.446]                               next
[15:32:22.446]                             if (!grepl(pattern, name)) 
[15:32:22.446]                               next
[15:32:22.446]                             invokeRestart(restart)
[15:32:22.446]                             muffled <- TRUE
[15:32:22.446]                             break
[15:32:22.446]                           }
[15:32:22.446]                         }
[15:32:22.446]                       }
[15:32:22.446]                       invisible(muffled)
[15:32:22.446]                     }
[15:32:22.446]                     muffleCondition(cond, pattern = "^muffle")
[15:32:22.446]                   }
[15:32:22.446]                 }
[15:32:22.446]             }
[15:32:22.446]         }))
[15:32:22.446]     }, error = function(ex) {
[15:32:22.446]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:22.446]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:22.446]                 ...future.rng), started = ...future.startTime, 
[15:32:22.446]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:22.446]             version = "1.8"), class = "FutureResult")
[15:32:22.446]     }, finally = {
[15:32:22.446]         if (!identical(...future.workdir, getwd())) 
[15:32:22.446]             setwd(...future.workdir)
[15:32:22.446]         {
[15:32:22.446]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:22.446]                 ...future.oldOptions$nwarnings <- NULL
[15:32:22.446]             }
[15:32:22.446]             base::options(...future.oldOptions)
[15:32:22.446]             if (.Platform$OS.type == "windows") {
[15:32:22.446]                 old_names <- names(...future.oldEnvVars)
[15:32:22.446]                 envs <- base::Sys.getenv()
[15:32:22.446]                 names <- names(envs)
[15:32:22.446]                 common <- intersect(names, old_names)
[15:32:22.446]                 added <- setdiff(names, old_names)
[15:32:22.446]                 removed <- setdiff(old_names, names)
[15:32:22.446]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:22.446]                   envs[common]]
[15:32:22.446]                 NAMES <- toupper(changed)
[15:32:22.446]                 args <- list()
[15:32:22.446]                 for (kk in seq_along(NAMES)) {
[15:32:22.446]                   name <- changed[[kk]]
[15:32:22.446]                   NAME <- NAMES[[kk]]
[15:32:22.446]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:22.446]                     next
[15:32:22.446]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:22.446]                 }
[15:32:22.446]                 NAMES <- toupper(added)
[15:32:22.446]                 for (kk in seq_along(NAMES)) {
[15:32:22.446]                   name <- added[[kk]]
[15:32:22.446]                   NAME <- NAMES[[kk]]
[15:32:22.446]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:22.446]                     next
[15:32:22.446]                   args[[name]] <- ""
[15:32:22.446]                 }
[15:32:22.446]                 NAMES <- toupper(removed)
[15:32:22.446]                 for (kk in seq_along(NAMES)) {
[15:32:22.446]                   name <- removed[[kk]]
[15:32:22.446]                   NAME <- NAMES[[kk]]
[15:32:22.446]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:22.446]                     next
[15:32:22.446]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:22.446]                 }
[15:32:22.446]                 if (length(args) > 0) 
[15:32:22.446]                   base::do.call(base::Sys.setenv, args = args)
[15:32:22.446]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:22.446]             }
[15:32:22.446]             else {
[15:32:22.446]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:22.446]             }
[15:32:22.446]             {
[15:32:22.446]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:22.446]                   0L) {
[15:32:22.446]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:22.446]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:22.446]                   base::options(opts)
[15:32:22.446]                 }
[15:32:22.446]                 {
[15:32:22.446]                   {
[15:32:22.446]                     NULL
[15:32:22.446]                     RNGkind("Mersenne-Twister")
[15:32:22.446]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:22.446]                       inherits = FALSE)
[15:32:22.446]                   }
[15:32:22.446]                   options(future.plan = NULL)
[15:32:22.446]                   if (is.na(NA_character_)) 
[15:32:22.446]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:22.446]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:22.446]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:22.446]                     .init = FALSE)
[15:32:22.446]                 }
[15:32:22.446]             }
[15:32:22.446]         }
[15:32:22.446]     })
[15:32:22.446]     if (TRUE) {
[15:32:22.446]         base::sink(type = "output", split = FALSE)
[15:32:22.446]         if (TRUE) {
[15:32:22.446]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:22.446]         }
[15:32:22.446]         else {
[15:32:22.446]             ...future.result["stdout"] <- base::list(NULL)
[15:32:22.446]         }
[15:32:22.446]         base::close(...future.stdout)
[15:32:22.446]         ...future.stdout <- NULL
[15:32:22.446]     }
[15:32:22.446]     ...future.result$conditions <- ...future.conditions
[15:32:22.446]     ...future.result$finished <- base::Sys.time()
[15:32:22.446]     ...future.result
[15:32:22.446] }
[15:32:22.452] assign_globals() ...
[15:32:22.453] List of 5
[15:32:22.453]  $ ...future.FUN            :function (x, ...)  
[15:32:22.453]  $ future.call.arguments    : list()
[15:32:22.453]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:22.453]  $ ...future.elements_ii    :List of 6
[15:32:22.453]   ..$ a1: int 1
[15:32:22.453]   ..$ a2: int 2
[15:32:22.453]   ..$ b1: int 2
[15:32:22.453]   ..$ b2: int 3
[15:32:22.453]   ..$ c1: int 3
[15:32:22.453]   ..$ c2: int 4
[15:32:22.453]  $ ...future.seeds_ii       : NULL
[15:32:22.453]  $ ...future.globals.maxSize: NULL
[15:32:22.453]  - attr(*, "where")=List of 5
[15:32:22.453]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:22.453]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:22.453]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:22.453]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:22.453]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:22.453]  - attr(*, "resolved")= logi FALSE
[15:32:22.453]  - attr(*, "total_size")= num 1248
[15:32:22.453]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:22.453]  - attr(*, "already-done")= logi TRUE
[15:32:22.465] - copied '...future.FUN' to environment
[15:32:22.465] - copied 'future.call.arguments' to environment
[15:32:22.466] - copied '...future.elements_ii' to environment
[15:32:22.466] - copied '...future.seeds_ii' to environment
[15:32:22.466] - copied '...future.globals.maxSize' to environment
[15:32:22.466] assign_globals() ... done
[15:32:22.467] plan(): Setting new future strategy stack:
[15:32:22.467] List of future strategies:
[15:32:22.467] 1. sequential:
[15:32:22.467]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:22.467]    - tweaked: FALSE
[15:32:22.467]    - call: NULL
[15:32:22.468] plan(): nbrOfWorkers() = 1
[15:32:22.470] plan(): Setting new future strategy stack:
[15:32:22.471] List of future strategies:
[15:32:22.471] 1. sequential:
[15:32:22.471]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:22.471]    - tweaked: FALSE
[15:32:22.471]    - call: plan(strategy)
[15:32:22.472] plan(): nbrOfWorkers() = 1
[15:32:22.472] SequentialFuture started (and completed)
[15:32:22.472] - Launch lazy future ... done
[15:32:22.473] run() for 'SequentialFuture' ... done
[15:32:22.473] Created future:
[15:32:22.473] SequentialFuture:
[15:32:22.473] Label: 'future_sapply-1'
[15:32:22.473] Expression:
[15:32:22.473] {
[15:32:22.473]     do.call(function(...) {
[15:32:22.473]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:22.473]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:22.473]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:22.473]             on.exit(options(oopts), add = TRUE)
[15:32:22.473]         }
[15:32:22.473]         {
[15:32:22.473]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:22.473]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:22.473]                 ...future.FUN(...future.X_jj, ...)
[15:32:22.473]             })
[15:32:22.473]         }
[15:32:22.473]     }, args = future.call.arguments)
[15:32:22.473] }
[15:32:22.473] Lazy evaluation: FALSE
[15:32:22.473] Asynchronous evaluation: FALSE
[15:32:22.473] Local evaluation: TRUE
[15:32:22.473] Environment: R_GlobalEnv
[15:32:22.473] Capture standard output: TRUE
[15:32:22.473] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:22.473] Globals: 5 objects totaling 1.55 KiB (function '...future.FUN' of 1.22 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 336 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:22.473] Packages: <none>
[15:32:22.473] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:22.473] Resolved: TRUE
[15:32:22.473] Value: 1.31 KiB of class 'list'
[15:32:22.473] Early signaling: FALSE
[15:32:22.473] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:22.473] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:22.476] Chunk #1 of 1 ... DONE
[15:32:22.476] Launching 1 futures (chunks) ... DONE
[15:32:22.476] Resolving 1 futures (chunks) ...
[15:32:22.476] resolve() on list ...
[15:32:22.477]  recursive: 0
[15:32:22.477]  length: 1
[15:32:22.477] 
[15:32:22.478] resolved() for 'SequentialFuture' ...
[15:32:22.478] - state: 'finished'
[15:32:22.478] - run: TRUE
[15:32:22.478] - result: 'FutureResult'
[15:32:22.479] resolved() for 'SequentialFuture' ... done
[15:32:22.479] Future #1
[15:32:22.479] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:22.480] - nx: 1
[15:32:22.480] - relay: TRUE
[15:32:22.480] - stdout: TRUE
[15:32:22.481] - signal: TRUE
[15:32:22.481] - resignal: FALSE
[15:32:22.481] - force: TRUE
[15:32:22.481] - relayed: [n=1] FALSE
[15:32:22.482] - queued futures: [n=1] FALSE
[15:32:22.482]  - until=1
[15:32:22.482]  - relaying element #1
[15:32:22.483] - relayed: [n=1] TRUE
[15:32:22.483] - queued futures: [n=1] TRUE
[15:32:22.483] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:22.484]  length: 0 (resolved future 1)
[15:32:22.484] Relaying remaining futures
[15:32:22.484] signalConditionsASAP(NULL, pos=0) ...
[15:32:22.485] - nx: 1
[15:32:22.485] - relay: TRUE
[15:32:22.485] - stdout: TRUE
[15:32:22.486] - signal: TRUE
[15:32:22.486] - resignal: FALSE
[15:32:22.486] - force: TRUE
[15:32:22.486] - relayed: [n=1] TRUE
[15:32:22.487] - queued futures: [n=1] TRUE
 - flush all
[15:32:22.487] - relayed: [n=1] TRUE
[15:32:22.488] - queued futures: [n=1] TRUE
[15:32:22.488] signalConditionsASAP(NULL, pos=0) ... done
[15:32:22.488] resolve() on list ... DONE
[15:32:22.492]  - Number of value chunks collected: 1
[15:32:22.493] Resolving 1 futures (chunks) ... DONE
[15:32:22.493] Reducing values from 1 chunks ...
[15:32:22.493]  - Number of values collected after concatenation: 6
[15:32:22.493]  - Number of values expected: 6
[15:32:22.494] Reducing values from 1 chunks ... DONE
[15:32:22.494] future_lapply() ... DONE
List of 2
 $ y0: Named int [1:6] 1 2 2 3 3 4
  ..- attr(*, "names")= chr [1:6] "a1" "a2" "b1" "b2" ...
 $ y1: Named int [1:6] 1 2 2 3 3 4
  ..- attr(*, "names")= chr [1:6] "a1" "a2" "b1" "b2" ...
[15:32:22.498] future_lapply() ...
[15:32:22.500] Number of chunks: 1
[15:32:22.500] getGlobalsAndPackagesXApply() ...
[15:32:22.500]  - future.globals: TRUE
[15:32:22.501] getGlobalsAndPackages() ...
[15:32:22.501] Searching for globals...
[15:32:22.505] - globals found: [5] 'FUN', '*', ':', 'outer', 'rep'
[15:32:22.505] Searching for globals ... DONE
[15:32:22.506] Resolving globals: FALSE
[15:32:22.507] The total size of the 1 globals is 4.62 KiB (4728 bytes)
[15:32:22.507] The total size of the 1 globals exported for future expression ('FUN()') is 4.62 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.62 KiB of class 'function')
[15:32:22.508] - globals: [1] 'FUN'
[15:32:22.508] 
[15:32:22.509] getGlobalsAndPackages() ... DONE
[15:32:22.509]  - globals found/used: [n=1] 'FUN'
[15:32:22.509]  - needed namespaces: [n=0] 
[15:32:22.510] Finding globals ... DONE
[15:32:22.510]  - use_args: TRUE
[15:32:22.510]  - Getting '...' globals ...
[15:32:22.511] resolve() on list ...
[15:32:22.512]  recursive: 0
[15:32:22.512]  length: 1
[15:32:22.512]  elements: '...'
[15:32:22.513]  length: 0 (resolved future 1)
[15:32:22.513] resolve() on list ... DONE
[15:32:22.513]    - '...' content: [n=0] 
[15:32:22.514] List of 1
[15:32:22.514]  $ ...: list()
[15:32:22.514]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:22.514]  - attr(*, "where")=List of 1
[15:32:22.514]   ..$ ...:<environment: 0x00000276e2493bf8> 
[15:32:22.514]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:22.514]  - attr(*, "resolved")= logi TRUE
[15:32:22.514]  - attr(*, "total_size")= num NA
[15:32:22.520]  - Getting '...' globals ... DONE
[15:32:22.520] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:22.521] List of 2
[15:32:22.521]  $ ...future.FUN:function (x, y = 2 * 1:5)  
[15:32:22.521]  $ ...          : list()
[15:32:22.521]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:22.521]  - attr(*, "where")=List of 2
[15:32:22.521]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:22.521]   ..$ ...          :<environment: 0x00000276e2493bf8> 
[15:32:22.521]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:22.521]  - attr(*, "resolved")= logi FALSE
[15:32:22.521]  - attr(*, "total_size")= num 4728
[15:32:22.527] Packages to be attached in all futures: [n=0] 
[15:32:22.528] getGlobalsAndPackagesXApply() ... DONE
[15:32:22.528] Number of futures (= number of chunks): 1
[15:32:22.529] Launching 1 futures (chunks) ...
[15:32:22.529] Chunk #1 of 1 ...
[15:32:22.529]  - Finding globals in 'X' for chunk #1 ...
[15:32:22.530] getGlobalsAndPackages() ...
[15:32:22.530] Searching for globals...
[15:32:22.531] 
[15:32:22.531] Searching for globals ... DONE
[15:32:22.532] - globals: [0] <none>
[15:32:22.532] getGlobalsAndPackages() ... DONE
[15:32:22.532]    + additional globals found: [n=0] 
[15:32:22.533]    + additional namespaces needed: [n=0] 
[15:32:22.533]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:22.533]  - seeds: <none>
[15:32:22.534]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:22.534] getGlobalsAndPackages() ...
[15:32:22.534] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:22.535] Resolving globals: FALSE
[15:32:22.535] Tweak future expression to call with '...' arguments ...
[15:32:22.535] {
[15:32:22.535]     do.call(function(...) {
[15:32:22.535]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:22.535]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:22.535]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:22.535]             on.exit(options(oopts), add = TRUE)
[15:32:22.535]         }
[15:32:22.535]         {
[15:32:22.535]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:22.535]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:22.535]                 ...future.FUN(...future.X_jj, ...)
[15:32:22.535]             })
[15:32:22.535]         }
[15:32:22.535]     }, args = future.call.arguments)
[15:32:22.535] }
[15:32:22.536] Tweak future expression to call with '...' arguments ... DONE
[15:32:22.537] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:22.538] 
[15:32:22.538] getGlobalsAndPackages() ... DONE
[15:32:22.542] run() for 'Future' ...
[15:32:22.543] - state: 'created'
[15:32:22.543] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:22.544] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:22.545] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:22.545]   - Field: 'label'
[15:32:22.546]   - Field: 'local'
[15:32:22.546]   - Field: 'owner'
[15:32:22.547]   - Field: 'envir'
[15:32:22.547]   - Field: 'packages'
[15:32:22.548]   - Field: 'gc'
[15:32:22.548]   - Field: 'conditions'
[15:32:22.548]   - Field: 'expr'
[15:32:22.549]   - Field: 'uuid'
[15:32:22.549]   - Field: 'seed'
[15:32:22.550]   - Field: 'version'
[15:32:22.550]   - Field: 'result'
[15:32:22.550]   - Field: 'asynchronous'
[15:32:22.551]   - Field: 'calls'
[15:32:22.551]   - Field: 'globals'
[15:32:22.552]   - Field: 'stdout'
[15:32:22.552]   - Field: 'earlySignal'
[15:32:22.553]   - Field: 'lazy'
[15:32:22.553]   - Field: 'state'
[15:32:22.553] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:22.554] - Launch lazy future ...
[15:32:22.554] Packages needed by the future expression (n = 0): <none>
[15:32:22.555] Packages needed by future strategies (n = 0): <none>
[15:32:22.556] {
[15:32:22.556]     {
[15:32:22.556]         {
[15:32:22.556]             ...future.startTime <- base::Sys.time()
[15:32:22.556]             {
[15:32:22.556]                 {
[15:32:22.556]                   {
[15:32:22.556]                     base::local({
[15:32:22.556]                       has_future <- base::requireNamespace("future", 
[15:32:22.556]                         quietly = TRUE)
[15:32:22.556]                       if (has_future) {
[15:32:22.556]                         ns <- base::getNamespace("future")
[15:32:22.556]                         version <- ns[[".package"]][["version"]]
[15:32:22.556]                         if (is.null(version)) 
[15:32:22.556]                           version <- utils::packageVersion("future")
[15:32:22.556]                       }
[15:32:22.556]                       else {
[15:32:22.556]                         version <- NULL
[15:32:22.556]                       }
[15:32:22.556]                       if (!has_future || version < "1.8.0") {
[15:32:22.556]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:22.556]                           "", base::R.version$version.string), 
[15:32:22.556]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:22.556]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:22.556]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:22.556]                             "release", "version")], collapse = " "), 
[15:32:22.556]                           hostname = base::Sys.info()[["nodename"]])
[15:32:22.556]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:22.556]                           info)
[15:32:22.556]                         info <- base::paste(info, collapse = "; ")
[15:32:22.556]                         if (!has_future) {
[15:32:22.556]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:22.556]                             info)
[15:32:22.556]                         }
[15:32:22.556]                         else {
[15:32:22.556]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:22.556]                             info, version)
[15:32:22.556]                         }
[15:32:22.556]                         base::stop(msg)
[15:32:22.556]                       }
[15:32:22.556]                     })
[15:32:22.556]                   }
[15:32:22.556]                   ...future.strategy.old <- future::plan("list")
[15:32:22.556]                   options(future.plan = NULL)
[15:32:22.556]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:22.556]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:22.556]                 }
[15:32:22.556]                 ...future.workdir <- getwd()
[15:32:22.556]             }
[15:32:22.556]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:22.556]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:22.556]         }
[15:32:22.556]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:22.556]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:22.556]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:22.556]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:22.556]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:22.556]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:22.556]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:22.556]             base::names(...future.oldOptions))
[15:32:22.556]     }
[15:32:22.556]     if (FALSE) {
[15:32:22.556]     }
[15:32:22.556]     else {
[15:32:22.556]         if (TRUE) {
[15:32:22.556]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:22.556]                 open = "w")
[15:32:22.556]         }
[15:32:22.556]         else {
[15:32:22.556]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:22.556]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:22.556]         }
[15:32:22.556]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:22.556]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:22.556]             base::sink(type = "output", split = FALSE)
[15:32:22.556]             base::close(...future.stdout)
[15:32:22.556]         }, add = TRUE)
[15:32:22.556]     }
[15:32:22.556]     ...future.frame <- base::sys.nframe()
[15:32:22.556]     ...future.conditions <- base::list()
[15:32:22.556]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:22.556]     if (FALSE) {
[15:32:22.556]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:22.556]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:22.556]     }
[15:32:22.556]     ...future.result <- base::tryCatch({
[15:32:22.556]         base::withCallingHandlers({
[15:32:22.556]             ...future.value <- base::withVisible(base::local({
[15:32:22.556]                 do.call(function(...) {
[15:32:22.556]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:22.556]                   if (!identical(...future.globals.maxSize.org, 
[15:32:22.556]                     ...future.globals.maxSize)) {
[15:32:22.556]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:22.556]                     on.exit(options(oopts), add = TRUE)
[15:32:22.556]                   }
[15:32:22.556]                   {
[15:32:22.556]                     lapply(seq_along(...future.elements_ii), 
[15:32:22.556]                       FUN = function(jj) {
[15:32:22.556]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:22.556]                         ...future.FUN(...future.X_jj, ...)
[15:32:22.556]                       })
[15:32:22.556]                   }
[15:32:22.556]                 }, args = future.call.arguments)
[15:32:22.556]             }))
[15:32:22.556]             future::FutureResult(value = ...future.value$value, 
[15:32:22.556]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:22.556]                   ...future.rng), globalenv = if (FALSE) 
[15:32:22.556]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:22.556]                     ...future.globalenv.names))
[15:32:22.556]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:22.556]         }, condition = base::local({
[15:32:22.556]             c <- base::c
[15:32:22.556]             inherits <- base::inherits
[15:32:22.556]             invokeRestart <- base::invokeRestart
[15:32:22.556]             length <- base::length
[15:32:22.556]             list <- base::list
[15:32:22.556]             seq.int <- base::seq.int
[15:32:22.556]             signalCondition <- base::signalCondition
[15:32:22.556]             sys.calls <- base::sys.calls
[15:32:22.556]             `[[` <- base::`[[`
[15:32:22.556]             `+` <- base::`+`
[15:32:22.556]             `<<-` <- base::`<<-`
[15:32:22.556]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:22.556]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:22.556]                   3L)]
[15:32:22.556]             }
[15:32:22.556]             function(cond) {
[15:32:22.556]                 is_error <- inherits(cond, "error")
[15:32:22.556]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:22.556]                   NULL)
[15:32:22.556]                 if (is_error) {
[15:32:22.556]                   sessionInformation <- function() {
[15:32:22.556]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:22.556]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:22.556]                       search = base::search(), system = base::Sys.info())
[15:32:22.556]                   }
[15:32:22.556]                   ...future.conditions[[length(...future.conditions) + 
[15:32:22.556]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:22.556]                     cond$call), session = sessionInformation(), 
[15:32:22.556]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:22.556]                   signalCondition(cond)
[15:32:22.556]                 }
[15:32:22.556]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:22.556]                 "immediateCondition"))) {
[15:32:22.556]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:22.556]                   ...future.conditions[[length(...future.conditions) + 
[15:32:22.556]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:22.556]                   if (TRUE && !signal) {
[15:32:22.556]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:22.556]                     {
[15:32:22.556]                       inherits <- base::inherits
[15:32:22.556]                       invokeRestart <- base::invokeRestart
[15:32:22.556]                       is.null <- base::is.null
[15:32:22.556]                       muffled <- FALSE
[15:32:22.556]                       if (inherits(cond, "message")) {
[15:32:22.556]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:22.556]                         if (muffled) 
[15:32:22.556]                           invokeRestart("muffleMessage")
[15:32:22.556]                       }
[15:32:22.556]                       else if (inherits(cond, "warning")) {
[15:32:22.556]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:22.556]                         if (muffled) 
[15:32:22.556]                           invokeRestart("muffleWarning")
[15:32:22.556]                       }
[15:32:22.556]                       else if (inherits(cond, "condition")) {
[15:32:22.556]                         if (!is.null(pattern)) {
[15:32:22.556]                           computeRestarts <- base::computeRestarts
[15:32:22.556]                           grepl <- base::grepl
[15:32:22.556]                           restarts <- computeRestarts(cond)
[15:32:22.556]                           for (restart in restarts) {
[15:32:22.556]                             name <- restart$name
[15:32:22.556]                             if (is.null(name)) 
[15:32:22.556]                               next
[15:32:22.556]                             if (!grepl(pattern, name)) 
[15:32:22.556]                               next
[15:32:22.556]                             invokeRestart(restart)
[15:32:22.556]                             muffled <- TRUE
[15:32:22.556]                             break
[15:32:22.556]                           }
[15:32:22.556]                         }
[15:32:22.556]                       }
[15:32:22.556]                       invisible(muffled)
[15:32:22.556]                     }
[15:32:22.556]                     muffleCondition(cond, pattern = "^muffle")
[15:32:22.556]                   }
[15:32:22.556]                 }
[15:32:22.556]                 else {
[15:32:22.556]                   if (TRUE) {
[15:32:22.556]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:22.556]                     {
[15:32:22.556]                       inherits <- base::inherits
[15:32:22.556]                       invokeRestart <- base::invokeRestart
[15:32:22.556]                       is.null <- base::is.null
[15:32:22.556]                       muffled <- FALSE
[15:32:22.556]                       if (inherits(cond, "message")) {
[15:32:22.556]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:22.556]                         if (muffled) 
[15:32:22.556]                           invokeRestart("muffleMessage")
[15:32:22.556]                       }
[15:32:22.556]                       else if (inherits(cond, "warning")) {
[15:32:22.556]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:22.556]                         if (muffled) 
[15:32:22.556]                           invokeRestart("muffleWarning")
[15:32:22.556]                       }
[15:32:22.556]                       else if (inherits(cond, "condition")) {
[15:32:22.556]                         if (!is.null(pattern)) {
[15:32:22.556]                           computeRestarts <- base::computeRestarts
[15:32:22.556]                           grepl <- base::grepl
[15:32:22.556]                           restarts <- computeRestarts(cond)
[15:32:22.556]                           for (restart in restarts) {
[15:32:22.556]                             name <- restart$name
[15:32:22.556]                             if (is.null(name)) 
[15:32:22.556]                               next
[15:32:22.556]                             if (!grepl(pattern, name)) 
[15:32:22.556]                               next
[15:32:22.556]                             invokeRestart(restart)
[15:32:22.556]                             muffled <- TRUE
[15:32:22.556]                             break
[15:32:22.556]                           }
[15:32:22.556]                         }
[15:32:22.556]                       }
[15:32:22.556]                       invisible(muffled)
[15:32:22.556]                     }
[15:32:22.556]                     muffleCondition(cond, pattern = "^muffle")
[15:32:22.556]                   }
[15:32:22.556]                 }
[15:32:22.556]             }
[15:32:22.556]         }))
[15:32:22.556]     }, error = function(ex) {
[15:32:22.556]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:22.556]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:22.556]                 ...future.rng), started = ...future.startTime, 
[15:32:22.556]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:22.556]             version = "1.8"), class = "FutureResult")
[15:32:22.556]     }, finally = {
[15:32:22.556]         if (!identical(...future.workdir, getwd())) 
[15:32:22.556]             setwd(...future.workdir)
[15:32:22.556]         {
[15:32:22.556]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:22.556]                 ...future.oldOptions$nwarnings <- NULL
[15:32:22.556]             }
[15:32:22.556]             base::options(...future.oldOptions)
[15:32:22.556]             if (.Platform$OS.type == "windows") {
[15:32:22.556]                 old_names <- names(...future.oldEnvVars)
[15:32:22.556]                 envs <- base::Sys.getenv()
[15:32:22.556]                 names <- names(envs)
[15:32:22.556]                 common <- intersect(names, old_names)
[15:32:22.556]                 added <- setdiff(names, old_names)
[15:32:22.556]                 removed <- setdiff(old_names, names)
[15:32:22.556]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:22.556]                   envs[common]]
[15:32:22.556]                 NAMES <- toupper(changed)
[15:32:22.556]                 args <- list()
[15:32:22.556]                 for (kk in seq_along(NAMES)) {
[15:32:22.556]                   name <- changed[[kk]]
[15:32:22.556]                   NAME <- NAMES[[kk]]
[15:32:22.556]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:22.556]                     next
[15:32:22.556]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:22.556]                 }
[15:32:22.556]                 NAMES <- toupper(added)
[15:32:22.556]                 for (kk in seq_along(NAMES)) {
[15:32:22.556]                   name <- added[[kk]]
[15:32:22.556]                   NAME <- NAMES[[kk]]
[15:32:22.556]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:22.556]                     next
[15:32:22.556]                   args[[name]] <- ""
[15:32:22.556]                 }
[15:32:22.556]                 NAMES <- toupper(removed)
[15:32:22.556]                 for (kk in seq_along(NAMES)) {
[15:32:22.556]                   name <- removed[[kk]]
[15:32:22.556]                   NAME <- NAMES[[kk]]
[15:32:22.556]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:22.556]                     next
[15:32:22.556]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:22.556]                 }
[15:32:22.556]                 if (length(args) > 0) 
[15:32:22.556]                   base::do.call(base::Sys.setenv, args = args)
[15:32:22.556]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:22.556]             }
[15:32:22.556]             else {
[15:32:22.556]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:22.556]             }
[15:32:22.556]             {
[15:32:22.556]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:22.556]                   0L) {
[15:32:22.556]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:22.556]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:22.556]                   base::options(opts)
[15:32:22.556]                 }
[15:32:22.556]                 {
[15:32:22.556]                   {
[15:32:22.556]                     NULL
[15:32:22.556]                     RNGkind("Mersenne-Twister")
[15:32:22.556]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:22.556]                       inherits = FALSE)
[15:32:22.556]                   }
[15:32:22.556]                   options(future.plan = NULL)
[15:32:22.556]                   if (is.na(NA_character_)) 
[15:32:22.556]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:22.556]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:22.556]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:22.556]                     .init = FALSE)
[15:32:22.556]                 }
[15:32:22.556]             }
[15:32:22.556]         }
[15:32:22.556]     })
[15:32:22.556]     if (TRUE) {
[15:32:22.556]         base::sink(type = "output", split = FALSE)
[15:32:22.556]         if (TRUE) {
[15:32:22.556]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:22.556]         }
[15:32:22.556]         else {
[15:32:22.556]             ...future.result["stdout"] <- base::list(NULL)
[15:32:22.556]         }
[15:32:22.556]         base::close(...future.stdout)
[15:32:22.556]         ...future.stdout <- NULL
[15:32:22.556]     }
[15:32:22.556]     ...future.result$conditions <- ...future.conditions
[15:32:22.556]     ...future.result$finished <- base::Sys.time()
[15:32:22.556]     ...future.result
[15:32:22.556] }
[15:32:22.565] assign_globals() ...
[15:32:22.565] List of 5
[15:32:22.565]  $ ...future.FUN            :function (x, y = 2 * 1:5)  
[15:32:22.565]  $ future.call.arguments    : list()
[15:32:22.565]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:22.565]  $ ...future.elements_ii    :List of 6
[15:32:22.565]   ..$ a1: int 1
[15:32:22.565]   ..$ a2: int 2
[15:32:22.565]   ..$ b1: int 2
[15:32:22.565]   ..$ b2: int 3
[15:32:22.565]   ..$ c1: int 3
[15:32:22.565]   ..$ c2: int 4
[15:32:22.565]  $ ...future.seeds_ii       : NULL
[15:32:22.565]  $ ...future.globals.maxSize: NULL
[15:32:22.565]  - attr(*, "where")=List of 5
[15:32:22.565]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:22.565]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:22.565]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:22.565]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:22.565]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:22.565]  - attr(*, "resolved")= logi FALSE
[15:32:22.565]  - attr(*, "total_size")= num 4728
[15:32:22.565]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:22.565]  - attr(*, "already-done")= logi TRUE
[15:32:22.579] - reassign environment for '...future.FUN'
[15:32:22.580] - copied '...future.FUN' to environment
[15:32:22.580] - copied 'future.call.arguments' to environment
[15:32:22.580] - copied '...future.elements_ii' to environment
[15:32:22.581] - copied '...future.seeds_ii' to environment
[15:32:22.581] - copied '...future.globals.maxSize' to environment
[15:32:22.581] assign_globals() ... done
[15:32:22.582] plan(): Setting new future strategy stack:
[15:32:22.582] List of future strategies:
[15:32:22.582] 1. sequential:
[15:32:22.582]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:22.582]    - tweaked: FALSE
[15:32:22.582]    - call: NULL
[15:32:22.583] plan(): nbrOfWorkers() = 1
[15:32:22.586] plan(): Setting new future strategy stack:
[15:32:22.586] List of future strategies:
[15:32:22.586] 1. sequential:
[15:32:22.586]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:22.586]    - tweaked: FALSE
[15:32:22.586]    - call: plan(strategy)
[15:32:22.587] plan(): nbrOfWorkers() = 1
[15:32:22.588] SequentialFuture started (and completed)
[15:32:22.588] - Launch lazy future ... done
[15:32:22.588] run() for 'SequentialFuture' ... done
[15:32:22.589] Created future:
[15:32:22.589] SequentialFuture:
[15:32:22.589] Label: 'future_sapply-1'
[15:32:22.589] Expression:
[15:32:22.589] {
[15:32:22.589]     do.call(function(...) {
[15:32:22.589]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:22.589]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:22.589]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:22.589]             on.exit(options(oopts), add = TRUE)
[15:32:22.589]         }
[15:32:22.589]         {
[15:32:22.589]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:22.589]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:22.589]                 ...future.FUN(...future.X_jj, ...)
[15:32:22.589]             })
[15:32:22.589]         }
[15:32:22.589]     }, args = future.call.arguments)
[15:32:22.589] }
[15:32:22.589] Lazy evaluation: FALSE
[15:32:22.589] Asynchronous evaluation: FALSE
[15:32:22.589] Local evaluation: TRUE
[15:32:22.589] Environment: R_GlobalEnv
[15:32:22.589] Capture standard output: TRUE
[15:32:22.589] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:22.589] Globals: 5 objects totaling 4.95 KiB (function '...future.FUN' of 4.62 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 336 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:22.589] Packages: <none>
[15:32:22.589] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:22.589] Resolved: TRUE
[15:32:22.589] Value: 2.02 KiB of class 'list'
[15:32:22.589] Early signaling: FALSE
[15:32:22.589] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:22.589] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:22.592] Chunk #1 of 1 ... DONE
[15:32:22.592] Launching 1 futures (chunks) ... DONE
[15:32:22.592] Resolving 1 futures (chunks) ...
[15:32:22.592] resolve() on list ...
[15:32:22.593]  recursive: 0
[15:32:22.593]  length: 1
[15:32:22.593] 
[15:32:22.594] resolved() for 'SequentialFuture' ...
[15:32:22.594] - state: 'finished'
[15:32:22.594] - run: TRUE
[15:32:22.595] - result: 'FutureResult'
[15:32:22.595] resolved() for 'SequentialFuture' ... done
[15:32:22.595] Future #1
[15:32:22.596] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:22.596] - nx: 1
[15:32:22.596] - relay: TRUE
[15:32:22.597] - stdout: TRUE
[15:32:22.597] - signal: TRUE
[15:32:22.597] - resignal: FALSE
[15:32:22.597] - force: TRUE
[15:32:22.598] - relayed: [n=1] FALSE
[15:32:22.598] - queued futures: [n=1] FALSE
[15:32:22.602]  - until=1
[15:32:22.602]  - relaying element #1
[15:32:22.603] - relayed: [n=1] TRUE
[15:32:22.603] - queued futures: [n=1] TRUE
[15:32:22.604] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:22.604]  length: 0 (resolved future 1)
[15:32:22.604] Relaying remaining futures
[15:32:22.605] signalConditionsASAP(NULL, pos=0) ...
[15:32:22.605] - nx: 1
[15:32:22.605] - relay: TRUE
[15:32:22.605] - stdout: TRUE
[15:32:22.606] - signal: TRUE
[15:32:22.606] - resignal: FALSE
[15:32:22.606] - force: TRUE
[15:32:22.607] - relayed: [n=1] TRUE
[15:32:22.607] - queued futures: [n=1] TRUE
 - flush all
[15:32:22.607] - relayed: [n=1] TRUE
[15:32:22.608] - queued futures: [n=1] TRUE
[15:32:22.608] signalConditionsASAP(NULL, pos=0) ... done
[15:32:22.608] resolve() on list ... DONE
[15:32:22.609]  - Number of value chunks collected: 1
[15:32:22.609] Resolving 1 futures (chunks) ... DONE
[15:32:22.610] Reducing values from 1 chunks ...
[15:32:22.610]  - Number of values collected after concatenation: 6
[15:32:22.610]  - Number of values expected: 6
[15:32:22.610] Reducing values from 1 chunks ... DONE
[15:32:22.611] future_lapply() ... DONE
List of 2
 $ y0: num [1:15, 1:6] 2 2 2 4 4 4 6 6 6 8 ...
  ..- attr(*, "dimnames")=List of 2
  .. ..$ : NULL
  .. ..$ : chr [1:6] "a1" "a2" "b1" "b2" ...
 $ y1: num [1:15, 1:6] 2 2 2 4 4 4 6 6 6 8 ...
  ..- attr(*, "dimnames")=List of 2
  .. ..$ : NULL
  .. ..$ : chr [1:6] "a1" "a2" "b1" "b2" ...
[15:32:22.617] future_lapply() ...
[15:32:22.618] Number of chunks: 1
[15:32:22.619] getGlobalsAndPackagesXApply() ...
[15:32:22.619]  - future.globals: TRUE
[15:32:22.619] getGlobalsAndPackages() ...
[15:32:22.619] Searching for globals...
[15:32:22.622] - globals found: [1] 'FUN'
[15:32:22.622] Searching for globals ... DONE
[15:32:22.622] Resolving globals: FALSE
[15:32:22.623] The total size of the 1 globals is 848 bytes (848 bytes)
[15:32:22.624] The total size of the 1 globals exported for future expression ('FUN()') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:32:22.624] - globals: [1] 'FUN'
[15:32:22.624] 
[15:32:22.625] getGlobalsAndPackages() ... DONE
[15:32:22.625]  - globals found/used: [n=1] 'FUN'
[15:32:22.625]  - needed namespaces: [n=0] 
[15:32:22.625] Finding globals ... DONE
[15:32:22.626]  - use_args: TRUE
[15:32:22.626]  - Getting '...' globals ...
[15:32:22.627] resolve() on list ...
[15:32:22.627]  recursive: 0
[15:32:22.627]  length: 1
[15:32:22.628]  elements: '...'
[15:32:22.628]  length: 0 (resolved future 1)
[15:32:22.628] resolve() on list ... DONE
[15:32:22.629]    - '...' content: [n=0] 
[15:32:22.629] List of 1
[15:32:22.629]  $ ...: list()
[15:32:22.629]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:22.629]  - attr(*, "where")=List of 1
[15:32:22.629]   ..$ ...:<environment: 0x00000276e071b140> 
[15:32:22.629]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:22.629]  - attr(*, "resolved")= logi TRUE
[15:32:22.629]  - attr(*, "total_size")= num NA
[15:32:22.634]  - Getting '...' globals ... DONE
[15:32:22.635] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:22.635] List of 2
[15:32:22.635]  $ ...future.FUN:function (x)  
[15:32:22.635]  $ ...          : list()
[15:32:22.635]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:22.635]  - attr(*, "where")=List of 2
[15:32:22.635]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:22.635]   ..$ ...          :<environment: 0x00000276e071b140> 
[15:32:22.635]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:22.635]  - attr(*, "resolved")= logi FALSE
[15:32:22.635]  - attr(*, "total_size")= num 848
[15:32:22.641] Packages to be attached in all futures: [n=0] 
[15:32:22.641] getGlobalsAndPackagesXApply() ... DONE
[15:32:22.642] Number of futures (= number of chunks): 1
[15:32:22.642] Launching 1 futures (chunks) ...
[15:32:22.642] Chunk #1 of 1 ...
[15:32:22.643]  - Finding globals in 'X' for chunk #1 ...
[15:32:22.643] getGlobalsAndPackages() ...
[15:32:22.643] Searching for globals...
[15:32:22.644] 
[15:32:22.648] Searching for globals ... DONE
[15:32:22.648] - globals: [0] <none>
[15:32:22.648] getGlobalsAndPackages() ... DONE
[15:32:22.649]    + additional globals found: [n=0] 
[15:32:22.649]    + additional namespaces needed: [n=0] 
[15:32:22.649]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:22.650]  - seeds: <none>
[15:32:22.650]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:22.650] getGlobalsAndPackages() ...
[15:32:22.651] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:22.651] Resolving globals: FALSE
[15:32:22.651] Tweak future expression to call with '...' arguments ...
[15:32:22.652] {
[15:32:22.652]     do.call(function(...) {
[15:32:22.652]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:22.652]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:22.652]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:22.652]             on.exit(options(oopts), add = TRUE)
[15:32:22.652]         }
[15:32:22.652]         {
[15:32:22.652]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:22.652]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:22.652]                 ...future.FUN(...future.X_jj, ...)
[15:32:22.652]             })
[15:32:22.652]         }
[15:32:22.652]     }, args = future.call.arguments)
[15:32:22.652] }
[15:32:22.653] Tweak future expression to call with '...' arguments ... DONE
[15:32:22.654] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:22.654] 
[15:32:22.654] getGlobalsAndPackages() ... DONE
[15:32:22.655] run() for 'Future' ...
[15:32:22.655] - state: 'created'
[15:32:22.656] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:22.657] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:22.657] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:22.657]   - Field: 'label'
[15:32:22.658]   - Field: 'local'
[15:32:22.658]   - Field: 'owner'
[15:32:22.658]   - Field: 'envir'
[15:32:22.659]   - Field: 'packages'
[15:32:22.659]   - Field: 'gc'
[15:32:22.659]   - Field: 'conditions'
[15:32:22.660]   - Field: 'expr'
[15:32:22.660]   - Field: 'uuid'
[15:32:22.660]   - Field: 'seed'
[15:32:22.661]   - Field: 'version'
[15:32:22.661]   - Field: 'result'
[15:32:22.662]   - Field: 'asynchronous'
[15:32:22.662]   - Field: 'calls'
[15:32:22.662]   - Field: 'globals'
[15:32:22.663]   - Field: 'stdout'
[15:32:22.663]   - Field: 'earlySignal'
[15:32:22.663]   - Field: 'lazy'
[15:32:22.664]   - Field: 'state'
[15:32:22.664] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:22.664] - Launch lazy future ...
[15:32:22.665] Packages needed by the future expression (n = 0): <none>
[15:32:22.665] Packages needed by future strategies (n = 0): <none>
[15:32:22.666] {
[15:32:22.666]     {
[15:32:22.666]         {
[15:32:22.666]             ...future.startTime <- base::Sys.time()
[15:32:22.666]             {
[15:32:22.666]                 {
[15:32:22.666]                   {
[15:32:22.666]                     base::local({
[15:32:22.666]                       has_future <- base::requireNamespace("future", 
[15:32:22.666]                         quietly = TRUE)
[15:32:22.666]                       if (has_future) {
[15:32:22.666]                         ns <- base::getNamespace("future")
[15:32:22.666]                         version <- ns[[".package"]][["version"]]
[15:32:22.666]                         if (is.null(version)) 
[15:32:22.666]                           version <- utils::packageVersion("future")
[15:32:22.666]                       }
[15:32:22.666]                       else {
[15:32:22.666]                         version <- NULL
[15:32:22.666]                       }
[15:32:22.666]                       if (!has_future || version < "1.8.0") {
[15:32:22.666]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:22.666]                           "", base::R.version$version.string), 
[15:32:22.666]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:22.666]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:22.666]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:22.666]                             "release", "version")], collapse = " "), 
[15:32:22.666]                           hostname = base::Sys.info()[["nodename"]])
[15:32:22.666]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:22.666]                           info)
[15:32:22.666]                         info <- base::paste(info, collapse = "; ")
[15:32:22.666]                         if (!has_future) {
[15:32:22.666]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:22.666]                             info)
[15:32:22.666]                         }
[15:32:22.666]                         else {
[15:32:22.666]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:22.666]                             info, version)
[15:32:22.666]                         }
[15:32:22.666]                         base::stop(msg)
[15:32:22.666]                       }
[15:32:22.666]                     })
[15:32:22.666]                   }
[15:32:22.666]                   ...future.strategy.old <- future::plan("list")
[15:32:22.666]                   options(future.plan = NULL)
[15:32:22.666]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:22.666]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:22.666]                 }
[15:32:22.666]                 ...future.workdir <- getwd()
[15:32:22.666]             }
[15:32:22.666]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:22.666]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:22.666]         }
[15:32:22.666]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:22.666]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:22.666]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:22.666]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:22.666]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:22.666]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:22.666]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:22.666]             base::names(...future.oldOptions))
[15:32:22.666]     }
[15:32:22.666]     if (FALSE) {
[15:32:22.666]     }
[15:32:22.666]     else {
[15:32:22.666]         if (TRUE) {
[15:32:22.666]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:22.666]                 open = "w")
[15:32:22.666]         }
[15:32:22.666]         else {
[15:32:22.666]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:22.666]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:22.666]         }
[15:32:22.666]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:22.666]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:22.666]             base::sink(type = "output", split = FALSE)
[15:32:22.666]             base::close(...future.stdout)
[15:32:22.666]         }, add = TRUE)
[15:32:22.666]     }
[15:32:22.666]     ...future.frame <- base::sys.nframe()
[15:32:22.666]     ...future.conditions <- base::list()
[15:32:22.666]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:22.666]     if (FALSE) {
[15:32:22.666]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:22.666]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:22.666]     }
[15:32:22.666]     ...future.result <- base::tryCatch({
[15:32:22.666]         base::withCallingHandlers({
[15:32:22.666]             ...future.value <- base::withVisible(base::local({
[15:32:22.666]                 do.call(function(...) {
[15:32:22.666]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:22.666]                   if (!identical(...future.globals.maxSize.org, 
[15:32:22.666]                     ...future.globals.maxSize)) {
[15:32:22.666]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:22.666]                     on.exit(options(oopts), add = TRUE)
[15:32:22.666]                   }
[15:32:22.666]                   {
[15:32:22.666]                     lapply(seq_along(...future.elements_ii), 
[15:32:22.666]                       FUN = function(jj) {
[15:32:22.666]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:22.666]                         ...future.FUN(...future.X_jj, ...)
[15:32:22.666]                       })
[15:32:22.666]                   }
[15:32:22.666]                 }, args = future.call.arguments)
[15:32:22.666]             }))
[15:32:22.666]             future::FutureResult(value = ...future.value$value, 
[15:32:22.666]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:22.666]                   ...future.rng), globalenv = if (FALSE) 
[15:32:22.666]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:22.666]                     ...future.globalenv.names))
[15:32:22.666]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:22.666]         }, condition = base::local({
[15:32:22.666]             c <- base::c
[15:32:22.666]             inherits <- base::inherits
[15:32:22.666]             invokeRestart <- base::invokeRestart
[15:32:22.666]             length <- base::length
[15:32:22.666]             list <- base::list
[15:32:22.666]             seq.int <- base::seq.int
[15:32:22.666]             signalCondition <- base::signalCondition
[15:32:22.666]             sys.calls <- base::sys.calls
[15:32:22.666]             `[[` <- base::`[[`
[15:32:22.666]             `+` <- base::`+`
[15:32:22.666]             `<<-` <- base::`<<-`
[15:32:22.666]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:22.666]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:22.666]                   3L)]
[15:32:22.666]             }
[15:32:22.666]             function(cond) {
[15:32:22.666]                 is_error <- inherits(cond, "error")
[15:32:22.666]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:22.666]                   NULL)
[15:32:22.666]                 if (is_error) {
[15:32:22.666]                   sessionInformation <- function() {
[15:32:22.666]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:22.666]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:22.666]                       search = base::search(), system = base::Sys.info())
[15:32:22.666]                   }
[15:32:22.666]                   ...future.conditions[[length(...future.conditions) + 
[15:32:22.666]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:22.666]                     cond$call), session = sessionInformation(), 
[15:32:22.666]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:22.666]                   signalCondition(cond)
[15:32:22.666]                 }
[15:32:22.666]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:22.666]                 "immediateCondition"))) {
[15:32:22.666]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:22.666]                   ...future.conditions[[length(...future.conditions) + 
[15:32:22.666]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:22.666]                   if (TRUE && !signal) {
[15:32:22.666]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:22.666]                     {
[15:32:22.666]                       inherits <- base::inherits
[15:32:22.666]                       invokeRestart <- base::invokeRestart
[15:32:22.666]                       is.null <- base::is.null
[15:32:22.666]                       muffled <- FALSE
[15:32:22.666]                       if (inherits(cond, "message")) {
[15:32:22.666]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:22.666]                         if (muffled) 
[15:32:22.666]                           invokeRestart("muffleMessage")
[15:32:22.666]                       }
[15:32:22.666]                       else if (inherits(cond, "warning")) {
[15:32:22.666]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:22.666]                         if (muffled) 
[15:32:22.666]                           invokeRestart("muffleWarning")
[15:32:22.666]                       }
[15:32:22.666]                       else if (inherits(cond, "condition")) {
[15:32:22.666]                         if (!is.null(pattern)) {
[15:32:22.666]                           computeRestarts <- base::computeRestarts
[15:32:22.666]                           grepl <- base::grepl
[15:32:22.666]                           restarts <- computeRestarts(cond)
[15:32:22.666]                           for (restart in restarts) {
[15:32:22.666]                             name <- restart$name
[15:32:22.666]                             if (is.null(name)) 
[15:32:22.666]                               next
[15:32:22.666]                             if (!grepl(pattern, name)) 
[15:32:22.666]                               next
[15:32:22.666]                             invokeRestart(restart)
[15:32:22.666]                             muffled <- TRUE
[15:32:22.666]                             break
[15:32:22.666]                           }
[15:32:22.666]                         }
[15:32:22.666]                       }
[15:32:22.666]                       invisible(muffled)
[15:32:22.666]                     }
[15:32:22.666]                     muffleCondition(cond, pattern = "^muffle")
[15:32:22.666]                   }
[15:32:22.666]                 }
[15:32:22.666]                 else {
[15:32:22.666]                   if (TRUE) {
[15:32:22.666]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:22.666]                     {
[15:32:22.666]                       inherits <- base::inherits
[15:32:22.666]                       invokeRestart <- base::invokeRestart
[15:32:22.666]                       is.null <- base::is.null
[15:32:22.666]                       muffled <- FALSE
[15:32:22.666]                       if (inherits(cond, "message")) {
[15:32:22.666]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:22.666]                         if (muffled) 
[15:32:22.666]                           invokeRestart("muffleMessage")
[15:32:22.666]                       }
[15:32:22.666]                       else if (inherits(cond, "warning")) {
[15:32:22.666]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:22.666]                         if (muffled) 
[15:32:22.666]                           invokeRestart("muffleWarning")
[15:32:22.666]                       }
[15:32:22.666]                       else if (inherits(cond, "condition")) {
[15:32:22.666]                         if (!is.null(pattern)) {
[15:32:22.666]                           computeRestarts <- base::computeRestarts
[15:32:22.666]                           grepl <- base::grepl
[15:32:22.666]                           restarts <- computeRestarts(cond)
[15:32:22.666]                           for (restart in restarts) {
[15:32:22.666]                             name <- restart$name
[15:32:22.666]                             if (is.null(name)) 
[15:32:22.666]                               next
[15:32:22.666]                             if (!grepl(pattern, name)) 
[15:32:22.666]                               next
[15:32:22.666]                             invokeRestart(restart)
[15:32:22.666]                             muffled <- TRUE
[15:32:22.666]                             break
[15:32:22.666]                           }
[15:32:22.666]                         }
[15:32:22.666]                       }
[15:32:22.666]                       invisible(muffled)
[15:32:22.666]                     }
[15:32:22.666]                     muffleCondition(cond, pattern = "^muffle")
[15:32:22.666]                   }
[15:32:22.666]                 }
[15:32:22.666]             }
[15:32:22.666]         }))
[15:32:22.666]     }, error = function(ex) {
[15:32:22.666]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:22.666]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:22.666]                 ...future.rng), started = ...future.startTime, 
[15:32:22.666]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:22.666]             version = "1.8"), class = "FutureResult")
[15:32:22.666]     }, finally = {
[15:32:22.666]         if (!identical(...future.workdir, getwd())) 
[15:32:22.666]             setwd(...future.workdir)
[15:32:22.666]         {
[15:32:22.666]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:22.666]                 ...future.oldOptions$nwarnings <- NULL
[15:32:22.666]             }
[15:32:22.666]             base::options(...future.oldOptions)
[15:32:22.666]             if (.Platform$OS.type == "windows") {
[15:32:22.666]                 old_names <- names(...future.oldEnvVars)
[15:32:22.666]                 envs <- base::Sys.getenv()
[15:32:22.666]                 names <- names(envs)
[15:32:22.666]                 common <- intersect(names, old_names)
[15:32:22.666]                 added <- setdiff(names, old_names)
[15:32:22.666]                 removed <- setdiff(old_names, names)
[15:32:22.666]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:22.666]                   envs[common]]
[15:32:22.666]                 NAMES <- toupper(changed)
[15:32:22.666]                 args <- list()
[15:32:22.666]                 for (kk in seq_along(NAMES)) {
[15:32:22.666]                   name <- changed[[kk]]
[15:32:22.666]                   NAME <- NAMES[[kk]]
[15:32:22.666]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:22.666]                     next
[15:32:22.666]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:22.666]                 }
[15:32:22.666]                 NAMES <- toupper(added)
[15:32:22.666]                 for (kk in seq_along(NAMES)) {
[15:32:22.666]                   name <- added[[kk]]
[15:32:22.666]                   NAME <- NAMES[[kk]]
[15:32:22.666]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:22.666]                     next
[15:32:22.666]                   args[[name]] <- ""
[15:32:22.666]                 }
[15:32:22.666]                 NAMES <- toupper(removed)
[15:32:22.666]                 for (kk in seq_along(NAMES)) {
[15:32:22.666]                   name <- removed[[kk]]
[15:32:22.666]                   NAME <- NAMES[[kk]]
[15:32:22.666]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:22.666]                     next
[15:32:22.666]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:22.666]                 }
[15:32:22.666]                 if (length(args) > 0) 
[15:32:22.666]                   base::do.call(base::Sys.setenv, args = args)
[15:32:22.666]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:22.666]             }
[15:32:22.666]             else {
[15:32:22.666]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:22.666]             }
[15:32:22.666]             {
[15:32:22.666]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:22.666]                   0L) {
[15:32:22.666]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:22.666]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:22.666]                   base::options(opts)
[15:32:22.666]                 }
[15:32:22.666]                 {
[15:32:22.666]                   {
[15:32:22.666]                     NULL
[15:32:22.666]                     RNGkind("Mersenne-Twister")
[15:32:22.666]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:22.666]                       inherits = FALSE)
[15:32:22.666]                   }
[15:32:22.666]                   options(future.plan = NULL)
[15:32:22.666]                   if (is.na(NA_character_)) 
[15:32:22.666]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:22.666]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:22.666]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:22.666]                     .init = FALSE)
[15:32:22.666]                 }
[15:32:22.666]             }
[15:32:22.666]         }
[15:32:22.666]     })
[15:32:22.666]     if (TRUE) {
[15:32:22.666]         base::sink(type = "output", split = FALSE)
[15:32:22.666]         if (TRUE) {
[15:32:22.666]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:22.666]         }
[15:32:22.666]         else {
[15:32:22.666]             ...future.result["stdout"] <- base::list(NULL)
[15:32:22.666]         }
[15:32:22.666]         base::close(...future.stdout)
[15:32:22.666]         ...future.stdout <- NULL
[15:32:22.666]     }
[15:32:22.666]     ...future.result$conditions <- ...future.conditions
[15:32:22.666]     ...future.result$finished <- base::Sys.time()
[15:32:22.666]     ...future.result
[15:32:22.666] }
[15:32:22.673] assign_globals() ...
[15:32:22.673] List of 5
[15:32:22.673]  $ ...future.FUN            :function (x)  
[15:32:22.673]  $ future.call.arguments    : list()
[15:32:22.673]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:22.673]  $ ...future.elements_ii    :List of 6
[15:32:22.673]   ..$ a1: int 1
[15:32:22.673]   ..$ a2: int 2
[15:32:22.673]   ..$ b1: int 2
[15:32:22.673]   ..$ b2: int 3
[15:32:22.673]   ..$ c1: int 3
[15:32:22.673]   ..$ c2: int 4
[15:32:22.673]  $ ...future.seeds_ii       : NULL
[15:32:22.673]  $ ...future.globals.maxSize: NULL
[15:32:22.673]  - attr(*, "where")=List of 5
[15:32:22.673]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:22.673]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:22.673]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:22.673]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:22.673]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:22.673]  - attr(*, "resolved")= logi FALSE
[15:32:22.673]  - attr(*, "total_size")= num 848
[15:32:22.673]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:22.673]  - attr(*, "already-done")= logi TRUE
[15:32:22.687] - copied '...future.FUN' to environment
[15:32:22.687] - copied 'future.call.arguments' to environment
[15:32:22.687] - copied '...future.elements_ii' to environment
[15:32:22.688] - copied '...future.seeds_ii' to environment
[15:32:22.688] - copied '...future.globals.maxSize' to environment
[15:32:22.688] assign_globals() ... done
[15:32:22.689] plan(): Setting new future strategy stack:
[15:32:22.689] List of future strategies:
[15:32:22.689] 1. sequential:
[15:32:22.689]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:22.689]    - tweaked: FALSE
[15:32:22.689]    - call: NULL
[15:32:22.690] plan(): nbrOfWorkers() = 1
[15:32:22.693] plan(): Setting new future strategy stack:
[15:32:22.693] List of future strategies:
[15:32:22.693] 1. sequential:
[15:32:22.693]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:22.693]    - tweaked: FALSE
[15:32:22.693]    - call: plan(strategy)
[15:32:22.694] plan(): nbrOfWorkers() = 1
[15:32:22.695] SequentialFuture started (and completed)
[15:32:22.695] - Launch lazy future ... done
[15:32:22.695] run() for 'SequentialFuture' ... done
[15:32:22.696] Created future:
[15:32:22.696] SequentialFuture:
[15:32:22.696] Label: 'future_sapply-1'
[15:32:22.696] Expression:
[15:32:22.696] {
[15:32:22.696]     do.call(function(...) {
[15:32:22.696]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:22.696]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:22.696]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:22.696]             on.exit(options(oopts), add = TRUE)
[15:32:22.696]         }
[15:32:22.696]         {
[15:32:22.696]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:22.696]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:22.696]                 ...future.FUN(...future.X_jj, ...)
[15:32:22.696]             })
[15:32:22.696]         }
[15:32:22.696]     }, args = future.call.arguments)
[15:32:22.696] }
[15:32:22.696] Lazy evaluation: FALSE
[15:32:22.696] Asynchronous evaluation: FALSE
[15:32:22.696] Local evaluation: TRUE
[15:32:22.696] Environment: R_GlobalEnv
[15:32:22.696] Capture standard output: TRUE
[15:32:22.696] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:22.696] Globals: 5 objects totaling 1.16 KiB (function '...future.FUN' of 848 bytes, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 336 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:22.696] Packages: <none>
[15:32:22.696] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:22.696] Resolved: TRUE
[15:32:22.696] Value: 336 bytes of class 'list'
[15:32:22.696] Early signaling: FALSE
[15:32:22.696] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:22.696] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:22.702] Chunk #1 of 1 ... DONE
[15:32:22.702] Launching 1 futures (chunks) ... DONE
[15:32:22.703] Resolving 1 futures (chunks) ...
[15:32:22.703] resolve() on list ...
[15:32:22.703]  recursive: 0
[15:32:22.704]  length: 1
[15:32:22.704] 
[15:32:22.704] resolved() for 'SequentialFuture' ...
[15:32:22.705] - state: 'finished'
[15:32:22.705] - run: TRUE
[15:32:22.705] - result: 'FutureResult'
[15:32:22.706] resolved() for 'SequentialFuture' ... done
[15:32:22.706] Future #1
[15:32:22.707] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:22.707] - nx: 1
[15:32:22.707] - relay: TRUE
[15:32:22.708] - stdout: TRUE
[15:32:22.708] - signal: TRUE
[15:32:22.708] - resignal: FALSE
[15:32:22.708] - force: TRUE
[15:32:22.709] - relayed: [n=1] FALSE
[15:32:22.709] - queued futures: [n=1] FALSE
[15:32:22.709]  - until=1
[15:32:22.710]  - relaying element #1
[15:32:22.710] - relayed: [n=1] TRUE
[15:32:22.711] - queued futures: [n=1] TRUE
[15:32:22.711] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:22.711]  length: 0 (resolved future 1)
[15:32:22.712] Relaying remaining futures
[15:32:22.712] signalConditionsASAP(NULL, pos=0) ...
[15:32:22.712] - nx: 1
[15:32:22.712] - relay: TRUE
[15:32:22.713] - stdout: TRUE
[15:32:22.713] - signal: TRUE
[15:32:22.713] - resignal: FALSE
[15:32:22.714] - force: TRUE
[15:32:22.714] - relayed: [n=1] TRUE
[15:32:22.714] - queued futures: [n=1] TRUE
 - flush all
[15:32:22.715] - relayed: [n=1] TRUE
[15:32:22.715] - queued futures: [n=1] TRUE
[15:32:22.715] signalConditionsASAP(NULL, pos=0) ... done
[15:32:22.716] resolve() on list ... DONE
[15:32:22.716]  - Number of value chunks collected: 1
[15:32:22.716] Resolving 1 futures (chunks) ... DONE
[15:32:22.717] Reducing values from 1 chunks ...
[15:32:22.717]  - Number of values collected after concatenation: 6
[15:32:22.717]  - Number of values expected: 6
[15:32:22.718] Reducing values from 1 chunks ... DONE
[15:32:22.718] future_lapply() ... DONE
List of 2
 $ y0: Named int [1:6] 1 2 2 3 3 4
  ..- attr(*, "names")= chr [1:6] "a1" "a2" "b1" "b2" ...
 $ y1: Named int [1:6] 1 2 2 3 3 4
  ..- attr(*, "names")= chr [1:6] "a1" "a2" "b1" "b2" ...
[15:32:22.722] future_lapply() ...
[15:32:22.723] Number of chunks: 1
[15:32:22.723] getGlobalsAndPackagesXApply() ...
[15:32:22.724]  - future.globals: TRUE
[15:32:22.724] getGlobalsAndPackages() ...
[15:32:22.724] Searching for globals...
[15:32:22.727] - globals found: [2] 'FUN', 'UseMethod'
[15:32:22.727] Searching for globals ... DONE
[15:32:22.727] Resolving globals: FALSE
[15:32:22.728] The total size of the 1 globals is 1.22 KiB (1248 bytes)
[15:32:22.729] The total size of the 1 globals exported for future expression ('FUN()') is 1.22 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.22 KiB of class 'function')
[15:32:22.729] - globals: [1] 'FUN'
[15:32:22.730] 
[15:32:22.730] getGlobalsAndPackages() ... DONE
[15:32:22.730]  - globals found/used: [n=1] 'FUN'
[15:32:22.730]  - needed namespaces: [n=0] 
[15:32:22.731] Finding globals ... DONE
[15:32:22.731]  - use_args: TRUE
[15:32:22.731]  - Getting '...' globals ...
[15:32:22.732] resolve() on list ...
[15:32:22.732]  recursive: 0
[15:32:22.733]  length: 1
[15:32:22.733]  elements: '...'
[15:32:22.733]  length: 0 (resolved future 1)
[15:32:22.734] resolve() on list ... DONE
[15:32:22.734]    - '...' content: [n=0] 
[15:32:22.734] List of 1
[15:32:22.734]  $ ...: list()
[15:32:22.734]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:22.734]  - attr(*, "where")=List of 1
[15:32:22.734]   ..$ ...:<environment: 0x00000276defb5b18> 
[15:32:22.734]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:22.734]  - attr(*, "resolved")= logi TRUE
[15:32:22.734]  - attr(*, "total_size")= num NA
[15:32:22.740]  - Getting '...' globals ... DONE
[15:32:22.740] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:22.741] List of 2
[15:32:22.741]  $ ...future.FUN:function (x, ...)  
[15:32:22.741]  $ ...          : list()
[15:32:22.741]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:22.741]  - attr(*, "where")=List of 2
[15:32:22.741]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:22.741]   ..$ ...          :<environment: 0x00000276defb5b18> 
[15:32:22.741]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:22.741]  - attr(*, "resolved")= logi FALSE
[15:32:22.741]  - attr(*, "total_size")= num 1248
[15:32:22.750] Packages to be attached in all futures: [n=0] 
[15:32:22.750] getGlobalsAndPackagesXApply() ... DONE
[15:32:22.751] Number of futures (= number of chunks): 1
[15:32:22.751] Launching 1 futures (chunks) ...
[15:32:22.751] Chunk #1 of 1 ...
[15:32:22.752]  - Finding globals in 'X' for chunk #1 ...
[15:32:22.752] getGlobalsAndPackages() ...
[15:32:22.752] Searching for globals...
[15:32:22.753] 
[15:32:22.753] Searching for globals ... DONE
[15:32:22.753] - globals: [0] <none>
[15:32:22.754] getGlobalsAndPackages() ... DONE
[15:32:22.754]    + additional globals found: [n=0] 
[15:32:22.754]    + additional namespaces needed: [n=0] 
[15:32:22.755]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:22.755]  - seeds: <none>
[15:32:22.755]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:22.756] getGlobalsAndPackages() ...
[15:32:22.756] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:22.756] Resolving globals: FALSE
[15:32:22.756] Tweak future expression to call with '...' arguments ...
[15:32:22.757] {
[15:32:22.757]     do.call(function(...) {
[15:32:22.757]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:22.757]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:22.757]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:22.757]             on.exit(options(oopts), add = TRUE)
[15:32:22.757]         }
[15:32:22.757]         {
[15:32:22.757]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:22.757]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:22.757]                 ...future.FUN(...future.X_jj, ...)
[15:32:22.757]             })
[15:32:22.757]         }
[15:32:22.757]     }, args = future.call.arguments)
[15:32:22.757] }
[15:32:22.758] Tweak future expression to call with '...' arguments ... DONE
[15:32:22.758] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:22.759] 
[15:32:22.759] getGlobalsAndPackages() ... DONE
[15:32:22.760] run() for 'Future' ...
[15:32:22.760] - state: 'created'
[15:32:22.760] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:22.761] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:22.761] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:22.762]   - Field: 'label'
[15:32:22.762]   - Field: 'local'
[15:32:22.762]   - Field: 'owner'
[15:32:22.763]   - Field: 'envir'
[15:32:22.763]   - Field: 'packages'
[15:32:22.763]   - Field: 'gc'
[15:32:22.763]   - Field: 'conditions'
[15:32:22.764]   - Field: 'expr'
[15:32:22.764]   - Field: 'uuid'
[15:32:22.764]   - Field: 'seed'
[15:32:22.765]   - Field: 'version'
[15:32:22.765]   - Field: 'result'
[15:32:22.765]   - Field: 'asynchronous'
[15:32:22.765]   - Field: 'calls'
[15:32:22.766]   - Field: 'globals'
[15:32:22.766]   - Field: 'stdout'
[15:32:22.766]   - Field: 'earlySignal'
[15:32:22.766]   - Field: 'lazy'
[15:32:22.767]   - Field: 'state'
[15:32:22.767] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:22.767] - Launch lazy future ...
[15:32:22.768] Packages needed by the future expression (n = 0): <none>
[15:32:22.768] Packages needed by future strategies (n = 0): <none>
[15:32:22.769] {
[15:32:22.769]     {
[15:32:22.769]         {
[15:32:22.769]             ...future.startTime <- base::Sys.time()
[15:32:22.769]             {
[15:32:22.769]                 {
[15:32:22.769]                   {
[15:32:22.769]                     base::local({
[15:32:22.769]                       has_future <- base::requireNamespace("future", 
[15:32:22.769]                         quietly = TRUE)
[15:32:22.769]                       if (has_future) {
[15:32:22.769]                         ns <- base::getNamespace("future")
[15:32:22.769]                         version <- ns[[".package"]][["version"]]
[15:32:22.769]                         if (is.null(version)) 
[15:32:22.769]                           version <- utils::packageVersion("future")
[15:32:22.769]                       }
[15:32:22.769]                       else {
[15:32:22.769]                         version <- NULL
[15:32:22.769]                       }
[15:32:22.769]                       if (!has_future || version < "1.8.0") {
[15:32:22.769]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:22.769]                           "", base::R.version$version.string), 
[15:32:22.769]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:22.769]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:22.769]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:22.769]                             "release", "version")], collapse = " "), 
[15:32:22.769]                           hostname = base::Sys.info()[["nodename"]])
[15:32:22.769]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:22.769]                           info)
[15:32:22.769]                         info <- base::paste(info, collapse = "; ")
[15:32:22.769]                         if (!has_future) {
[15:32:22.769]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:22.769]                             info)
[15:32:22.769]                         }
[15:32:22.769]                         else {
[15:32:22.769]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:22.769]                             info, version)
[15:32:22.769]                         }
[15:32:22.769]                         base::stop(msg)
[15:32:22.769]                       }
[15:32:22.769]                     })
[15:32:22.769]                   }
[15:32:22.769]                   ...future.strategy.old <- future::plan("list")
[15:32:22.769]                   options(future.plan = NULL)
[15:32:22.769]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:22.769]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:22.769]                 }
[15:32:22.769]                 ...future.workdir <- getwd()
[15:32:22.769]             }
[15:32:22.769]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:22.769]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:22.769]         }
[15:32:22.769]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:22.769]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:22.769]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:22.769]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:22.769]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:22.769]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:22.769]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:22.769]             base::names(...future.oldOptions))
[15:32:22.769]     }
[15:32:22.769]     if (FALSE) {
[15:32:22.769]     }
[15:32:22.769]     else {
[15:32:22.769]         if (TRUE) {
[15:32:22.769]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:22.769]                 open = "w")
[15:32:22.769]         }
[15:32:22.769]         else {
[15:32:22.769]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:22.769]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:22.769]         }
[15:32:22.769]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:22.769]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:22.769]             base::sink(type = "output", split = FALSE)
[15:32:22.769]             base::close(...future.stdout)
[15:32:22.769]         }, add = TRUE)
[15:32:22.769]     }
[15:32:22.769]     ...future.frame <- base::sys.nframe()
[15:32:22.769]     ...future.conditions <- base::list()
[15:32:22.769]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:22.769]     if (FALSE) {
[15:32:22.769]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:22.769]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:22.769]     }
[15:32:22.769]     ...future.result <- base::tryCatch({
[15:32:22.769]         base::withCallingHandlers({
[15:32:22.769]             ...future.value <- base::withVisible(base::local({
[15:32:22.769]                 do.call(function(...) {
[15:32:22.769]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:22.769]                   if (!identical(...future.globals.maxSize.org, 
[15:32:22.769]                     ...future.globals.maxSize)) {
[15:32:22.769]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:22.769]                     on.exit(options(oopts), add = TRUE)
[15:32:22.769]                   }
[15:32:22.769]                   {
[15:32:22.769]                     lapply(seq_along(...future.elements_ii), 
[15:32:22.769]                       FUN = function(jj) {
[15:32:22.769]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:22.769]                         ...future.FUN(...future.X_jj, ...)
[15:32:22.769]                       })
[15:32:22.769]                   }
[15:32:22.769]                 }, args = future.call.arguments)
[15:32:22.769]             }))
[15:32:22.769]             future::FutureResult(value = ...future.value$value, 
[15:32:22.769]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:22.769]                   ...future.rng), globalenv = if (FALSE) 
[15:32:22.769]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:22.769]                     ...future.globalenv.names))
[15:32:22.769]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:22.769]         }, condition = base::local({
[15:32:22.769]             c <- base::c
[15:32:22.769]             inherits <- base::inherits
[15:32:22.769]             invokeRestart <- base::invokeRestart
[15:32:22.769]             length <- base::length
[15:32:22.769]             list <- base::list
[15:32:22.769]             seq.int <- base::seq.int
[15:32:22.769]             signalCondition <- base::signalCondition
[15:32:22.769]             sys.calls <- base::sys.calls
[15:32:22.769]             `[[` <- base::`[[`
[15:32:22.769]             `+` <- base::`+`
[15:32:22.769]             `<<-` <- base::`<<-`
[15:32:22.769]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:22.769]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:22.769]                   3L)]
[15:32:22.769]             }
[15:32:22.769]             function(cond) {
[15:32:22.769]                 is_error <- inherits(cond, "error")
[15:32:22.769]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:22.769]                   NULL)
[15:32:22.769]                 if (is_error) {
[15:32:22.769]                   sessionInformation <- function() {
[15:32:22.769]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:22.769]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:22.769]                       search = base::search(), system = base::Sys.info())
[15:32:22.769]                   }
[15:32:22.769]                   ...future.conditions[[length(...future.conditions) + 
[15:32:22.769]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:22.769]                     cond$call), session = sessionInformation(), 
[15:32:22.769]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:22.769]                   signalCondition(cond)
[15:32:22.769]                 }
[15:32:22.769]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:22.769]                 "immediateCondition"))) {
[15:32:22.769]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:22.769]                   ...future.conditions[[length(...future.conditions) + 
[15:32:22.769]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:22.769]                   if (TRUE && !signal) {
[15:32:22.769]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:22.769]                     {
[15:32:22.769]                       inherits <- base::inherits
[15:32:22.769]                       invokeRestart <- base::invokeRestart
[15:32:22.769]                       is.null <- base::is.null
[15:32:22.769]                       muffled <- FALSE
[15:32:22.769]                       if (inherits(cond, "message")) {
[15:32:22.769]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:22.769]                         if (muffled) 
[15:32:22.769]                           invokeRestart("muffleMessage")
[15:32:22.769]                       }
[15:32:22.769]                       else if (inherits(cond, "warning")) {
[15:32:22.769]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:22.769]                         if (muffled) 
[15:32:22.769]                           invokeRestart("muffleWarning")
[15:32:22.769]                       }
[15:32:22.769]                       else if (inherits(cond, "condition")) {
[15:32:22.769]                         if (!is.null(pattern)) {
[15:32:22.769]                           computeRestarts <- base::computeRestarts
[15:32:22.769]                           grepl <- base::grepl
[15:32:22.769]                           restarts <- computeRestarts(cond)
[15:32:22.769]                           for (restart in restarts) {
[15:32:22.769]                             name <- restart$name
[15:32:22.769]                             if (is.null(name)) 
[15:32:22.769]                               next
[15:32:22.769]                             if (!grepl(pattern, name)) 
[15:32:22.769]                               next
[15:32:22.769]                             invokeRestart(restart)
[15:32:22.769]                             muffled <- TRUE
[15:32:22.769]                             break
[15:32:22.769]                           }
[15:32:22.769]                         }
[15:32:22.769]                       }
[15:32:22.769]                       invisible(muffled)
[15:32:22.769]                     }
[15:32:22.769]                     muffleCondition(cond, pattern = "^muffle")
[15:32:22.769]                   }
[15:32:22.769]                 }
[15:32:22.769]                 else {
[15:32:22.769]                   if (TRUE) {
[15:32:22.769]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:22.769]                     {
[15:32:22.769]                       inherits <- base::inherits
[15:32:22.769]                       invokeRestart <- base::invokeRestart
[15:32:22.769]                       is.null <- base::is.null
[15:32:22.769]                       muffled <- FALSE
[15:32:22.769]                       if (inherits(cond, "message")) {
[15:32:22.769]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:22.769]                         if (muffled) 
[15:32:22.769]                           invokeRestart("muffleMessage")
[15:32:22.769]                       }
[15:32:22.769]                       else if (inherits(cond, "warning")) {
[15:32:22.769]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:22.769]                         if (muffled) 
[15:32:22.769]                           invokeRestart("muffleWarning")
[15:32:22.769]                       }
[15:32:22.769]                       else if (inherits(cond, "condition")) {
[15:32:22.769]                         if (!is.null(pattern)) {
[15:32:22.769]                           computeRestarts <- base::computeRestarts
[15:32:22.769]                           grepl <- base::grepl
[15:32:22.769]                           restarts <- computeRestarts(cond)
[15:32:22.769]                           for (restart in restarts) {
[15:32:22.769]                             name <- restart$name
[15:32:22.769]                             if (is.null(name)) 
[15:32:22.769]                               next
[15:32:22.769]                             if (!grepl(pattern, name)) 
[15:32:22.769]                               next
[15:32:22.769]                             invokeRestart(restart)
[15:32:22.769]                             muffled <- TRUE
[15:32:22.769]                             break
[15:32:22.769]                           }
[15:32:22.769]                         }
[15:32:22.769]                       }
[15:32:22.769]                       invisible(muffled)
[15:32:22.769]                     }
[15:32:22.769]                     muffleCondition(cond, pattern = "^muffle")
[15:32:22.769]                   }
[15:32:22.769]                 }
[15:32:22.769]             }
[15:32:22.769]         }))
[15:32:22.769]     }, error = function(ex) {
[15:32:22.769]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:22.769]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:22.769]                 ...future.rng), started = ...future.startTime, 
[15:32:22.769]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:22.769]             version = "1.8"), class = "FutureResult")
[15:32:22.769]     }, finally = {
[15:32:22.769]         if (!identical(...future.workdir, getwd())) 
[15:32:22.769]             setwd(...future.workdir)
[15:32:22.769]         {
[15:32:22.769]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:22.769]                 ...future.oldOptions$nwarnings <- NULL
[15:32:22.769]             }
[15:32:22.769]             base::options(...future.oldOptions)
[15:32:22.769]             if (.Platform$OS.type == "windows") {
[15:32:22.769]                 old_names <- names(...future.oldEnvVars)
[15:32:22.769]                 envs <- base::Sys.getenv()
[15:32:22.769]                 names <- names(envs)
[15:32:22.769]                 common <- intersect(names, old_names)
[15:32:22.769]                 added <- setdiff(names, old_names)
[15:32:22.769]                 removed <- setdiff(old_names, names)
[15:32:22.769]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:22.769]                   envs[common]]
[15:32:22.769]                 NAMES <- toupper(changed)
[15:32:22.769]                 args <- list()
[15:32:22.769]                 for (kk in seq_along(NAMES)) {
[15:32:22.769]                   name <- changed[[kk]]
[15:32:22.769]                   NAME <- NAMES[[kk]]
[15:32:22.769]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:22.769]                     next
[15:32:22.769]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:22.769]                 }
[15:32:22.769]                 NAMES <- toupper(added)
[15:32:22.769]                 for (kk in seq_along(NAMES)) {
[15:32:22.769]                   name <- added[[kk]]
[15:32:22.769]                   NAME <- NAMES[[kk]]
[15:32:22.769]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:22.769]                     next
[15:32:22.769]                   args[[name]] <- ""
[15:32:22.769]                 }
[15:32:22.769]                 NAMES <- toupper(removed)
[15:32:22.769]                 for (kk in seq_along(NAMES)) {
[15:32:22.769]                   name <- removed[[kk]]
[15:32:22.769]                   NAME <- NAMES[[kk]]
[15:32:22.769]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:22.769]                     next
[15:32:22.769]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:22.769]                 }
[15:32:22.769]                 if (length(args) > 0) 
[15:32:22.769]                   base::do.call(base::Sys.setenv, args = args)
[15:32:22.769]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:22.769]             }
[15:32:22.769]             else {
[15:32:22.769]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:22.769]             }
[15:32:22.769]             {
[15:32:22.769]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:22.769]                   0L) {
[15:32:22.769]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:22.769]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:22.769]                   base::options(opts)
[15:32:22.769]                 }
[15:32:22.769]                 {
[15:32:22.769]                   {
[15:32:22.769]                     NULL
[15:32:22.769]                     RNGkind("Mersenne-Twister")
[15:32:22.769]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:22.769]                       inherits = FALSE)
[15:32:22.769]                   }
[15:32:22.769]                   options(future.plan = NULL)
[15:32:22.769]                   if (is.na(NA_character_)) 
[15:32:22.769]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:22.769]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:22.769]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:22.769]                     .init = FALSE)
[15:32:22.769]                 }
[15:32:22.769]             }
[15:32:22.769]         }
[15:32:22.769]     })
[15:32:22.769]     if (TRUE) {
[15:32:22.769]         base::sink(type = "output", split = FALSE)
[15:32:22.769]         if (TRUE) {
[15:32:22.769]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:22.769]         }
[15:32:22.769]         else {
[15:32:22.769]             ...future.result["stdout"] <- base::list(NULL)
[15:32:22.769]         }
[15:32:22.769]         base::close(...future.stdout)
[15:32:22.769]         ...future.stdout <- NULL
[15:32:22.769]     }
[15:32:22.769]     ...future.result$conditions <- ...future.conditions
[15:32:22.769]     ...future.result$finished <- base::Sys.time()
[15:32:22.769]     ...future.result
[15:32:22.769] }
[15:32:22.775] assign_globals() ...
[15:32:22.776] List of 5
[15:32:22.776]  $ ...future.FUN            :function (x, ...)  
[15:32:22.776]  $ future.call.arguments    : list()
[15:32:22.776]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:22.776]  $ ...future.elements_ii    :List of 6
[15:32:22.776]   ..$ a1: int 1
[15:32:22.776]   ..$ a2: int 2
[15:32:22.776]   ..$ b1: int 2
[15:32:22.776]   ..$ b2: int 3
[15:32:22.776]   ..$ c1: int 3
[15:32:22.776]   ..$ c2: int 4
[15:32:22.776]  $ ...future.seeds_ii       : NULL
[15:32:22.776]  $ ...future.globals.maxSize: NULL
[15:32:22.776]  - attr(*, "where")=List of 5
[15:32:22.776]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:22.776]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:22.776]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:22.776]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:22.776]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:22.776]  - attr(*, "resolved")= logi FALSE
[15:32:22.776]  - attr(*, "total_size")= num 1248
[15:32:22.776]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:22.776]  - attr(*, "already-done")= logi TRUE
[15:32:22.787] - copied '...future.FUN' to environment
[15:32:22.788] - copied 'future.call.arguments' to environment
[15:32:22.788] - copied '...future.elements_ii' to environment
[15:32:22.788] - copied '...future.seeds_ii' to environment
[15:32:22.788] - copied '...future.globals.maxSize' to environment
[15:32:22.789] assign_globals() ... done
[15:32:22.789] plan(): Setting new future strategy stack:
[15:32:22.790] List of future strategies:
[15:32:22.790] 1. sequential:
[15:32:22.790]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:22.790]    - tweaked: FALSE
[15:32:22.790]    - call: NULL
[15:32:22.791] plan(): nbrOfWorkers() = 1
[15:32:22.793] plan(): Setting new future strategy stack:
[15:32:22.793] List of future strategies:
[15:32:22.793] 1. sequential:
[15:32:22.793]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:22.793]    - tweaked: FALSE
[15:32:22.793]    - call: plan(strategy)
[15:32:22.798] plan(): nbrOfWorkers() = 1
[15:32:22.798] SequentialFuture started (and completed)
[15:32:22.799] - Launch lazy future ... done
[15:32:22.799] run() for 'SequentialFuture' ... done
[15:32:22.800] Created future:
[15:32:22.800] SequentialFuture:
[15:32:22.800] Label: 'future_sapply-1'
[15:32:22.800] Expression:
[15:32:22.800] {
[15:32:22.800]     do.call(function(...) {
[15:32:22.800]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:22.800]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:22.800]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:22.800]             on.exit(options(oopts), add = TRUE)
[15:32:22.800]         }
[15:32:22.800]         {
[15:32:22.800]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:22.800]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:22.800]                 ...future.FUN(...future.X_jj, ...)
[15:32:22.800]             })
[15:32:22.800]         }
[15:32:22.800]     }, args = future.call.arguments)
[15:32:22.800] }
[15:32:22.800] Lazy evaluation: FALSE
[15:32:22.800] Asynchronous evaluation: FALSE
[15:32:22.800] Local evaluation: TRUE
[15:32:22.800] Environment: R_GlobalEnv
[15:32:22.800] Capture standard output: TRUE
[15:32:22.800] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:22.800] Globals: 5 objects totaling 1.55 KiB (function '...future.FUN' of 1.22 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 336 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:22.800] Packages: <none>
[15:32:22.800] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:22.800] Resolved: TRUE
[15:32:22.800] Value: 1.31 KiB of class 'list'
[15:32:22.800] Early signaling: FALSE
[15:32:22.800] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:22.800] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:22.802] Chunk #1 of 1 ... DONE
[15:32:22.803] Launching 1 futures (chunks) ... DONE
[15:32:22.803] Resolving 1 futures (chunks) ...
[15:32:22.803] resolve() on list ...
[15:32:22.803]  recursive: 0
[15:32:22.804]  length: 1
[15:32:22.804] 
[15:32:22.804] resolved() for 'SequentialFuture' ...
[15:32:22.805] - state: 'finished'
[15:32:22.805] - run: TRUE
[15:32:22.805] - result: 'FutureResult'
[15:32:22.805] resolved() for 'SequentialFuture' ... done
[15:32:22.806] Future #1
[15:32:22.806] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:22.806] - nx: 1
[15:32:22.807] - relay: TRUE
[15:32:22.807] - stdout: TRUE
[15:32:22.807] - signal: TRUE
[15:32:22.807] - resignal: FALSE
[15:32:22.808] - force: TRUE
[15:32:22.808] - relayed: [n=1] FALSE
[15:32:22.808] - queued futures: [n=1] FALSE
[15:32:22.809]  - until=1
[15:32:22.809]  - relaying element #1
[15:32:22.809] - relayed: [n=1] TRUE
[15:32:22.810] - queued futures: [n=1] TRUE
[15:32:22.810] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:22.810]  length: 0 (resolved future 1)
[15:32:22.810] Relaying remaining futures
[15:32:22.811] signalConditionsASAP(NULL, pos=0) ...
[15:32:22.811] - nx: 1
[15:32:22.811] - relay: TRUE
[15:32:22.811] - stdout: TRUE
[15:32:22.812] - signal: TRUE
[15:32:22.812] - resignal: FALSE
[15:32:22.812] - force: TRUE
[15:32:22.812] - relayed: [n=1] TRUE
[15:32:22.813] - queued futures: [n=1] TRUE
 - flush all
[15:32:22.813] - relayed: [n=1] TRUE
[15:32:22.813] - queued futures: [n=1] TRUE
[15:32:22.814] signalConditionsASAP(NULL, pos=0) ... done
[15:32:22.814] resolve() on list ... DONE
[15:32:22.814]  - Number of value chunks collected: 1
[15:32:22.814] Resolving 1 futures (chunks) ... DONE
[15:32:22.815] Reducing values from 1 chunks ...
[15:32:22.815]  - Number of values collected after concatenation: 6
[15:32:22.815]  - Number of values expected: 6
[15:32:22.815] Reducing values from 1 chunks ... DONE
[15:32:22.816] future_lapply() ... DONE
List of 2
 $ y0: Named int [1:6] 1 2 2 3 3 4
  ..- attr(*, "names")= chr [1:6] "a1" "a2" "b1" "b2" ...
 $ y1: Named int [1:6] 1 2 2 3 3 4
  ..- attr(*, "names")= chr [1:6] "a1" "a2" "b1" "b2" ...
[15:32:22.819] future_lapply() ...
[15:32:22.821] Number of chunks: 1
[15:32:22.821] getGlobalsAndPackagesXApply() ...
[15:32:22.821]  - future.globals: TRUE
[15:32:22.821] getGlobalsAndPackages() ...
[15:32:22.822] Searching for globals...
[15:32:22.824] - globals found: [5] 'FUN', '*', ':', 'outer', 'rep'
[15:32:22.825] Searching for globals ... DONE
[15:32:22.825] Resolving globals: FALSE
[15:32:22.826] The total size of the 1 globals is 4.62 KiB (4728 bytes)
[15:32:22.826] The total size of the 1 globals exported for future expression ('FUN()') is 4.62 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.62 KiB of class 'function')
[15:32:22.827] - globals: [1] 'FUN'
[15:32:22.827] 
[15:32:22.827] getGlobalsAndPackages() ... DONE
[15:32:22.827]  - globals found/used: [n=1] 'FUN'
[15:32:22.828]  - needed namespaces: [n=0] 
[15:32:22.828] Finding globals ... DONE
[15:32:22.828]  - use_args: TRUE
[15:32:22.828]  - Getting '...' globals ...
[15:32:22.829] resolve() on list ...
[15:32:22.829]  recursive: 0
[15:32:22.830]  length: 1
[15:32:22.830]  elements: '...'
[15:32:22.830]  length: 0 (resolved future 1)
[15:32:22.830] resolve() on list ... DONE
[15:32:22.831]    - '...' content: [n=0] 
[15:32:22.831] List of 1
[15:32:22.831]  $ ...: list()
[15:32:22.831]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:22.831]  - attr(*, "where")=List of 1
[15:32:22.831]   ..$ ...:<environment: 0x00000276e04b6500> 
[15:32:22.831]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:22.831]  - attr(*, "resolved")= logi TRUE
[15:32:22.831]  - attr(*, "total_size")= num NA
[15:32:22.840]  - Getting '...' globals ... DONE
[15:32:22.840] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:22.841] List of 2
[15:32:22.841]  $ ...future.FUN:function (x, y = 2 * 1:5)  
[15:32:22.841]  $ ...          : list()
[15:32:22.841]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:22.841]  - attr(*, "where")=List of 2
[15:32:22.841]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:22.841]   ..$ ...          :<environment: 0x00000276e04b6500> 
[15:32:22.841]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:22.841]  - attr(*, "resolved")= logi FALSE
[15:32:22.841]  - attr(*, "total_size")= num 4728
[15:32:22.847] Packages to be attached in all futures: [n=0] 
[15:32:22.847] getGlobalsAndPackagesXApply() ... DONE
[15:32:22.848] Number of futures (= number of chunks): 1
[15:32:22.848] Launching 1 futures (chunks) ...
[15:32:22.848] Chunk #1 of 1 ...
[15:32:22.849]  - Finding globals in 'X' for chunk #1 ...
[15:32:22.849] getGlobalsAndPackages() ...
[15:32:22.849] Searching for globals...
[15:32:22.850] 
[15:32:22.850] Searching for globals ... DONE
[15:32:22.850] - globals: [0] <none>
[15:32:22.851] getGlobalsAndPackages() ... DONE
[15:32:22.851]    + additional globals found: [n=0] 
[15:32:22.851]    + additional namespaces needed: [n=0] 
[15:32:22.851]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:22.852]  - seeds: <none>
[15:32:22.852]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:22.852] getGlobalsAndPackages() ...
[15:32:22.852] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:22.853] Resolving globals: FALSE
[15:32:22.853] Tweak future expression to call with '...' arguments ...
[15:32:22.853] {
[15:32:22.853]     do.call(function(...) {
[15:32:22.853]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:22.853]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:22.853]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:22.853]             on.exit(options(oopts), add = TRUE)
[15:32:22.853]         }
[15:32:22.853]         {
[15:32:22.853]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:22.853]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:22.853]                 ...future.FUN(...future.X_jj, ...)
[15:32:22.853]             })
[15:32:22.853]         }
[15:32:22.853]     }, args = future.call.arguments)
[15:32:22.853] }
[15:32:22.854] Tweak future expression to call with '...' arguments ... DONE
[15:32:22.855] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:22.855] 
[15:32:22.855] getGlobalsAndPackages() ... DONE
[15:32:22.856] run() for 'Future' ...
[15:32:22.856] - state: 'created'
[15:32:22.857] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:22.857] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:22.857] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:22.858]   - Field: 'label'
[15:32:22.858]   - Field: 'local'
[15:32:22.858]   - Field: 'owner'
[15:32:22.859]   - Field: 'envir'
[15:32:22.859]   - Field: 'packages'
[15:32:22.859]   - Field: 'gc'
[15:32:22.859]   - Field: 'conditions'
[15:32:22.860]   - Field: 'expr'
[15:32:22.860]   - Field: 'uuid'
[15:32:22.860]   - Field: 'seed'
[15:32:22.861]   - Field: 'version'
[15:32:22.861]   - Field: 'result'
[15:32:22.861]   - Field: 'asynchronous'
[15:32:22.862]   - Field: 'calls'
[15:32:22.862]   - Field: 'globals'
[15:32:22.862]   - Field: 'stdout'
[15:32:22.862]   - Field: 'earlySignal'
[15:32:22.863]   - Field: 'lazy'
[15:32:22.863]   - Field: 'state'
[15:32:22.863] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:22.864] - Launch lazy future ...
[15:32:22.864] Packages needed by the future expression (n = 0): <none>
[15:32:22.864] Packages needed by future strategies (n = 0): <none>
[15:32:22.865] {
[15:32:22.865]     {
[15:32:22.865]         {
[15:32:22.865]             ...future.startTime <- base::Sys.time()
[15:32:22.865]             {
[15:32:22.865]                 {
[15:32:22.865]                   {
[15:32:22.865]                     base::local({
[15:32:22.865]                       has_future <- base::requireNamespace("future", 
[15:32:22.865]                         quietly = TRUE)
[15:32:22.865]                       if (has_future) {
[15:32:22.865]                         ns <- base::getNamespace("future")
[15:32:22.865]                         version <- ns[[".package"]][["version"]]
[15:32:22.865]                         if (is.null(version)) 
[15:32:22.865]                           version <- utils::packageVersion("future")
[15:32:22.865]                       }
[15:32:22.865]                       else {
[15:32:22.865]                         version <- NULL
[15:32:22.865]                       }
[15:32:22.865]                       if (!has_future || version < "1.8.0") {
[15:32:22.865]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:22.865]                           "", base::R.version$version.string), 
[15:32:22.865]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:22.865]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:22.865]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:22.865]                             "release", "version")], collapse = " "), 
[15:32:22.865]                           hostname = base::Sys.info()[["nodename"]])
[15:32:22.865]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:22.865]                           info)
[15:32:22.865]                         info <- base::paste(info, collapse = "; ")
[15:32:22.865]                         if (!has_future) {
[15:32:22.865]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:22.865]                             info)
[15:32:22.865]                         }
[15:32:22.865]                         else {
[15:32:22.865]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:22.865]                             info, version)
[15:32:22.865]                         }
[15:32:22.865]                         base::stop(msg)
[15:32:22.865]                       }
[15:32:22.865]                     })
[15:32:22.865]                   }
[15:32:22.865]                   ...future.strategy.old <- future::plan("list")
[15:32:22.865]                   options(future.plan = NULL)
[15:32:22.865]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:22.865]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:22.865]                 }
[15:32:22.865]                 ...future.workdir <- getwd()
[15:32:22.865]             }
[15:32:22.865]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:22.865]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:22.865]         }
[15:32:22.865]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:22.865]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:22.865]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:22.865]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:22.865]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:22.865]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:22.865]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:22.865]             base::names(...future.oldOptions))
[15:32:22.865]     }
[15:32:22.865]     if (FALSE) {
[15:32:22.865]     }
[15:32:22.865]     else {
[15:32:22.865]         if (TRUE) {
[15:32:22.865]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:22.865]                 open = "w")
[15:32:22.865]         }
[15:32:22.865]         else {
[15:32:22.865]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:22.865]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:22.865]         }
[15:32:22.865]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:22.865]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:22.865]             base::sink(type = "output", split = FALSE)
[15:32:22.865]             base::close(...future.stdout)
[15:32:22.865]         }, add = TRUE)
[15:32:22.865]     }
[15:32:22.865]     ...future.frame <- base::sys.nframe()
[15:32:22.865]     ...future.conditions <- base::list()
[15:32:22.865]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:22.865]     if (FALSE) {
[15:32:22.865]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:22.865]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:22.865]     }
[15:32:22.865]     ...future.result <- base::tryCatch({
[15:32:22.865]         base::withCallingHandlers({
[15:32:22.865]             ...future.value <- base::withVisible(base::local({
[15:32:22.865]                 do.call(function(...) {
[15:32:22.865]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:22.865]                   if (!identical(...future.globals.maxSize.org, 
[15:32:22.865]                     ...future.globals.maxSize)) {
[15:32:22.865]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:22.865]                     on.exit(options(oopts), add = TRUE)
[15:32:22.865]                   }
[15:32:22.865]                   {
[15:32:22.865]                     lapply(seq_along(...future.elements_ii), 
[15:32:22.865]                       FUN = function(jj) {
[15:32:22.865]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:22.865]                         ...future.FUN(...future.X_jj, ...)
[15:32:22.865]                       })
[15:32:22.865]                   }
[15:32:22.865]                 }, args = future.call.arguments)
[15:32:22.865]             }))
[15:32:22.865]             future::FutureResult(value = ...future.value$value, 
[15:32:22.865]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:22.865]                   ...future.rng), globalenv = if (FALSE) 
[15:32:22.865]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:22.865]                     ...future.globalenv.names))
[15:32:22.865]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:22.865]         }, condition = base::local({
[15:32:22.865]             c <- base::c
[15:32:22.865]             inherits <- base::inherits
[15:32:22.865]             invokeRestart <- base::invokeRestart
[15:32:22.865]             length <- base::length
[15:32:22.865]             list <- base::list
[15:32:22.865]             seq.int <- base::seq.int
[15:32:22.865]             signalCondition <- base::signalCondition
[15:32:22.865]             sys.calls <- base::sys.calls
[15:32:22.865]             `[[` <- base::`[[`
[15:32:22.865]             `+` <- base::`+`
[15:32:22.865]             `<<-` <- base::`<<-`
[15:32:22.865]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:22.865]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:22.865]                   3L)]
[15:32:22.865]             }
[15:32:22.865]             function(cond) {
[15:32:22.865]                 is_error <- inherits(cond, "error")
[15:32:22.865]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:22.865]                   NULL)
[15:32:22.865]                 if (is_error) {
[15:32:22.865]                   sessionInformation <- function() {
[15:32:22.865]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:22.865]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:22.865]                       search = base::search(), system = base::Sys.info())
[15:32:22.865]                   }
[15:32:22.865]                   ...future.conditions[[length(...future.conditions) + 
[15:32:22.865]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:22.865]                     cond$call), session = sessionInformation(), 
[15:32:22.865]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:22.865]                   signalCondition(cond)
[15:32:22.865]                 }
[15:32:22.865]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:22.865]                 "immediateCondition"))) {
[15:32:22.865]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:22.865]                   ...future.conditions[[length(...future.conditions) + 
[15:32:22.865]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:22.865]                   if (TRUE && !signal) {
[15:32:22.865]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:22.865]                     {
[15:32:22.865]                       inherits <- base::inherits
[15:32:22.865]                       invokeRestart <- base::invokeRestart
[15:32:22.865]                       is.null <- base::is.null
[15:32:22.865]                       muffled <- FALSE
[15:32:22.865]                       if (inherits(cond, "message")) {
[15:32:22.865]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:22.865]                         if (muffled) 
[15:32:22.865]                           invokeRestart("muffleMessage")
[15:32:22.865]                       }
[15:32:22.865]                       else if (inherits(cond, "warning")) {
[15:32:22.865]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:22.865]                         if (muffled) 
[15:32:22.865]                           invokeRestart("muffleWarning")
[15:32:22.865]                       }
[15:32:22.865]                       else if (inherits(cond, "condition")) {
[15:32:22.865]                         if (!is.null(pattern)) {
[15:32:22.865]                           computeRestarts <- base::computeRestarts
[15:32:22.865]                           grepl <- base::grepl
[15:32:22.865]                           restarts <- computeRestarts(cond)
[15:32:22.865]                           for (restart in restarts) {
[15:32:22.865]                             name <- restart$name
[15:32:22.865]                             if (is.null(name)) 
[15:32:22.865]                               next
[15:32:22.865]                             if (!grepl(pattern, name)) 
[15:32:22.865]                               next
[15:32:22.865]                             invokeRestart(restart)
[15:32:22.865]                             muffled <- TRUE
[15:32:22.865]                             break
[15:32:22.865]                           }
[15:32:22.865]                         }
[15:32:22.865]                       }
[15:32:22.865]                       invisible(muffled)
[15:32:22.865]                     }
[15:32:22.865]                     muffleCondition(cond, pattern = "^muffle")
[15:32:22.865]                   }
[15:32:22.865]                 }
[15:32:22.865]                 else {
[15:32:22.865]                   if (TRUE) {
[15:32:22.865]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:22.865]                     {
[15:32:22.865]                       inherits <- base::inherits
[15:32:22.865]                       invokeRestart <- base::invokeRestart
[15:32:22.865]                       is.null <- base::is.null
[15:32:22.865]                       muffled <- FALSE
[15:32:22.865]                       if (inherits(cond, "message")) {
[15:32:22.865]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:22.865]                         if (muffled) 
[15:32:22.865]                           invokeRestart("muffleMessage")
[15:32:22.865]                       }
[15:32:22.865]                       else if (inherits(cond, "warning")) {
[15:32:22.865]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:22.865]                         if (muffled) 
[15:32:22.865]                           invokeRestart("muffleWarning")
[15:32:22.865]                       }
[15:32:22.865]                       else if (inherits(cond, "condition")) {
[15:32:22.865]                         if (!is.null(pattern)) {
[15:32:22.865]                           computeRestarts <- base::computeRestarts
[15:32:22.865]                           grepl <- base::grepl
[15:32:22.865]                           restarts <- computeRestarts(cond)
[15:32:22.865]                           for (restart in restarts) {
[15:32:22.865]                             name <- restart$name
[15:32:22.865]                             if (is.null(name)) 
[15:32:22.865]                               next
[15:32:22.865]                             if (!grepl(pattern, name)) 
[15:32:22.865]                               next
[15:32:22.865]                             invokeRestart(restart)
[15:32:22.865]                             muffled <- TRUE
[15:32:22.865]                             break
[15:32:22.865]                           }
[15:32:22.865]                         }
[15:32:22.865]                       }
[15:32:22.865]                       invisible(muffled)
[15:32:22.865]                     }
[15:32:22.865]                     muffleCondition(cond, pattern = "^muffle")
[15:32:22.865]                   }
[15:32:22.865]                 }
[15:32:22.865]             }
[15:32:22.865]         }))
[15:32:22.865]     }, error = function(ex) {
[15:32:22.865]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:22.865]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:22.865]                 ...future.rng), started = ...future.startTime, 
[15:32:22.865]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:22.865]             version = "1.8"), class = "FutureResult")
[15:32:22.865]     }, finally = {
[15:32:22.865]         if (!identical(...future.workdir, getwd())) 
[15:32:22.865]             setwd(...future.workdir)
[15:32:22.865]         {
[15:32:22.865]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:22.865]                 ...future.oldOptions$nwarnings <- NULL
[15:32:22.865]             }
[15:32:22.865]             base::options(...future.oldOptions)
[15:32:22.865]             if (.Platform$OS.type == "windows") {
[15:32:22.865]                 old_names <- names(...future.oldEnvVars)
[15:32:22.865]                 envs <- base::Sys.getenv()
[15:32:22.865]                 names <- names(envs)
[15:32:22.865]                 common <- intersect(names, old_names)
[15:32:22.865]                 added <- setdiff(names, old_names)
[15:32:22.865]                 removed <- setdiff(old_names, names)
[15:32:22.865]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:22.865]                   envs[common]]
[15:32:22.865]                 NAMES <- toupper(changed)
[15:32:22.865]                 args <- list()
[15:32:22.865]                 for (kk in seq_along(NAMES)) {
[15:32:22.865]                   name <- changed[[kk]]
[15:32:22.865]                   NAME <- NAMES[[kk]]
[15:32:22.865]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:22.865]                     next
[15:32:22.865]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:22.865]                 }
[15:32:22.865]                 NAMES <- toupper(added)
[15:32:22.865]                 for (kk in seq_along(NAMES)) {
[15:32:22.865]                   name <- added[[kk]]
[15:32:22.865]                   NAME <- NAMES[[kk]]
[15:32:22.865]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:22.865]                     next
[15:32:22.865]                   args[[name]] <- ""
[15:32:22.865]                 }
[15:32:22.865]                 NAMES <- toupper(removed)
[15:32:22.865]                 for (kk in seq_along(NAMES)) {
[15:32:22.865]                   name <- removed[[kk]]
[15:32:22.865]                   NAME <- NAMES[[kk]]
[15:32:22.865]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:22.865]                     next
[15:32:22.865]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:22.865]                 }
[15:32:22.865]                 if (length(args) > 0) 
[15:32:22.865]                   base::do.call(base::Sys.setenv, args = args)
[15:32:22.865]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:22.865]             }
[15:32:22.865]             else {
[15:32:22.865]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:22.865]             }
[15:32:22.865]             {
[15:32:22.865]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:22.865]                   0L) {
[15:32:22.865]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:22.865]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:22.865]                   base::options(opts)
[15:32:22.865]                 }
[15:32:22.865]                 {
[15:32:22.865]                   {
[15:32:22.865]                     NULL
[15:32:22.865]                     RNGkind("Mersenne-Twister")
[15:32:22.865]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:22.865]                       inherits = FALSE)
[15:32:22.865]                   }
[15:32:22.865]                   options(future.plan = NULL)
[15:32:22.865]                   if (is.na(NA_character_)) 
[15:32:22.865]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:22.865]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:22.865]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:22.865]                     .init = FALSE)
[15:32:22.865]                 }
[15:32:22.865]             }
[15:32:22.865]         }
[15:32:22.865]     })
[15:32:22.865]     if (TRUE) {
[15:32:22.865]         base::sink(type = "output", split = FALSE)
[15:32:22.865]         if (TRUE) {
[15:32:22.865]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:22.865]         }
[15:32:22.865]         else {
[15:32:22.865]             ...future.result["stdout"] <- base::list(NULL)
[15:32:22.865]         }
[15:32:22.865]         base::close(...future.stdout)
[15:32:22.865]         ...future.stdout <- NULL
[15:32:22.865]     }
[15:32:22.865]     ...future.result$conditions <- ...future.conditions
[15:32:22.865]     ...future.result$finished <- base::Sys.time()
[15:32:22.865]     ...future.result
[15:32:22.865] }
[15:32:22.872] assign_globals() ...
[15:32:22.872] List of 5
[15:32:22.872]  $ ...future.FUN            :function (x, y = 2 * 1:5)  
[15:32:22.872]  $ future.call.arguments    : list()
[15:32:22.872]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:22.872]  $ ...future.elements_ii    :List of 6
[15:32:22.872]   ..$ a1: int 1
[15:32:22.872]   ..$ a2: int 2
[15:32:22.872]   ..$ b1: int 2
[15:32:22.872]   ..$ b2: int 3
[15:32:22.872]   ..$ c1: int 3
[15:32:22.872]   ..$ c2: int 4
[15:32:22.872]  $ ...future.seeds_ii       : NULL
[15:32:22.872]  $ ...future.globals.maxSize: NULL
[15:32:22.872]  - attr(*, "where")=List of 5
[15:32:22.872]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:22.872]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:22.872]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:22.872]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:22.872]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:22.872]  - attr(*, "resolved")= logi FALSE
[15:32:22.872]  - attr(*, "total_size")= num 4728
[15:32:22.872]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:22.872]  - attr(*, "already-done")= logi TRUE
[15:32:22.889] - reassign environment for '...future.FUN'
[15:32:22.889] - copied '...future.FUN' to environment
[15:32:22.890] - copied 'future.call.arguments' to environment
[15:32:22.890] - copied '...future.elements_ii' to environment
[15:32:22.890] - copied '...future.seeds_ii' to environment
[15:32:22.891] - copied '...future.globals.maxSize' to environment
[15:32:22.891] assign_globals() ... done
[15:32:22.892] plan(): Setting new future strategy stack:
[15:32:22.892] List of future strategies:
[15:32:22.892] 1. sequential:
[15:32:22.892]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:22.892]    - tweaked: FALSE
[15:32:22.892]    - call: NULL
[15:32:22.893] plan(): nbrOfWorkers() = 1
[15:32:22.895] plan(): Setting new future strategy stack:
[15:32:22.896] List of future strategies:
[15:32:22.896] 1. sequential:
[15:32:22.896]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:22.896]    - tweaked: FALSE
[15:32:22.896]    - call: plan(strategy)
[15:32:22.897] plan(): nbrOfWorkers() = 1
[15:32:22.897] SequentialFuture started (and completed)
[15:32:22.898] - Launch lazy future ... done
[15:32:22.898] run() for 'SequentialFuture' ... done
[15:32:22.898] Created future:
[15:32:22.899] SequentialFuture:
[15:32:22.899] Label: 'future_sapply-1'
[15:32:22.899] Expression:
[15:32:22.899] {
[15:32:22.899]     do.call(function(...) {
[15:32:22.899]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:22.899]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:22.899]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:22.899]             on.exit(options(oopts), add = TRUE)
[15:32:22.899]         }
[15:32:22.899]         {
[15:32:22.899]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:22.899]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:22.899]                 ...future.FUN(...future.X_jj, ...)
[15:32:22.899]             })
[15:32:22.899]         }
[15:32:22.899]     }, args = future.call.arguments)
[15:32:22.899] }
[15:32:22.899] Lazy evaluation: FALSE
[15:32:22.899] Asynchronous evaluation: FALSE
[15:32:22.899] Local evaluation: TRUE
[15:32:22.899] Environment: R_GlobalEnv
[15:32:22.899] Capture standard output: TRUE
[15:32:22.899] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:22.899] Globals: 5 objects totaling 4.95 KiB (function '...future.FUN' of 4.62 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 336 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:22.899] Packages: <none>
[15:32:22.899] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:22.899] Resolved: TRUE
[15:32:22.899] Value: 2.02 KiB of class 'list'
[15:32:22.899] Early signaling: FALSE
[15:32:22.899] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:22.899] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:22.901] Chunk #1 of 1 ... DONE
[15:32:22.901] Launching 1 futures (chunks) ... DONE
[15:32:22.902] Resolving 1 futures (chunks) ...
[15:32:22.902] resolve() on list ...
[15:32:22.902]  recursive: 0
[15:32:22.902]  length: 1
[15:32:22.903] 
[15:32:22.903] resolved() for 'SequentialFuture' ...
[15:32:22.903] - state: 'finished'
[15:32:22.904] - run: TRUE
[15:32:22.904] - result: 'FutureResult'
[15:32:22.904] resolved() for 'SequentialFuture' ... done
[15:32:22.904] Future #1
[15:32:22.905] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:22.905] - nx: 1
[15:32:22.905] - relay: TRUE
[15:32:22.906] - stdout: TRUE
[15:32:22.906] - signal: TRUE
[15:32:22.906] - resignal: FALSE
[15:32:22.906] - force: TRUE
[15:32:22.907] - relayed: [n=1] FALSE
[15:32:22.907] - queued futures: [n=1] FALSE
[15:32:22.907]  - until=1
[15:32:22.907]  - relaying element #1
[15:32:22.908] - relayed: [n=1] TRUE
[15:32:22.908] - queued futures: [n=1] TRUE
[15:32:22.908] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:22.909]  length: 0 (resolved future 1)
[15:32:22.909] Relaying remaining futures
[15:32:22.909] signalConditionsASAP(NULL, pos=0) ...
[15:32:22.910] - nx: 1
[15:32:22.910] - relay: TRUE
[15:32:22.910] - stdout: TRUE
[15:32:22.910] - signal: TRUE
[15:32:22.911] - resignal: FALSE
[15:32:22.911] - force: TRUE
[15:32:22.911] - relayed: [n=1] TRUE
[15:32:22.911] - queued futures: [n=1] TRUE
 - flush all
[15:32:22.912] - relayed: [n=1] TRUE
[15:32:22.912] - queued futures: [n=1] TRUE
[15:32:22.912] signalConditionsASAP(NULL, pos=0) ... done
[15:32:22.913] resolve() on list ... DONE
[15:32:22.913]  - Number of value chunks collected: 1
[15:32:22.913] Resolving 1 futures (chunks) ... DONE
[15:32:22.914] Reducing values from 1 chunks ...
[15:32:22.914]  - Number of values collected after concatenation: 6
[15:32:22.914]  - Number of values expected: 6
[15:32:22.914] Reducing values from 1 chunks ... DONE
[15:32:22.915] future_lapply() ... DONE
List of 2
 $ y0: num [1:3, 1:5, 1:6] 2 2 2 4 4 4 6 6 6 8 ...
  ..- attr(*, "dimnames")=List of 3
  .. ..$ : NULL
  .. ..$ : NULL
  .. ..$ : chr [1:6] "a1" "a2" "b1" "b2" ...
 $ y1: num [1:3, 1:5, 1:6] 2 2 2 4 4 4 6 6 6 8 ...
  ..- attr(*, "dimnames")=List of 3
  .. ..$ : NULL
  .. ..$ : NULL
  .. ..$ : chr [1:6] "a1" "a2" "b1" "b2" ...
[15:32:22.921] future_lapply() ...
[15:32:22.922] Number of chunks: 1
[15:32:22.922] getGlobalsAndPackagesXApply() ...
[15:32:22.922]  - future.globals: TRUE
[15:32:22.923] getGlobalsAndPackages() ...
[15:32:22.923] Searching for globals...
[15:32:22.925] - globals found: [1] 'FUN'
[15:32:22.925] Searching for globals ... DONE
[15:32:22.925] Resolving globals: FALSE
[15:32:22.926] The total size of the 1 globals is 848 bytes (848 bytes)
[15:32:22.927] The total size of the 1 globals exported for future expression ('FUN()') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:32:22.927] - globals: [1] 'FUN'
[15:32:22.927] 
[15:32:22.928] getGlobalsAndPackages() ... DONE
[15:32:22.928]  - globals found/used: [n=1] 'FUN'
[15:32:22.932]  - needed namespaces: [n=0] 
[15:32:22.932] Finding globals ... DONE
[15:32:22.932]  - use_args: TRUE
[15:32:22.933]  - Getting '...' globals ...
[15:32:22.934] resolve() on list ...
[15:32:22.934]  recursive: 0
[15:32:22.934]  length: 1
[15:32:22.935]  elements: '...'
[15:32:22.935]  length: 0 (resolved future 1)
[15:32:22.935] resolve() on list ... DONE
[15:32:22.936]    - '...' content: [n=0] 
[15:32:22.936] List of 1
[15:32:22.936]  $ ...: list()
[15:32:22.936]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:22.936]  - attr(*, "where")=List of 1
[15:32:22.936]   ..$ ...:<environment: 0x00000276e1c7a530> 
[15:32:22.936]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:22.936]  - attr(*, "resolved")= logi TRUE
[15:32:22.936]  - attr(*, "total_size")= num NA
[15:32:22.942]  - Getting '...' globals ... DONE
[15:32:22.942] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:22.943] List of 2
[15:32:22.943]  $ ...future.FUN:function (x)  
[15:32:22.943]  $ ...          : list()
[15:32:22.943]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:22.943]  - attr(*, "where")=List of 2
[15:32:22.943]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:22.943]   ..$ ...          :<environment: 0x00000276e1c7a530> 
[15:32:22.943]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:22.943]  - attr(*, "resolved")= logi FALSE
[15:32:22.943]  - attr(*, "total_size")= num 848
[15:32:22.948] Packages to be attached in all futures: [n=0] 
[15:32:22.949] getGlobalsAndPackagesXApply() ... DONE
[15:32:22.949] Number of futures (= number of chunks): 1
[15:32:22.949] Launching 1 futures (chunks) ...
[15:32:22.950] Chunk #1 of 1 ...
[15:32:22.950]  - Finding globals in 'X' for chunk #1 ...
[15:32:22.950] getGlobalsAndPackages() ...
[15:32:22.951] Searching for globals...
[15:32:22.951] 
[15:32:22.951] Searching for globals ... DONE
[15:32:22.952] - globals: [0] <none>
[15:32:22.952] getGlobalsAndPackages() ... DONE
[15:32:22.952]    + additional globals found: [n=0] 
[15:32:22.953]    + additional namespaces needed: [n=0] 
[15:32:22.953]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:22.953]  - seeds: <none>
[15:32:22.953]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:22.954] getGlobalsAndPackages() ...
[15:32:22.954] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:22.954] Resolving globals: FALSE
[15:32:22.954] Tweak future expression to call with '...' arguments ...
[15:32:22.955] {
[15:32:22.955]     do.call(function(...) {
[15:32:22.955]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:22.955]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:22.955]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:22.955]             on.exit(options(oopts), add = TRUE)
[15:32:22.955]         }
[15:32:22.955]         {
[15:32:22.955]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:22.955]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:22.955]                 ...future.FUN(...future.X_jj, ...)
[15:32:22.955]             })
[15:32:22.955]         }
[15:32:22.955]     }, args = future.call.arguments)
[15:32:22.955] }
[15:32:22.956] Tweak future expression to call with '...' arguments ... DONE
[15:32:22.956] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:22.957] 
[15:32:22.957] getGlobalsAndPackages() ... DONE
[15:32:22.957] run() for 'Future' ...
[15:32:22.958] - state: 'created'
[15:32:22.958] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:22.959] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:22.959] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:22.959]   - Field: 'label'
[15:32:22.960]   - Field: 'local'
[15:32:22.960]   - Field: 'owner'
[15:32:22.961]   - Field: 'envir'
[15:32:22.961]   - Field: 'packages'
[15:32:22.961]   - Field: 'gc'
[15:32:22.962]   - Field: 'conditions'
[15:32:22.962]   - Field: 'expr'
[15:32:22.962]   - Field: 'uuid'
[15:32:22.963]   - Field: 'seed'
[15:32:22.963]   - Field: 'version'
[15:32:22.963]   - Field: 'result'
[15:32:22.964]   - Field: 'asynchronous'
[15:32:22.964]   - Field: 'calls'
[15:32:22.964]   - Field: 'globals'
[15:32:22.965]   - Field: 'stdout'
[15:32:22.965]   - Field: 'earlySignal'
[15:32:22.965]   - Field: 'lazy'
[15:32:22.965]   - Field: 'state'
[15:32:22.966] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:22.966] - Launch lazy future ...
[15:32:22.966] Packages needed by the future expression (n = 0): <none>
[15:32:22.967] Packages needed by future strategies (n = 0): <none>
[15:32:22.968] {
[15:32:22.968]     {
[15:32:22.968]         {
[15:32:22.968]             ...future.startTime <- base::Sys.time()
[15:32:22.968]             {
[15:32:22.968]                 {
[15:32:22.968]                   {
[15:32:22.968]                     base::local({
[15:32:22.968]                       has_future <- base::requireNamespace("future", 
[15:32:22.968]                         quietly = TRUE)
[15:32:22.968]                       if (has_future) {
[15:32:22.968]                         ns <- base::getNamespace("future")
[15:32:22.968]                         version <- ns[[".package"]][["version"]]
[15:32:22.968]                         if (is.null(version)) 
[15:32:22.968]                           version <- utils::packageVersion("future")
[15:32:22.968]                       }
[15:32:22.968]                       else {
[15:32:22.968]                         version <- NULL
[15:32:22.968]                       }
[15:32:22.968]                       if (!has_future || version < "1.8.0") {
[15:32:22.968]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:22.968]                           "", base::R.version$version.string), 
[15:32:22.968]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:22.968]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:22.968]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:22.968]                             "release", "version")], collapse = " "), 
[15:32:22.968]                           hostname = base::Sys.info()[["nodename"]])
[15:32:22.968]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:22.968]                           info)
[15:32:22.968]                         info <- base::paste(info, collapse = "; ")
[15:32:22.968]                         if (!has_future) {
[15:32:22.968]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:22.968]                             info)
[15:32:22.968]                         }
[15:32:22.968]                         else {
[15:32:22.968]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:22.968]                             info, version)
[15:32:22.968]                         }
[15:32:22.968]                         base::stop(msg)
[15:32:22.968]                       }
[15:32:22.968]                     })
[15:32:22.968]                   }
[15:32:22.968]                   ...future.strategy.old <- future::plan("list")
[15:32:22.968]                   options(future.plan = NULL)
[15:32:22.968]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:22.968]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:22.968]                 }
[15:32:22.968]                 ...future.workdir <- getwd()
[15:32:22.968]             }
[15:32:22.968]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:22.968]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:22.968]         }
[15:32:22.968]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:22.968]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:22.968]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:22.968]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:22.968]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:22.968]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:22.968]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:22.968]             base::names(...future.oldOptions))
[15:32:22.968]     }
[15:32:22.968]     if (FALSE) {
[15:32:22.968]     }
[15:32:22.968]     else {
[15:32:22.968]         if (TRUE) {
[15:32:22.968]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:22.968]                 open = "w")
[15:32:22.968]         }
[15:32:22.968]         else {
[15:32:22.968]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:22.968]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:22.968]         }
[15:32:22.968]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:22.968]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:22.968]             base::sink(type = "output", split = FALSE)
[15:32:22.968]             base::close(...future.stdout)
[15:32:22.968]         }, add = TRUE)
[15:32:22.968]     }
[15:32:22.968]     ...future.frame <- base::sys.nframe()
[15:32:22.968]     ...future.conditions <- base::list()
[15:32:22.968]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:22.968]     if (FALSE) {
[15:32:22.968]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:22.968]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:22.968]     }
[15:32:22.968]     ...future.result <- base::tryCatch({
[15:32:22.968]         base::withCallingHandlers({
[15:32:22.968]             ...future.value <- base::withVisible(base::local({
[15:32:22.968]                 do.call(function(...) {
[15:32:22.968]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:22.968]                   if (!identical(...future.globals.maxSize.org, 
[15:32:22.968]                     ...future.globals.maxSize)) {
[15:32:22.968]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:22.968]                     on.exit(options(oopts), add = TRUE)
[15:32:22.968]                   }
[15:32:22.968]                   {
[15:32:22.968]                     lapply(seq_along(...future.elements_ii), 
[15:32:22.968]                       FUN = function(jj) {
[15:32:22.968]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:22.968]                         ...future.FUN(...future.X_jj, ...)
[15:32:22.968]                       })
[15:32:22.968]                   }
[15:32:22.968]                 }, args = future.call.arguments)
[15:32:22.968]             }))
[15:32:22.968]             future::FutureResult(value = ...future.value$value, 
[15:32:22.968]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:22.968]                   ...future.rng), globalenv = if (FALSE) 
[15:32:22.968]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:22.968]                     ...future.globalenv.names))
[15:32:22.968]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:22.968]         }, condition = base::local({
[15:32:22.968]             c <- base::c
[15:32:22.968]             inherits <- base::inherits
[15:32:22.968]             invokeRestart <- base::invokeRestart
[15:32:22.968]             length <- base::length
[15:32:22.968]             list <- base::list
[15:32:22.968]             seq.int <- base::seq.int
[15:32:22.968]             signalCondition <- base::signalCondition
[15:32:22.968]             sys.calls <- base::sys.calls
[15:32:22.968]             `[[` <- base::`[[`
[15:32:22.968]             `+` <- base::`+`
[15:32:22.968]             `<<-` <- base::`<<-`
[15:32:22.968]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:22.968]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:22.968]                   3L)]
[15:32:22.968]             }
[15:32:22.968]             function(cond) {
[15:32:22.968]                 is_error <- inherits(cond, "error")
[15:32:22.968]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:22.968]                   NULL)
[15:32:22.968]                 if (is_error) {
[15:32:22.968]                   sessionInformation <- function() {
[15:32:22.968]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:22.968]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:22.968]                       search = base::search(), system = base::Sys.info())
[15:32:22.968]                   }
[15:32:22.968]                   ...future.conditions[[length(...future.conditions) + 
[15:32:22.968]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:22.968]                     cond$call), session = sessionInformation(), 
[15:32:22.968]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:22.968]                   signalCondition(cond)
[15:32:22.968]                 }
[15:32:22.968]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:22.968]                 "immediateCondition"))) {
[15:32:22.968]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:22.968]                   ...future.conditions[[length(...future.conditions) + 
[15:32:22.968]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:22.968]                   if (TRUE && !signal) {
[15:32:22.968]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:22.968]                     {
[15:32:22.968]                       inherits <- base::inherits
[15:32:22.968]                       invokeRestart <- base::invokeRestart
[15:32:22.968]                       is.null <- base::is.null
[15:32:22.968]                       muffled <- FALSE
[15:32:22.968]                       if (inherits(cond, "message")) {
[15:32:22.968]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:22.968]                         if (muffled) 
[15:32:22.968]                           invokeRestart("muffleMessage")
[15:32:22.968]                       }
[15:32:22.968]                       else if (inherits(cond, "warning")) {
[15:32:22.968]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:22.968]                         if (muffled) 
[15:32:22.968]                           invokeRestart("muffleWarning")
[15:32:22.968]                       }
[15:32:22.968]                       else if (inherits(cond, "condition")) {
[15:32:22.968]                         if (!is.null(pattern)) {
[15:32:22.968]                           computeRestarts <- base::computeRestarts
[15:32:22.968]                           grepl <- base::grepl
[15:32:22.968]                           restarts <- computeRestarts(cond)
[15:32:22.968]                           for (restart in restarts) {
[15:32:22.968]                             name <- restart$name
[15:32:22.968]                             if (is.null(name)) 
[15:32:22.968]                               next
[15:32:22.968]                             if (!grepl(pattern, name)) 
[15:32:22.968]                               next
[15:32:22.968]                             invokeRestart(restart)
[15:32:22.968]                             muffled <- TRUE
[15:32:22.968]                             break
[15:32:22.968]                           }
[15:32:22.968]                         }
[15:32:22.968]                       }
[15:32:22.968]                       invisible(muffled)
[15:32:22.968]                     }
[15:32:22.968]                     muffleCondition(cond, pattern = "^muffle")
[15:32:22.968]                   }
[15:32:22.968]                 }
[15:32:22.968]                 else {
[15:32:22.968]                   if (TRUE) {
[15:32:22.968]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:22.968]                     {
[15:32:22.968]                       inherits <- base::inherits
[15:32:22.968]                       invokeRestart <- base::invokeRestart
[15:32:22.968]                       is.null <- base::is.null
[15:32:22.968]                       muffled <- FALSE
[15:32:22.968]                       if (inherits(cond, "message")) {
[15:32:22.968]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:22.968]                         if (muffled) 
[15:32:22.968]                           invokeRestart("muffleMessage")
[15:32:22.968]                       }
[15:32:22.968]                       else if (inherits(cond, "warning")) {
[15:32:22.968]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:22.968]                         if (muffled) 
[15:32:22.968]                           invokeRestart("muffleWarning")
[15:32:22.968]                       }
[15:32:22.968]                       else if (inherits(cond, "condition")) {
[15:32:22.968]                         if (!is.null(pattern)) {
[15:32:22.968]                           computeRestarts <- base::computeRestarts
[15:32:22.968]                           grepl <- base::grepl
[15:32:22.968]                           restarts <- computeRestarts(cond)
[15:32:22.968]                           for (restart in restarts) {
[15:32:22.968]                             name <- restart$name
[15:32:22.968]                             if (is.null(name)) 
[15:32:22.968]                               next
[15:32:22.968]                             if (!grepl(pattern, name)) 
[15:32:22.968]                               next
[15:32:22.968]                             invokeRestart(restart)
[15:32:22.968]                             muffled <- TRUE
[15:32:22.968]                             break
[15:32:22.968]                           }
[15:32:22.968]                         }
[15:32:22.968]                       }
[15:32:22.968]                       invisible(muffled)
[15:32:22.968]                     }
[15:32:22.968]                     muffleCondition(cond, pattern = "^muffle")
[15:32:22.968]                   }
[15:32:22.968]                 }
[15:32:22.968]             }
[15:32:22.968]         }))
[15:32:22.968]     }, error = function(ex) {
[15:32:22.968]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:22.968]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:22.968]                 ...future.rng), started = ...future.startTime, 
[15:32:22.968]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:22.968]             version = "1.8"), class = "FutureResult")
[15:32:22.968]     }, finally = {
[15:32:22.968]         if (!identical(...future.workdir, getwd())) 
[15:32:22.968]             setwd(...future.workdir)
[15:32:22.968]         {
[15:32:22.968]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:22.968]                 ...future.oldOptions$nwarnings <- NULL
[15:32:22.968]             }
[15:32:22.968]             base::options(...future.oldOptions)
[15:32:22.968]             if (.Platform$OS.type == "windows") {
[15:32:22.968]                 old_names <- names(...future.oldEnvVars)
[15:32:22.968]                 envs <- base::Sys.getenv()
[15:32:22.968]                 names <- names(envs)
[15:32:22.968]                 common <- intersect(names, old_names)
[15:32:22.968]                 added <- setdiff(names, old_names)
[15:32:22.968]                 removed <- setdiff(old_names, names)
[15:32:22.968]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:22.968]                   envs[common]]
[15:32:22.968]                 NAMES <- toupper(changed)
[15:32:22.968]                 args <- list()
[15:32:22.968]                 for (kk in seq_along(NAMES)) {
[15:32:22.968]                   name <- changed[[kk]]
[15:32:22.968]                   NAME <- NAMES[[kk]]
[15:32:22.968]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:22.968]                     next
[15:32:22.968]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:22.968]                 }
[15:32:22.968]                 NAMES <- toupper(added)
[15:32:22.968]                 for (kk in seq_along(NAMES)) {
[15:32:22.968]                   name <- added[[kk]]
[15:32:22.968]                   NAME <- NAMES[[kk]]
[15:32:22.968]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:22.968]                     next
[15:32:22.968]                   args[[name]] <- ""
[15:32:22.968]                 }
[15:32:22.968]                 NAMES <- toupper(removed)
[15:32:22.968]                 for (kk in seq_along(NAMES)) {
[15:32:22.968]                   name <- removed[[kk]]
[15:32:22.968]                   NAME <- NAMES[[kk]]
[15:32:22.968]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:22.968]                     next
[15:32:22.968]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:22.968]                 }
[15:32:22.968]                 if (length(args) > 0) 
[15:32:22.968]                   base::do.call(base::Sys.setenv, args = args)
[15:32:22.968]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:22.968]             }
[15:32:22.968]             else {
[15:32:22.968]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:22.968]             }
[15:32:22.968]             {
[15:32:22.968]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:22.968]                   0L) {
[15:32:22.968]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:22.968]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:22.968]                   base::options(opts)
[15:32:22.968]                 }
[15:32:22.968]                 {
[15:32:22.968]                   {
[15:32:22.968]                     NULL
[15:32:22.968]                     RNGkind("Mersenne-Twister")
[15:32:22.968]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:22.968]                       inherits = FALSE)
[15:32:22.968]                   }
[15:32:22.968]                   options(future.plan = NULL)
[15:32:22.968]                   if (is.na(NA_character_)) 
[15:32:22.968]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:22.968]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:22.968]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:22.968]                     .init = FALSE)
[15:32:22.968]                 }
[15:32:22.968]             }
[15:32:22.968]         }
[15:32:22.968]     })
[15:32:22.968]     if (TRUE) {
[15:32:22.968]         base::sink(type = "output", split = FALSE)
[15:32:22.968]         if (TRUE) {
[15:32:22.968]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:22.968]         }
[15:32:22.968]         else {
[15:32:22.968]             ...future.result["stdout"] <- base::list(NULL)
[15:32:22.968]         }
[15:32:22.968]         base::close(...future.stdout)
[15:32:22.968]         ...future.stdout <- NULL
[15:32:22.968]     }
[15:32:22.968]     ...future.result$conditions <- ...future.conditions
[15:32:22.968]     ...future.result$finished <- base::Sys.time()
[15:32:22.968]     ...future.result
[15:32:22.968] }
[15:32:22.974] assign_globals() ...
[15:32:22.975] List of 5
[15:32:22.975]  $ ...future.FUN            :function (x)  
[15:32:22.975]  $ future.call.arguments    : list()
[15:32:22.975]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:22.975]  $ ...future.elements_ii    :List of 3
[15:32:22.975]   ..$ : chr "a"
[15:32:22.975]   ..$ : chr "b"
[15:32:22.975]   ..$ : chr "c"
[15:32:22.975]  $ ...future.seeds_ii       : NULL
[15:32:22.975]  $ ...future.globals.maxSize: NULL
[15:32:22.975]  - attr(*, "where")=List of 5
[15:32:22.975]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:22.975]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:22.975]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:22.975]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:22.975]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:22.975]  - attr(*, "resolved")= logi FALSE
[15:32:22.975]  - attr(*, "total_size")= num 848
[15:32:22.975]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:22.975]  - attr(*, "already-done")= logi TRUE
[15:32:22.989] - copied '...future.FUN' to environment
[15:32:22.989] - copied 'future.call.arguments' to environment
[15:32:22.989] - copied '...future.elements_ii' to environment
[15:32:22.989] - copied '...future.seeds_ii' to environment
[15:32:22.990] - copied '...future.globals.maxSize' to environment
[15:32:22.990] assign_globals() ... done
[15:32:22.991] plan(): Setting new future strategy stack:
[15:32:22.991] List of future strategies:
[15:32:22.991] 1. sequential:
[15:32:22.991]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:22.991]    - tweaked: FALSE
[15:32:22.991]    - call: NULL
[15:32:22.992] plan(): nbrOfWorkers() = 1
[15:32:22.994] plan(): Setting new future strategy stack:
[15:32:22.994] List of future strategies:
[15:32:22.994] 1. sequential:
[15:32:22.994]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:22.994]    - tweaked: FALSE
[15:32:22.994]    - call: plan(strategy)
[15:32:22.995] plan(): nbrOfWorkers() = 1
[15:32:22.995] SequentialFuture started (and completed)
[15:32:22.996] - Launch lazy future ... done
[15:32:22.996] run() for 'SequentialFuture' ... done
[15:32:22.996] Created future:
[15:32:22.997] SequentialFuture:
[15:32:22.997] Label: 'future_sapply-1'
[15:32:22.997] Expression:
[15:32:22.997] {
[15:32:22.997]     do.call(function(...) {
[15:32:22.997]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:22.997]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:22.997]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:22.997]             on.exit(options(oopts), add = TRUE)
[15:32:22.997]         }
[15:32:22.997]         {
[15:32:22.997]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:22.997]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:22.997]                 ...future.FUN(...future.X_jj, ...)
[15:32:22.997]             })
[15:32:22.997]         }
[15:32:22.997]     }, args = future.call.arguments)
[15:32:22.997] }
[15:32:22.997] Lazy evaluation: FALSE
[15:32:22.997] Asynchronous evaluation: FALSE
[15:32:22.997] Local evaluation: TRUE
[15:32:22.997] Environment: R_GlobalEnv
[15:32:22.997] Capture standard output: TRUE
[15:32:22.997] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:22.997] Globals: 5 objects totaling 1.16 KiB (function '...future.FUN' of 848 bytes, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 336 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:22.997] Packages: <none>
[15:32:22.997] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:22.997] Resolved: TRUE
[15:32:22.997] Value: 336 bytes of class 'list'
[15:32:22.997] Early signaling: FALSE
[15:32:22.997] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:22.997] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:22.999] Chunk #1 of 1 ... DONE
[15:32:22.999] Launching 1 futures (chunks) ... DONE
[15:32:22.999] Resolving 1 futures (chunks) ...
[15:32:22.999] resolve() on list ...
[15:32:23.000]  recursive: 0
[15:32:23.000]  length: 1
[15:32:23.000] 
[15:32:23.000] resolved() for 'SequentialFuture' ...
[15:32:23.001] - state: 'finished'
[15:32:23.001] - run: TRUE
[15:32:23.001] - result: 'FutureResult'
[15:32:23.002] resolved() for 'SequentialFuture' ... done
[15:32:23.002] Future #1
[15:32:23.002] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:23.003] - nx: 1
[15:32:23.003] - relay: TRUE
[15:32:23.003] - stdout: TRUE
[15:32:23.004] - signal: TRUE
[15:32:23.004] - resignal: FALSE
[15:32:23.004] - force: TRUE
[15:32:23.004] - relayed: [n=1] FALSE
[15:32:23.005] - queued futures: [n=1] FALSE
[15:32:23.005]  - until=1
[15:32:23.005]  - relaying element #1
[15:32:23.006] - relayed: [n=1] TRUE
[15:32:23.006] - queued futures: [n=1] TRUE
[15:32:23.006] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:23.007]  length: 0 (resolved future 1)
[15:32:23.007] Relaying remaining futures
[15:32:23.007] signalConditionsASAP(NULL, pos=0) ...
[15:32:23.008] - nx: 1
[15:32:23.008] - relay: TRUE
[15:32:23.008] - stdout: TRUE
[15:32:23.008] - signal: TRUE
[15:32:23.009] - resignal: FALSE
[15:32:23.009] - force: TRUE
[15:32:23.009] - relayed: [n=1] TRUE
[15:32:23.009] - queued futures: [n=1] TRUE
 - flush all
[15:32:23.010] - relayed: [n=1] TRUE
[15:32:23.010] - queued futures: [n=1] TRUE
[15:32:23.011] signalConditionsASAP(NULL, pos=0) ... done
[15:32:23.011] resolve() on list ... DONE
[15:32:23.011]  - Number of value chunks collected: 1
[15:32:23.012] Resolving 1 futures (chunks) ... DONE
[15:32:23.012] Reducing values from 1 chunks ...
[15:32:23.012]  - Number of values collected after concatenation: 3
[15:32:23.012]  - Number of values expected: 3
[15:32:23.013] Reducing values from 1 chunks ... DONE
[15:32:23.013] future_lapply() ... DONE
List of 2
 $ y0:List of 3
  ..$ : chr "a"
  ..$ : chr "b"
  ..$ : chr "c"
 $ y1:List of 3
  ..$ : chr "a"
  ..$ : chr "b"
  ..$ : chr "c"
List of 2
 $ y0:List of 3
  ..$ : chr "a"
  ..$ : chr "b"
  ..$ : chr "c"
 $ y2:List of 3
  ..$ : chr "a"
  ..$ : chr "b"
  ..$ : chr "c"
[15:32:23.029] future_lapply() ...
[15:32:23.030] Number of chunks: 1
[15:32:23.030] getGlobalsAndPackagesXApply() ...
[15:32:23.031]  - future.globals: TRUE
[15:32:23.031] getGlobalsAndPackages() ...
[15:32:23.031] Searching for globals...
[15:32:23.034] - globals found: [2] 'FUN', 'UseMethod'
[15:32:23.034] Searching for globals ... DONE
[15:32:23.035] Resolving globals: FALSE
[15:32:23.036] The total size of the 1 globals is 1.22 KiB (1248 bytes)
[15:32:23.036] The total size of the 1 globals exported for future expression ('FUN()') is 1.22 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.22 KiB of class 'function')
[15:32:23.037] - globals: [1] 'FUN'
[15:32:23.037] 
[15:32:23.037] getGlobalsAndPackages() ... DONE
[15:32:23.038]  - globals found/used: [n=1] 'FUN'
[15:32:23.038]  - needed namespaces: [n=0] 
[15:32:23.038] Finding globals ... DONE
[15:32:23.039]  - use_args: TRUE
[15:32:23.039]  - Getting '...' globals ...
[15:32:23.040] resolve() on list ...
[15:32:23.040]  recursive: 0
[15:32:23.041]  length: 1
[15:32:23.041]  elements: '...'
[15:32:23.041]  length: 0 (resolved future 1)
[15:32:23.042] resolve() on list ... DONE
[15:32:23.042]    - '...' content: [n=0] 
[15:32:23.042] List of 1
[15:32:23.042]  $ ...: list()
[15:32:23.042]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:23.042]  - attr(*, "where")=List of 1
[15:32:23.042]   ..$ ...:<environment: 0x00000276e1a52840> 
[15:32:23.042]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:23.042]  - attr(*, "resolved")= logi TRUE
[15:32:23.042]  - attr(*, "total_size")= num NA
[15:32:23.048]  - Getting '...' globals ... DONE
[15:32:23.048] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:23.049] List of 2
[15:32:23.049]  $ ...future.FUN:function (x, ...)  
[15:32:23.049]  $ ...          : list()
[15:32:23.049]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:23.049]  - attr(*, "where")=List of 2
[15:32:23.049]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:23.049]   ..$ ...          :<environment: 0x00000276e1a52840> 
[15:32:23.049]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:23.049]  - attr(*, "resolved")= logi FALSE
[15:32:23.049]  - attr(*, "total_size")= num 1248
[15:32:23.055] Packages to be attached in all futures: [n=0] 
[15:32:23.055] getGlobalsAndPackagesXApply() ... DONE
[15:32:23.055] Number of futures (= number of chunks): 1
[15:32:23.056] Launching 1 futures (chunks) ...
[15:32:23.056] Chunk #1 of 1 ...
[15:32:23.056]  - Finding globals in 'X' for chunk #1 ...
[15:32:23.057] getGlobalsAndPackages() ...
[15:32:23.057] Searching for globals...
[15:32:23.058] 
[15:32:23.058] Searching for globals ... DONE
[15:32:23.058] - globals: [0] <none>
[15:32:23.059] getGlobalsAndPackages() ... DONE
[15:32:23.059]    + additional globals found: [n=0] 
[15:32:23.059]    + additional namespaces needed: [n=0] 
[15:32:23.060]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:23.060]  - seeds: <none>
[15:32:23.060]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:23.060] getGlobalsAndPackages() ...
[15:32:23.061] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:23.061] Resolving globals: FALSE
[15:32:23.061] Tweak future expression to call with '...' arguments ...
[15:32:23.062] {
[15:32:23.062]     do.call(function(...) {
[15:32:23.062]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:23.062]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:23.062]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:23.062]             on.exit(options(oopts), add = TRUE)
[15:32:23.062]         }
[15:32:23.062]         {
[15:32:23.062]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:23.062]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:23.062]                 ...future.FUN(...future.X_jj, ...)
[15:32:23.062]             })
[15:32:23.062]         }
[15:32:23.062]     }, args = future.call.arguments)
[15:32:23.062] }
[15:32:23.063] Tweak future expression to call with '...' arguments ... DONE
[15:32:23.064] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:23.064] 
[15:32:23.064] getGlobalsAndPackages() ... DONE
[15:32:23.065] run() for 'Future' ...
[15:32:23.065] - state: 'created'
[15:32:23.066] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:23.067] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:23.067] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:23.067]   - Field: 'label'
[15:32:23.068]   - Field: 'local'
[15:32:23.068]   - Field: 'owner'
[15:32:23.068]   - Field: 'envir'
[15:32:23.069]   - Field: 'packages'
[15:32:23.069]   - Field: 'gc'
[15:32:23.070]   - Field: 'conditions'
[15:32:23.073]   - Field: 'expr'
[15:32:23.073]   - Field: 'uuid'
[15:32:23.074]   - Field: 'seed'
[15:32:23.074]   - Field: 'version'
[15:32:23.075]   - Field: 'result'
[15:32:23.075]   - Field: 'asynchronous'
[15:32:23.075]   - Field: 'calls'
[15:32:23.076]   - Field: 'globals'
[15:32:23.076]   - Field: 'stdout'
[15:32:23.076]   - Field: 'earlySignal'
[15:32:23.077]   - Field: 'lazy'
[15:32:23.077]   - Field: 'state'
[15:32:23.077] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:23.078] - Launch lazy future ...
[15:32:23.078] Packages needed by the future expression (n = 0): <none>
[15:32:23.079] Packages needed by future strategies (n = 0): <none>
[15:32:23.080] {
[15:32:23.080]     {
[15:32:23.080]         {
[15:32:23.080]             ...future.startTime <- base::Sys.time()
[15:32:23.080]             {
[15:32:23.080]                 {
[15:32:23.080]                   {
[15:32:23.080]                     base::local({
[15:32:23.080]                       has_future <- base::requireNamespace("future", 
[15:32:23.080]                         quietly = TRUE)
[15:32:23.080]                       if (has_future) {
[15:32:23.080]                         ns <- base::getNamespace("future")
[15:32:23.080]                         version <- ns[[".package"]][["version"]]
[15:32:23.080]                         if (is.null(version)) 
[15:32:23.080]                           version <- utils::packageVersion("future")
[15:32:23.080]                       }
[15:32:23.080]                       else {
[15:32:23.080]                         version <- NULL
[15:32:23.080]                       }
[15:32:23.080]                       if (!has_future || version < "1.8.0") {
[15:32:23.080]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:23.080]                           "", base::R.version$version.string), 
[15:32:23.080]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:23.080]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:23.080]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:23.080]                             "release", "version")], collapse = " "), 
[15:32:23.080]                           hostname = base::Sys.info()[["nodename"]])
[15:32:23.080]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:23.080]                           info)
[15:32:23.080]                         info <- base::paste(info, collapse = "; ")
[15:32:23.080]                         if (!has_future) {
[15:32:23.080]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:23.080]                             info)
[15:32:23.080]                         }
[15:32:23.080]                         else {
[15:32:23.080]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:23.080]                             info, version)
[15:32:23.080]                         }
[15:32:23.080]                         base::stop(msg)
[15:32:23.080]                       }
[15:32:23.080]                     })
[15:32:23.080]                   }
[15:32:23.080]                   ...future.strategy.old <- future::plan("list")
[15:32:23.080]                   options(future.plan = NULL)
[15:32:23.080]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:23.080]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:23.080]                 }
[15:32:23.080]                 ...future.workdir <- getwd()
[15:32:23.080]             }
[15:32:23.080]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:23.080]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:23.080]         }
[15:32:23.080]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:23.080]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:23.080]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:23.080]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:23.080]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:23.080]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:23.080]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:23.080]             base::names(...future.oldOptions))
[15:32:23.080]     }
[15:32:23.080]     if (FALSE) {
[15:32:23.080]     }
[15:32:23.080]     else {
[15:32:23.080]         if (TRUE) {
[15:32:23.080]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:23.080]                 open = "w")
[15:32:23.080]         }
[15:32:23.080]         else {
[15:32:23.080]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:23.080]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:23.080]         }
[15:32:23.080]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:23.080]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:23.080]             base::sink(type = "output", split = FALSE)
[15:32:23.080]             base::close(...future.stdout)
[15:32:23.080]         }, add = TRUE)
[15:32:23.080]     }
[15:32:23.080]     ...future.frame <- base::sys.nframe()
[15:32:23.080]     ...future.conditions <- base::list()
[15:32:23.080]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:23.080]     if (FALSE) {
[15:32:23.080]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:23.080]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:23.080]     }
[15:32:23.080]     ...future.result <- base::tryCatch({
[15:32:23.080]         base::withCallingHandlers({
[15:32:23.080]             ...future.value <- base::withVisible(base::local({
[15:32:23.080]                 do.call(function(...) {
[15:32:23.080]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:23.080]                   if (!identical(...future.globals.maxSize.org, 
[15:32:23.080]                     ...future.globals.maxSize)) {
[15:32:23.080]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:23.080]                     on.exit(options(oopts), add = TRUE)
[15:32:23.080]                   }
[15:32:23.080]                   {
[15:32:23.080]                     lapply(seq_along(...future.elements_ii), 
[15:32:23.080]                       FUN = function(jj) {
[15:32:23.080]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:23.080]                         ...future.FUN(...future.X_jj, ...)
[15:32:23.080]                       })
[15:32:23.080]                   }
[15:32:23.080]                 }, args = future.call.arguments)
[15:32:23.080]             }))
[15:32:23.080]             future::FutureResult(value = ...future.value$value, 
[15:32:23.080]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:23.080]                   ...future.rng), globalenv = if (FALSE) 
[15:32:23.080]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:23.080]                     ...future.globalenv.names))
[15:32:23.080]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:23.080]         }, condition = base::local({
[15:32:23.080]             c <- base::c
[15:32:23.080]             inherits <- base::inherits
[15:32:23.080]             invokeRestart <- base::invokeRestart
[15:32:23.080]             length <- base::length
[15:32:23.080]             list <- base::list
[15:32:23.080]             seq.int <- base::seq.int
[15:32:23.080]             signalCondition <- base::signalCondition
[15:32:23.080]             sys.calls <- base::sys.calls
[15:32:23.080]             `[[` <- base::`[[`
[15:32:23.080]             `+` <- base::`+`
[15:32:23.080]             `<<-` <- base::`<<-`
[15:32:23.080]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:23.080]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:23.080]                   3L)]
[15:32:23.080]             }
[15:32:23.080]             function(cond) {
[15:32:23.080]                 is_error <- inherits(cond, "error")
[15:32:23.080]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:23.080]                   NULL)
[15:32:23.080]                 if (is_error) {
[15:32:23.080]                   sessionInformation <- function() {
[15:32:23.080]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:23.080]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:23.080]                       search = base::search(), system = base::Sys.info())
[15:32:23.080]                   }
[15:32:23.080]                   ...future.conditions[[length(...future.conditions) + 
[15:32:23.080]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:23.080]                     cond$call), session = sessionInformation(), 
[15:32:23.080]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:23.080]                   signalCondition(cond)
[15:32:23.080]                 }
[15:32:23.080]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:23.080]                 "immediateCondition"))) {
[15:32:23.080]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:23.080]                   ...future.conditions[[length(...future.conditions) + 
[15:32:23.080]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:23.080]                   if (TRUE && !signal) {
[15:32:23.080]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:23.080]                     {
[15:32:23.080]                       inherits <- base::inherits
[15:32:23.080]                       invokeRestart <- base::invokeRestart
[15:32:23.080]                       is.null <- base::is.null
[15:32:23.080]                       muffled <- FALSE
[15:32:23.080]                       if (inherits(cond, "message")) {
[15:32:23.080]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:23.080]                         if (muffled) 
[15:32:23.080]                           invokeRestart("muffleMessage")
[15:32:23.080]                       }
[15:32:23.080]                       else if (inherits(cond, "warning")) {
[15:32:23.080]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:23.080]                         if (muffled) 
[15:32:23.080]                           invokeRestart("muffleWarning")
[15:32:23.080]                       }
[15:32:23.080]                       else if (inherits(cond, "condition")) {
[15:32:23.080]                         if (!is.null(pattern)) {
[15:32:23.080]                           computeRestarts <- base::computeRestarts
[15:32:23.080]                           grepl <- base::grepl
[15:32:23.080]                           restarts <- computeRestarts(cond)
[15:32:23.080]                           for (restart in restarts) {
[15:32:23.080]                             name <- restart$name
[15:32:23.080]                             if (is.null(name)) 
[15:32:23.080]                               next
[15:32:23.080]                             if (!grepl(pattern, name)) 
[15:32:23.080]                               next
[15:32:23.080]                             invokeRestart(restart)
[15:32:23.080]                             muffled <- TRUE
[15:32:23.080]                             break
[15:32:23.080]                           }
[15:32:23.080]                         }
[15:32:23.080]                       }
[15:32:23.080]                       invisible(muffled)
[15:32:23.080]                     }
[15:32:23.080]                     muffleCondition(cond, pattern = "^muffle")
[15:32:23.080]                   }
[15:32:23.080]                 }
[15:32:23.080]                 else {
[15:32:23.080]                   if (TRUE) {
[15:32:23.080]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:23.080]                     {
[15:32:23.080]                       inherits <- base::inherits
[15:32:23.080]                       invokeRestart <- base::invokeRestart
[15:32:23.080]                       is.null <- base::is.null
[15:32:23.080]                       muffled <- FALSE
[15:32:23.080]                       if (inherits(cond, "message")) {
[15:32:23.080]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:23.080]                         if (muffled) 
[15:32:23.080]                           invokeRestart("muffleMessage")
[15:32:23.080]                       }
[15:32:23.080]                       else if (inherits(cond, "warning")) {
[15:32:23.080]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:23.080]                         if (muffled) 
[15:32:23.080]                           invokeRestart("muffleWarning")
[15:32:23.080]                       }
[15:32:23.080]                       else if (inherits(cond, "condition")) {
[15:32:23.080]                         if (!is.null(pattern)) {
[15:32:23.080]                           computeRestarts <- base::computeRestarts
[15:32:23.080]                           grepl <- base::grepl
[15:32:23.080]                           restarts <- computeRestarts(cond)
[15:32:23.080]                           for (restart in restarts) {
[15:32:23.080]                             name <- restart$name
[15:32:23.080]                             if (is.null(name)) 
[15:32:23.080]                               next
[15:32:23.080]                             if (!grepl(pattern, name)) 
[15:32:23.080]                               next
[15:32:23.080]                             invokeRestart(restart)
[15:32:23.080]                             muffled <- TRUE
[15:32:23.080]                             break
[15:32:23.080]                           }
[15:32:23.080]                         }
[15:32:23.080]                       }
[15:32:23.080]                       invisible(muffled)
[15:32:23.080]                     }
[15:32:23.080]                     muffleCondition(cond, pattern = "^muffle")
[15:32:23.080]                   }
[15:32:23.080]                 }
[15:32:23.080]             }
[15:32:23.080]         }))
[15:32:23.080]     }, error = function(ex) {
[15:32:23.080]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:23.080]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:23.080]                 ...future.rng), started = ...future.startTime, 
[15:32:23.080]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:23.080]             version = "1.8"), class = "FutureResult")
[15:32:23.080]     }, finally = {
[15:32:23.080]         if (!identical(...future.workdir, getwd())) 
[15:32:23.080]             setwd(...future.workdir)
[15:32:23.080]         {
[15:32:23.080]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:23.080]                 ...future.oldOptions$nwarnings <- NULL
[15:32:23.080]             }
[15:32:23.080]             base::options(...future.oldOptions)
[15:32:23.080]             if (.Platform$OS.type == "windows") {
[15:32:23.080]                 old_names <- names(...future.oldEnvVars)
[15:32:23.080]                 envs <- base::Sys.getenv()
[15:32:23.080]                 names <- names(envs)
[15:32:23.080]                 common <- intersect(names, old_names)
[15:32:23.080]                 added <- setdiff(names, old_names)
[15:32:23.080]                 removed <- setdiff(old_names, names)
[15:32:23.080]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:23.080]                   envs[common]]
[15:32:23.080]                 NAMES <- toupper(changed)
[15:32:23.080]                 args <- list()
[15:32:23.080]                 for (kk in seq_along(NAMES)) {
[15:32:23.080]                   name <- changed[[kk]]
[15:32:23.080]                   NAME <- NAMES[[kk]]
[15:32:23.080]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:23.080]                     next
[15:32:23.080]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:23.080]                 }
[15:32:23.080]                 NAMES <- toupper(added)
[15:32:23.080]                 for (kk in seq_along(NAMES)) {
[15:32:23.080]                   name <- added[[kk]]
[15:32:23.080]                   NAME <- NAMES[[kk]]
[15:32:23.080]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:23.080]                     next
[15:32:23.080]                   args[[name]] <- ""
[15:32:23.080]                 }
[15:32:23.080]                 NAMES <- toupper(removed)
[15:32:23.080]                 for (kk in seq_along(NAMES)) {
[15:32:23.080]                   name <- removed[[kk]]
[15:32:23.080]                   NAME <- NAMES[[kk]]
[15:32:23.080]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:23.080]                     next
[15:32:23.080]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:23.080]                 }
[15:32:23.080]                 if (length(args) > 0) 
[15:32:23.080]                   base::do.call(base::Sys.setenv, args = args)
[15:32:23.080]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:23.080]             }
[15:32:23.080]             else {
[15:32:23.080]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:23.080]             }
[15:32:23.080]             {
[15:32:23.080]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:23.080]                   0L) {
[15:32:23.080]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:23.080]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:23.080]                   base::options(opts)
[15:32:23.080]                 }
[15:32:23.080]                 {
[15:32:23.080]                   {
[15:32:23.080]                     NULL
[15:32:23.080]                     RNGkind("Mersenne-Twister")
[15:32:23.080]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:23.080]                       inherits = FALSE)
[15:32:23.080]                   }
[15:32:23.080]                   options(future.plan = NULL)
[15:32:23.080]                   if (is.na(NA_character_)) 
[15:32:23.080]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:23.080]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:23.080]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:23.080]                     .init = FALSE)
[15:32:23.080]                 }
[15:32:23.080]             }
[15:32:23.080]         }
[15:32:23.080]     })
[15:32:23.080]     if (TRUE) {
[15:32:23.080]         base::sink(type = "output", split = FALSE)
[15:32:23.080]         if (TRUE) {
[15:32:23.080]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:23.080]         }
[15:32:23.080]         else {
[15:32:23.080]             ...future.result["stdout"] <- base::list(NULL)
[15:32:23.080]         }
[15:32:23.080]         base::close(...future.stdout)
[15:32:23.080]         ...future.stdout <- NULL
[15:32:23.080]     }
[15:32:23.080]     ...future.result$conditions <- ...future.conditions
[15:32:23.080]     ...future.result$finished <- base::Sys.time()
[15:32:23.080]     ...future.result
[15:32:23.080] }
[15:32:23.088] assign_globals() ...
[15:32:23.088] List of 5
[15:32:23.088]  $ ...future.FUN            :function (x, ...)  
[15:32:23.088]  $ future.call.arguments    : list()
[15:32:23.088]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:23.088]  $ ...future.elements_ii    :List of 3
[15:32:23.088]   ..$ : chr "a"
[15:32:23.088]   ..$ : chr "b"
[15:32:23.088]   ..$ : chr "c"
[15:32:23.088]  $ ...future.seeds_ii       : NULL
[15:32:23.088]  $ ...future.globals.maxSize: NULL
[15:32:23.088]  - attr(*, "where")=List of 5
[15:32:23.088]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:23.088]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:23.088]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:23.088]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:23.088]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:23.088]  - attr(*, "resolved")= logi FALSE
[15:32:23.088]  - attr(*, "total_size")= num 1248
[15:32:23.088]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:23.088]  - attr(*, "already-done")= logi TRUE
[15:32:23.100] - copied '...future.FUN' to environment
[15:32:23.101] - copied 'future.call.arguments' to environment
[15:32:23.101] - copied '...future.elements_ii' to environment
[15:32:23.101] - copied '...future.seeds_ii' to environment
[15:32:23.102] - copied '...future.globals.maxSize' to environment
[15:32:23.102] assign_globals() ... done
[15:32:23.103] plan(): Setting new future strategy stack:
[15:32:23.103] List of future strategies:
[15:32:23.103] 1. sequential:
[15:32:23.103]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:23.103]    - tweaked: FALSE
[15:32:23.103]    - call: NULL
[15:32:23.104] plan(): nbrOfWorkers() = 1
[15:32:23.107] plan(): Setting new future strategy stack:
[15:32:23.107] List of future strategies:
[15:32:23.107] 1. sequential:
[15:32:23.107]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:23.107]    - tweaked: FALSE
[15:32:23.107]    - call: plan(strategy)
[15:32:23.108] plan(): nbrOfWorkers() = 1
[15:32:23.109] SequentialFuture started (and completed)
[15:32:23.109] - Launch lazy future ... done
[15:32:23.109] run() for 'SequentialFuture' ... done
[15:32:23.110] Created future:
[15:32:23.110] SequentialFuture:
[15:32:23.110] Label: 'future_sapply-1'
[15:32:23.110] Expression:
[15:32:23.110] {
[15:32:23.110]     do.call(function(...) {
[15:32:23.110]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:23.110]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:23.110]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:23.110]             on.exit(options(oopts), add = TRUE)
[15:32:23.110]         }
[15:32:23.110]         {
[15:32:23.110]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:23.110]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:23.110]                 ...future.FUN(...future.X_jj, ...)
[15:32:23.110]             })
[15:32:23.110]         }
[15:32:23.110]     }, args = future.call.arguments)
[15:32:23.110] }
[15:32:23.110] Lazy evaluation: FALSE
[15:32:23.110] Asynchronous evaluation: FALSE
[15:32:23.110] Local evaluation: TRUE
[15:32:23.110] Environment: R_GlobalEnv
[15:32:23.110] Capture standard output: TRUE
[15:32:23.110] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:23.110] Globals: 5 objects totaling 1.55 KiB (function '...future.FUN' of 1.22 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 336 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:23.110] Packages: <none>
[15:32:23.110] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:23.110] Resolved: TRUE
[15:32:23.110] Value: 840 bytes of class 'list'
[15:32:23.110] Early signaling: FALSE
[15:32:23.110] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:23.110] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:23.112] Chunk #1 of 1 ... DONE
[15:32:23.113] Launching 1 futures (chunks) ... DONE
[15:32:23.113] Resolving 1 futures (chunks) ...
[15:32:23.113] resolve() on list ...
[15:32:23.114]  recursive: 0
[15:32:23.114]  length: 1
[15:32:23.114] 
[15:32:23.115] resolved() for 'SequentialFuture' ...
[15:32:23.115] - state: 'finished'
[15:32:23.115] - run: TRUE
[15:32:23.116] - result: 'FutureResult'
[15:32:23.116] resolved() for 'SequentialFuture' ... done
[15:32:23.116] Future #1
[15:32:23.117] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:23.117] - nx: 1
[15:32:23.117] - relay: TRUE
[15:32:23.118] - stdout: TRUE
[15:32:23.118] - signal: TRUE
[15:32:23.118] - resignal: FALSE
[15:32:23.119] - force: TRUE
[15:32:23.119] - relayed: [n=1] FALSE
[15:32:23.119] - queued futures: [n=1] FALSE
[15:32:23.120]  - until=1
[15:32:23.120]  - relaying element #1
[15:32:23.120] - relayed: [n=1] TRUE
[15:32:23.121] - queued futures: [n=1] TRUE
[15:32:23.121] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:23.121]  length: 0 (resolved future 1)
[15:32:23.122] Relaying remaining futures
[15:32:23.122] signalConditionsASAP(NULL, pos=0) ...
[15:32:23.122] - nx: 1
[15:32:23.122] - relay: TRUE
[15:32:23.123] - stdout: TRUE
[15:32:23.123] - signal: TRUE
[15:32:23.123] - resignal: FALSE
[15:32:23.124] - force: TRUE
[15:32:23.124] - relayed: [n=1] TRUE
[15:32:23.124] - queued futures: [n=1] TRUE
 - flush all
[15:32:23.125] - relayed: [n=1] TRUE
[15:32:23.125] - queued futures: [n=1] TRUE
[15:32:23.125] signalConditionsASAP(NULL, pos=0) ... done
[15:32:23.126] resolve() on list ... DONE
[15:32:23.126]  - Number of value chunks collected: 1
[15:32:23.126] Resolving 1 futures (chunks) ... DONE
[15:32:23.127] Reducing values from 1 chunks ...
[15:32:23.127]  - Number of values collected after concatenation: 3
[15:32:23.127]  - Number of values expected: 3
[15:32:23.128] Reducing values from 1 chunks ... DONE
[15:32:23.128] future_lapply() ... DONE
List of 2
 $ y0:List of 3
  ..$ : chr [1, 1] "a"
  ..$ : chr [1, 1] "b"
  ..$ : chr [1, 1] "c"
 $ y1:List of 3
  ..$ : chr [1, 1] "a"
  ..$ : chr [1, 1] "b"
  ..$ : chr [1, 1] "c"
List of 2
 $ y0:List of 3
  ..$ : chr [1, 1] "a"
  ..$ : chr [1, 1] "b"
  ..$ : chr [1, 1] "c"
 $ y2:List of 3
  ..$ : chr [1, 1] "a"
  ..$ : chr [1, 1] "b"
  ..$ : chr [1, 1] "c"
[15:32:23.144] future_lapply() ...
[15:32:23.146] Number of chunks: 1
[15:32:23.146] getGlobalsAndPackagesXApply() ...
[15:32:23.146]  - future.globals: TRUE
[15:32:23.147] getGlobalsAndPackages() ...
[15:32:23.147] Searching for globals...
[15:32:23.149] - globals found: [1] 'FUN'
[15:32:23.150] Searching for globals ... DONE
[15:32:23.150] Resolving globals: FALSE
[15:32:23.151] The total size of the 1 globals is 848 bytes (848 bytes)
[15:32:23.151] The total size of the 1 globals exported for future expression ('FUN()') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:32:23.152] - globals: [1] 'FUN'
[15:32:23.152] 
[15:32:23.152] getGlobalsAndPackages() ... DONE
[15:32:23.153]  - globals found/used: [n=1] 'FUN'
[15:32:23.153]  - needed namespaces: [n=0] 
[15:32:23.153] Finding globals ... DONE
[15:32:23.154]  - use_args: TRUE
[15:32:23.154]  - Getting '...' globals ...
[15:32:23.155] resolve() on list ...
[15:32:23.155]  recursive: 0
[15:32:23.155]  length: 1
[15:32:23.156]  elements: '...'
[15:32:23.156]  length: 0 (resolved future 1)
[15:32:23.156] resolve() on list ... DONE
[15:32:23.157]    - '...' content: [n=0] 
[15:32:23.157] List of 1
[15:32:23.157]  $ ...: list()
[15:32:23.157]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:23.157]  - attr(*, "where")=List of 1
[15:32:23.157]   ..$ ...:<environment: 0x00000276e017fdf0> 
[15:32:23.157]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:23.157]  - attr(*, "resolved")= logi TRUE
[15:32:23.157]  - attr(*, "total_size")= num NA
[15:32:23.162]  - Getting '...' globals ... DONE
[15:32:23.162] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:23.162] List of 2
[15:32:23.162]  $ ...future.FUN:function (x)  
[15:32:23.162]  $ ...          : list()
[15:32:23.162]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:23.162]  - attr(*, "where")=List of 2
[15:32:23.162]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:23.162]   ..$ ...          :<environment: 0x00000276e017fdf0> 
[15:32:23.162]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:23.162]  - attr(*, "resolved")= logi FALSE
[15:32:23.162]  - attr(*, "total_size")= num 848
[15:32:23.166] Packages to be attached in all futures: [n=0] 
[15:32:23.166] getGlobalsAndPackagesXApply() ... DONE
[15:32:23.167] Number of futures (= number of chunks): 1
[15:32:23.167] Launching 1 futures (chunks) ...
[15:32:23.167] Chunk #1 of 1 ...
[15:32:23.167]  - Finding globals in 'X' for chunk #1 ...
[15:32:23.168] getGlobalsAndPackages() ...
[15:32:23.168] Searching for globals...
[15:32:23.168] 
[15:32:23.169] Searching for globals ... DONE
[15:32:23.169] - globals: [0] <none>
[15:32:23.169] getGlobalsAndPackages() ... DONE
[15:32:23.169]    + additional globals found: [n=0] 
[15:32:23.170]    + additional namespaces needed: [n=0] 
[15:32:23.173]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:23.174]  - seeds: <none>
[15:32:23.174]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:23.174] getGlobalsAndPackages() ...
[15:32:23.175] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:23.175] Resolving globals: FALSE
[15:32:23.176] Tweak future expression to call with '...' arguments ...
[15:32:23.176] {
[15:32:23.176]     do.call(function(...) {
[15:32:23.176]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:23.176]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:23.176]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:23.176]             on.exit(options(oopts), add = TRUE)
[15:32:23.176]         }
[15:32:23.176]         {
[15:32:23.176]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:23.176]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:23.176]                 ...future.FUN(...future.X_jj, ...)
[15:32:23.176]             })
[15:32:23.176]         }
[15:32:23.176]     }, args = future.call.arguments)
[15:32:23.176] }
[15:32:23.177] Tweak future expression to call with '...' arguments ... DONE
[15:32:23.178] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:23.179] 
[15:32:23.179] getGlobalsAndPackages() ... DONE
[15:32:23.180] run() for 'Future' ...
[15:32:23.180] - state: 'created'
[15:32:23.181] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:23.182] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:23.182] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:23.182]   - Field: 'label'
[15:32:23.183]   - Field: 'local'
[15:32:23.183]   - Field: 'owner'
[15:32:23.184]   - Field: 'envir'
[15:32:23.184]   - Field: 'packages'
[15:32:23.185]   - Field: 'gc'
[15:32:23.185]   - Field: 'conditions'
[15:32:23.185]   - Field: 'expr'
[15:32:23.186]   - Field: 'uuid'
[15:32:23.186]   - Field: 'seed'
[15:32:23.187]   - Field: 'version'
[15:32:23.187]   - Field: 'result'
[15:32:23.188]   - Field: 'asynchronous'
[15:32:23.188]   - Field: 'calls'
[15:32:23.189]   - Field: 'globals'
[15:32:23.189]   - Field: 'stdout'
[15:32:23.189]   - Field: 'earlySignal'
[15:32:23.190]   - Field: 'lazy'
[15:32:23.190]   - Field: 'state'
[15:32:23.191] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:23.191] - Launch lazy future ...
[15:32:23.192] Packages needed by the future expression (n = 0): <none>
[15:32:23.192] Packages needed by future strategies (n = 0): <none>
[15:32:23.193] {
[15:32:23.193]     {
[15:32:23.193]         {
[15:32:23.193]             ...future.startTime <- base::Sys.time()
[15:32:23.193]             {
[15:32:23.193]                 {
[15:32:23.193]                   {
[15:32:23.193]                     base::local({
[15:32:23.193]                       has_future <- base::requireNamespace("future", 
[15:32:23.193]                         quietly = TRUE)
[15:32:23.193]                       if (has_future) {
[15:32:23.193]                         ns <- base::getNamespace("future")
[15:32:23.193]                         version <- ns[[".package"]][["version"]]
[15:32:23.193]                         if (is.null(version)) 
[15:32:23.193]                           version <- utils::packageVersion("future")
[15:32:23.193]                       }
[15:32:23.193]                       else {
[15:32:23.193]                         version <- NULL
[15:32:23.193]                       }
[15:32:23.193]                       if (!has_future || version < "1.8.0") {
[15:32:23.193]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:23.193]                           "", base::R.version$version.string), 
[15:32:23.193]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:23.193]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:23.193]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:23.193]                             "release", "version")], collapse = " "), 
[15:32:23.193]                           hostname = base::Sys.info()[["nodename"]])
[15:32:23.193]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:23.193]                           info)
[15:32:23.193]                         info <- base::paste(info, collapse = "; ")
[15:32:23.193]                         if (!has_future) {
[15:32:23.193]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:23.193]                             info)
[15:32:23.193]                         }
[15:32:23.193]                         else {
[15:32:23.193]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:23.193]                             info, version)
[15:32:23.193]                         }
[15:32:23.193]                         base::stop(msg)
[15:32:23.193]                       }
[15:32:23.193]                     })
[15:32:23.193]                   }
[15:32:23.193]                   ...future.strategy.old <- future::plan("list")
[15:32:23.193]                   options(future.plan = NULL)
[15:32:23.193]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:23.193]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:23.193]                 }
[15:32:23.193]                 ...future.workdir <- getwd()
[15:32:23.193]             }
[15:32:23.193]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:23.193]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:23.193]         }
[15:32:23.193]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:23.193]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:23.193]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:23.193]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:23.193]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:23.193]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:23.193]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:23.193]             base::names(...future.oldOptions))
[15:32:23.193]     }
[15:32:23.193]     if (FALSE) {
[15:32:23.193]     }
[15:32:23.193]     else {
[15:32:23.193]         if (TRUE) {
[15:32:23.193]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:23.193]                 open = "w")
[15:32:23.193]         }
[15:32:23.193]         else {
[15:32:23.193]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:23.193]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:23.193]         }
[15:32:23.193]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:23.193]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:23.193]             base::sink(type = "output", split = FALSE)
[15:32:23.193]             base::close(...future.stdout)
[15:32:23.193]         }, add = TRUE)
[15:32:23.193]     }
[15:32:23.193]     ...future.frame <- base::sys.nframe()
[15:32:23.193]     ...future.conditions <- base::list()
[15:32:23.193]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:23.193]     if (FALSE) {
[15:32:23.193]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:23.193]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:23.193]     }
[15:32:23.193]     ...future.result <- base::tryCatch({
[15:32:23.193]         base::withCallingHandlers({
[15:32:23.193]             ...future.value <- base::withVisible(base::local({
[15:32:23.193]                 do.call(function(...) {
[15:32:23.193]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:23.193]                   if (!identical(...future.globals.maxSize.org, 
[15:32:23.193]                     ...future.globals.maxSize)) {
[15:32:23.193]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:23.193]                     on.exit(options(oopts), add = TRUE)
[15:32:23.193]                   }
[15:32:23.193]                   {
[15:32:23.193]                     lapply(seq_along(...future.elements_ii), 
[15:32:23.193]                       FUN = function(jj) {
[15:32:23.193]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:23.193]                         ...future.FUN(...future.X_jj, ...)
[15:32:23.193]                       })
[15:32:23.193]                   }
[15:32:23.193]                 }, args = future.call.arguments)
[15:32:23.193]             }))
[15:32:23.193]             future::FutureResult(value = ...future.value$value, 
[15:32:23.193]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:23.193]                   ...future.rng), globalenv = if (FALSE) 
[15:32:23.193]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:23.193]                     ...future.globalenv.names))
[15:32:23.193]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:23.193]         }, condition = base::local({
[15:32:23.193]             c <- base::c
[15:32:23.193]             inherits <- base::inherits
[15:32:23.193]             invokeRestart <- base::invokeRestart
[15:32:23.193]             length <- base::length
[15:32:23.193]             list <- base::list
[15:32:23.193]             seq.int <- base::seq.int
[15:32:23.193]             signalCondition <- base::signalCondition
[15:32:23.193]             sys.calls <- base::sys.calls
[15:32:23.193]             `[[` <- base::`[[`
[15:32:23.193]             `+` <- base::`+`
[15:32:23.193]             `<<-` <- base::`<<-`
[15:32:23.193]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:23.193]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:23.193]                   3L)]
[15:32:23.193]             }
[15:32:23.193]             function(cond) {
[15:32:23.193]                 is_error <- inherits(cond, "error")
[15:32:23.193]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:23.193]                   NULL)
[15:32:23.193]                 if (is_error) {
[15:32:23.193]                   sessionInformation <- function() {
[15:32:23.193]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:23.193]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:23.193]                       search = base::search(), system = base::Sys.info())
[15:32:23.193]                   }
[15:32:23.193]                   ...future.conditions[[length(...future.conditions) + 
[15:32:23.193]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:23.193]                     cond$call), session = sessionInformation(), 
[15:32:23.193]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:23.193]                   signalCondition(cond)
[15:32:23.193]                 }
[15:32:23.193]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:23.193]                 "immediateCondition"))) {
[15:32:23.193]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:23.193]                   ...future.conditions[[length(...future.conditions) + 
[15:32:23.193]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:23.193]                   if (TRUE && !signal) {
[15:32:23.193]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:23.193]                     {
[15:32:23.193]                       inherits <- base::inherits
[15:32:23.193]                       invokeRestart <- base::invokeRestart
[15:32:23.193]                       is.null <- base::is.null
[15:32:23.193]                       muffled <- FALSE
[15:32:23.193]                       if (inherits(cond, "message")) {
[15:32:23.193]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:23.193]                         if (muffled) 
[15:32:23.193]                           invokeRestart("muffleMessage")
[15:32:23.193]                       }
[15:32:23.193]                       else if (inherits(cond, "warning")) {
[15:32:23.193]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:23.193]                         if (muffled) 
[15:32:23.193]                           invokeRestart("muffleWarning")
[15:32:23.193]                       }
[15:32:23.193]                       else if (inherits(cond, "condition")) {
[15:32:23.193]                         if (!is.null(pattern)) {
[15:32:23.193]                           computeRestarts <- base::computeRestarts
[15:32:23.193]                           grepl <- base::grepl
[15:32:23.193]                           restarts <- computeRestarts(cond)
[15:32:23.193]                           for (restart in restarts) {
[15:32:23.193]                             name <- restart$name
[15:32:23.193]                             if (is.null(name)) 
[15:32:23.193]                               next
[15:32:23.193]                             if (!grepl(pattern, name)) 
[15:32:23.193]                               next
[15:32:23.193]                             invokeRestart(restart)
[15:32:23.193]                             muffled <- TRUE
[15:32:23.193]                             break
[15:32:23.193]                           }
[15:32:23.193]                         }
[15:32:23.193]                       }
[15:32:23.193]                       invisible(muffled)
[15:32:23.193]                     }
[15:32:23.193]                     muffleCondition(cond, pattern = "^muffle")
[15:32:23.193]                   }
[15:32:23.193]                 }
[15:32:23.193]                 else {
[15:32:23.193]                   if (TRUE) {
[15:32:23.193]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:23.193]                     {
[15:32:23.193]                       inherits <- base::inherits
[15:32:23.193]                       invokeRestart <- base::invokeRestart
[15:32:23.193]                       is.null <- base::is.null
[15:32:23.193]                       muffled <- FALSE
[15:32:23.193]                       if (inherits(cond, "message")) {
[15:32:23.193]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:23.193]                         if (muffled) 
[15:32:23.193]                           invokeRestart("muffleMessage")
[15:32:23.193]                       }
[15:32:23.193]                       else if (inherits(cond, "warning")) {
[15:32:23.193]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:23.193]                         if (muffled) 
[15:32:23.193]                           invokeRestart("muffleWarning")
[15:32:23.193]                       }
[15:32:23.193]                       else if (inherits(cond, "condition")) {
[15:32:23.193]                         if (!is.null(pattern)) {
[15:32:23.193]                           computeRestarts <- base::computeRestarts
[15:32:23.193]                           grepl <- base::grepl
[15:32:23.193]                           restarts <- computeRestarts(cond)
[15:32:23.193]                           for (restart in restarts) {
[15:32:23.193]                             name <- restart$name
[15:32:23.193]                             if (is.null(name)) 
[15:32:23.193]                               next
[15:32:23.193]                             if (!grepl(pattern, name)) 
[15:32:23.193]                               next
[15:32:23.193]                             invokeRestart(restart)
[15:32:23.193]                             muffled <- TRUE
[15:32:23.193]                             break
[15:32:23.193]                           }
[15:32:23.193]                         }
[15:32:23.193]                       }
[15:32:23.193]                       invisible(muffled)
[15:32:23.193]                     }
[15:32:23.193]                     muffleCondition(cond, pattern = "^muffle")
[15:32:23.193]                   }
[15:32:23.193]                 }
[15:32:23.193]             }
[15:32:23.193]         }))
[15:32:23.193]     }, error = function(ex) {
[15:32:23.193]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:23.193]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:23.193]                 ...future.rng), started = ...future.startTime, 
[15:32:23.193]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:23.193]             version = "1.8"), class = "FutureResult")
[15:32:23.193]     }, finally = {
[15:32:23.193]         if (!identical(...future.workdir, getwd())) 
[15:32:23.193]             setwd(...future.workdir)
[15:32:23.193]         {
[15:32:23.193]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:23.193]                 ...future.oldOptions$nwarnings <- NULL
[15:32:23.193]             }
[15:32:23.193]             base::options(...future.oldOptions)
[15:32:23.193]             if (.Platform$OS.type == "windows") {
[15:32:23.193]                 old_names <- names(...future.oldEnvVars)
[15:32:23.193]                 envs <- base::Sys.getenv()
[15:32:23.193]                 names <- names(envs)
[15:32:23.193]                 common <- intersect(names, old_names)
[15:32:23.193]                 added <- setdiff(names, old_names)
[15:32:23.193]                 removed <- setdiff(old_names, names)
[15:32:23.193]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:23.193]                   envs[common]]
[15:32:23.193]                 NAMES <- toupper(changed)
[15:32:23.193]                 args <- list()
[15:32:23.193]                 for (kk in seq_along(NAMES)) {
[15:32:23.193]                   name <- changed[[kk]]
[15:32:23.193]                   NAME <- NAMES[[kk]]
[15:32:23.193]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:23.193]                     next
[15:32:23.193]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:23.193]                 }
[15:32:23.193]                 NAMES <- toupper(added)
[15:32:23.193]                 for (kk in seq_along(NAMES)) {
[15:32:23.193]                   name <- added[[kk]]
[15:32:23.193]                   NAME <- NAMES[[kk]]
[15:32:23.193]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:23.193]                     next
[15:32:23.193]                   args[[name]] <- ""
[15:32:23.193]                 }
[15:32:23.193]                 NAMES <- toupper(removed)
[15:32:23.193]                 for (kk in seq_along(NAMES)) {
[15:32:23.193]                   name <- removed[[kk]]
[15:32:23.193]                   NAME <- NAMES[[kk]]
[15:32:23.193]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:23.193]                     next
[15:32:23.193]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:23.193]                 }
[15:32:23.193]                 if (length(args) > 0) 
[15:32:23.193]                   base::do.call(base::Sys.setenv, args = args)
[15:32:23.193]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:23.193]             }
[15:32:23.193]             else {
[15:32:23.193]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:23.193]             }
[15:32:23.193]             {
[15:32:23.193]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:23.193]                   0L) {
[15:32:23.193]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:23.193]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:23.193]                   base::options(opts)
[15:32:23.193]                 }
[15:32:23.193]                 {
[15:32:23.193]                   {
[15:32:23.193]                     NULL
[15:32:23.193]                     RNGkind("Mersenne-Twister")
[15:32:23.193]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:23.193]                       inherits = FALSE)
[15:32:23.193]                   }
[15:32:23.193]                   options(future.plan = NULL)
[15:32:23.193]                   if (is.na(NA_character_)) 
[15:32:23.193]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:23.193]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:23.193]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:23.193]                     .init = FALSE)
[15:32:23.193]                 }
[15:32:23.193]             }
[15:32:23.193]         }
[15:32:23.193]     })
[15:32:23.193]     if (TRUE) {
[15:32:23.193]         base::sink(type = "output", split = FALSE)
[15:32:23.193]         if (TRUE) {
[15:32:23.193]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:23.193]         }
[15:32:23.193]         else {
[15:32:23.193]             ...future.result["stdout"] <- base::list(NULL)
[15:32:23.193]         }
[15:32:23.193]         base::close(...future.stdout)
[15:32:23.193]         ...future.stdout <- NULL
[15:32:23.193]     }
[15:32:23.193]     ...future.result$conditions <- ...future.conditions
[15:32:23.193]     ...future.result$finished <- base::Sys.time()
[15:32:23.193]     ...future.result
[15:32:23.193] }
[15:32:23.202] assign_globals() ...
[15:32:23.202] List of 5
[15:32:23.202]  $ ...future.FUN            :function (x)  
[15:32:23.202]  $ future.call.arguments    : list()
[15:32:23.202]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:23.202]  $ ...future.elements_ii    :List of 3
[15:32:23.202]   ..$ : chr "a"
[15:32:23.202]   ..$ : chr "b"
[15:32:23.202]   ..$ : chr "c"
[15:32:23.202]  $ ...future.seeds_ii       : NULL
[15:32:23.202]  $ ...future.globals.maxSize: NULL
[15:32:23.202]  - attr(*, "where")=List of 5
[15:32:23.202]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:23.202]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:23.202]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:23.202]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:23.202]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:23.202]  - attr(*, "resolved")= logi FALSE
[15:32:23.202]  - attr(*, "total_size")= num 848
[15:32:23.202]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:23.202]  - attr(*, "already-done")= logi TRUE
[15:32:23.215] - copied '...future.FUN' to environment
[15:32:23.216] - copied 'future.call.arguments' to environment
[15:32:23.216] - copied '...future.elements_ii' to environment
[15:32:23.217] - copied '...future.seeds_ii' to environment
[15:32:23.217] - copied '...future.globals.maxSize' to environment
[15:32:23.217] assign_globals() ... done
[15:32:23.218] plan(): Setting new future strategy stack:
[15:32:23.219] List of future strategies:
[15:32:23.219] 1. sequential:
[15:32:23.219]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:23.219]    - tweaked: FALSE
[15:32:23.219]    - call: NULL
[15:32:23.220] plan(): nbrOfWorkers() = 1
[15:32:23.222] plan(): Setting new future strategy stack:
[15:32:23.223] List of future strategies:
[15:32:23.223] 1. sequential:
[15:32:23.223]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:23.223]    - tweaked: FALSE
[15:32:23.223]    - call: plan(strategy)
[15:32:23.224] plan(): nbrOfWorkers() = 1
[15:32:23.224] SequentialFuture started (and completed)
[15:32:23.225] - Launch lazy future ... done
[15:32:23.225] run() for 'SequentialFuture' ... done
[15:32:23.226] Created future:
[15:32:23.226] SequentialFuture:
[15:32:23.226] Label: 'future_sapply-1'
[15:32:23.226] Expression:
[15:32:23.226] {
[15:32:23.226]     do.call(function(...) {
[15:32:23.226]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:23.226]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:23.226]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:23.226]             on.exit(options(oopts), add = TRUE)
[15:32:23.226]         }
[15:32:23.226]         {
[15:32:23.226]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:23.226]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:23.226]                 ...future.FUN(...future.X_jj, ...)
[15:32:23.226]             })
[15:32:23.226]         }
[15:32:23.226]     }, args = future.call.arguments)
[15:32:23.226] }
[15:32:23.226] Lazy evaluation: FALSE
[15:32:23.226] Asynchronous evaluation: FALSE
[15:32:23.226] Local evaluation: TRUE
[15:32:23.226] Environment: R_GlobalEnv
[15:32:23.226] Capture standard output: TRUE
[15:32:23.226] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:23.226] Globals: 5 objects totaling 1.16 KiB (function '...future.FUN' of 848 bytes, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 336 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:23.226] Packages: <none>
[15:32:23.226] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:23.226] Resolved: TRUE
[15:32:23.226] Value: 336 bytes of class 'list'
[15:32:23.226] Early signaling: FALSE
[15:32:23.226] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:23.226] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:23.229] Chunk #1 of 1 ... DONE
[15:32:23.229] Launching 1 futures (chunks) ... DONE
[15:32:23.229] Resolving 1 futures (chunks) ...
[15:32:23.230] resolve() on list ...
[15:32:23.230]  recursive: 0
[15:32:23.231]  length: 1
[15:32:23.231] 
[15:32:23.231] resolved() for 'SequentialFuture' ...
[15:32:23.232] - state: 'finished'
[15:32:23.232] - run: TRUE
[15:32:23.232] - result: 'FutureResult'
[15:32:23.233] resolved() for 'SequentialFuture' ... done
[15:32:23.233] Future #1
[15:32:23.234] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:23.234] - nx: 1
[15:32:23.234] - relay: TRUE
[15:32:23.235] - stdout: TRUE
[15:32:23.235] - signal: TRUE
[15:32:23.235] - resignal: FALSE
[15:32:23.235] - force: TRUE
[15:32:23.235] - relayed: [n=1] FALSE
[15:32:23.239] - queued futures: [n=1] FALSE
[15:32:23.239]  - until=1
[15:32:23.239]  - relaying element #1
[15:32:23.240] - relayed: [n=1] TRUE
[15:32:23.240] - queued futures: [n=1] TRUE
[15:32:23.241] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:23.241]  length: 0 (resolved future 1)
[15:32:23.241] Relaying remaining futures
[15:32:23.241] signalConditionsASAP(NULL, pos=0) ...
[15:32:23.242] - nx: 1
[15:32:23.242] - relay: TRUE
[15:32:23.242] - stdout: TRUE
[15:32:23.242] - signal: TRUE
[15:32:23.243] - resignal: FALSE
[15:32:23.243] - force: TRUE
[15:32:23.243] - relayed: [n=1] TRUE
[15:32:23.243] - queued futures: [n=1] TRUE
 - flush all
[15:32:23.244] - relayed: [n=1] TRUE
[15:32:23.244] - queued futures: [n=1] TRUE
[15:32:23.244] signalConditionsASAP(NULL, pos=0) ... done
[15:32:23.245] resolve() on list ... DONE
[15:32:23.245]  - Number of value chunks collected: 1
[15:32:23.245] Resolving 1 futures (chunks) ... DONE
[15:32:23.246] Reducing values from 1 chunks ...
[15:32:23.246]  - Number of values collected after concatenation: 3
[15:32:23.246]  - Number of values expected: 3
[15:32:23.246] Reducing values from 1 chunks ... DONE
[15:32:23.247] future_lapply() ... DONE
List of 2
 $ y0: chr [1:3] "a" "b" "c"
 $ y1: chr [1:3] "a" "b" "c"
[15:32:23.249] future_lapply() ...
[15:32:23.250] Number of chunks: 1
[15:32:23.250] getGlobalsAndPackagesXApply() ...
[15:32:23.250]  - future.globals: TRUE
[15:32:23.251] getGlobalsAndPackages() ...
[15:32:23.251] Searching for globals...
[15:32:23.253] - globals found: [2] 'FUN', 'UseMethod'
[15:32:23.253] Searching for globals ... DONE
[15:32:23.254] Resolving globals: FALSE
[15:32:23.254] The total size of the 1 globals is 1.22 KiB (1248 bytes)
[15:32:23.255] The total size of the 1 globals exported for future expression ('FUN()') is 1.22 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.22 KiB of class 'function')
[15:32:23.255] - globals: [1] 'FUN'
[15:32:23.256] 
[15:32:23.256] getGlobalsAndPackages() ... DONE
[15:32:23.256]  - globals found/used: [n=1] 'FUN'
[15:32:23.256]  - needed namespaces: [n=0] 
[15:32:23.257] Finding globals ... DONE
[15:32:23.257]  - use_args: TRUE
[15:32:23.257]  - Getting '...' globals ...
[15:32:23.258] resolve() on list ...
[15:32:23.258]  recursive: 0
[15:32:23.258]  length: 1
[15:32:23.259]  elements: '...'
[15:32:23.259]  length: 0 (resolved future 1)
[15:32:23.259] resolve() on list ... DONE
[15:32:23.259]    - '...' content: [n=0] 
[15:32:23.260] List of 1
[15:32:23.260]  $ ...: list()
[15:32:23.260]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:23.260]  - attr(*, "where")=List of 1
[15:32:23.260]   ..$ ...:<environment: 0x00000276e264ea70> 
[15:32:23.260]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:23.260]  - attr(*, "resolved")= logi TRUE
[15:32:23.260]  - attr(*, "total_size")= num NA
[15:32:23.264]  - Getting '...' globals ... DONE
[15:32:23.265] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:23.265] List of 2
[15:32:23.265]  $ ...future.FUN:function (x, ...)  
[15:32:23.265]  $ ...          : list()
[15:32:23.265]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:23.265]  - attr(*, "where")=List of 2
[15:32:23.265]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:23.265]   ..$ ...          :<environment: 0x00000276e264ea70> 
[15:32:23.265]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:23.265]  - attr(*, "resolved")= logi FALSE
[15:32:23.265]  - attr(*, "total_size")= num 1248
[15:32:23.270] Packages to be attached in all futures: [n=0] 
[15:32:23.270] getGlobalsAndPackagesXApply() ... DONE
[15:32:23.270] Number of futures (= number of chunks): 1
[15:32:23.271] Launching 1 futures (chunks) ...
[15:32:23.271] Chunk #1 of 1 ...
[15:32:23.271]  - Finding globals in 'X' for chunk #1 ...
[15:32:23.272] getGlobalsAndPackages() ...
[15:32:23.272] Searching for globals...
[15:32:23.272] 
[15:32:23.273] Searching for globals ... DONE
[15:32:23.273] - globals: [0] <none>
[15:32:23.273] getGlobalsAndPackages() ... DONE
[15:32:23.273]    + additional globals found: [n=0] 
[15:32:23.274]    + additional namespaces needed: [n=0] 
[15:32:23.274]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:23.274]  - seeds: <none>
[15:32:23.274]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:23.275] getGlobalsAndPackages() ...
[15:32:23.275] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:23.275] Resolving globals: FALSE
[15:32:23.275] Tweak future expression to call with '...' arguments ...
[15:32:23.276] {
[15:32:23.276]     do.call(function(...) {
[15:32:23.276]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:23.276]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:23.276]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:23.276]             on.exit(options(oopts), add = TRUE)
[15:32:23.276]         }
[15:32:23.276]         {
[15:32:23.276]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:23.276]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:23.276]                 ...future.FUN(...future.X_jj, ...)
[15:32:23.276]             })
[15:32:23.276]         }
[15:32:23.276]     }, args = future.call.arguments)
[15:32:23.276] }
[15:32:23.277] Tweak future expression to call with '...' arguments ... DONE
[15:32:23.280] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:23.281] 
[15:32:23.281] getGlobalsAndPackages() ... DONE
[15:32:23.282] run() for 'Future' ...
[15:32:23.282] - state: 'created'
[15:32:23.282] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:23.283] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:23.283] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:23.284]   - Field: 'label'
[15:32:23.284]   - Field: 'local'
[15:32:23.284]   - Field: 'owner'
[15:32:23.285]   - Field: 'envir'
[15:32:23.285]   - Field: 'packages'
[15:32:23.285]   - Field: 'gc'
[15:32:23.286]   - Field: 'conditions'
[15:32:23.286]   - Field: 'expr'
[15:32:23.286]   - Field: 'uuid'
[15:32:23.287]   - Field: 'seed'
[15:32:23.287]   - Field: 'version'
[15:32:23.287]   - Field: 'result'
[15:32:23.288]   - Field: 'asynchronous'
[15:32:23.288]   - Field: 'calls'
[15:32:23.288]   - Field: 'globals'
[15:32:23.289]   - Field: 'stdout'
[15:32:23.289]   - Field: 'earlySignal'
[15:32:23.290]   - Field: 'lazy'
[15:32:23.290]   - Field: 'state'
[15:32:23.290] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:23.290] - Launch lazy future ...
[15:32:23.291] Packages needed by the future expression (n = 0): <none>
[15:32:23.291] Packages needed by future strategies (n = 0): <none>
[15:32:23.292] {
[15:32:23.292]     {
[15:32:23.292]         {
[15:32:23.292]             ...future.startTime <- base::Sys.time()
[15:32:23.292]             {
[15:32:23.292]                 {
[15:32:23.292]                   {
[15:32:23.292]                     base::local({
[15:32:23.292]                       has_future <- base::requireNamespace("future", 
[15:32:23.292]                         quietly = TRUE)
[15:32:23.292]                       if (has_future) {
[15:32:23.292]                         ns <- base::getNamespace("future")
[15:32:23.292]                         version <- ns[[".package"]][["version"]]
[15:32:23.292]                         if (is.null(version)) 
[15:32:23.292]                           version <- utils::packageVersion("future")
[15:32:23.292]                       }
[15:32:23.292]                       else {
[15:32:23.292]                         version <- NULL
[15:32:23.292]                       }
[15:32:23.292]                       if (!has_future || version < "1.8.0") {
[15:32:23.292]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:23.292]                           "", base::R.version$version.string), 
[15:32:23.292]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:23.292]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:23.292]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:23.292]                             "release", "version")], collapse = " "), 
[15:32:23.292]                           hostname = base::Sys.info()[["nodename"]])
[15:32:23.292]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:23.292]                           info)
[15:32:23.292]                         info <- base::paste(info, collapse = "; ")
[15:32:23.292]                         if (!has_future) {
[15:32:23.292]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:23.292]                             info)
[15:32:23.292]                         }
[15:32:23.292]                         else {
[15:32:23.292]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:23.292]                             info, version)
[15:32:23.292]                         }
[15:32:23.292]                         base::stop(msg)
[15:32:23.292]                       }
[15:32:23.292]                     })
[15:32:23.292]                   }
[15:32:23.292]                   ...future.strategy.old <- future::plan("list")
[15:32:23.292]                   options(future.plan = NULL)
[15:32:23.292]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:23.292]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:23.292]                 }
[15:32:23.292]                 ...future.workdir <- getwd()
[15:32:23.292]             }
[15:32:23.292]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:23.292]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:23.292]         }
[15:32:23.292]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:23.292]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:23.292]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:23.292]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:23.292]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:23.292]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:23.292]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:23.292]             base::names(...future.oldOptions))
[15:32:23.292]     }
[15:32:23.292]     if (FALSE) {
[15:32:23.292]     }
[15:32:23.292]     else {
[15:32:23.292]         if (TRUE) {
[15:32:23.292]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:23.292]                 open = "w")
[15:32:23.292]         }
[15:32:23.292]         else {
[15:32:23.292]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:23.292]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:23.292]         }
[15:32:23.292]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:23.292]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:23.292]             base::sink(type = "output", split = FALSE)
[15:32:23.292]             base::close(...future.stdout)
[15:32:23.292]         }, add = TRUE)
[15:32:23.292]     }
[15:32:23.292]     ...future.frame <- base::sys.nframe()
[15:32:23.292]     ...future.conditions <- base::list()
[15:32:23.292]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:23.292]     if (FALSE) {
[15:32:23.292]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:23.292]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:23.292]     }
[15:32:23.292]     ...future.result <- base::tryCatch({
[15:32:23.292]         base::withCallingHandlers({
[15:32:23.292]             ...future.value <- base::withVisible(base::local({
[15:32:23.292]                 do.call(function(...) {
[15:32:23.292]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:23.292]                   if (!identical(...future.globals.maxSize.org, 
[15:32:23.292]                     ...future.globals.maxSize)) {
[15:32:23.292]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:23.292]                     on.exit(options(oopts), add = TRUE)
[15:32:23.292]                   }
[15:32:23.292]                   {
[15:32:23.292]                     lapply(seq_along(...future.elements_ii), 
[15:32:23.292]                       FUN = function(jj) {
[15:32:23.292]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:23.292]                         ...future.FUN(...future.X_jj, ...)
[15:32:23.292]                       })
[15:32:23.292]                   }
[15:32:23.292]                 }, args = future.call.arguments)
[15:32:23.292]             }))
[15:32:23.292]             future::FutureResult(value = ...future.value$value, 
[15:32:23.292]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:23.292]                   ...future.rng), globalenv = if (FALSE) 
[15:32:23.292]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:23.292]                     ...future.globalenv.names))
[15:32:23.292]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:23.292]         }, condition = base::local({
[15:32:23.292]             c <- base::c
[15:32:23.292]             inherits <- base::inherits
[15:32:23.292]             invokeRestart <- base::invokeRestart
[15:32:23.292]             length <- base::length
[15:32:23.292]             list <- base::list
[15:32:23.292]             seq.int <- base::seq.int
[15:32:23.292]             signalCondition <- base::signalCondition
[15:32:23.292]             sys.calls <- base::sys.calls
[15:32:23.292]             `[[` <- base::`[[`
[15:32:23.292]             `+` <- base::`+`
[15:32:23.292]             `<<-` <- base::`<<-`
[15:32:23.292]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:23.292]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:23.292]                   3L)]
[15:32:23.292]             }
[15:32:23.292]             function(cond) {
[15:32:23.292]                 is_error <- inherits(cond, "error")
[15:32:23.292]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:23.292]                   NULL)
[15:32:23.292]                 if (is_error) {
[15:32:23.292]                   sessionInformation <- function() {
[15:32:23.292]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:23.292]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:23.292]                       search = base::search(), system = base::Sys.info())
[15:32:23.292]                   }
[15:32:23.292]                   ...future.conditions[[length(...future.conditions) + 
[15:32:23.292]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:23.292]                     cond$call), session = sessionInformation(), 
[15:32:23.292]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:23.292]                   signalCondition(cond)
[15:32:23.292]                 }
[15:32:23.292]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:23.292]                 "immediateCondition"))) {
[15:32:23.292]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:23.292]                   ...future.conditions[[length(...future.conditions) + 
[15:32:23.292]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:23.292]                   if (TRUE && !signal) {
[15:32:23.292]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:23.292]                     {
[15:32:23.292]                       inherits <- base::inherits
[15:32:23.292]                       invokeRestart <- base::invokeRestart
[15:32:23.292]                       is.null <- base::is.null
[15:32:23.292]                       muffled <- FALSE
[15:32:23.292]                       if (inherits(cond, "message")) {
[15:32:23.292]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:23.292]                         if (muffled) 
[15:32:23.292]                           invokeRestart("muffleMessage")
[15:32:23.292]                       }
[15:32:23.292]                       else if (inherits(cond, "warning")) {
[15:32:23.292]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:23.292]                         if (muffled) 
[15:32:23.292]                           invokeRestart("muffleWarning")
[15:32:23.292]                       }
[15:32:23.292]                       else if (inherits(cond, "condition")) {
[15:32:23.292]                         if (!is.null(pattern)) {
[15:32:23.292]                           computeRestarts <- base::computeRestarts
[15:32:23.292]                           grepl <- base::grepl
[15:32:23.292]                           restarts <- computeRestarts(cond)
[15:32:23.292]                           for (restart in restarts) {
[15:32:23.292]                             name <- restart$name
[15:32:23.292]                             if (is.null(name)) 
[15:32:23.292]                               next
[15:32:23.292]                             if (!grepl(pattern, name)) 
[15:32:23.292]                               next
[15:32:23.292]                             invokeRestart(restart)
[15:32:23.292]                             muffled <- TRUE
[15:32:23.292]                             break
[15:32:23.292]                           }
[15:32:23.292]                         }
[15:32:23.292]                       }
[15:32:23.292]                       invisible(muffled)
[15:32:23.292]                     }
[15:32:23.292]                     muffleCondition(cond, pattern = "^muffle")
[15:32:23.292]                   }
[15:32:23.292]                 }
[15:32:23.292]                 else {
[15:32:23.292]                   if (TRUE) {
[15:32:23.292]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:23.292]                     {
[15:32:23.292]                       inherits <- base::inherits
[15:32:23.292]                       invokeRestart <- base::invokeRestart
[15:32:23.292]                       is.null <- base::is.null
[15:32:23.292]                       muffled <- FALSE
[15:32:23.292]                       if (inherits(cond, "message")) {
[15:32:23.292]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:23.292]                         if (muffled) 
[15:32:23.292]                           invokeRestart("muffleMessage")
[15:32:23.292]                       }
[15:32:23.292]                       else if (inherits(cond, "warning")) {
[15:32:23.292]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:23.292]                         if (muffled) 
[15:32:23.292]                           invokeRestart("muffleWarning")
[15:32:23.292]                       }
[15:32:23.292]                       else if (inherits(cond, "condition")) {
[15:32:23.292]                         if (!is.null(pattern)) {
[15:32:23.292]                           computeRestarts <- base::computeRestarts
[15:32:23.292]                           grepl <- base::grepl
[15:32:23.292]                           restarts <- computeRestarts(cond)
[15:32:23.292]                           for (restart in restarts) {
[15:32:23.292]                             name <- restart$name
[15:32:23.292]                             if (is.null(name)) 
[15:32:23.292]                               next
[15:32:23.292]                             if (!grepl(pattern, name)) 
[15:32:23.292]                               next
[15:32:23.292]                             invokeRestart(restart)
[15:32:23.292]                             muffled <- TRUE
[15:32:23.292]                             break
[15:32:23.292]                           }
[15:32:23.292]                         }
[15:32:23.292]                       }
[15:32:23.292]                       invisible(muffled)
[15:32:23.292]                     }
[15:32:23.292]                     muffleCondition(cond, pattern = "^muffle")
[15:32:23.292]                   }
[15:32:23.292]                 }
[15:32:23.292]             }
[15:32:23.292]         }))
[15:32:23.292]     }, error = function(ex) {
[15:32:23.292]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:23.292]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:23.292]                 ...future.rng), started = ...future.startTime, 
[15:32:23.292]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:23.292]             version = "1.8"), class = "FutureResult")
[15:32:23.292]     }, finally = {
[15:32:23.292]         if (!identical(...future.workdir, getwd())) 
[15:32:23.292]             setwd(...future.workdir)
[15:32:23.292]         {
[15:32:23.292]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:23.292]                 ...future.oldOptions$nwarnings <- NULL
[15:32:23.292]             }
[15:32:23.292]             base::options(...future.oldOptions)
[15:32:23.292]             if (.Platform$OS.type == "windows") {
[15:32:23.292]                 old_names <- names(...future.oldEnvVars)
[15:32:23.292]                 envs <- base::Sys.getenv()
[15:32:23.292]                 names <- names(envs)
[15:32:23.292]                 common <- intersect(names, old_names)
[15:32:23.292]                 added <- setdiff(names, old_names)
[15:32:23.292]                 removed <- setdiff(old_names, names)
[15:32:23.292]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:23.292]                   envs[common]]
[15:32:23.292]                 NAMES <- toupper(changed)
[15:32:23.292]                 args <- list()
[15:32:23.292]                 for (kk in seq_along(NAMES)) {
[15:32:23.292]                   name <- changed[[kk]]
[15:32:23.292]                   NAME <- NAMES[[kk]]
[15:32:23.292]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:23.292]                     next
[15:32:23.292]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:23.292]                 }
[15:32:23.292]                 NAMES <- toupper(added)
[15:32:23.292]                 for (kk in seq_along(NAMES)) {
[15:32:23.292]                   name <- added[[kk]]
[15:32:23.292]                   NAME <- NAMES[[kk]]
[15:32:23.292]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:23.292]                     next
[15:32:23.292]                   args[[name]] <- ""
[15:32:23.292]                 }
[15:32:23.292]                 NAMES <- toupper(removed)
[15:32:23.292]                 for (kk in seq_along(NAMES)) {
[15:32:23.292]                   name <- removed[[kk]]
[15:32:23.292]                   NAME <- NAMES[[kk]]
[15:32:23.292]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:23.292]                     next
[15:32:23.292]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:23.292]                 }
[15:32:23.292]                 if (length(args) > 0) 
[15:32:23.292]                   base::do.call(base::Sys.setenv, args = args)
[15:32:23.292]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:23.292]             }
[15:32:23.292]             else {
[15:32:23.292]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:23.292]             }
[15:32:23.292]             {
[15:32:23.292]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:23.292]                   0L) {
[15:32:23.292]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:23.292]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:23.292]                   base::options(opts)
[15:32:23.292]                 }
[15:32:23.292]                 {
[15:32:23.292]                   {
[15:32:23.292]                     NULL
[15:32:23.292]                     RNGkind("Mersenne-Twister")
[15:32:23.292]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:23.292]                       inherits = FALSE)
[15:32:23.292]                   }
[15:32:23.292]                   options(future.plan = NULL)
[15:32:23.292]                   if (is.na(NA_character_)) 
[15:32:23.292]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:23.292]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:23.292]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:23.292]                     .init = FALSE)
[15:32:23.292]                 }
[15:32:23.292]             }
[15:32:23.292]         }
[15:32:23.292]     })
[15:32:23.292]     if (TRUE) {
[15:32:23.292]         base::sink(type = "output", split = FALSE)
[15:32:23.292]         if (TRUE) {
[15:32:23.292]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:23.292]         }
[15:32:23.292]         else {
[15:32:23.292]             ...future.result["stdout"] <- base::list(NULL)
[15:32:23.292]         }
[15:32:23.292]         base::close(...future.stdout)
[15:32:23.292]         ...future.stdout <- NULL
[15:32:23.292]     }
[15:32:23.292]     ...future.result$conditions <- ...future.conditions
[15:32:23.292]     ...future.result$finished <- base::Sys.time()
[15:32:23.292]     ...future.result
[15:32:23.292] }
[15:32:23.298] assign_globals() ...
[15:32:23.298] List of 5
[15:32:23.298]  $ ...future.FUN            :function (x, ...)  
[15:32:23.298]  $ future.call.arguments    : list()
[15:32:23.298]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:23.298]  $ ...future.elements_ii    :List of 3
[15:32:23.298]   ..$ : chr "a"
[15:32:23.298]   ..$ : chr "b"
[15:32:23.298]   ..$ : chr "c"
[15:32:23.298]  $ ...future.seeds_ii       : NULL
[15:32:23.298]  $ ...future.globals.maxSize: NULL
[15:32:23.298]  - attr(*, "where")=List of 5
[15:32:23.298]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:23.298]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:23.298]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:23.298]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:23.298]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:23.298]  - attr(*, "resolved")= logi FALSE
[15:32:23.298]  - attr(*, "total_size")= num 1248
[15:32:23.298]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:23.298]  - attr(*, "already-done")= logi TRUE
[15:32:23.309] - copied '...future.FUN' to environment
[15:32:23.309] - copied 'future.call.arguments' to environment
[15:32:23.309] - copied '...future.elements_ii' to environment
[15:32:23.310] - copied '...future.seeds_ii' to environment
[15:32:23.310] - copied '...future.globals.maxSize' to environment
[15:32:23.310] assign_globals() ... done
[15:32:23.311] plan(): Setting new future strategy stack:
[15:32:23.311] List of future strategies:
[15:32:23.311] 1. sequential:
[15:32:23.311]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:23.311]    - tweaked: FALSE
[15:32:23.311]    - call: NULL
[15:32:23.312] plan(): nbrOfWorkers() = 1
[15:32:23.314] plan(): Setting new future strategy stack:
[15:32:23.314] List of future strategies:
[15:32:23.314] 1. sequential:
[15:32:23.314]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:23.314]    - tweaked: FALSE
[15:32:23.314]    - call: plan(strategy)
[15:32:23.315] plan(): nbrOfWorkers() = 1
[15:32:23.316] SequentialFuture started (and completed)
[15:32:23.316] - Launch lazy future ... done
[15:32:23.316] run() for 'SequentialFuture' ... done
[15:32:23.317] Created future:
[15:32:23.317] SequentialFuture:
[15:32:23.317] Label: 'future_sapply-1'
[15:32:23.317] Expression:
[15:32:23.317] {
[15:32:23.317]     do.call(function(...) {
[15:32:23.317]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:23.317]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:23.317]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:23.317]             on.exit(options(oopts), add = TRUE)
[15:32:23.317]         }
[15:32:23.317]         {
[15:32:23.317]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:23.317]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:23.317]                 ...future.FUN(...future.X_jj, ...)
[15:32:23.317]             })
[15:32:23.317]         }
[15:32:23.317]     }, args = future.call.arguments)
[15:32:23.317] }
[15:32:23.317] Lazy evaluation: FALSE
[15:32:23.317] Asynchronous evaluation: FALSE
[15:32:23.317] Local evaluation: TRUE
[15:32:23.317] Environment: R_GlobalEnv
[15:32:23.317] Capture standard output: TRUE
[15:32:23.317] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:23.317] Globals: 5 objects totaling 1.55 KiB (function '...future.FUN' of 1.22 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 336 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:23.317] Packages: <none>
[15:32:23.317] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:23.317] Resolved: TRUE
[15:32:23.317] Value: 840 bytes of class 'list'
[15:32:23.317] Early signaling: FALSE
[15:32:23.317] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:23.317] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:23.319] Chunk #1 of 1 ... DONE
[15:32:23.319] Launching 1 futures (chunks) ... DONE
[15:32:23.320] Resolving 1 futures (chunks) ...
[15:32:23.320] resolve() on list ...
[15:32:23.320]  recursive: 0
[15:32:23.321]  length: 1
[15:32:23.321] 
[15:32:23.321] resolved() for 'SequentialFuture' ...
[15:32:23.321] - state: 'finished'
[15:32:23.322] - run: TRUE
[15:32:23.322] - result: 'FutureResult'
[15:32:23.322] resolved() for 'SequentialFuture' ... done
[15:32:23.323] Future #1
[15:32:23.323] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:23.323] - nx: 1
[15:32:23.324] - relay: TRUE
[15:32:23.324] - stdout: TRUE
[15:32:23.324] - signal: TRUE
[15:32:23.324] - resignal: FALSE
[15:32:23.325] - force: TRUE
[15:32:23.325] - relayed: [n=1] FALSE
[15:32:23.325] - queued futures: [n=1] FALSE
[15:32:23.326]  - until=1
[15:32:23.326]  - relaying element #1
[15:32:23.326] - relayed: [n=1] TRUE
[15:32:23.327] - queued futures: [n=1] TRUE
[15:32:23.327] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:23.327]  length: 0 (resolved future 1)
[15:32:23.328] Relaying remaining futures
[15:32:23.328] signalConditionsASAP(NULL, pos=0) ...
[15:32:23.332] - nx: 1
[15:32:23.332] - relay: TRUE
[15:32:23.332] - stdout: TRUE
[15:32:23.332] - signal: TRUE
[15:32:23.333] - resignal: FALSE
[15:32:23.333] - force: TRUE
[15:32:23.333] - relayed: [n=1] TRUE
[15:32:23.334] - queued futures: [n=1] TRUE
 - flush all
[15:32:23.334] - relayed: [n=1] TRUE
[15:32:23.334] - queued futures: [n=1] TRUE
[15:32:23.335] signalConditionsASAP(NULL, pos=0) ... done
[15:32:23.335] resolve() on list ... DONE
[15:32:23.336]  - Number of value chunks collected: 1
[15:32:23.336] Resolving 1 futures (chunks) ... DONE
[15:32:23.336] Reducing values from 1 chunks ...
[15:32:23.337]  - Number of values collected after concatenation: 3
[15:32:23.337]  - Number of values expected: 3
[15:32:23.337] Reducing values from 1 chunks ... DONE
[15:32:23.338] future_lapply() ... DONE
List of 2
 $ y0: chr [1:3] "a" "b" "c"
 $ y1: chr [1:3] "a" "b" "c"
[15:32:23.340] future_lapply() ...
[15:32:23.341] Number of chunks: 1
[15:32:23.342] getGlobalsAndPackagesXApply() ...
[15:32:23.342]  - future.globals: TRUE
[15:32:23.342] getGlobalsAndPackages() ...
[15:32:23.342] Searching for globals...
[15:32:23.344] - globals found: [1] 'FUN'
[15:32:23.344] Searching for globals ... DONE
[15:32:23.344] Resolving globals: FALSE
[15:32:23.345] The total size of the 1 globals is 848 bytes (848 bytes)
[15:32:23.346] The total size of the 1 globals exported for future expression ('FUN()') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:32:23.346] - globals: [1] 'FUN'
[15:32:23.346] 
[15:32:23.346] getGlobalsAndPackages() ... DONE
[15:32:23.347]  - globals found/used: [n=1] 'FUN'
[15:32:23.347]  - needed namespaces: [n=0] 
[15:32:23.347] Finding globals ... DONE
[15:32:23.348]  - use_args: TRUE
[15:32:23.348]  - Getting '...' globals ...
[15:32:23.348] resolve() on list ...
[15:32:23.349]  recursive: 0
[15:32:23.349]  length: 1
[15:32:23.349]  elements: '...'
[15:32:23.349]  length: 0 (resolved future 1)
[15:32:23.350] resolve() on list ... DONE
[15:32:23.350]    - '...' content: [n=0] 
[15:32:23.350] List of 1
[15:32:23.350]  $ ...: list()
[15:32:23.350]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:23.350]  - attr(*, "where")=List of 1
[15:32:23.350]   ..$ ...:<environment: 0x00000276e254e4f8> 
[15:32:23.350]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:23.350]  - attr(*, "resolved")= logi TRUE
[15:32:23.350]  - attr(*, "total_size")= num NA
[15:32:23.354]  - Getting '...' globals ... DONE
[15:32:23.355] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:23.355] List of 2
[15:32:23.355]  $ ...future.FUN:function (x)  
[15:32:23.355]  $ ...          : list()
[15:32:23.355]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:23.355]  - attr(*, "where")=List of 2
[15:32:23.355]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:23.355]   ..$ ...          :<environment: 0x00000276e254e4f8> 
[15:32:23.355]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:23.355]  - attr(*, "resolved")= logi FALSE
[15:32:23.355]  - attr(*, "total_size")= num 848
[15:32:23.360] Packages to be attached in all futures: [n=0] 
[15:32:23.360] getGlobalsAndPackagesXApply() ... DONE
[15:32:23.361] Number of futures (= number of chunks): 1
[15:32:23.361] Launching 1 futures (chunks) ...
[15:32:23.361] Chunk #1 of 1 ...
[15:32:23.362]  - Finding globals in 'X' for chunk #1 ...
[15:32:23.362] getGlobalsAndPackages() ...
[15:32:23.362] Searching for globals...
[15:32:23.363] 
[15:32:23.363] Searching for globals ... DONE
[15:32:23.363] - globals: [0] <none>
[15:32:23.363] getGlobalsAndPackages() ... DONE
[15:32:23.363]    + additional globals found: [n=0] 
[15:32:23.363]    + additional namespaces needed: [n=0] 
[15:32:23.364]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:23.364]  - seeds: <none>
[15:32:23.364]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:23.364] getGlobalsAndPackages() ...
[15:32:23.364] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:23.364] Resolving globals: FALSE
[15:32:23.365] Tweak future expression to call with '...' arguments ...
[15:32:23.365] {
[15:32:23.365]     do.call(function(...) {
[15:32:23.365]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:23.365]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:23.365]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:23.365]             on.exit(options(oopts), add = TRUE)
[15:32:23.365]         }
[15:32:23.365]         {
[15:32:23.365]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:23.365]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:23.365]                 ...future.FUN(...future.X_jj, ...)
[15:32:23.365]             })
[15:32:23.365]         }
[15:32:23.365]     }, args = future.call.arguments)
[15:32:23.365] }
[15:32:23.365] Tweak future expression to call with '...' arguments ... DONE
[15:32:23.366] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:23.366] 
[15:32:23.366] getGlobalsAndPackages() ... DONE
[15:32:23.367] run() for 'Future' ...
[15:32:23.367] - state: 'created'
[15:32:23.367] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:23.370] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:23.371] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:23.371]   - Field: 'label'
[15:32:23.371]   - Field: 'local'
[15:32:23.371]   - Field: 'owner'
[15:32:23.371]   - Field: 'envir'
[15:32:23.372]   - Field: 'packages'
[15:32:23.372]   - Field: 'gc'
[15:32:23.372]   - Field: 'conditions'
[15:32:23.372]   - Field: 'expr'
[15:32:23.372]   - Field: 'uuid'
[15:32:23.373]   - Field: 'seed'
[15:32:23.373]   - Field: 'version'
[15:32:23.373]   - Field: 'result'
[15:32:23.373]   - Field: 'asynchronous'
[15:32:23.373]   - Field: 'calls'
[15:32:23.374]   - Field: 'globals'
[15:32:23.374]   - Field: 'stdout'
[15:32:23.374]   - Field: 'earlySignal'
[15:32:23.374]   - Field: 'lazy'
[15:32:23.375]   - Field: 'state'
[15:32:23.375] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:23.375] - Launch lazy future ...
[15:32:23.375] Packages needed by the future expression (n = 0): <none>
[15:32:23.376] Packages needed by future strategies (n = 0): <none>
[15:32:23.377] {
[15:32:23.377]     {
[15:32:23.377]         {
[15:32:23.377]             ...future.startTime <- base::Sys.time()
[15:32:23.377]             {
[15:32:23.377]                 {
[15:32:23.377]                   {
[15:32:23.377]                     base::local({
[15:32:23.377]                       has_future <- base::requireNamespace("future", 
[15:32:23.377]                         quietly = TRUE)
[15:32:23.377]                       if (has_future) {
[15:32:23.377]                         ns <- base::getNamespace("future")
[15:32:23.377]                         version <- ns[[".package"]][["version"]]
[15:32:23.377]                         if (is.null(version)) 
[15:32:23.377]                           version <- utils::packageVersion("future")
[15:32:23.377]                       }
[15:32:23.377]                       else {
[15:32:23.377]                         version <- NULL
[15:32:23.377]                       }
[15:32:23.377]                       if (!has_future || version < "1.8.0") {
[15:32:23.377]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:23.377]                           "", base::R.version$version.string), 
[15:32:23.377]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:23.377]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:23.377]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:23.377]                             "release", "version")], collapse = " "), 
[15:32:23.377]                           hostname = base::Sys.info()[["nodename"]])
[15:32:23.377]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:23.377]                           info)
[15:32:23.377]                         info <- base::paste(info, collapse = "; ")
[15:32:23.377]                         if (!has_future) {
[15:32:23.377]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:23.377]                             info)
[15:32:23.377]                         }
[15:32:23.377]                         else {
[15:32:23.377]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:23.377]                             info, version)
[15:32:23.377]                         }
[15:32:23.377]                         base::stop(msg)
[15:32:23.377]                       }
[15:32:23.377]                     })
[15:32:23.377]                   }
[15:32:23.377]                   ...future.strategy.old <- future::plan("list")
[15:32:23.377]                   options(future.plan = NULL)
[15:32:23.377]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:23.377]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:23.377]                 }
[15:32:23.377]                 ...future.workdir <- getwd()
[15:32:23.377]             }
[15:32:23.377]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:23.377]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:23.377]         }
[15:32:23.377]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:23.377]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:23.377]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:23.377]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:23.377]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:23.377]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:23.377]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:23.377]             base::names(...future.oldOptions))
[15:32:23.377]     }
[15:32:23.377]     if (FALSE) {
[15:32:23.377]     }
[15:32:23.377]     else {
[15:32:23.377]         if (TRUE) {
[15:32:23.377]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:23.377]                 open = "w")
[15:32:23.377]         }
[15:32:23.377]         else {
[15:32:23.377]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:23.377]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:23.377]         }
[15:32:23.377]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:23.377]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:23.377]             base::sink(type = "output", split = FALSE)
[15:32:23.377]             base::close(...future.stdout)
[15:32:23.377]         }, add = TRUE)
[15:32:23.377]     }
[15:32:23.377]     ...future.frame <- base::sys.nframe()
[15:32:23.377]     ...future.conditions <- base::list()
[15:32:23.377]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:23.377]     if (FALSE) {
[15:32:23.377]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:23.377]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:23.377]     }
[15:32:23.377]     ...future.result <- base::tryCatch({
[15:32:23.377]         base::withCallingHandlers({
[15:32:23.377]             ...future.value <- base::withVisible(base::local({
[15:32:23.377]                 do.call(function(...) {
[15:32:23.377]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:23.377]                   if (!identical(...future.globals.maxSize.org, 
[15:32:23.377]                     ...future.globals.maxSize)) {
[15:32:23.377]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:23.377]                     on.exit(options(oopts), add = TRUE)
[15:32:23.377]                   }
[15:32:23.377]                   {
[15:32:23.377]                     lapply(seq_along(...future.elements_ii), 
[15:32:23.377]                       FUN = function(jj) {
[15:32:23.377]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:23.377]                         ...future.FUN(...future.X_jj, ...)
[15:32:23.377]                       })
[15:32:23.377]                   }
[15:32:23.377]                 }, args = future.call.arguments)
[15:32:23.377]             }))
[15:32:23.377]             future::FutureResult(value = ...future.value$value, 
[15:32:23.377]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:23.377]                   ...future.rng), globalenv = if (FALSE) 
[15:32:23.377]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:23.377]                     ...future.globalenv.names))
[15:32:23.377]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:23.377]         }, condition = base::local({
[15:32:23.377]             c <- base::c
[15:32:23.377]             inherits <- base::inherits
[15:32:23.377]             invokeRestart <- base::invokeRestart
[15:32:23.377]             length <- base::length
[15:32:23.377]             list <- base::list
[15:32:23.377]             seq.int <- base::seq.int
[15:32:23.377]             signalCondition <- base::signalCondition
[15:32:23.377]             sys.calls <- base::sys.calls
[15:32:23.377]             `[[` <- base::`[[`
[15:32:23.377]             `+` <- base::`+`
[15:32:23.377]             `<<-` <- base::`<<-`
[15:32:23.377]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:23.377]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:23.377]                   3L)]
[15:32:23.377]             }
[15:32:23.377]             function(cond) {
[15:32:23.377]                 is_error <- inherits(cond, "error")
[15:32:23.377]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:23.377]                   NULL)
[15:32:23.377]                 if (is_error) {
[15:32:23.377]                   sessionInformation <- function() {
[15:32:23.377]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:23.377]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:23.377]                       search = base::search(), system = base::Sys.info())
[15:32:23.377]                   }
[15:32:23.377]                   ...future.conditions[[length(...future.conditions) + 
[15:32:23.377]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:23.377]                     cond$call), session = sessionInformation(), 
[15:32:23.377]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:23.377]                   signalCondition(cond)
[15:32:23.377]                 }
[15:32:23.377]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:23.377]                 "immediateCondition"))) {
[15:32:23.377]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:23.377]                   ...future.conditions[[length(...future.conditions) + 
[15:32:23.377]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:23.377]                   if (TRUE && !signal) {
[15:32:23.377]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:23.377]                     {
[15:32:23.377]                       inherits <- base::inherits
[15:32:23.377]                       invokeRestart <- base::invokeRestart
[15:32:23.377]                       is.null <- base::is.null
[15:32:23.377]                       muffled <- FALSE
[15:32:23.377]                       if (inherits(cond, "message")) {
[15:32:23.377]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:23.377]                         if (muffled) 
[15:32:23.377]                           invokeRestart("muffleMessage")
[15:32:23.377]                       }
[15:32:23.377]                       else if (inherits(cond, "warning")) {
[15:32:23.377]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:23.377]                         if (muffled) 
[15:32:23.377]                           invokeRestart("muffleWarning")
[15:32:23.377]                       }
[15:32:23.377]                       else if (inherits(cond, "condition")) {
[15:32:23.377]                         if (!is.null(pattern)) {
[15:32:23.377]                           computeRestarts <- base::computeRestarts
[15:32:23.377]                           grepl <- base::grepl
[15:32:23.377]                           restarts <- computeRestarts(cond)
[15:32:23.377]                           for (restart in restarts) {
[15:32:23.377]                             name <- restart$name
[15:32:23.377]                             if (is.null(name)) 
[15:32:23.377]                               next
[15:32:23.377]                             if (!grepl(pattern, name)) 
[15:32:23.377]                               next
[15:32:23.377]                             invokeRestart(restart)
[15:32:23.377]                             muffled <- TRUE
[15:32:23.377]                             break
[15:32:23.377]                           }
[15:32:23.377]                         }
[15:32:23.377]                       }
[15:32:23.377]                       invisible(muffled)
[15:32:23.377]                     }
[15:32:23.377]                     muffleCondition(cond, pattern = "^muffle")
[15:32:23.377]                   }
[15:32:23.377]                 }
[15:32:23.377]                 else {
[15:32:23.377]                   if (TRUE) {
[15:32:23.377]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:23.377]                     {
[15:32:23.377]                       inherits <- base::inherits
[15:32:23.377]                       invokeRestart <- base::invokeRestart
[15:32:23.377]                       is.null <- base::is.null
[15:32:23.377]                       muffled <- FALSE
[15:32:23.377]                       if (inherits(cond, "message")) {
[15:32:23.377]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:23.377]                         if (muffled) 
[15:32:23.377]                           invokeRestart("muffleMessage")
[15:32:23.377]                       }
[15:32:23.377]                       else if (inherits(cond, "warning")) {
[15:32:23.377]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:23.377]                         if (muffled) 
[15:32:23.377]                           invokeRestart("muffleWarning")
[15:32:23.377]                       }
[15:32:23.377]                       else if (inherits(cond, "condition")) {
[15:32:23.377]                         if (!is.null(pattern)) {
[15:32:23.377]                           computeRestarts <- base::computeRestarts
[15:32:23.377]                           grepl <- base::grepl
[15:32:23.377]                           restarts <- computeRestarts(cond)
[15:32:23.377]                           for (restart in restarts) {
[15:32:23.377]                             name <- restart$name
[15:32:23.377]                             if (is.null(name)) 
[15:32:23.377]                               next
[15:32:23.377]                             if (!grepl(pattern, name)) 
[15:32:23.377]                               next
[15:32:23.377]                             invokeRestart(restart)
[15:32:23.377]                             muffled <- TRUE
[15:32:23.377]                             break
[15:32:23.377]                           }
[15:32:23.377]                         }
[15:32:23.377]                       }
[15:32:23.377]                       invisible(muffled)
[15:32:23.377]                     }
[15:32:23.377]                     muffleCondition(cond, pattern = "^muffle")
[15:32:23.377]                   }
[15:32:23.377]                 }
[15:32:23.377]             }
[15:32:23.377]         }))
[15:32:23.377]     }, error = function(ex) {
[15:32:23.377]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:23.377]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:23.377]                 ...future.rng), started = ...future.startTime, 
[15:32:23.377]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:23.377]             version = "1.8"), class = "FutureResult")
[15:32:23.377]     }, finally = {
[15:32:23.377]         if (!identical(...future.workdir, getwd())) 
[15:32:23.377]             setwd(...future.workdir)
[15:32:23.377]         {
[15:32:23.377]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:23.377]                 ...future.oldOptions$nwarnings <- NULL
[15:32:23.377]             }
[15:32:23.377]             base::options(...future.oldOptions)
[15:32:23.377]             if (.Platform$OS.type == "windows") {
[15:32:23.377]                 old_names <- names(...future.oldEnvVars)
[15:32:23.377]                 envs <- base::Sys.getenv()
[15:32:23.377]                 names <- names(envs)
[15:32:23.377]                 common <- intersect(names, old_names)
[15:32:23.377]                 added <- setdiff(names, old_names)
[15:32:23.377]                 removed <- setdiff(old_names, names)
[15:32:23.377]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:23.377]                   envs[common]]
[15:32:23.377]                 NAMES <- toupper(changed)
[15:32:23.377]                 args <- list()
[15:32:23.377]                 for (kk in seq_along(NAMES)) {
[15:32:23.377]                   name <- changed[[kk]]
[15:32:23.377]                   NAME <- NAMES[[kk]]
[15:32:23.377]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:23.377]                     next
[15:32:23.377]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:23.377]                 }
[15:32:23.377]                 NAMES <- toupper(added)
[15:32:23.377]                 for (kk in seq_along(NAMES)) {
[15:32:23.377]                   name <- added[[kk]]
[15:32:23.377]                   NAME <- NAMES[[kk]]
[15:32:23.377]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:23.377]                     next
[15:32:23.377]                   args[[name]] <- ""
[15:32:23.377]                 }
[15:32:23.377]                 NAMES <- toupper(removed)
[15:32:23.377]                 for (kk in seq_along(NAMES)) {
[15:32:23.377]                   name <- removed[[kk]]
[15:32:23.377]                   NAME <- NAMES[[kk]]
[15:32:23.377]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:23.377]                     next
[15:32:23.377]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:23.377]                 }
[15:32:23.377]                 if (length(args) > 0) 
[15:32:23.377]                   base::do.call(base::Sys.setenv, args = args)
[15:32:23.377]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:23.377]             }
[15:32:23.377]             else {
[15:32:23.377]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:23.377]             }
[15:32:23.377]             {
[15:32:23.377]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:23.377]                   0L) {
[15:32:23.377]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:23.377]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:23.377]                   base::options(opts)
[15:32:23.377]                 }
[15:32:23.377]                 {
[15:32:23.377]                   {
[15:32:23.377]                     NULL
[15:32:23.377]                     RNGkind("Mersenne-Twister")
[15:32:23.377]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:23.377]                       inherits = FALSE)
[15:32:23.377]                   }
[15:32:23.377]                   options(future.plan = NULL)
[15:32:23.377]                   if (is.na(NA_character_)) 
[15:32:23.377]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:23.377]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:23.377]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:23.377]                     .init = FALSE)
[15:32:23.377]                 }
[15:32:23.377]             }
[15:32:23.377]         }
[15:32:23.377]     })
[15:32:23.377]     if (TRUE) {
[15:32:23.377]         base::sink(type = "output", split = FALSE)
[15:32:23.377]         if (TRUE) {
[15:32:23.377]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:23.377]         }
[15:32:23.377]         else {
[15:32:23.377]             ...future.result["stdout"] <- base::list(NULL)
[15:32:23.377]         }
[15:32:23.377]         base::close(...future.stdout)
[15:32:23.377]         ...future.stdout <- NULL
[15:32:23.377]     }
[15:32:23.377]     ...future.result$conditions <- ...future.conditions
[15:32:23.377]     ...future.result$finished <- base::Sys.time()
[15:32:23.377]     ...future.result
[15:32:23.377] }
[15:32:23.384] assign_globals() ...
[15:32:23.384] List of 5
[15:32:23.384]  $ ...future.FUN            :function (x)  
[15:32:23.384]  $ future.call.arguments    : list()
[15:32:23.384]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:23.384]  $ ...future.elements_ii    :List of 3
[15:32:23.384]   ..$ : chr "a"
[15:32:23.384]   ..$ : chr "b"
[15:32:23.384]   ..$ : chr "c"
[15:32:23.384]  $ ...future.seeds_ii       : NULL
[15:32:23.384]  $ ...future.globals.maxSize: NULL
[15:32:23.384]  - attr(*, "where")=List of 5
[15:32:23.384]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:23.384]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:23.384]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:23.384]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:23.384]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:23.384]  - attr(*, "resolved")= logi FALSE
[15:32:23.384]  - attr(*, "total_size")= num 848
[15:32:23.384]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:23.384]  - attr(*, "already-done")= logi TRUE
[15:32:23.392] - copied '...future.FUN' to environment
[15:32:23.392] - copied 'future.call.arguments' to environment
[15:32:23.392] - copied '...future.elements_ii' to environment
[15:32:23.392] - copied '...future.seeds_ii' to environment
[15:32:23.393] - copied '...future.globals.maxSize' to environment
[15:32:23.393] assign_globals() ... done
[15:32:23.393] plan(): Setting new future strategy stack:
[15:32:23.393] List of future strategies:
[15:32:23.393] 1. sequential:
[15:32:23.393]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:23.393]    - tweaked: FALSE
[15:32:23.393]    - call: NULL
[15:32:23.394] plan(): nbrOfWorkers() = 1
[15:32:23.396] plan(): Setting new future strategy stack:
[15:32:23.396] List of future strategies:
[15:32:23.396] 1. sequential:
[15:32:23.396]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:23.396]    - tweaked: FALSE
[15:32:23.396]    - call: plan(strategy)
[15:32:23.397] plan(): nbrOfWorkers() = 1
[15:32:23.397] SequentialFuture started (and completed)
[15:32:23.398] - Launch lazy future ... done
[15:32:23.398] run() for 'SequentialFuture' ... done
[15:32:23.398] Created future:
[15:32:23.399] SequentialFuture:
[15:32:23.399] Label: 'future_sapply-1'
[15:32:23.399] Expression:
[15:32:23.399] {
[15:32:23.399]     do.call(function(...) {
[15:32:23.399]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:23.399]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:23.399]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:23.399]             on.exit(options(oopts), add = TRUE)
[15:32:23.399]         }
[15:32:23.399]         {
[15:32:23.399]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:23.399]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:23.399]                 ...future.FUN(...future.X_jj, ...)
[15:32:23.399]             })
[15:32:23.399]         }
[15:32:23.399]     }, args = future.call.arguments)
[15:32:23.399] }
[15:32:23.399] Lazy evaluation: FALSE
[15:32:23.399] Asynchronous evaluation: FALSE
[15:32:23.399] Local evaluation: TRUE
[15:32:23.399] Environment: R_GlobalEnv
[15:32:23.399] Capture standard output: TRUE
[15:32:23.399] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:23.399] Globals: 5 objects totaling 1.16 KiB (function '...future.FUN' of 848 bytes, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 336 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:23.399] Packages: <none>
[15:32:23.399] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:23.399] Resolved: TRUE
[15:32:23.399] Value: 336 bytes of class 'list'
[15:32:23.399] Early signaling: FALSE
[15:32:23.399] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:23.399] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:23.400] Chunk #1 of 1 ... DONE
[15:32:23.400] Launching 1 futures (chunks) ... DONE
[15:32:23.400] Resolving 1 futures (chunks) ...
[15:32:23.401] resolve() on list ...
[15:32:23.401]  recursive: 0
[15:32:23.401]  length: 1
[15:32:23.401] 
[15:32:23.402] resolved() for 'SequentialFuture' ...
[15:32:23.402] - state: 'finished'
[15:32:23.402] - run: TRUE
[15:32:23.402] - result: 'FutureResult'
[15:32:23.402] resolved() for 'SequentialFuture' ... done
[15:32:23.403] Future #1
[15:32:23.403] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:23.403] - nx: 1
[15:32:23.403] - relay: TRUE
[15:32:23.403] - stdout: TRUE
[15:32:23.404] - signal: TRUE
[15:32:23.404] - resignal: FALSE
[15:32:23.404] - force: TRUE
[15:32:23.404] - relayed: [n=1] FALSE
[15:32:23.404] - queued futures: [n=1] FALSE
[15:32:23.404]  - until=1
[15:32:23.405]  - relaying element #1
[15:32:23.405] - relayed: [n=1] TRUE
[15:32:23.405] - queued futures: [n=1] TRUE
[15:32:23.405] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:23.406]  length: 0 (resolved future 1)
[15:32:23.406] Relaying remaining futures
[15:32:23.406] signalConditionsASAP(NULL, pos=0) ...
[15:32:23.406] - nx: 1
[15:32:23.406] - relay: TRUE
[15:32:23.406] - stdout: TRUE
[15:32:23.406] - signal: TRUE
[15:32:23.407] - resignal: FALSE
[15:32:23.407] - force: TRUE
[15:32:23.407] - relayed: [n=1] TRUE
[15:32:23.407] - queued futures: [n=1] TRUE
 - flush all
[15:32:23.410] - relayed: [n=1] TRUE
[15:32:23.410] - queued futures: [n=1] TRUE
[15:32:23.410] signalConditionsASAP(NULL, pos=0) ... done
[15:32:23.410] resolve() on list ... DONE
[15:32:23.411]  - Number of value chunks collected: 1
[15:32:23.411] Resolving 1 futures (chunks) ... DONE
[15:32:23.411] Reducing values from 1 chunks ...
[15:32:23.411]  - Number of values collected after concatenation: 3
[15:32:23.411]  - Number of values expected: 3
[15:32:23.412] Reducing values from 1 chunks ... DONE
[15:32:23.412] future_lapply() ... DONE
List of 2
 $ y0: chr [1:3] "a" "b" "c"
 $ y1: chr [1:3] "a" "b" "c"
[15:32:23.413] future_lapply() ...
[15:32:23.414] Number of chunks: 1
[15:32:23.414] getGlobalsAndPackagesXApply() ...
[15:32:23.415]  - future.globals: TRUE
[15:32:23.415] getGlobalsAndPackages() ...
[15:32:23.415] Searching for globals...
[15:32:23.417] - globals found: [2] 'FUN', 'UseMethod'
[15:32:23.417] Searching for globals ... DONE
[15:32:23.417] Resolving globals: FALSE
[15:32:23.418] The total size of the 1 globals is 1.22 KiB (1248 bytes)
[15:32:23.418] The total size of the 1 globals exported for future expression ('FUN()') is 1.22 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.22 KiB of class 'function')
[15:32:23.419] - globals: [1] 'FUN'
[15:32:23.419] 
[15:32:23.419] getGlobalsAndPackages() ... DONE
[15:32:23.419]  - globals found/used: [n=1] 'FUN'
[15:32:23.419]  - needed namespaces: [n=0] 
[15:32:23.420] Finding globals ... DONE
[15:32:23.420]  - use_args: TRUE
[15:32:23.420]  - Getting '...' globals ...
[15:32:23.420] resolve() on list ...
[15:32:23.421]  recursive: 0
[15:32:23.421]  length: 1
[15:32:23.421]  elements: '...'
[15:32:23.421]  length: 0 (resolved future 1)
[15:32:23.422] resolve() on list ... DONE
[15:32:23.422]    - '...' content: [n=0] 
[15:32:23.422] List of 1
[15:32:23.422]  $ ...: list()
[15:32:23.422]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:23.422]  - attr(*, "where")=List of 1
[15:32:23.422]   ..$ ...:<environment: 0x00000276e2761538> 
[15:32:23.422]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:23.422]  - attr(*, "resolved")= logi TRUE
[15:32:23.422]  - attr(*, "total_size")= num NA
[15:32:23.427]  - Getting '...' globals ... DONE
[15:32:23.428] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:23.428] List of 2
[15:32:23.428]  $ ...future.FUN:function (x, ...)  
[15:32:23.428]  $ ...          : list()
[15:32:23.428]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:23.428]  - attr(*, "where")=List of 2
[15:32:23.428]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:23.428]   ..$ ...          :<environment: 0x00000276e2761538> 
[15:32:23.428]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:23.428]  - attr(*, "resolved")= logi FALSE
[15:32:23.428]  - attr(*, "total_size")= num 1248
[15:32:23.434] Packages to be attached in all futures: [n=0] 
[15:32:23.434] getGlobalsAndPackagesXApply() ... DONE
[15:32:23.434] Number of futures (= number of chunks): 1
[15:32:23.435] Launching 1 futures (chunks) ...
[15:32:23.435] Chunk #1 of 1 ...
[15:32:23.435]  - Finding globals in 'X' for chunk #1 ...
[15:32:23.436] getGlobalsAndPackages() ...
[15:32:23.436] Searching for globals...
[15:32:23.437] 
[15:32:23.437] Searching for globals ... DONE
[15:32:23.437] - globals: [0] <none>
[15:32:23.438] getGlobalsAndPackages() ... DONE
[15:32:23.438]    + additional globals found: [n=0] 
[15:32:23.438]    + additional namespaces needed: [n=0] 
[15:32:23.439]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:23.439]  - seeds: <none>
[15:32:23.439]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:23.439] getGlobalsAndPackages() ...
[15:32:23.440] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:23.440] Resolving globals: FALSE
[15:32:23.440] Tweak future expression to call with '...' arguments ...
[15:32:23.441] {
[15:32:23.441]     do.call(function(...) {
[15:32:23.441]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:23.441]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:23.441]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:23.441]             on.exit(options(oopts), add = TRUE)
[15:32:23.441]         }
[15:32:23.441]         {
[15:32:23.441]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:23.441]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:23.441]                 ...future.FUN(...future.X_jj, ...)
[15:32:23.441]             })
[15:32:23.441]         }
[15:32:23.441]     }, args = future.call.arguments)
[15:32:23.441] }
[15:32:23.442] Tweak future expression to call with '...' arguments ... DONE
[15:32:23.442] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:23.443] 
[15:32:23.443] getGlobalsAndPackages() ... DONE
[15:32:23.444] run() for 'Future' ...
[15:32:23.444] - state: 'created'
[15:32:23.444] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:23.445] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:23.445] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:23.446]   - Field: 'label'
[15:32:23.449]   - Field: 'local'
[15:32:23.450]   - Field: 'owner'
[15:32:23.450]   - Field: 'envir'
[15:32:23.450]   - Field: 'packages'
[15:32:23.451]   - Field: 'gc'
[15:32:23.451]   - Field: 'conditions'
[15:32:23.452]   - Field: 'expr'
[15:32:23.452]   - Field: 'uuid'
[15:32:23.452]   - Field: 'seed'
[15:32:23.453]   - Field: 'version'
[15:32:23.453]   - Field: 'result'
[15:32:23.453]   - Field: 'asynchronous'
[15:32:23.454]   - Field: 'calls'
[15:32:23.454]   - Field: 'globals'
[15:32:23.454]   - Field: 'stdout'
[15:32:23.455]   - Field: 'earlySignal'
[15:32:23.455]   - Field: 'lazy'
[15:32:23.455]   - Field: 'state'
[15:32:23.456] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:23.456] - Launch lazy future ...
[15:32:23.457] Packages needed by the future expression (n = 0): <none>
[15:32:23.457] Packages needed by future strategies (n = 0): <none>
[15:32:23.458] {
[15:32:23.458]     {
[15:32:23.458]         {
[15:32:23.458]             ...future.startTime <- base::Sys.time()
[15:32:23.458]             {
[15:32:23.458]                 {
[15:32:23.458]                   {
[15:32:23.458]                     base::local({
[15:32:23.458]                       has_future <- base::requireNamespace("future", 
[15:32:23.458]                         quietly = TRUE)
[15:32:23.458]                       if (has_future) {
[15:32:23.458]                         ns <- base::getNamespace("future")
[15:32:23.458]                         version <- ns[[".package"]][["version"]]
[15:32:23.458]                         if (is.null(version)) 
[15:32:23.458]                           version <- utils::packageVersion("future")
[15:32:23.458]                       }
[15:32:23.458]                       else {
[15:32:23.458]                         version <- NULL
[15:32:23.458]                       }
[15:32:23.458]                       if (!has_future || version < "1.8.0") {
[15:32:23.458]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:23.458]                           "", base::R.version$version.string), 
[15:32:23.458]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:23.458]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:23.458]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:23.458]                             "release", "version")], collapse = " "), 
[15:32:23.458]                           hostname = base::Sys.info()[["nodename"]])
[15:32:23.458]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:23.458]                           info)
[15:32:23.458]                         info <- base::paste(info, collapse = "; ")
[15:32:23.458]                         if (!has_future) {
[15:32:23.458]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:23.458]                             info)
[15:32:23.458]                         }
[15:32:23.458]                         else {
[15:32:23.458]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:23.458]                             info, version)
[15:32:23.458]                         }
[15:32:23.458]                         base::stop(msg)
[15:32:23.458]                       }
[15:32:23.458]                     })
[15:32:23.458]                   }
[15:32:23.458]                   ...future.strategy.old <- future::plan("list")
[15:32:23.458]                   options(future.plan = NULL)
[15:32:23.458]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:23.458]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:23.458]                 }
[15:32:23.458]                 ...future.workdir <- getwd()
[15:32:23.458]             }
[15:32:23.458]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:23.458]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:23.458]         }
[15:32:23.458]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:23.458]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:23.458]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:23.458]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:23.458]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:23.458]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:23.458]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:23.458]             base::names(...future.oldOptions))
[15:32:23.458]     }
[15:32:23.458]     if (FALSE) {
[15:32:23.458]     }
[15:32:23.458]     else {
[15:32:23.458]         if (TRUE) {
[15:32:23.458]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:23.458]                 open = "w")
[15:32:23.458]         }
[15:32:23.458]         else {
[15:32:23.458]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:23.458]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:23.458]         }
[15:32:23.458]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:23.458]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:23.458]             base::sink(type = "output", split = FALSE)
[15:32:23.458]             base::close(...future.stdout)
[15:32:23.458]         }, add = TRUE)
[15:32:23.458]     }
[15:32:23.458]     ...future.frame <- base::sys.nframe()
[15:32:23.458]     ...future.conditions <- base::list()
[15:32:23.458]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:23.458]     if (FALSE) {
[15:32:23.458]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:23.458]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:23.458]     }
[15:32:23.458]     ...future.result <- base::tryCatch({
[15:32:23.458]         base::withCallingHandlers({
[15:32:23.458]             ...future.value <- base::withVisible(base::local({
[15:32:23.458]                 do.call(function(...) {
[15:32:23.458]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:23.458]                   if (!identical(...future.globals.maxSize.org, 
[15:32:23.458]                     ...future.globals.maxSize)) {
[15:32:23.458]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:23.458]                     on.exit(options(oopts), add = TRUE)
[15:32:23.458]                   }
[15:32:23.458]                   {
[15:32:23.458]                     lapply(seq_along(...future.elements_ii), 
[15:32:23.458]                       FUN = function(jj) {
[15:32:23.458]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:23.458]                         ...future.FUN(...future.X_jj, ...)
[15:32:23.458]                       })
[15:32:23.458]                   }
[15:32:23.458]                 }, args = future.call.arguments)
[15:32:23.458]             }))
[15:32:23.458]             future::FutureResult(value = ...future.value$value, 
[15:32:23.458]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:23.458]                   ...future.rng), globalenv = if (FALSE) 
[15:32:23.458]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:23.458]                     ...future.globalenv.names))
[15:32:23.458]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:23.458]         }, condition = base::local({
[15:32:23.458]             c <- base::c
[15:32:23.458]             inherits <- base::inherits
[15:32:23.458]             invokeRestart <- base::invokeRestart
[15:32:23.458]             length <- base::length
[15:32:23.458]             list <- base::list
[15:32:23.458]             seq.int <- base::seq.int
[15:32:23.458]             signalCondition <- base::signalCondition
[15:32:23.458]             sys.calls <- base::sys.calls
[15:32:23.458]             `[[` <- base::`[[`
[15:32:23.458]             `+` <- base::`+`
[15:32:23.458]             `<<-` <- base::`<<-`
[15:32:23.458]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:23.458]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:23.458]                   3L)]
[15:32:23.458]             }
[15:32:23.458]             function(cond) {
[15:32:23.458]                 is_error <- inherits(cond, "error")
[15:32:23.458]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:23.458]                   NULL)
[15:32:23.458]                 if (is_error) {
[15:32:23.458]                   sessionInformation <- function() {
[15:32:23.458]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:23.458]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:23.458]                       search = base::search(), system = base::Sys.info())
[15:32:23.458]                   }
[15:32:23.458]                   ...future.conditions[[length(...future.conditions) + 
[15:32:23.458]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:23.458]                     cond$call), session = sessionInformation(), 
[15:32:23.458]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:23.458]                   signalCondition(cond)
[15:32:23.458]                 }
[15:32:23.458]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:23.458]                 "immediateCondition"))) {
[15:32:23.458]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:23.458]                   ...future.conditions[[length(...future.conditions) + 
[15:32:23.458]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:23.458]                   if (TRUE && !signal) {
[15:32:23.458]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:23.458]                     {
[15:32:23.458]                       inherits <- base::inherits
[15:32:23.458]                       invokeRestart <- base::invokeRestart
[15:32:23.458]                       is.null <- base::is.null
[15:32:23.458]                       muffled <- FALSE
[15:32:23.458]                       if (inherits(cond, "message")) {
[15:32:23.458]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:23.458]                         if (muffled) 
[15:32:23.458]                           invokeRestart("muffleMessage")
[15:32:23.458]                       }
[15:32:23.458]                       else if (inherits(cond, "warning")) {
[15:32:23.458]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:23.458]                         if (muffled) 
[15:32:23.458]                           invokeRestart("muffleWarning")
[15:32:23.458]                       }
[15:32:23.458]                       else if (inherits(cond, "condition")) {
[15:32:23.458]                         if (!is.null(pattern)) {
[15:32:23.458]                           computeRestarts <- base::computeRestarts
[15:32:23.458]                           grepl <- base::grepl
[15:32:23.458]                           restarts <- computeRestarts(cond)
[15:32:23.458]                           for (restart in restarts) {
[15:32:23.458]                             name <- restart$name
[15:32:23.458]                             if (is.null(name)) 
[15:32:23.458]                               next
[15:32:23.458]                             if (!grepl(pattern, name)) 
[15:32:23.458]                               next
[15:32:23.458]                             invokeRestart(restart)
[15:32:23.458]                             muffled <- TRUE
[15:32:23.458]                             break
[15:32:23.458]                           }
[15:32:23.458]                         }
[15:32:23.458]                       }
[15:32:23.458]                       invisible(muffled)
[15:32:23.458]                     }
[15:32:23.458]                     muffleCondition(cond, pattern = "^muffle")
[15:32:23.458]                   }
[15:32:23.458]                 }
[15:32:23.458]                 else {
[15:32:23.458]                   if (TRUE) {
[15:32:23.458]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:23.458]                     {
[15:32:23.458]                       inherits <- base::inherits
[15:32:23.458]                       invokeRestart <- base::invokeRestart
[15:32:23.458]                       is.null <- base::is.null
[15:32:23.458]                       muffled <- FALSE
[15:32:23.458]                       if (inherits(cond, "message")) {
[15:32:23.458]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:23.458]                         if (muffled) 
[15:32:23.458]                           invokeRestart("muffleMessage")
[15:32:23.458]                       }
[15:32:23.458]                       else if (inherits(cond, "warning")) {
[15:32:23.458]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:23.458]                         if (muffled) 
[15:32:23.458]                           invokeRestart("muffleWarning")
[15:32:23.458]                       }
[15:32:23.458]                       else if (inherits(cond, "condition")) {
[15:32:23.458]                         if (!is.null(pattern)) {
[15:32:23.458]                           computeRestarts <- base::computeRestarts
[15:32:23.458]                           grepl <- base::grepl
[15:32:23.458]                           restarts <- computeRestarts(cond)
[15:32:23.458]                           for (restart in restarts) {
[15:32:23.458]                             name <- restart$name
[15:32:23.458]                             if (is.null(name)) 
[15:32:23.458]                               next
[15:32:23.458]                             if (!grepl(pattern, name)) 
[15:32:23.458]                               next
[15:32:23.458]                             invokeRestart(restart)
[15:32:23.458]                             muffled <- TRUE
[15:32:23.458]                             break
[15:32:23.458]                           }
[15:32:23.458]                         }
[15:32:23.458]                       }
[15:32:23.458]                       invisible(muffled)
[15:32:23.458]                     }
[15:32:23.458]                     muffleCondition(cond, pattern = "^muffle")
[15:32:23.458]                   }
[15:32:23.458]                 }
[15:32:23.458]             }
[15:32:23.458]         }))
[15:32:23.458]     }, error = function(ex) {
[15:32:23.458]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:23.458]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:23.458]                 ...future.rng), started = ...future.startTime, 
[15:32:23.458]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:23.458]             version = "1.8"), class = "FutureResult")
[15:32:23.458]     }, finally = {
[15:32:23.458]         if (!identical(...future.workdir, getwd())) 
[15:32:23.458]             setwd(...future.workdir)
[15:32:23.458]         {
[15:32:23.458]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:23.458]                 ...future.oldOptions$nwarnings <- NULL
[15:32:23.458]             }
[15:32:23.458]             base::options(...future.oldOptions)
[15:32:23.458]             if (.Platform$OS.type == "windows") {
[15:32:23.458]                 old_names <- names(...future.oldEnvVars)
[15:32:23.458]                 envs <- base::Sys.getenv()
[15:32:23.458]                 names <- names(envs)
[15:32:23.458]                 common <- intersect(names, old_names)
[15:32:23.458]                 added <- setdiff(names, old_names)
[15:32:23.458]                 removed <- setdiff(old_names, names)
[15:32:23.458]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:23.458]                   envs[common]]
[15:32:23.458]                 NAMES <- toupper(changed)
[15:32:23.458]                 args <- list()
[15:32:23.458]                 for (kk in seq_along(NAMES)) {
[15:32:23.458]                   name <- changed[[kk]]
[15:32:23.458]                   NAME <- NAMES[[kk]]
[15:32:23.458]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:23.458]                     next
[15:32:23.458]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:23.458]                 }
[15:32:23.458]                 NAMES <- toupper(added)
[15:32:23.458]                 for (kk in seq_along(NAMES)) {
[15:32:23.458]                   name <- added[[kk]]
[15:32:23.458]                   NAME <- NAMES[[kk]]
[15:32:23.458]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:23.458]                     next
[15:32:23.458]                   args[[name]] <- ""
[15:32:23.458]                 }
[15:32:23.458]                 NAMES <- toupper(removed)
[15:32:23.458]                 for (kk in seq_along(NAMES)) {
[15:32:23.458]                   name <- removed[[kk]]
[15:32:23.458]                   NAME <- NAMES[[kk]]
[15:32:23.458]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:23.458]                     next
[15:32:23.458]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:23.458]                 }
[15:32:23.458]                 if (length(args) > 0) 
[15:32:23.458]                   base::do.call(base::Sys.setenv, args = args)
[15:32:23.458]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:23.458]             }
[15:32:23.458]             else {
[15:32:23.458]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:23.458]             }
[15:32:23.458]             {
[15:32:23.458]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:23.458]                   0L) {
[15:32:23.458]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:23.458]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:23.458]                   base::options(opts)
[15:32:23.458]                 }
[15:32:23.458]                 {
[15:32:23.458]                   {
[15:32:23.458]                     NULL
[15:32:23.458]                     RNGkind("Mersenne-Twister")
[15:32:23.458]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:23.458]                       inherits = FALSE)
[15:32:23.458]                   }
[15:32:23.458]                   options(future.plan = NULL)
[15:32:23.458]                   if (is.na(NA_character_)) 
[15:32:23.458]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:23.458]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:23.458]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:23.458]                     .init = FALSE)
[15:32:23.458]                 }
[15:32:23.458]             }
[15:32:23.458]         }
[15:32:23.458]     })
[15:32:23.458]     if (TRUE) {
[15:32:23.458]         base::sink(type = "output", split = FALSE)
[15:32:23.458]         if (TRUE) {
[15:32:23.458]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:23.458]         }
[15:32:23.458]         else {
[15:32:23.458]             ...future.result["stdout"] <- base::list(NULL)
[15:32:23.458]         }
[15:32:23.458]         base::close(...future.stdout)
[15:32:23.458]         ...future.stdout <- NULL
[15:32:23.458]     }
[15:32:23.458]     ...future.result$conditions <- ...future.conditions
[15:32:23.458]     ...future.result$finished <- base::Sys.time()
[15:32:23.458]     ...future.result
[15:32:23.458] }
[15:32:23.465] assign_globals() ...
[15:32:23.465] List of 5
[15:32:23.465]  $ ...future.FUN            :function (x, ...)  
[15:32:23.465]  $ future.call.arguments    : list()
[15:32:23.465]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:23.465]  $ ...future.elements_ii    :List of 3
[15:32:23.465]   ..$ : chr "a"
[15:32:23.465]   ..$ : chr "b"
[15:32:23.465]   ..$ : chr "c"
[15:32:23.465]  $ ...future.seeds_ii       : NULL
[15:32:23.465]  $ ...future.globals.maxSize: NULL
[15:32:23.465]  - attr(*, "where")=List of 5
[15:32:23.465]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:23.465]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:23.465]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:23.465]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:23.465]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:23.465]  - attr(*, "resolved")= logi FALSE
[15:32:23.465]  - attr(*, "total_size")= num 1248
[15:32:23.465]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:23.465]  - attr(*, "already-done")= logi TRUE
[15:32:23.477] - copied '...future.FUN' to environment
[15:32:23.477] - copied 'future.call.arguments' to environment
[15:32:23.478] - copied '...future.elements_ii' to environment
[15:32:23.478] - copied '...future.seeds_ii' to environment
[15:32:23.478] - copied '...future.globals.maxSize' to environment
[15:32:23.478] assign_globals() ... done
[15:32:23.479] plan(): Setting new future strategy stack:
[15:32:23.479] List of future strategies:
[15:32:23.479] 1. sequential:
[15:32:23.479]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:23.479]    - tweaked: FALSE
[15:32:23.479]    - call: NULL
[15:32:23.480] plan(): nbrOfWorkers() = 1
[15:32:23.483] plan(): Setting new future strategy stack:
[15:32:23.483] List of future strategies:
[15:32:23.483] 1. sequential:
[15:32:23.483]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:23.483]    - tweaked: FALSE
[15:32:23.483]    - call: plan(strategy)
[15:32:23.484] plan(): nbrOfWorkers() = 1
[15:32:23.485] SequentialFuture started (and completed)
[15:32:23.485] - Launch lazy future ... done
[15:32:23.485] run() for 'SequentialFuture' ... done
[15:32:23.486] Created future:
[15:32:23.486] SequentialFuture:
[15:32:23.486] Label: 'future_sapply-1'
[15:32:23.486] Expression:
[15:32:23.486] {
[15:32:23.486]     do.call(function(...) {
[15:32:23.486]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:23.486]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:23.486]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:23.486]             on.exit(options(oopts), add = TRUE)
[15:32:23.486]         }
[15:32:23.486]         {
[15:32:23.486]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:23.486]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:23.486]                 ...future.FUN(...future.X_jj, ...)
[15:32:23.486]             })
[15:32:23.486]         }
[15:32:23.486]     }, args = future.call.arguments)
[15:32:23.486] }
[15:32:23.486] Lazy evaluation: FALSE
[15:32:23.486] Asynchronous evaluation: FALSE
[15:32:23.486] Local evaluation: TRUE
[15:32:23.486] Environment: R_GlobalEnv
[15:32:23.486] Capture standard output: TRUE
[15:32:23.486] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:23.486] Globals: 5 objects totaling 1.55 KiB (function '...future.FUN' of 1.22 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 336 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:23.486] Packages: <none>
[15:32:23.486] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:23.486] Resolved: TRUE
[15:32:23.486] Value: 840 bytes of class 'list'
[15:32:23.486] Early signaling: FALSE
[15:32:23.486] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:23.486] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:23.488] Chunk #1 of 1 ... DONE
[15:32:23.489] Launching 1 futures (chunks) ... DONE
[15:32:23.489] Resolving 1 futures (chunks) ...
[15:32:23.489] resolve() on list ...
[15:32:23.490]  recursive: 0
[15:32:23.490]  length: 1
[15:32:23.490] 
[15:32:23.490] resolved() for 'SequentialFuture' ...
[15:32:23.491] - state: 'finished'
[15:32:23.491] - run: TRUE
[15:32:23.491] - result: 'FutureResult'
[15:32:23.492] resolved() for 'SequentialFuture' ... done
[15:32:23.492] Future #1
[15:32:23.492] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:23.493] - nx: 1
[15:32:23.493] - relay: TRUE
[15:32:23.493] - stdout: TRUE
[15:32:23.494] - signal: TRUE
[15:32:23.494] - resignal: FALSE
[15:32:23.494] - force: TRUE
[15:32:23.494] - relayed: [n=1] FALSE
[15:32:23.495] - queued futures: [n=1] FALSE
[15:32:23.495]  - until=1
[15:32:23.495]  - relaying element #1
[15:32:23.496] - relayed: [n=1] TRUE
[15:32:23.496] - queued futures: [n=1] TRUE
[15:32:23.496] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:23.497]  length: 0 (resolved future 1)
[15:32:23.497] Relaying remaining futures
[15:32:23.497] signalConditionsASAP(NULL, pos=0) ...
[15:32:23.497] - nx: 1
[15:32:23.498] - relay: TRUE
[15:32:23.498] - stdout: TRUE
[15:32:23.498] - signal: TRUE
[15:32:23.498] - resignal: FALSE
[15:32:23.499] - force: TRUE
[15:32:23.499] - relayed: [n=1] TRUE
[15:32:23.499] - queued futures: [n=1] TRUE
 - flush all
[15:32:23.500] - relayed: [n=1] TRUE
[15:32:23.503] - queued futures: [n=1] TRUE
[15:32:23.504] signalConditionsASAP(NULL, pos=0) ... done
[15:32:23.504] resolve() on list ... DONE
[15:32:23.505]  - Number of value chunks collected: 1
[15:32:23.505] Resolving 1 futures (chunks) ... DONE
[15:32:23.505] Reducing values from 1 chunks ...
[15:32:23.505]  - Number of values collected after concatenation: 3
[15:32:23.506]  - Number of values expected: 3
[15:32:23.506] Reducing values from 1 chunks ... DONE
[15:32:23.506] future_lapply() ... DONE
List of 2
 $ y0: chr [1:3] "a" "b" "c"
 $ y1: chr [1:3] "a" "b" "c"
[15:32:23.508] future_lapply() ...
[15:32:23.510] Number of chunks: 1
[15:32:23.510] getGlobalsAndPackagesXApply() ...
[15:32:23.510]  - future.globals: TRUE
[15:32:23.510] getGlobalsAndPackages() ...
[15:32:23.511] Searching for globals...
[15:32:23.513] - globals found: [1] 'FUN'
[15:32:23.513] Searching for globals ... DONE
[15:32:23.514] Resolving globals: FALSE
[15:32:23.514] The total size of the 1 globals is 848 bytes (848 bytes)
[15:32:23.515] The total size of the 1 globals exported for future expression ('FUN()') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:32:23.515] - globals: [1] 'FUN'
[15:32:23.516] 
[15:32:23.516] getGlobalsAndPackages() ... DONE
[15:32:23.516]  - globals found/used: [n=1] 'FUN'
[15:32:23.517]  - needed namespaces: [n=0] 
[15:32:23.517] Finding globals ... DONE
[15:32:23.517]  - use_args: TRUE
[15:32:23.518]  - Getting '...' globals ...
[15:32:23.518] resolve() on list ...
[15:32:23.519]  recursive: 0
[15:32:23.519]  length: 1
[15:32:23.519]  elements: '...'
[15:32:23.520]  length: 0 (resolved future 1)
[15:32:23.520] resolve() on list ... DONE
[15:32:23.520]    - '...' content: [n=0] 
[15:32:23.520] List of 1
[15:32:23.520]  $ ...: list()
[15:32:23.520]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:23.520]  - attr(*, "where")=List of 1
[15:32:23.520]   ..$ ...:<environment: 0x00000276e1c134f8> 
[15:32:23.520]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:23.520]  - attr(*, "resolved")= logi TRUE
[15:32:23.520]  - attr(*, "total_size")= num NA
[15:32:23.525]  - Getting '...' globals ... DONE
[15:32:23.526] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:23.526] List of 2
[15:32:23.526]  $ ...future.FUN:function (x)  
[15:32:23.526]  $ ...          : list()
[15:32:23.526]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:23.526]  - attr(*, "where")=List of 2
[15:32:23.526]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:23.526]   ..$ ...          :<environment: 0x00000276e1c134f8> 
[15:32:23.526]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:23.526]  - attr(*, "resolved")= logi FALSE
[15:32:23.526]  - attr(*, "total_size")= num 848
[15:32:23.531] Packages to be attached in all futures: [n=0] 
[15:32:23.532] getGlobalsAndPackagesXApply() ... DONE
[15:32:23.532] Number of futures (= number of chunks): 1
[15:32:23.532] Launching 1 futures (chunks) ...
[15:32:23.533] Chunk #1 of 1 ...
[15:32:23.533]  - Finding globals in 'X' for chunk #1 ...
[15:32:23.533] getGlobalsAndPackages() ...
[15:32:23.534] Searching for globals...
[15:32:23.534] 
[15:32:23.534] Searching for globals ... DONE
[15:32:23.535] - globals: [0] <none>
[15:32:23.535] getGlobalsAndPackages() ... DONE
[15:32:23.535]    + additional globals found: [n=0] 
[15:32:23.535]    + additional namespaces needed: [n=0] 
[15:32:23.536]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:23.536]  - seeds: <none>
[15:32:23.536]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:23.537] getGlobalsAndPackages() ...
[15:32:23.537] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:23.537] Resolving globals: FALSE
[15:32:23.538] Tweak future expression to call with '...' arguments ...
[15:32:23.538] {
[15:32:23.538]     do.call(function(...) {
[15:32:23.538]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:23.538]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:23.538]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:23.538]             on.exit(options(oopts), add = TRUE)
[15:32:23.538]         }
[15:32:23.538]         {
[15:32:23.538]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:23.538]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:23.538]                 ...future.FUN(...future.X_jj, ...)
[15:32:23.538]             })
[15:32:23.538]         }
[15:32:23.538]     }, args = future.call.arguments)
[15:32:23.538] }
[15:32:23.539] Tweak future expression to call with '...' arguments ... DONE
[15:32:23.540] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:23.540] 
[15:32:23.540] getGlobalsAndPackages() ... DONE
[15:32:23.541] run() for 'Future' ...
[15:32:23.541] - state: 'created'
[15:32:23.541] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:23.542] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:23.542] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:23.543]   - Field: 'label'
[15:32:23.543]   - Field: 'local'
[15:32:23.547]   - Field: 'owner'
[15:32:23.547]   - Field: 'envir'
[15:32:23.548]   - Field: 'packages'
[15:32:23.548]   - Field: 'gc'
[15:32:23.548]   - Field: 'conditions'
[15:32:23.549]   - Field: 'expr'
[15:32:23.549]   - Field: 'uuid'
[15:32:23.549]   - Field: 'seed'
[15:32:23.550]   - Field: 'version'
[15:32:23.550]   - Field: 'result'
[15:32:23.550]   - Field: 'asynchronous'
[15:32:23.551]   - Field: 'calls'
[15:32:23.551]   - Field: 'globals'
[15:32:23.551]   - Field: 'stdout'
[15:32:23.552]   - Field: 'earlySignal'
[15:32:23.552]   - Field: 'lazy'
[15:32:23.552]   - Field: 'state'
[15:32:23.553] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:23.553] - Launch lazy future ...
[15:32:23.553] Packages needed by the future expression (n = 0): <none>
[15:32:23.554] Packages needed by future strategies (n = 0): <none>
[15:32:23.555] {
[15:32:23.555]     {
[15:32:23.555]         {
[15:32:23.555]             ...future.startTime <- base::Sys.time()
[15:32:23.555]             {
[15:32:23.555]                 {
[15:32:23.555]                   {
[15:32:23.555]                     base::local({
[15:32:23.555]                       has_future <- base::requireNamespace("future", 
[15:32:23.555]                         quietly = TRUE)
[15:32:23.555]                       if (has_future) {
[15:32:23.555]                         ns <- base::getNamespace("future")
[15:32:23.555]                         version <- ns[[".package"]][["version"]]
[15:32:23.555]                         if (is.null(version)) 
[15:32:23.555]                           version <- utils::packageVersion("future")
[15:32:23.555]                       }
[15:32:23.555]                       else {
[15:32:23.555]                         version <- NULL
[15:32:23.555]                       }
[15:32:23.555]                       if (!has_future || version < "1.8.0") {
[15:32:23.555]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:23.555]                           "", base::R.version$version.string), 
[15:32:23.555]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:23.555]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:23.555]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:23.555]                             "release", "version")], collapse = " "), 
[15:32:23.555]                           hostname = base::Sys.info()[["nodename"]])
[15:32:23.555]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:23.555]                           info)
[15:32:23.555]                         info <- base::paste(info, collapse = "; ")
[15:32:23.555]                         if (!has_future) {
[15:32:23.555]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:23.555]                             info)
[15:32:23.555]                         }
[15:32:23.555]                         else {
[15:32:23.555]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:23.555]                             info, version)
[15:32:23.555]                         }
[15:32:23.555]                         base::stop(msg)
[15:32:23.555]                       }
[15:32:23.555]                     })
[15:32:23.555]                   }
[15:32:23.555]                   ...future.strategy.old <- future::plan("list")
[15:32:23.555]                   options(future.plan = NULL)
[15:32:23.555]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:23.555]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:23.555]                 }
[15:32:23.555]                 ...future.workdir <- getwd()
[15:32:23.555]             }
[15:32:23.555]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:23.555]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:23.555]         }
[15:32:23.555]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:23.555]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:23.555]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:23.555]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:23.555]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:23.555]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:23.555]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:23.555]             base::names(...future.oldOptions))
[15:32:23.555]     }
[15:32:23.555]     if (FALSE) {
[15:32:23.555]     }
[15:32:23.555]     else {
[15:32:23.555]         if (TRUE) {
[15:32:23.555]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:23.555]                 open = "w")
[15:32:23.555]         }
[15:32:23.555]         else {
[15:32:23.555]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:23.555]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:23.555]         }
[15:32:23.555]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:23.555]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:23.555]             base::sink(type = "output", split = FALSE)
[15:32:23.555]             base::close(...future.stdout)
[15:32:23.555]         }, add = TRUE)
[15:32:23.555]     }
[15:32:23.555]     ...future.frame <- base::sys.nframe()
[15:32:23.555]     ...future.conditions <- base::list()
[15:32:23.555]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:23.555]     if (FALSE) {
[15:32:23.555]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:23.555]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:23.555]     }
[15:32:23.555]     ...future.result <- base::tryCatch({
[15:32:23.555]         base::withCallingHandlers({
[15:32:23.555]             ...future.value <- base::withVisible(base::local({
[15:32:23.555]                 do.call(function(...) {
[15:32:23.555]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:23.555]                   if (!identical(...future.globals.maxSize.org, 
[15:32:23.555]                     ...future.globals.maxSize)) {
[15:32:23.555]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:23.555]                     on.exit(options(oopts), add = TRUE)
[15:32:23.555]                   }
[15:32:23.555]                   {
[15:32:23.555]                     lapply(seq_along(...future.elements_ii), 
[15:32:23.555]                       FUN = function(jj) {
[15:32:23.555]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:23.555]                         ...future.FUN(...future.X_jj, ...)
[15:32:23.555]                       })
[15:32:23.555]                   }
[15:32:23.555]                 }, args = future.call.arguments)
[15:32:23.555]             }))
[15:32:23.555]             future::FutureResult(value = ...future.value$value, 
[15:32:23.555]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:23.555]                   ...future.rng), globalenv = if (FALSE) 
[15:32:23.555]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:23.555]                     ...future.globalenv.names))
[15:32:23.555]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:23.555]         }, condition = base::local({
[15:32:23.555]             c <- base::c
[15:32:23.555]             inherits <- base::inherits
[15:32:23.555]             invokeRestart <- base::invokeRestart
[15:32:23.555]             length <- base::length
[15:32:23.555]             list <- base::list
[15:32:23.555]             seq.int <- base::seq.int
[15:32:23.555]             signalCondition <- base::signalCondition
[15:32:23.555]             sys.calls <- base::sys.calls
[15:32:23.555]             `[[` <- base::`[[`
[15:32:23.555]             `+` <- base::`+`
[15:32:23.555]             `<<-` <- base::`<<-`
[15:32:23.555]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:23.555]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:23.555]                   3L)]
[15:32:23.555]             }
[15:32:23.555]             function(cond) {
[15:32:23.555]                 is_error <- inherits(cond, "error")
[15:32:23.555]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:23.555]                   NULL)
[15:32:23.555]                 if (is_error) {
[15:32:23.555]                   sessionInformation <- function() {
[15:32:23.555]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:23.555]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:23.555]                       search = base::search(), system = base::Sys.info())
[15:32:23.555]                   }
[15:32:23.555]                   ...future.conditions[[length(...future.conditions) + 
[15:32:23.555]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:23.555]                     cond$call), session = sessionInformation(), 
[15:32:23.555]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:23.555]                   signalCondition(cond)
[15:32:23.555]                 }
[15:32:23.555]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:23.555]                 "immediateCondition"))) {
[15:32:23.555]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:23.555]                   ...future.conditions[[length(...future.conditions) + 
[15:32:23.555]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:23.555]                   if (TRUE && !signal) {
[15:32:23.555]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:23.555]                     {
[15:32:23.555]                       inherits <- base::inherits
[15:32:23.555]                       invokeRestart <- base::invokeRestart
[15:32:23.555]                       is.null <- base::is.null
[15:32:23.555]                       muffled <- FALSE
[15:32:23.555]                       if (inherits(cond, "message")) {
[15:32:23.555]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:23.555]                         if (muffled) 
[15:32:23.555]                           invokeRestart("muffleMessage")
[15:32:23.555]                       }
[15:32:23.555]                       else if (inherits(cond, "warning")) {
[15:32:23.555]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:23.555]                         if (muffled) 
[15:32:23.555]                           invokeRestart("muffleWarning")
[15:32:23.555]                       }
[15:32:23.555]                       else if (inherits(cond, "condition")) {
[15:32:23.555]                         if (!is.null(pattern)) {
[15:32:23.555]                           computeRestarts <- base::computeRestarts
[15:32:23.555]                           grepl <- base::grepl
[15:32:23.555]                           restarts <- computeRestarts(cond)
[15:32:23.555]                           for (restart in restarts) {
[15:32:23.555]                             name <- restart$name
[15:32:23.555]                             if (is.null(name)) 
[15:32:23.555]                               next
[15:32:23.555]                             if (!grepl(pattern, name)) 
[15:32:23.555]                               next
[15:32:23.555]                             invokeRestart(restart)
[15:32:23.555]                             muffled <- TRUE
[15:32:23.555]                             break
[15:32:23.555]                           }
[15:32:23.555]                         }
[15:32:23.555]                       }
[15:32:23.555]                       invisible(muffled)
[15:32:23.555]                     }
[15:32:23.555]                     muffleCondition(cond, pattern = "^muffle")
[15:32:23.555]                   }
[15:32:23.555]                 }
[15:32:23.555]                 else {
[15:32:23.555]                   if (TRUE) {
[15:32:23.555]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:23.555]                     {
[15:32:23.555]                       inherits <- base::inherits
[15:32:23.555]                       invokeRestart <- base::invokeRestart
[15:32:23.555]                       is.null <- base::is.null
[15:32:23.555]                       muffled <- FALSE
[15:32:23.555]                       if (inherits(cond, "message")) {
[15:32:23.555]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:23.555]                         if (muffled) 
[15:32:23.555]                           invokeRestart("muffleMessage")
[15:32:23.555]                       }
[15:32:23.555]                       else if (inherits(cond, "warning")) {
[15:32:23.555]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:23.555]                         if (muffled) 
[15:32:23.555]                           invokeRestart("muffleWarning")
[15:32:23.555]                       }
[15:32:23.555]                       else if (inherits(cond, "condition")) {
[15:32:23.555]                         if (!is.null(pattern)) {
[15:32:23.555]                           computeRestarts <- base::computeRestarts
[15:32:23.555]                           grepl <- base::grepl
[15:32:23.555]                           restarts <- computeRestarts(cond)
[15:32:23.555]                           for (restart in restarts) {
[15:32:23.555]                             name <- restart$name
[15:32:23.555]                             if (is.null(name)) 
[15:32:23.555]                               next
[15:32:23.555]                             if (!grepl(pattern, name)) 
[15:32:23.555]                               next
[15:32:23.555]                             invokeRestart(restart)
[15:32:23.555]                             muffled <- TRUE
[15:32:23.555]                             break
[15:32:23.555]                           }
[15:32:23.555]                         }
[15:32:23.555]                       }
[15:32:23.555]                       invisible(muffled)
[15:32:23.555]                     }
[15:32:23.555]                     muffleCondition(cond, pattern = "^muffle")
[15:32:23.555]                   }
[15:32:23.555]                 }
[15:32:23.555]             }
[15:32:23.555]         }))
[15:32:23.555]     }, error = function(ex) {
[15:32:23.555]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:23.555]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:23.555]                 ...future.rng), started = ...future.startTime, 
[15:32:23.555]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:23.555]             version = "1.8"), class = "FutureResult")
[15:32:23.555]     }, finally = {
[15:32:23.555]         if (!identical(...future.workdir, getwd())) 
[15:32:23.555]             setwd(...future.workdir)
[15:32:23.555]         {
[15:32:23.555]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:23.555]                 ...future.oldOptions$nwarnings <- NULL
[15:32:23.555]             }
[15:32:23.555]             base::options(...future.oldOptions)
[15:32:23.555]             if (.Platform$OS.type == "windows") {
[15:32:23.555]                 old_names <- names(...future.oldEnvVars)
[15:32:23.555]                 envs <- base::Sys.getenv()
[15:32:23.555]                 names <- names(envs)
[15:32:23.555]                 common <- intersect(names, old_names)
[15:32:23.555]                 added <- setdiff(names, old_names)
[15:32:23.555]                 removed <- setdiff(old_names, names)
[15:32:23.555]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:23.555]                   envs[common]]
[15:32:23.555]                 NAMES <- toupper(changed)
[15:32:23.555]                 args <- list()
[15:32:23.555]                 for (kk in seq_along(NAMES)) {
[15:32:23.555]                   name <- changed[[kk]]
[15:32:23.555]                   NAME <- NAMES[[kk]]
[15:32:23.555]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:23.555]                     next
[15:32:23.555]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:23.555]                 }
[15:32:23.555]                 NAMES <- toupper(added)
[15:32:23.555]                 for (kk in seq_along(NAMES)) {
[15:32:23.555]                   name <- added[[kk]]
[15:32:23.555]                   NAME <- NAMES[[kk]]
[15:32:23.555]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:23.555]                     next
[15:32:23.555]                   args[[name]] <- ""
[15:32:23.555]                 }
[15:32:23.555]                 NAMES <- toupper(removed)
[15:32:23.555]                 for (kk in seq_along(NAMES)) {
[15:32:23.555]                   name <- removed[[kk]]
[15:32:23.555]                   NAME <- NAMES[[kk]]
[15:32:23.555]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:23.555]                     next
[15:32:23.555]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:23.555]                 }
[15:32:23.555]                 if (length(args) > 0) 
[15:32:23.555]                   base::do.call(base::Sys.setenv, args = args)
[15:32:23.555]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:23.555]             }
[15:32:23.555]             else {
[15:32:23.555]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:23.555]             }
[15:32:23.555]             {
[15:32:23.555]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:23.555]                   0L) {
[15:32:23.555]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:23.555]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:23.555]                   base::options(opts)
[15:32:23.555]                 }
[15:32:23.555]                 {
[15:32:23.555]                   {
[15:32:23.555]                     NULL
[15:32:23.555]                     RNGkind("Mersenne-Twister")
[15:32:23.555]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:23.555]                       inherits = FALSE)
[15:32:23.555]                   }
[15:32:23.555]                   options(future.plan = NULL)
[15:32:23.555]                   if (is.na(NA_character_)) 
[15:32:23.555]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:23.555]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:23.555]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:23.555]                     .init = FALSE)
[15:32:23.555]                 }
[15:32:23.555]             }
[15:32:23.555]         }
[15:32:23.555]     })
[15:32:23.555]     if (TRUE) {
[15:32:23.555]         base::sink(type = "output", split = FALSE)
[15:32:23.555]         if (TRUE) {
[15:32:23.555]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:23.555]         }
[15:32:23.555]         else {
[15:32:23.555]             ...future.result["stdout"] <- base::list(NULL)
[15:32:23.555]         }
[15:32:23.555]         base::close(...future.stdout)
[15:32:23.555]         ...future.stdout <- NULL
[15:32:23.555]     }
[15:32:23.555]     ...future.result$conditions <- ...future.conditions
[15:32:23.555]     ...future.result$finished <- base::Sys.time()
[15:32:23.555]     ...future.result
[15:32:23.555] }
[15:32:23.562] assign_globals() ...
[15:32:23.562] List of 5
[15:32:23.562]  $ ...future.FUN            :function (x)  
[15:32:23.562]  $ future.call.arguments    : list()
[15:32:23.562]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:23.562]  $ ...future.elements_ii    :List of 3
[15:32:23.562]   ..$ : chr "a"
[15:32:23.562]   ..$ : chr "b"
[15:32:23.562]   ..$ : chr "c"
[15:32:23.562]  $ ...future.seeds_ii       : NULL
[15:32:23.562]  $ ...future.globals.maxSize: NULL
[15:32:23.562]  - attr(*, "where")=List of 5
[15:32:23.562]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:23.562]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:23.562]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:23.562]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:23.562]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:23.562]  - attr(*, "resolved")= logi FALSE
[15:32:23.562]  - attr(*, "total_size")= num 848
[15:32:23.562]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:23.562]  - attr(*, "already-done")= logi TRUE
[15:32:23.573] - copied '...future.FUN' to environment
[15:32:23.573] - copied 'future.call.arguments' to environment
[15:32:23.574] - copied '...future.elements_ii' to environment
[15:32:23.574] - copied '...future.seeds_ii' to environment
[15:32:23.574] - copied '...future.globals.maxSize' to environment
[15:32:23.575] assign_globals() ... done
[15:32:23.575] plan(): Setting new future strategy stack:
[15:32:23.575] List of future strategies:
[15:32:23.575] 1. sequential:
[15:32:23.575]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:23.575]    - tweaked: FALSE
[15:32:23.575]    - call: NULL
[15:32:23.576] plan(): nbrOfWorkers() = 1
[15:32:23.579] plan(): Setting new future strategy stack:
[15:32:23.579] List of future strategies:
[15:32:23.579] 1. sequential:
[15:32:23.579]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:23.579]    - tweaked: FALSE
[15:32:23.579]    - call: plan(strategy)
[15:32:23.580] plan(): nbrOfWorkers() = 1
[15:32:23.580] SequentialFuture started (and completed)
[15:32:23.581] - Launch lazy future ... done
[15:32:23.581] run() for 'SequentialFuture' ... done
[15:32:23.581] Created future:
[15:32:23.582] SequentialFuture:
[15:32:23.582] Label: 'future_sapply-1'
[15:32:23.582] Expression:
[15:32:23.582] {
[15:32:23.582]     do.call(function(...) {
[15:32:23.582]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:23.582]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:23.582]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:23.582]             on.exit(options(oopts), add = TRUE)
[15:32:23.582]         }
[15:32:23.582]         {
[15:32:23.582]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:23.582]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:23.582]                 ...future.FUN(...future.X_jj, ...)
[15:32:23.582]             })
[15:32:23.582]         }
[15:32:23.582]     }, args = future.call.arguments)
[15:32:23.582] }
[15:32:23.582] Lazy evaluation: FALSE
[15:32:23.582] Asynchronous evaluation: FALSE
[15:32:23.582] Local evaluation: TRUE
[15:32:23.582] Environment: R_GlobalEnv
[15:32:23.582] Capture standard output: TRUE
[15:32:23.582] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:23.582] Globals: 5 objects totaling 1.16 KiB (function '...future.FUN' of 848 bytes, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 336 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:23.582] Packages: <none>
[15:32:23.582] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:23.582] Resolved: TRUE
[15:32:23.582] Value: 336 bytes of class 'list'
[15:32:23.582] Early signaling: FALSE
[15:32:23.582] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:23.582] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:23.584] Chunk #1 of 1 ... DONE
[15:32:23.584] Launching 1 futures (chunks) ... DONE
[15:32:23.584] Resolving 1 futures (chunks) ...
[15:32:23.585] resolve() on list ...
[15:32:23.585]  recursive: 0
[15:32:23.585]  length: 1
[15:32:23.585] 
[15:32:23.586] resolved() for 'SequentialFuture' ...
[15:32:23.586] - state: 'finished'
[15:32:23.586] - run: TRUE
[15:32:23.587] - result: 'FutureResult'
[15:32:23.587] resolved() for 'SequentialFuture' ... done
[15:32:23.587] Future #1
[15:32:23.588] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:23.588] - nx: 1
[15:32:23.588] - relay: TRUE
[15:32:23.588] - stdout: TRUE
[15:32:23.589] - signal: TRUE
[15:32:23.589] - resignal: FALSE
[15:32:23.589] - force: TRUE
[15:32:23.589] - relayed: [n=1] FALSE
[15:32:23.590] - queued futures: [n=1] FALSE
[15:32:23.590]  - until=1
[15:32:23.590]  - relaying element #1
[15:32:23.591] - relayed: [n=1] TRUE
[15:32:23.591] - queued futures: [n=1] TRUE
[15:32:23.591] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:23.592]  length: 0 (resolved future 1)
[15:32:23.592] Relaying remaining futures
[15:32:23.592] signalConditionsASAP(NULL, pos=0) ...
[15:32:23.592] - nx: 1
[15:32:23.593] - relay: TRUE
[15:32:23.593] - stdout: TRUE
[15:32:23.593] - signal: TRUE
[15:32:23.593] - resignal: FALSE
[15:32:23.594] - force: TRUE
[15:32:23.594] - relayed: [n=1] TRUE
[15:32:23.594] - queued futures: [n=1] TRUE
 - flush all
[15:32:23.598] - relayed: [n=1] TRUE
[15:32:23.598] - queued futures: [n=1] TRUE
[15:32:23.599] signalConditionsASAP(NULL, pos=0) ... done
[15:32:23.599] resolve() on list ... DONE
[15:32:23.599]  - Number of value chunks collected: 1
[15:32:23.600] Resolving 1 futures (chunks) ... DONE
[15:32:23.600] Reducing values from 1 chunks ...
[15:32:23.600]  - Number of values collected after concatenation: 3
[15:32:23.601]  - Number of values expected: 3
[15:32:23.601] Reducing values from 1 chunks ... DONE
[15:32:23.601] future_lapply() ... DONE
List of 2
 $ y0:List of 3
  ..$ a: chr "a"
  ..$ b: chr "b"
  ..$ c: chr "c"
 $ y1:List of 3
  ..$ a: chr "a"
  ..$ b: chr "b"
  ..$ c: chr "c"
List of 2
 $ y0:List of 3
  ..$ a: chr "a"
  ..$ b: chr "b"
  ..$ c: chr "c"
 $ y2:List of 3
  ..$ : chr "a"
  ..$ : chr "b"
  ..$ : chr "c"
[15:32:23.612] future_lapply() ...
[15:32:23.613] Number of chunks: 1
[15:32:23.613] getGlobalsAndPackagesXApply() ...
[15:32:23.613]  - future.globals: TRUE
[15:32:23.614] getGlobalsAndPackages() ...
[15:32:23.614] Searching for globals...
[15:32:23.616] - globals found: [2] 'FUN', 'UseMethod'
[15:32:23.617] Searching for globals ... DONE
[15:32:23.617] Resolving globals: FALSE
[15:32:23.618] The total size of the 1 globals is 1.22 KiB (1248 bytes)
[15:32:23.618] The total size of the 1 globals exported for future expression ('FUN()') is 1.22 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.22 KiB of class 'function')
[15:32:23.619] - globals: [1] 'FUN'
[15:32:23.619] 
[15:32:23.619] getGlobalsAndPackages() ... DONE
[15:32:23.619]  - globals found/used: [n=1] 'FUN'
[15:32:23.620]  - needed namespaces: [n=0] 
[15:32:23.620] Finding globals ... DONE
[15:32:23.620]  - use_args: TRUE
[15:32:23.621]  - Getting '...' globals ...
[15:32:23.621] resolve() on list ...
[15:32:23.622]  recursive: 0
[15:32:23.622]  length: 1
[15:32:23.622]  elements: '...'
[15:32:23.622]  length: 0 (resolved future 1)
[15:32:23.623] resolve() on list ... DONE
[15:32:23.623]    - '...' content: [n=0] 
[15:32:23.623] List of 1
[15:32:23.623]  $ ...: list()
[15:32:23.623]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:23.623]  - attr(*, "where")=List of 1
[15:32:23.623]   ..$ ...:<environment: 0x00000276e0ab0ca8> 
[15:32:23.623]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:23.623]  - attr(*, "resolved")= logi TRUE
[15:32:23.623]  - attr(*, "total_size")= num NA
[15:32:23.628]  - Getting '...' globals ... DONE
[15:32:23.629] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:23.629] List of 2
[15:32:23.629]  $ ...future.FUN:function (x, ...)  
[15:32:23.629]  $ ...          : list()
[15:32:23.629]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:23.629]  - attr(*, "where")=List of 2
[15:32:23.629]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:23.629]   ..$ ...          :<environment: 0x00000276e0ab0ca8> 
[15:32:23.629]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:23.629]  - attr(*, "resolved")= logi FALSE
[15:32:23.629]  - attr(*, "total_size")= num 1248
[15:32:23.638] Packages to be attached in all futures: [n=0] 
[15:32:23.638] getGlobalsAndPackagesXApply() ... DONE
[15:32:23.639] Number of futures (= number of chunks): 1
[15:32:23.639] Launching 1 futures (chunks) ...
[15:32:23.639] Chunk #1 of 1 ...
[15:32:23.640]  - Finding globals in 'X' for chunk #1 ...
[15:32:23.640] getGlobalsAndPackages() ...
[15:32:23.640] Searching for globals...
[15:32:23.641] 
[15:32:23.641] Searching for globals ... DONE
[15:32:23.642] - globals: [0] <none>
[15:32:23.642] getGlobalsAndPackages() ... DONE
[15:32:23.642]    + additional globals found: [n=0] 
[15:32:23.643]    + additional namespaces needed: [n=0] 
[15:32:23.643]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:23.643]  - seeds: <none>
[15:32:23.643]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:23.644] getGlobalsAndPackages() ...
[15:32:23.644] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:23.644] Resolving globals: FALSE
[15:32:23.645] Tweak future expression to call with '...' arguments ...
[15:32:23.645] {
[15:32:23.645]     do.call(function(...) {
[15:32:23.645]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:23.645]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:23.645]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:23.645]             on.exit(options(oopts), add = TRUE)
[15:32:23.645]         }
[15:32:23.645]         {
[15:32:23.645]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:23.645]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:23.645]                 ...future.FUN(...future.X_jj, ...)
[15:32:23.645]             })
[15:32:23.645]         }
[15:32:23.645]     }, args = future.call.arguments)
[15:32:23.645] }
[15:32:23.646] Tweak future expression to call with '...' arguments ... DONE
[15:32:23.647] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:23.647] 
[15:32:23.647] getGlobalsAndPackages() ... DONE
[15:32:23.648] run() for 'Future' ...
[15:32:23.648] - state: 'created'
[15:32:23.649] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:23.650] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:23.650] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:23.650]   - Field: 'label'
[15:32:23.651]   - Field: 'local'
[15:32:23.651]   - Field: 'owner'
[15:32:23.651]   - Field: 'envir'
[15:32:23.651]   - Field: 'packages'
[15:32:23.652]   - Field: 'gc'
[15:32:23.652]   - Field: 'conditions'
[15:32:23.652]   - Field: 'expr'
[15:32:23.653]   - Field: 'uuid'
[15:32:23.653]   - Field: 'seed'
[15:32:23.653]   - Field: 'version'
[15:32:23.654]   - Field: 'result'
[15:32:23.654]   - Field: 'asynchronous'
[15:32:23.654]   - Field: 'calls'
[15:32:23.655]   - Field: 'globals'
[15:32:23.655]   - Field: 'stdout'
[15:32:23.655]   - Field: 'earlySignal'
[15:32:23.656]   - Field: 'lazy'
[15:32:23.656]   - Field: 'state'
[15:32:23.656] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:23.656] - Launch lazy future ...
[15:32:23.657] Packages needed by the future expression (n = 0): <none>
[15:32:23.657] Packages needed by future strategies (n = 0): <none>
[15:32:23.658] {
[15:32:23.658]     {
[15:32:23.658]         {
[15:32:23.658]             ...future.startTime <- base::Sys.time()
[15:32:23.658]             {
[15:32:23.658]                 {
[15:32:23.658]                   {
[15:32:23.658]                     base::local({
[15:32:23.658]                       has_future <- base::requireNamespace("future", 
[15:32:23.658]                         quietly = TRUE)
[15:32:23.658]                       if (has_future) {
[15:32:23.658]                         ns <- base::getNamespace("future")
[15:32:23.658]                         version <- ns[[".package"]][["version"]]
[15:32:23.658]                         if (is.null(version)) 
[15:32:23.658]                           version <- utils::packageVersion("future")
[15:32:23.658]                       }
[15:32:23.658]                       else {
[15:32:23.658]                         version <- NULL
[15:32:23.658]                       }
[15:32:23.658]                       if (!has_future || version < "1.8.0") {
[15:32:23.658]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:23.658]                           "", base::R.version$version.string), 
[15:32:23.658]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:23.658]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:23.658]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:23.658]                             "release", "version")], collapse = " "), 
[15:32:23.658]                           hostname = base::Sys.info()[["nodename"]])
[15:32:23.658]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:23.658]                           info)
[15:32:23.658]                         info <- base::paste(info, collapse = "; ")
[15:32:23.658]                         if (!has_future) {
[15:32:23.658]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:23.658]                             info)
[15:32:23.658]                         }
[15:32:23.658]                         else {
[15:32:23.658]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:23.658]                             info, version)
[15:32:23.658]                         }
[15:32:23.658]                         base::stop(msg)
[15:32:23.658]                       }
[15:32:23.658]                     })
[15:32:23.658]                   }
[15:32:23.658]                   ...future.strategy.old <- future::plan("list")
[15:32:23.658]                   options(future.plan = NULL)
[15:32:23.658]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:23.658]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:23.658]                 }
[15:32:23.658]                 ...future.workdir <- getwd()
[15:32:23.658]             }
[15:32:23.658]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:23.658]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:23.658]         }
[15:32:23.658]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:23.658]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:23.658]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:23.658]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:23.658]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:23.658]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:23.658]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:23.658]             base::names(...future.oldOptions))
[15:32:23.658]     }
[15:32:23.658]     if (FALSE) {
[15:32:23.658]     }
[15:32:23.658]     else {
[15:32:23.658]         if (TRUE) {
[15:32:23.658]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:23.658]                 open = "w")
[15:32:23.658]         }
[15:32:23.658]         else {
[15:32:23.658]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:23.658]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:23.658]         }
[15:32:23.658]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:23.658]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:23.658]             base::sink(type = "output", split = FALSE)
[15:32:23.658]             base::close(...future.stdout)
[15:32:23.658]         }, add = TRUE)
[15:32:23.658]     }
[15:32:23.658]     ...future.frame <- base::sys.nframe()
[15:32:23.658]     ...future.conditions <- base::list()
[15:32:23.658]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:23.658]     if (FALSE) {
[15:32:23.658]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:23.658]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:23.658]     }
[15:32:23.658]     ...future.result <- base::tryCatch({
[15:32:23.658]         base::withCallingHandlers({
[15:32:23.658]             ...future.value <- base::withVisible(base::local({
[15:32:23.658]                 do.call(function(...) {
[15:32:23.658]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:23.658]                   if (!identical(...future.globals.maxSize.org, 
[15:32:23.658]                     ...future.globals.maxSize)) {
[15:32:23.658]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:23.658]                     on.exit(options(oopts), add = TRUE)
[15:32:23.658]                   }
[15:32:23.658]                   {
[15:32:23.658]                     lapply(seq_along(...future.elements_ii), 
[15:32:23.658]                       FUN = function(jj) {
[15:32:23.658]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:23.658]                         ...future.FUN(...future.X_jj, ...)
[15:32:23.658]                       })
[15:32:23.658]                   }
[15:32:23.658]                 }, args = future.call.arguments)
[15:32:23.658]             }))
[15:32:23.658]             future::FutureResult(value = ...future.value$value, 
[15:32:23.658]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:23.658]                   ...future.rng), globalenv = if (FALSE) 
[15:32:23.658]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:23.658]                     ...future.globalenv.names))
[15:32:23.658]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:23.658]         }, condition = base::local({
[15:32:23.658]             c <- base::c
[15:32:23.658]             inherits <- base::inherits
[15:32:23.658]             invokeRestart <- base::invokeRestart
[15:32:23.658]             length <- base::length
[15:32:23.658]             list <- base::list
[15:32:23.658]             seq.int <- base::seq.int
[15:32:23.658]             signalCondition <- base::signalCondition
[15:32:23.658]             sys.calls <- base::sys.calls
[15:32:23.658]             `[[` <- base::`[[`
[15:32:23.658]             `+` <- base::`+`
[15:32:23.658]             `<<-` <- base::`<<-`
[15:32:23.658]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:23.658]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:23.658]                   3L)]
[15:32:23.658]             }
[15:32:23.658]             function(cond) {
[15:32:23.658]                 is_error <- inherits(cond, "error")
[15:32:23.658]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:23.658]                   NULL)
[15:32:23.658]                 if (is_error) {
[15:32:23.658]                   sessionInformation <- function() {
[15:32:23.658]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:23.658]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:23.658]                       search = base::search(), system = base::Sys.info())
[15:32:23.658]                   }
[15:32:23.658]                   ...future.conditions[[length(...future.conditions) + 
[15:32:23.658]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:23.658]                     cond$call), session = sessionInformation(), 
[15:32:23.658]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:23.658]                   signalCondition(cond)
[15:32:23.658]                 }
[15:32:23.658]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:23.658]                 "immediateCondition"))) {
[15:32:23.658]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:23.658]                   ...future.conditions[[length(...future.conditions) + 
[15:32:23.658]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:23.658]                   if (TRUE && !signal) {
[15:32:23.658]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:23.658]                     {
[15:32:23.658]                       inherits <- base::inherits
[15:32:23.658]                       invokeRestart <- base::invokeRestart
[15:32:23.658]                       is.null <- base::is.null
[15:32:23.658]                       muffled <- FALSE
[15:32:23.658]                       if (inherits(cond, "message")) {
[15:32:23.658]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:23.658]                         if (muffled) 
[15:32:23.658]                           invokeRestart("muffleMessage")
[15:32:23.658]                       }
[15:32:23.658]                       else if (inherits(cond, "warning")) {
[15:32:23.658]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:23.658]                         if (muffled) 
[15:32:23.658]                           invokeRestart("muffleWarning")
[15:32:23.658]                       }
[15:32:23.658]                       else if (inherits(cond, "condition")) {
[15:32:23.658]                         if (!is.null(pattern)) {
[15:32:23.658]                           computeRestarts <- base::computeRestarts
[15:32:23.658]                           grepl <- base::grepl
[15:32:23.658]                           restarts <- computeRestarts(cond)
[15:32:23.658]                           for (restart in restarts) {
[15:32:23.658]                             name <- restart$name
[15:32:23.658]                             if (is.null(name)) 
[15:32:23.658]                               next
[15:32:23.658]                             if (!grepl(pattern, name)) 
[15:32:23.658]                               next
[15:32:23.658]                             invokeRestart(restart)
[15:32:23.658]                             muffled <- TRUE
[15:32:23.658]                             break
[15:32:23.658]                           }
[15:32:23.658]                         }
[15:32:23.658]                       }
[15:32:23.658]                       invisible(muffled)
[15:32:23.658]                     }
[15:32:23.658]                     muffleCondition(cond, pattern = "^muffle")
[15:32:23.658]                   }
[15:32:23.658]                 }
[15:32:23.658]                 else {
[15:32:23.658]                   if (TRUE) {
[15:32:23.658]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:23.658]                     {
[15:32:23.658]                       inherits <- base::inherits
[15:32:23.658]                       invokeRestart <- base::invokeRestart
[15:32:23.658]                       is.null <- base::is.null
[15:32:23.658]                       muffled <- FALSE
[15:32:23.658]                       if (inherits(cond, "message")) {
[15:32:23.658]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:23.658]                         if (muffled) 
[15:32:23.658]                           invokeRestart("muffleMessage")
[15:32:23.658]                       }
[15:32:23.658]                       else if (inherits(cond, "warning")) {
[15:32:23.658]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:23.658]                         if (muffled) 
[15:32:23.658]                           invokeRestart("muffleWarning")
[15:32:23.658]                       }
[15:32:23.658]                       else if (inherits(cond, "condition")) {
[15:32:23.658]                         if (!is.null(pattern)) {
[15:32:23.658]                           computeRestarts <- base::computeRestarts
[15:32:23.658]                           grepl <- base::grepl
[15:32:23.658]                           restarts <- computeRestarts(cond)
[15:32:23.658]                           for (restart in restarts) {
[15:32:23.658]                             name <- restart$name
[15:32:23.658]                             if (is.null(name)) 
[15:32:23.658]                               next
[15:32:23.658]                             if (!grepl(pattern, name)) 
[15:32:23.658]                               next
[15:32:23.658]                             invokeRestart(restart)
[15:32:23.658]                             muffled <- TRUE
[15:32:23.658]                             break
[15:32:23.658]                           }
[15:32:23.658]                         }
[15:32:23.658]                       }
[15:32:23.658]                       invisible(muffled)
[15:32:23.658]                     }
[15:32:23.658]                     muffleCondition(cond, pattern = "^muffle")
[15:32:23.658]                   }
[15:32:23.658]                 }
[15:32:23.658]             }
[15:32:23.658]         }))
[15:32:23.658]     }, error = function(ex) {
[15:32:23.658]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:23.658]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:23.658]                 ...future.rng), started = ...future.startTime, 
[15:32:23.658]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:23.658]             version = "1.8"), class = "FutureResult")
[15:32:23.658]     }, finally = {
[15:32:23.658]         if (!identical(...future.workdir, getwd())) 
[15:32:23.658]             setwd(...future.workdir)
[15:32:23.658]         {
[15:32:23.658]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:23.658]                 ...future.oldOptions$nwarnings <- NULL
[15:32:23.658]             }
[15:32:23.658]             base::options(...future.oldOptions)
[15:32:23.658]             if (.Platform$OS.type == "windows") {
[15:32:23.658]                 old_names <- names(...future.oldEnvVars)
[15:32:23.658]                 envs <- base::Sys.getenv()
[15:32:23.658]                 names <- names(envs)
[15:32:23.658]                 common <- intersect(names, old_names)
[15:32:23.658]                 added <- setdiff(names, old_names)
[15:32:23.658]                 removed <- setdiff(old_names, names)
[15:32:23.658]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:23.658]                   envs[common]]
[15:32:23.658]                 NAMES <- toupper(changed)
[15:32:23.658]                 args <- list()
[15:32:23.658]                 for (kk in seq_along(NAMES)) {
[15:32:23.658]                   name <- changed[[kk]]
[15:32:23.658]                   NAME <- NAMES[[kk]]
[15:32:23.658]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:23.658]                     next
[15:32:23.658]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:23.658]                 }
[15:32:23.658]                 NAMES <- toupper(added)
[15:32:23.658]                 for (kk in seq_along(NAMES)) {
[15:32:23.658]                   name <- added[[kk]]
[15:32:23.658]                   NAME <- NAMES[[kk]]
[15:32:23.658]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:23.658]                     next
[15:32:23.658]                   args[[name]] <- ""
[15:32:23.658]                 }
[15:32:23.658]                 NAMES <- toupper(removed)
[15:32:23.658]                 for (kk in seq_along(NAMES)) {
[15:32:23.658]                   name <- removed[[kk]]
[15:32:23.658]                   NAME <- NAMES[[kk]]
[15:32:23.658]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:23.658]                     next
[15:32:23.658]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:23.658]                 }
[15:32:23.658]                 if (length(args) > 0) 
[15:32:23.658]                   base::do.call(base::Sys.setenv, args = args)
[15:32:23.658]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:23.658]             }
[15:32:23.658]             else {
[15:32:23.658]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:23.658]             }
[15:32:23.658]             {
[15:32:23.658]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:23.658]                   0L) {
[15:32:23.658]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:23.658]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:23.658]                   base::options(opts)
[15:32:23.658]                 }
[15:32:23.658]                 {
[15:32:23.658]                   {
[15:32:23.658]                     NULL
[15:32:23.658]                     RNGkind("Mersenne-Twister")
[15:32:23.658]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:23.658]                       inherits = FALSE)
[15:32:23.658]                   }
[15:32:23.658]                   options(future.plan = NULL)
[15:32:23.658]                   if (is.na(NA_character_)) 
[15:32:23.658]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:23.658]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:23.658]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:23.658]                     .init = FALSE)
[15:32:23.658]                 }
[15:32:23.658]             }
[15:32:23.658]         }
[15:32:23.658]     })
[15:32:23.658]     if (TRUE) {
[15:32:23.658]         base::sink(type = "output", split = FALSE)
[15:32:23.658]         if (TRUE) {
[15:32:23.658]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:23.658]         }
[15:32:23.658]         else {
[15:32:23.658]             ...future.result["stdout"] <- base::list(NULL)
[15:32:23.658]         }
[15:32:23.658]         base::close(...future.stdout)
[15:32:23.658]         ...future.stdout <- NULL
[15:32:23.658]     }
[15:32:23.658]     ...future.result$conditions <- ...future.conditions
[15:32:23.658]     ...future.result$finished <- base::Sys.time()
[15:32:23.658]     ...future.result
[15:32:23.658] }
[15:32:23.665] assign_globals() ...
[15:32:23.665] List of 5
[15:32:23.665]  $ ...future.FUN            :function (x, ...)  
[15:32:23.665]  $ future.call.arguments    : list()
[15:32:23.665]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:23.665]  $ ...future.elements_ii    :List of 3
[15:32:23.665]   ..$ : chr "a"
[15:32:23.665]   ..$ : chr "b"
[15:32:23.665]   ..$ : chr "c"
[15:32:23.665]  $ ...future.seeds_ii       : NULL
[15:32:23.665]  $ ...future.globals.maxSize: NULL
[15:32:23.665]  - attr(*, "where")=List of 5
[15:32:23.665]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:23.665]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:23.665]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:23.665]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:23.665]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:23.665]  - attr(*, "resolved")= logi FALSE
[15:32:23.665]  - attr(*, "total_size")= num 1248
[15:32:23.665]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:23.665]  - attr(*, "already-done")= logi TRUE
[15:32:23.675] - copied '...future.FUN' to environment
[15:32:23.676] - copied 'future.call.arguments' to environment
[15:32:23.676] - copied '...future.elements_ii' to environment
[15:32:23.676] - copied '...future.seeds_ii' to environment
[15:32:23.676] - copied '...future.globals.maxSize' to environment
[15:32:23.677] assign_globals() ... done
[15:32:23.677] plan(): Setting new future strategy stack:
[15:32:23.678] List of future strategies:
[15:32:23.678] 1. sequential:
[15:32:23.678]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:23.678]    - tweaked: FALSE
[15:32:23.678]    - call: NULL
[15:32:23.679] plan(): nbrOfWorkers() = 1
[15:32:23.681] plan(): Setting new future strategy stack:
[15:32:23.681] List of future strategies:
[15:32:23.681] 1. sequential:
[15:32:23.681]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:23.681]    - tweaked: FALSE
[15:32:23.681]    - call: plan(strategy)
[15:32:23.682] plan(): nbrOfWorkers() = 1
[15:32:23.682] SequentialFuture started (and completed)
[15:32:23.683] - Launch lazy future ... done
[15:32:23.683] run() for 'SequentialFuture' ... done
[15:32:23.683] Created future:
[15:32:23.687] SequentialFuture:
[15:32:23.687] Label: 'future_sapply-1'
[15:32:23.687] Expression:
[15:32:23.687] {
[15:32:23.687]     do.call(function(...) {
[15:32:23.687]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:23.687]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:23.687]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:23.687]             on.exit(options(oopts), add = TRUE)
[15:32:23.687]         }
[15:32:23.687]         {
[15:32:23.687]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:23.687]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:23.687]                 ...future.FUN(...future.X_jj, ...)
[15:32:23.687]             })
[15:32:23.687]         }
[15:32:23.687]     }, args = future.call.arguments)
[15:32:23.687] }
[15:32:23.687] Lazy evaluation: FALSE
[15:32:23.687] Asynchronous evaluation: FALSE
[15:32:23.687] Local evaluation: TRUE
[15:32:23.687] Environment: R_GlobalEnv
[15:32:23.687] Capture standard output: TRUE
[15:32:23.687] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:23.687] Globals: 5 objects totaling 1.55 KiB (function '...future.FUN' of 1.22 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 336 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:23.687] Packages: <none>
[15:32:23.687] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:23.687] Resolved: TRUE
[15:32:23.687] Value: 840 bytes of class 'list'
[15:32:23.687] Early signaling: FALSE
[15:32:23.687] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:23.687] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:23.690] Chunk #1 of 1 ... DONE
[15:32:23.690] Launching 1 futures (chunks) ... DONE
[15:32:23.690] Resolving 1 futures (chunks) ...
[15:32:23.691] resolve() on list ...
[15:32:23.691]  recursive: 0
[15:32:23.691]  length: 1
[15:32:23.691] 
[15:32:23.692] resolved() for 'SequentialFuture' ...
[15:32:23.692] - state: 'finished'
[15:32:23.692] - run: TRUE
[15:32:23.693] - result: 'FutureResult'
[15:32:23.693] resolved() for 'SequentialFuture' ... done
[15:32:23.693] Future #1
[15:32:23.694] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:23.694] - nx: 1
[15:32:23.694] - relay: TRUE
[15:32:23.695] - stdout: TRUE
[15:32:23.695] - signal: TRUE
[15:32:23.695] - resignal: FALSE
[15:32:23.695] - force: TRUE
[15:32:23.696] - relayed: [n=1] FALSE
[15:32:23.696] - queued futures: [n=1] FALSE
[15:32:23.696]  - until=1
[15:32:23.697]  - relaying element #1
[15:32:23.697] - relayed: [n=1] TRUE
[15:32:23.697] - queued futures: [n=1] TRUE
[15:32:23.698] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:23.698]  length: 0 (resolved future 1)
[15:32:23.698] Relaying remaining futures
[15:32:23.699] signalConditionsASAP(NULL, pos=0) ...
[15:32:23.699] - nx: 1
[15:32:23.699] - relay: TRUE
[15:32:23.699] - stdout: TRUE
[15:32:23.700] - signal: TRUE
[15:32:23.700] - resignal: FALSE
[15:32:23.700] - force: TRUE
[15:32:23.700] - relayed: [n=1] TRUE
[15:32:23.701] - queued futures: [n=1] TRUE
 - flush all
[15:32:23.701] - relayed: [n=1] TRUE
[15:32:23.701] - queued futures: [n=1] TRUE
[15:32:23.702] signalConditionsASAP(NULL, pos=0) ... done
[15:32:23.702] resolve() on list ... DONE
[15:32:23.702]  - Number of value chunks collected: 1
[15:32:23.703] Resolving 1 futures (chunks) ... DONE
[15:32:23.703] Reducing values from 1 chunks ...
[15:32:23.703]  - Number of values collected after concatenation: 3
[15:32:23.704]  - Number of values expected: 3
[15:32:23.704] Reducing values from 1 chunks ... DONE
[15:32:23.704] future_lapply() ... DONE
List of 2
 $ y0:List of 3
  ..$ a: chr [1, 1] "a"
  ..$ b: chr [1, 1] "b"
  ..$ c: chr [1, 1] "c"
 $ y1:List of 3
  ..$ a: chr [1, 1] "a"
  ..$ b: chr [1, 1] "b"
  ..$ c: chr [1, 1] "c"
List of 2
 $ y0:List of 3
  ..$ a: chr [1, 1] "a"
  ..$ b: chr [1, 1] "b"
  ..$ c: chr [1, 1] "c"
 $ y2:List of 3
  ..$ : chr [1, 1] "a"
  ..$ : chr [1, 1] "b"
  ..$ : chr [1, 1] "c"
[15:32:23.716] future_lapply() ...
[15:32:23.717] Number of chunks: 1
[15:32:23.717] getGlobalsAndPackagesXApply() ...
[15:32:23.717]  - future.globals: TRUE
[15:32:23.718] getGlobalsAndPackages() ...
[15:32:23.718] Searching for globals...
[15:32:23.720] - globals found: [1] 'FUN'
[15:32:23.721] Searching for globals ... DONE
[15:32:23.721] Resolving globals: FALSE
[15:32:23.722] The total size of the 1 globals is 848 bytes (848 bytes)
[15:32:23.722] The total size of the 1 globals exported for future expression ('FUN()') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:32:23.723] - globals: [1] 'FUN'
[15:32:23.723] 
[15:32:23.723] getGlobalsAndPackages() ... DONE
[15:32:23.724]  - globals found/used: [n=1] 'FUN'
[15:32:23.724]  - needed namespaces: [n=0] 
[15:32:23.724] Finding globals ... DONE
[15:32:23.725]  - use_args: TRUE
[15:32:23.725]  - Getting '...' globals ...
[15:32:23.726] resolve() on list ...
[15:32:23.726]  recursive: 0
[15:32:23.726]  length: 1
[15:32:23.727]  elements: '...'
[15:32:23.727]  length: 0 (resolved future 1)
[15:32:23.727] resolve() on list ... DONE
[15:32:23.728]    - '...' content: [n=0] 
[15:32:23.728] List of 1
[15:32:23.728]  $ ...: list()
[15:32:23.728]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:23.728]  - attr(*, "where")=List of 1
[15:32:23.728]   ..$ ...:<environment: 0x00000276e076e338> 
[15:32:23.728]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:23.728]  - attr(*, "resolved")= logi TRUE
[15:32:23.728]  - attr(*, "total_size")= num NA
[15:32:23.770]  - Getting '...' globals ... DONE
[15:32:23.771] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:23.771] List of 2
[15:32:23.771]  $ ...future.FUN:function (x)  
[15:32:23.771]  $ ...          : list()
[15:32:23.771]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:23.771]  - attr(*, "where")=List of 2
[15:32:23.771]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:23.771]   ..$ ...          :<environment: 0x00000276e076e338> 
[15:32:23.771]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:23.771]  - attr(*, "resolved")= logi FALSE
[15:32:23.771]  - attr(*, "total_size")= num 848
[15:32:23.774] Packages to be attached in all futures: [n=0] 
[15:32:23.775] getGlobalsAndPackagesXApply() ... DONE
[15:32:23.775] Number of futures (= number of chunks): 1
[15:32:23.775] Launching 1 futures (chunks) ...
[15:32:23.775] Chunk #1 of 1 ...
[15:32:23.776]  - Finding globals in 'X' for chunk #1 ...
[15:32:23.776] getGlobalsAndPackages() ...
[15:32:23.776] Searching for globals...
[15:32:23.776] 
[15:32:23.777] Searching for globals ... DONE
[15:32:23.777] - globals: [0] <none>
[15:32:23.777] getGlobalsAndPackages() ... DONE
[15:32:23.777]    + additional globals found: [n=0] 
[15:32:23.777]    + additional namespaces needed: [n=0] 
[15:32:23.777]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:23.778]  - seeds: <none>
[15:32:23.778]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:23.778] getGlobalsAndPackages() ...
[15:32:23.778] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:23.778] Resolving globals: FALSE
[15:32:23.779] Tweak future expression to call with '...' arguments ...
[15:32:23.779] {
[15:32:23.779]     do.call(function(...) {
[15:32:23.779]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:23.779]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:23.779]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:23.779]             on.exit(options(oopts), add = TRUE)
[15:32:23.779]         }
[15:32:23.779]         {
[15:32:23.779]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:23.779]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:23.779]                 ...future.FUN(...future.X_jj, ...)
[15:32:23.779]             })
[15:32:23.779]         }
[15:32:23.779]     }, args = future.call.arguments)
[15:32:23.779] }
[15:32:23.779] Tweak future expression to call with '...' arguments ... DONE
[15:32:23.780] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:23.780] 
[15:32:23.780] getGlobalsAndPackages() ... DONE
[15:32:23.781] run() for 'Future' ...
[15:32:23.781] - state: 'created'
[15:32:23.781] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:23.782] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:23.782] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:23.782]   - Field: 'label'
[15:32:23.782]   - Field: 'local'
[15:32:23.782]   - Field: 'owner'
[15:32:23.783]   - Field: 'envir'
[15:32:23.783]   - Field: 'packages'
[15:32:23.783]   - Field: 'gc'
[15:32:23.783]   - Field: 'conditions'
[15:32:23.783]   - Field: 'expr'
[15:32:23.783]   - Field: 'uuid'
[15:32:23.784]   - Field: 'seed'
[15:32:23.784]   - Field: 'version'
[15:32:23.784]   - Field: 'result'
[15:32:23.784]   - Field: 'asynchronous'
[15:32:23.784]   - Field: 'calls'
[15:32:23.785]   - Field: 'globals'
[15:32:23.785]   - Field: 'stdout'
[15:32:23.785]   - Field: 'earlySignal'
[15:32:23.785]   - Field: 'lazy'
[15:32:23.785]   - Field: 'state'
[15:32:23.785] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:23.786] - Launch lazy future ...
[15:32:23.786] Packages needed by the future expression (n = 0): <none>
[15:32:23.786] Packages needed by future strategies (n = 0): <none>
[15:32:23.787] {
[15:32:23.787]     {
[15:32:23.787]         {
[15:32:23.787]             ...future.startTime <- base::Sys.time()
[15:32:23.787]             {
[15:32:23.787]                 {
[15:32:23.787]                   {
[15:32:23.787]                     base::local({
[15:32:23.787]                       has_future <- base::requireNamespace("future", 
[15:32:23.787]                         quietly = TRUE)
[15:32:23.787]                       if (has_future) {
[15:32:23.787]                         ns <- base::getNamespace("future")
[15:32:23.787]                         version <- ns[[".package"]][["version"]]
[15:32:23.787]                         if (is.null(version)) 
[15:32:23.787]                           version <- utils::packageVersion("future")
[15:32:23.787]                       }
[15:32:23.787]                       else {
[15:32:23.787]                         version <- NULL
[15:32:23.787]                       }
[15:32:23.787]                       if (!has_future || version < "1.8.0") {
[15:32:23.787]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:23.787]                           "", base::R.version$version.string), 
[15:32:23.787]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:23.787]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:23.787]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:23.787]                             "release", "version")], collapse = " "), 
[15:32:23.787]                           hostname = base::Sys.info()[["nodename"]])
[15:32:23.787]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:23.787]                           info)
[15:32:23.787]                         info <- base::paste(info, collapse = "; ")
[15:32:23.787]                         if (!has_future) {
[15:32:23.787]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:23.787]                             info)
[15:32:23.787]                         }
[15:32:23.787]                         else {
[15:32:23.787]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:23.787]                             info, version)
[15:32:23.787]                         }
[15:32:23.787]                         base::stop(msg)
[15:32:23.787]                       }
[15:32:23.787]                     })
[15:32:23.787]                   }
[15:32:23.787]                   ...future.strategy.old <- future::plan("list")
[15:32:23.787]                   options(future.plan = NULL)
[15:32:23.787]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:23.787]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:23.787]                 }
[15:32:23.787]                 ...future.workdir <- getwd()
[15:32:23.787]             }
[15:32:23.787]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:23.787]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:23.787]         }
[15:32:23.787]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:23.787]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:23.787]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:23.787]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:23.787]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:23.787]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:23.787]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:23.787]             base::names(...future.oldOptions))
[15:32:23.787]     }
[15:32:23.787]     if (FALSE) {
[15:32:23.787]     }
[15:32:23.787]     else {
[15:32:23.787]         if (TRUE) {
[15:32:23.787]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:23.787]                 open = "w")
[15:32:23.787]         }
[15:32:23.787]         else {
[15:32:23.787]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:23.787]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:23.787]         }
[15:32:23.787]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:23.787]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:23.787]             base::sink(type = "output", split = FALSE)
[15:32:23.787]             base::close(...future.stdout)
[15:32:23.787]         }, add = TRUE)
[15:32:23.787]     }
[15:32:23.787]     ...future.frame <- base::sys.nframe()
[15:32:23.787]     ...future.conditions <- base::list()
[15:32:23.787]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:23.787]     if (FALSE) {
[15:32:23.787]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:23.787]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:23.787]     }
[15:32:23.787]     ...future.result <- base::tryCatch({
[15:32:23.787]         base::withCallingHandlers({
[15:32:23.787]             ...future.value <- base::withVisible(base::local({
[15:32:23.787]                 do.call(function(...) {
[15:32:23.787]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:23.787]                   if (!identical(...future.globals.maxSize.org, 
[15:32:23.787]                     ...future.globals.maxSize)) {
[15:32:23.787]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:23.787]                     on.exit(options(oopts), add = TRUE)
[15:32:23.787]                   }
[15:32:23.787]                   {
[15:32:23.787]                     lapply(seq_along(...future.elements_ii), 
[15:32:23.787]                       FUN = function(jj) {
[15:32:23.787]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:23.787]                         ...future.FUN(...future.X_jj, ...)
[15:32:23.787]                       })
[15:32:23.787]                   }
[15:32:23.787]                 }, args = future.call.arguments)
[15:32:23.787]             }))
[15:32:23.787]             future::FutureResult(value = ...future.value$value, 
[15:32:23.787]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:23.787]                   ...future.rng), globalenv = if (FALSE) 
[15:32:23.787]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:23.787]                     ...future.globalenv.names))
[15:32:23.787]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:23.787]         }, condition = base::local({
[15:32:23.787]             c <- base::c
[15:32:23.787]             inherits <- base::inherits
[15:32:23.787]             invokeRestart <- base::invokeRestart
[15:32:23.787]             length <- base::length
[15:32:23.787]             list <- base::list
[15:32:23.787]             seq.int <- base::seq.int
[15:32:23.787]             signalCondition <- base::signalCondition
[15:32:23.787]             sys.calls <- base::sys.calls
[15:32:23.787]             `[[` <- base::`[[`
[15:32:23.787]             `+` <- base::`+`
[15:32:23.787]             `<<-` <- base::`<<-`
[15:32:23.787]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:23.787]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:23.787]                   3L)]
[15:32:23.787]             }
[15:32:23.787]             function(cond) {
[15:32:23.787]                 is_error <- inherits(cond, "error")
[15:32:23.787]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:23.787]                   NULL)
[15:32:23.787]                 if (is_error) {
[15:32:23.787]                   sessionInformation <- function() {
[15:32:23.787]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:23.787]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:23.787]                       search = base::search(), system = base::Sys.info())
[15:32:23.787]                   }
[15:32:23.787]                   ...future.conditions[[length(...future.conditions) + 
[15:32:23.787]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:23.787]                     cond$call), session = sessionInformation(), 
[15:32:23.787]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:23.787]                   signalCondition(cond)
[15:32:23.787]                 }
[15:32:23.787]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:23.787]                 "immediateCondition"))) {
[15:32:23.787]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:23.787]                   ...future.conditions[[length(...future.conditions) + 
[15:32:23.787]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:23.787]                   if (TRUE && !signal) {
[15:32:23.787]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:23.787]                     {
[15:32:23.787]                       inherits <- base::inherits
[15:32:23.787]                       invokeRestart <- base::invokeRestart
[15:32:23.787]                       is.null <- base::is.null
[15:32:23.787]                       muffled <- FALSE
[15:32:23.787]                       if (inherits(cond, "message")) {
[15:32:23.787]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:23.787]                         if (muffled) 
[15:32:23.787]                           invokeRestart("muffleMessage")
[15:32:23.787]                       }
[15:32:23.787]                       else if (inherits(cond, "warning")) {
[15:32:23.787]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:23.787]                         if (muffled) 
[15:32:23.787]                           invokeRestart("muffleWarning")
[15:32:23.787]                       }
[15:32:23.787]                       else if (inherits(cond, "condition")) {
[15:32:23.787]                         if (!is.null(pattern)) {
[15:32:23.787]                           computeRestarts <- base::computeRestarts
[15:32:23.787]                           grepl <- base::grepl
[15:32:23.787]                           restarts <- computeRestarts(cond)
[15:32:23.787]                           for (restart in restarts) {
[15:32:23.787]                             name <- restart$name
[15:32:23.787]                             if (is.null(name)) 
[15:32:23.787]                               next
[15:32:23.787]                             if (!grepl(pattern, name)) 
[15:32:23.787]                               next
[15:32:23.787]                             invokeRestart(restart)
[15:32:23.787]                             muffled <- TRUE
[15:32:23.787]                             break
[15:32:23.787]                           }
[15:32:23.787]                         }
[15:32:23.787]                       }
[15:32:23.787]                       invisible(muffled)
[15:32:23.787]                     }
[15:32:23.787]                     muffleCondition(cond, pattern = "^muffle")
[15:32:23.787]                   }
[15:32:23.787]                 }
[15:32:23.787]                 else {
[15:32:23.787]                   if (TRUE) {
[15:32:23.787]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:23.787]                     {
[15:32:23.787]                       inherits <- base::inherits
[15:32:23.787]                       invokeRestart <- base::invokeRestart
[15:32:23.787]                       is.null <- base::is.null
[15:32:23.787]                       muffled <- FALSE
[15:32:23.787]                       if (inherits(cond, "message")) {
[15:32:23.787]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:23.787]                         if (muffled) 
[15:32:23.787]                           invokeRestart("muffleMessage")
[15:32:23.787]                       }
[15:32:23.787]                       else if (inherits(cond, "warning")) {
[15:32:23.787]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:23.787]                         if (muffled) 
[15:32:23.787]                           invokeRestart("muffleWarning")
[15:32:23.787]                       }
[15:32:23.787]                       else if (inherits(cond, "condition")) {
[15:32:23.787]                         if (!is.null(pattern)) {
[15:32:23.787]                           computeRestarts <- base::computeRestarts
[15:32:23.787]                           grepl <- base::grepl
[15:32:23.787]                           restarts <- computeRestarts(cond)
[15:32:23.787]                           for (restart in restarts) {
[15:32:23.787]                             name <- restart$name
[15:32:23.787]                             if (is.null(name)) 
[15:32:23.787]                               next
[15:32:23.787]                             if (!grepl(pattern, name)) 
[15:32:23.787]                               next
[15:32:23.787]                             invokeRestart(restart)
[15:32:23.787]                             muffled <- TRUE
[15:32:23.787]                             break
[15:32:23.787]                           }
[15:32:23.787]                         }
[15:32:23.787]                       }
[15:32:23.787]                       invisible(muffled)
[15:32:23.787]                     }
[15:32:23.787]                     muffleCondition(cond, pattern = "^muffle")
[15:32:23.787]                   }
[15:32:23.787]                 }
[15:32:23.787]             }
[15:32:23.787]         }))
[15:32:23.787]     }, error = function(ex) {
[15:32:23.787]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:23.787]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:23.787]                 ...future.rng), started = ...future.startTime, 
[15:32:23.787]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:23.787]             version = "1.8"), class = "FutureResult")
[15:32:23.787]     }, finally = {
[15:32:23.787]         if (!identical(...future.workdir, getwd())) 
[15:32:23.787]             setwd(...future.workdir)
[15:32:23.787]         {
[15:32:23.787]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:23.787]                 ...future.oldOptions$nwarnings <- NULL
[15:32:23.787]             }
[15:32:23.787]             base::options(...future.oldOptions)
[15:32:23.787]             if (.Platform$OS.type == "windows") {
[15:32:23.787]                 old_names <- names(...future.oldEnvVars)
[15:32:23.787]                 envs <- base::Sys.getenv()
[15:32:23.787]                 names <- names(envs)
[15:32:23.787]                 common <- intersect(names, old_names)
[15:32:23.787]                 added <- setdiff(names, old_names)
[15:32:23.787]                 removed <- setdiff(old_names, names)
[15:32:23.787]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:23.787]                   envs[common]]
[15:32:23.787]                 NAMES <- toupper(changed)
[15:32:23.787]                 args <- list()
[15:32:23.787]                 for (kk in seq_along(NAMES)) {
[15:32:23.787]                   name <- changed[[kk]]
[15:32:23.787]                   NAME <- NAMES[[kk]]
[15:32:23.787]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:23.787]                     next
[15:32:23.787]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:23.787]                 }
[15:32:23.787]                 NAMES <- toupper(added)
[15:32:23.787]                 for (kk in seq_along(NAMES)) {
[15:32:23.787]                   name <- added[[kk]]
[15:32:23.787]                   NAME <- NAMES[[kk]]
[15:32:23.787]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:23.787]                     next
[15:32:23.787]                   args[[name]] <- ""
[15:32:23.787]                 }
[15:32:23.787]                 NAMES <- toupper(removed)
[15:32:23.787]                 for (kk in seq_along(NAMES)) {
[15:32:23.787]                   name <- removed[[kk]]
[15:32:23.787]                   NAME <- NAMES[[kk]]
[15:32:23.787]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:23.787]                     next
[15:32:23.787]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:23.787]                 }
[15:32:23.787]                 if (length(args) > 0) 
[15:32:23.787]                   base::do.call(base::Sys.setenv, args = args)
[15:32:23.787]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:23.787]             }
[15:32:23.787]             else {
[15:32:23.787]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:23.787]             }
[15:32:23.787]             {
[15:32:23.787]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:23.787]                   0L) {
[15:32:23.787]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:23.787]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:23.787]                   base::options(opts)
[15:32:23.787]                 }
[15:32:23.787]                 {
[15:32:23.787]                   {
[15:32:23.787]                     NULL
[15:32:23.787]                     RNGkind("Mersenne-Twister")
[15:32:23.787]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:23.787]                       inherits = FALSE)
[15:32:23.787]                   }
[15:32:23.787]                   options(future.plan = NULL)
[15:32:23.787]                   if (is.na(NA_character_)) 
[15:32:23.787]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:23.787]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:23.787]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:23.787]                     .init = FALSE)
[15:32:23.787]                 }
[15:32:23.787]             }
[15:32:23.787]         }
[15:32:23.787]     })
[15:32:23.787]     if (TRUE) {
[15:32:23.787]         base::sink(type = "output", split = FALSE)
[15:32:23.787]         if (TRUE) {
[15:32:23.787]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:23.787]         }
[15:32:23.787]         else {
[15:32:23.787]             ...future.result["stdout"] <- base::list(NULL)
[15:32:23.787]         }
[15:32:23.787]         base::close(...future.stdout)
[15:32:23.787]         ...future.stdout <- NULL
[15:32:23.787]     }
[15:32:23.787]     ...future.result$conditions <- ...future.conditions
[15:32:23.787]     ...future.result$finished <- base::Sys.time()
[15:32:23.787]     ...future.result
[15:32:23.787] }
[15:32:23.791] assign_globals() ...
[15:32:23.792] List of 5
[15:32:23.792]  $ ...future.FUN            :function (x)  
[15:32:23.792]  $ future.call.arguments    : list()
[15:32:23.792]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:23.792]  $ ...future.elements_ii    :List of 3
[15:32:23.792]   ..$ : chr "a"
[15:32:23.792]   ..$ : chr "b"
[15:32:23.792]   ..$ : chr "c"
[15:32:23.792]  $ ...future.seeds_ii       : NULL
[15:32:23.792]  $ ...future.globals.maxSize: NULL
[15:32:23.792]  - attr(*, "where")=List of 5
[15:32:23.792]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:23.792]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:23.792]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:23.792]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:23.792]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:23.792]  - attr(*, "resolved")= logi FALSE
[15:32:23.792]  - attr(*, "total_size")= num 848
[15:32:23.792]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:23.792]  - attr(*, "already-done")= logi TRUE
[15:32:23.799] - copied '...future.FUN' to environment
[15:32:23.799] - copied 'future.call.arguments' to environment
[15:32:23.800] - copied '...future.elements_ii' to environment
[15:32:23.800] - copied '...future.seeds_ii' to environment
[15:32:23.800] - copied '...future.globals.maxSize' to environment
[15:32:23.800] assign_globals() ... done
[15:32:23.801] plan(): Setting new future strategy stack:
[15:32:23.801] List of future strategies:
[15:32:23.801] 1. sequential:
[15:32:23.801]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:23.801]    - tweaked: FALSE
[15:32:23.801]    - call: NULL
[15:32:23.802] plan(): nbrOfWorkers() = 1
[15:32:23.803] plan(): Setting new future strategy stack:
[15:32:23.803] List of future strategies:
[15:32:23.803] 1. sequential:
[15:32:23.803]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:23.803]    - tweaked: FALSE
[15:32:23.803]    - call: plan(strategy)
[15:32:23.804] plan(): nbrOfWorkers() = 1
[15:32:23.804] SequentialFuture started (and completed)
[15:32:23.804] - Launch lazy future ... done
[15:32:23.805] run() for 'SequentialFuture' ... done
[15:32:23.805] Created future:
[15:32:23.805] SequentialFuture:
[15:32:23.805] Label: 'future_sapply-1'
[15:32:23.805] Expression:
[15:32:23.805] {
[15:32:23.805]     do.call(function(...) {
[15:32:23.805]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:23.805]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:23.805]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:23.805]             on.exit(options(oopts), add = TRUE)
[15:32:23.805]         }
[15:32:23.805]         {
[15:32:23.805]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:23.805]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:23.805]                 ...future.FUN(...future.X_jj, ...)
[15:32:23.805]             })
[15:32:23.805]         }
[15:32:23.805]     }, args = future.call.arguments)
[15:32:23.805] }
[15:32:23.805] Lazy evaluation: FALSE
[15:32:23.805] Asynchronous evaluation: FALSE
[15:32:23.805] Local evaluation: TRUE
[15:32:23.805] Environment: R_GlobalEnv
[15:32:23.805] Capture standard output: TRUE
[15:32:23.805] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:23.805] Globals: 5 objects totaling 1.16 KiB (function '...future.FUN' of 848 bytes, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 336 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:23.805] Packages: <none>
[15:32:23.805] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:23.805] Resolved: TRUE
[15:32:23.805] Value: 336 bytes of class 'list'
[15:32:23.805] Early signaling: FALSE
[15:32:23.805] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:23.805] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:23.807] Chunk #1 of 1 ... DONE
[15:32:23.807] Launching 1 futures (chunks) ... DONE
[15:32:23.807] Resolving 1 futures (chunks) ...
[15:32:23.807] resolve() on list ...
[15:32:23.807]  recursive: 0
[15:32:23.807]  length: 1
[15:32:23.808] 
[15:32:23.808] resolved() for 'SequentialFuture' ...
[15:32:23.808] - state: 'finished'
[15:32:23.808] - run: TRUE
[15:32:23.808] - result: 'FutureResult'
[15:32:23.809] resolved() for 'SequentialFuture' ... done
[15:32:23.809] Future #1
[15:32:23.809] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:23.809] - nx: 1
[15:32:23.809] - relay: TRUE
[15:32:23.810] - stdout: TRUE
[15:32:23.810] - signal: TRUE
[15:32:23.810] - resignal: FALSE
[15:32:23.810] - force: TRUE
[15:32:23.810] - relayed: [n=1] FALSE
[15:32:23.810] - queued futures: [n=1] FALSE
[15:32:23.811]  - until=1
[15:32:23.811]  - relaying element #1
[15:32:23.811] - relayed: [n=1] TRUE
[15:32:23.811] - queued futures: [n=1] TRUE
[15:32:23.811] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:23.812]  length: 0 (resolved future 1)
[15:32:23.812] Relaying remaining futures
[15:32:23.812] signalConditionsASAP(NULL, pos=0) ...
[15:32:23.812] - nx: 1
[15:32:23.812] - relay: TRUE
[15:32:23.813] - stdout: TRUE
[15:32:23.813] - signal: TRUE
[15:32:23.813] - resignal: FALSE
[15:32:23.813] - force: TRUE
[15:32:23.813] - relayed: [n=1] TRUE
[15:32:23.813] - queued futures: [n=1] TRUE
 - flush all
[15:32:23.814] - relayed: [n=1] TRUE
[15:32:23.814] - queued futures: [n=1] TRUE
[15:32:23.814] signalConditionsASAP(NULL, pos=0) ... done
[15:32:23.814] resolve() on list ... DONE
[15:32:23.814]  - Number of value chunks collected: 1
[15:32:23.815] Resolving 1 futures (chunks) ... DONE
[15:32:23.815] Reducing values from 1 chunks ...
[15:32:23.815]  - Number of values collected after concatenation: 3
[15:32:23.815]  - Number of values expected: 3
[15:32:23.815] Reducing values from 1 chunks ... DONE
[15:32:23.816] future_lapply() ... DONE
List of 2
 $ y0: Named chr [1:3] "a" "b" "c"
  ..- attr(*, "names")= chr [1:3] "a" "b" "c"
 $ y1: Named chr [1:3] "a" "b" "c"
  ..- attr(*, "names")= chr [1:3] "a" "b" "c"
[15:32:23.818] future_lapply() ...
[15:32:23.819] Number of chunks: 1
[15:32:23.819] getGlobalsAndPackagesXApply() ...
[15:32:23.820]  - future.globals: TRUE
[15:32:23.820] getGlobalsAndPackages() ...
[15:32:23.820] Searching for globals...
[15:32:23.822] - globals found: [2] 'FUN', 'UseMethod'
[15:32:23.822] Searching for globals ... DONE
[15:32:23.823] Resolving globals: FALSE
[15:32:23.823] The total size of the 1 globals is 1.22 KiB (1248 bytes)
[15:32:23.824] The total size of the 1 globals exported for future expression ('FUN()') is 1.22 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.22 KiB of class 'function')
[15:32:23.824] - globals: [1] 'FUN'
[15:32:23.825] 
[15:32:23.825] getGlobalsAndPackages() ... DONE
[15:32:23.825]  - globals found/used: [n=1] 'FUN'
[15:32:23.825]  - needed namespaces: [n=0] 
[15:32:23.825] Finding globals ... DONE
[15:32:23.826]  - use_args: TRUE
[15:32:23.826]  - Getting '...' globals ...
[15:32:23.826] resolve() on list ...
[15:32:23.827]  recursive: 0
[15:32:23.827]  length: 1
[15:32:23.827]  elements: '...'
[15:32:23.827]  length: 0 (resolved future 1)
[15:32:23.828] resolve() on list ... DONE
[15:32:23.828]    - '...' content: [n=0] 
[15:32:23.828] List of 1
[15:32:23.828]  $ ...: list()
[15:32:23.828]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:23.828]  - attr(*, "where")=List of 1
[15:32:23.828]   ..$ ...:<environment: 0x00000276e435c8b0> 
[15:32:23.828]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:23.828]  - attr(*, "resolved")= logi TRUE
[15:32:23.828]  - attr(*, "total_size")= num NA
[15:32:23.833]  - Getting '...' globals ... DONE
[15:32:23.833] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:23.833] List of 2
[15:32:23.833]  $ ...future.FUN:function (x, ...)  
[15:32:23.833]  $ ...          : list()
[15:32:23.833]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:23.833]  - attr(*, "where")=List of 2
[15:32:23.833]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:23.833]   ..$ ...          :<environment: 0x00000276e435c8b0> 
[15:32:23.833]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:23.833]  - attr(*, "resolved")= logi FALSE
[15:32:23.833]  - attr(*, "total_size")= num 1248
[15:32:23.838] Packages to be attached in all futures: [n=0] 
[15:32:23.839] getGlobalsAndPackagesXApply() ... DONE
[15:32:23.839] Number of futures (= number of chunks): 1
[15:32:23.839] Launching 1 futures (chunks) ...
[15:32:23.839] Chunk #1 of 1 ...
[15:32:23.840]  - Finding globals in 'X' for chunk #1 ...
[15:32:23.840] getGlobalsAndPackages() ...
[15:32:23.840] Searching for globals...
[15:32:23.841] 
[15:32:23.841] Searching for globals ... DONE
[15:32:23.841] - globals: [0] <none>
[15:32:23.841] getGlobalsAndPackages() ... DONE
[15:32:23.842]    + additional globals found: [n=0] 
[15:32:23.842]    + additional namespaces needed: [n=0] 
[15:32:23.842]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:23.842]  - seeds: <none>
[15:32:23.842]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:23.843] getGlobalsAndPackages() ...
[15:32:23.843] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:23.843] Resolving globals: FALSE
[15:32:23.843] Tweak future expression to call with '...' arguments ...
[15:32:23.844] {
[15:32:23.844]     do.call(function(...) {
[15:32:23.844]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:23.844]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:23.844]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:23.844]             on.exit(options(oopts), add = TRUE)
[15:32:23.844]         }
[15:32:23.844]         {
[15:32:23.844]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:23.844]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:23.844]                 ...future.FUN(...future.X_jj, ...)
[15:32:23.844]             })
[15:32:23.844]         }
[15:32:23.844]     }, args = future.call.arguments)
[15:32:23.844] }
[15:32:23.844] Tweak future expression to call with '...' arguments ... DONE
[15:32:23.845] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:23.845] 
[15:32:23.845] getGlobalsAndPackages() ... DONE
[15:32:23.846] run() for 'Future' ...
[15:32:23.846] - state: 'created'
[15:32:23.846] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:23.847] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:23.847] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:23.847]   - Field: 'label'
[15:32:23.848]   - Field: 'local'
[15:32:23.848]   - Field: 'owner'
[15:32:23.848]   - Field: 'envir'
[15:32:23.848]   - Field: 'packages'
[15:32:23.849]   - Field: 'gc'
[15:32:23.849]   - Field: 'conditions'
[15:32:23.849]   - Field: 'expr'
[15:32:23.849]   - Field: 'uuid'
[15:32:23.850]   - Field: 'seed'
[15:32:23.850]   - Field: 'version'
[15:32:23.850]   - Field: 'result'
[15:32:23.850]   - Field: 'asynchronous'
[15:32:23.851]   - Field: 'calls'
[15:32:23.851]   - Field: 'globals'
[15:32:23.851]   - Field: 'stdout'
[15:32:23.851]   - Field: 'earlySignal'
[15:32:23.851]   - Field: 'lazy'
[15:32:23.852]   - Field: 'state'
[15:32:23.852] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:23.852] - Launch lazy future ...
[15:32:23.852] Packages needed by the future expression (n = 0): <none>
[15:32:23.853] Packages needed by future strategies (n = 0): <none>
[15:32:23.854] {
[15:32:23.854]     {
[15:32:23.854]         {
[15:32:23.854]             ...future.startTime <- base::Sys.time()
[15:32:23.854]             {
[15:32:23.854]                 {
[15:32:23.854]                   {
[15:32:23.854]                     base::local({
[15:32:23.854]                       has_future <- base::requireNamespace("future", 
[15:32:23.854]                         quietly = TRUE)
[15:32:23.854]                       if (has_future) {
[15:32:23.854]                         ns <- base::getNamespace("future")
[15:32:23.854]                         version <- ns[[".package"]][["version"]]
[15:32:23.854]                         if (is.null(version)) 
[15:32:23.854]                           version <- utils::packageVersion("future")
[15:32:23.854]                       }
[15:32:23.854]                       else {
[15:32:23.854]                         version <- NULL
[15:32:23.854]                       }
[15:32:23.854]                       if (!has_future || version < "1.8.0") {
[15:32:23.854]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:23.854]                           "", base::R.version$version.string), 
[15:32:23.854]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:23.854]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:23.854]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:23.854]                             "release", "version")], collapse = " "), 
[15:32:23.854]                           hostname = base::Sys.info()[["nodename"]])
[15:32:23.854]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:23.854]                           info)
[15:32:23.854]                         info <- base::paste(info, collapse = "; ")
[15:32:23.854]                         if (!has_future) {
[15:32:23.854]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:23.854]                             info)
[15:32:23.854]                         }
[15:32:23.854]                         else {
[15:32:23.854]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:23.854]                             info, version)
[15:32:23.854]                         }
[15:32:23.854]                         base::stop(msg)
[15:32:23.854]                       }
[15:32:23.854]                     })
[15:32:23.854]                   }
[15:32:23.854]                   ...future.strategy.old <- future::plan("list")
[15:32:23.854]                   options(future.plan = NULL)
[15:32:23.854]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:23.854]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:23.854]                 }
[15:32:23.854]                 ...future.workdir <- getwd()
[15:32:23.854]             }
[15:32:23.854]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:23.854]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:23.854]         }
[15:32:23.854]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:23.854]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:23.854]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:23.854]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:23.854]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:23.854]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:23.854]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:23.854]             base::names(...future.oldOptions))
[15:32:23.854]     }
[15:32:23.854]     if (FALSE) {
[15:32:23.854]     }
[15:32:23.854]     else {
[15:32:23.854]         if (TRUE) {
[15:32:23.854]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:23.854]                 open = "w")
[15:32:23.854]         }
[15:32:23.854]         else {
[15:32:23.854]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:23.854]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:23.854]         }
[15:32:23.854]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:23.854]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:23.854]             base::sink(type = "output", split = FALSE)
[15:32:23.854]             base::close(...future.stdout)
[15:32:23.854]         }, add = TRUE)
[15:32:23.854]     }
[15:32:23.854]     ...future.frame <- base::sys.nframe()
[15:32:23.854]     ...future.conditions <- base::list()
[15:32:23.854]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:23.854]     if (FALSE) {
[15:32:23.854]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:23.854]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:23.854]     }
[15:32:23.854]     ...future.result <- base::tryCatch({
[15:32:23.854]         base::withCallingHandlers({
[15:32:23.854]             ...future.value <- base::withVisible(base::local({
[15:32:23.854]                 do.call(function(...) {
[15:32:23.854]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:23.854]                   if (!identical(...future.globals.maxSize.org, 
[15:32:23.854]                     ...future.globals.maxSize)) {
[15:32:23.854]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:23.854]                     on.exit(options(oopts), add = TRUE)
[15:32:23.854]                   }
[15:32:23.854]                   {
[15:32:23.854]                     lapply(seq_along(...future.elements_ii), 
[15:32:23.854]                       FUN = function(jj) {
[15:32:23.854]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:23.854]                         ...future.FUN(...future.X_jj, ...)
[15:32:23.854]                       })
[15:32:23.854]                   }
[15:32:23.854]                 }, args = future.call.arguments)
[15:32:23.854]             }))
[15:32:23.854]             future::FutureResult(value = ...future.value$value, 
[15:32:23.854]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:23.854]                   ...future.rng), globalenv = if (FALSE) 
[15:32:23.854]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:23.854]                     ...future.globalenv.names))
[15:32:23.854]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:23.854]         }, condition = base::local({
[15:32:23.854]             c <- base::c
[15:32:23.854]             inherits <- base::inherits
[15:32:23.854]             invokeRestart <- base::invokeRestart
[15:32:23.854]             length <- base::length
[15:32:23.854]             list <- base::list
[15:32:23.854]             seq.int <- base::seq.int
[15:32:23.854]             signalCondition <- base::signalCondition
[15:32:23.854]             sys.calls <- base::sys.calls
[15:32:23.854]             `[[` <- base::`[[`
[15:32:23.854]             `+` <- base::`+`
[15:32:23.854]             `<<-` <- base::`<<-`
[15:32:23.854]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:23.854]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:23.854]                   3L)]
[15:32:23.854]             }
[15:32:23.854]             function(cond) {
[15:32:23.854]                 is_error <- inherits(cond, "error")
[15:32:23.854]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:23.854]                   NULL)
[15:32:23.854]                 if (is_error) {
[15:32:23.854]                   sessionInformation <- function() {
[15:32:23.854]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:23.854]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:23.854]                       search = base::search(), system = base::Sys.info())
[15:32:23.854]                   }
[15:32:23.854]                   ...future.conditions[[length(...future.conditions) + 
[15:32:23.854]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:23.854]                     cond$call), session = sessionInformation(), 
[15:32:23.854]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:23.854]                   signalCondition(cond)
[15:32:23.854]                 }
[15:32:23.854]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:23.854]                 "immediateCondition"))) {
[15:32:23.854]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:23.854]                   ...future.conditions[[length(...future.conditions) + 
[15:32:23.854]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:23.854]                   if (TRUE && !signal) {
[15:32:23.854]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:23.854]                     {
[15:32:23.854]                       inherits <- base::inherits
[15:32:23.854]                       invokeRestart <- base::invokeRestart
[15:32:23.854]                       is.null <- base::is.null
[15:32:23.854]                       muffled <- FALSE
[15:32:23.854]                       if (inherits(cond, "message")) {
[15:32:23.854]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:23.854]                         if (muffled) 
[15:32:23.854]                           invokeRestart("muffleMessage")
[15:32:23.854]                       }
[15:32:23.854]                       else if (inherits(cond, "warning")) {
[15:32:23.854]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:23.854]                         if (muffled) 
[15:32:23.854]                           invokeRestart("muffleWarning")
[15:32:23.854]                       }
[15:32:23.854]                       else if (inherits(cond, "condition")) {
[15:32:23.854]                         if (!is.null(pattern)) {
[15:32:23.854]                           computeRestarts <- base::computeRestarts
[15:32:23.854]                           grepl <- base::grepl
[15:32:23.854]                           restarts <- computeRestarts(cond)
[15:32:23.854]                           for (restart in restarts) {
[15:32:23.854]                             name <- restart$name
[15:32:23.854]                             if (is.null(name)) 
[15:32:23.854]                               next
[15:32:23.854]                             if (!grepl(pattern, name)) 
[15:32:23.854]                               next
[15:32:23.854]                             invokeRestart(restart)
[15:32:23.854]                             muffled <- TRUE
[15:32:23.854]                             break
[15:32:23.854]                           }
[15:32:23.854]                         }
[15:32:23.854]                       }
[15:32:23.854]                       invisible(muffled)
[15:32:23.854]                     }
[15:32:23.854]                     muffleCondition(cond, pattern = "^muffle")
[15:32:23.854]                   }
[15:32:23.854]                 }
[15:32:23.854]                 else {
[15:32:23.854]                   if (TRUE) {
[15:32:23.854]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:23.854]                     {
[15:32:23.854]                       inherits <- base::inherits
[15:32:23.854]                       invokeRestart <- base::invokeRestart
[15:32:23.854]                       is.null <- base::is.null
[15:32:23.854]                       muffled <- FALSE
[15:32:23.854]                       if (inherits(cond, "message")) {
[15:32:23.854]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:23.854]                         if (muffled) 
[15:32:23.854]                           invokeRestart("muffleMessage")
[15:32:23.854]                       }
[15:32:23.854]                       else if (inherits(cond, "warning")) {
[15:32:23.854]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:23.854]                         if (muffled) 
[15:32:23.854]                           invokeRestart("muffleWarning")
[15:32:23.854]                       }
[15:32:23.854]                       else if (inherits(cond, "condition")) {
[15:32:23.854]                         if (!is.null(pattern)) {
[15:32:23.854]                           computeRestarts <- base::computeRestarts
[15:32:23.854]                           grepl <- base::grepl
[15:32:23.854]                           restarts <- computeRestarts(cond)
[15:32:23.854]                           for (restart in restarts) {
[15:32:23.854]                             name <- restart$name
[15:32:23.854]                             if (is.null(name)) 
[15:32:23.854]                               next
[15:32:23.854]                             if (!grepl(pattern, name)) 
[15:32:23.854]                               next
[15:32:23.854]                             invokeRestart(restart)
[15:32:23.854]                             muffled <- TRUE
[15:32:23.854]                             break
[15:32:23.854]                           }
[15:32:23.854]                         }
[15:32:23.854]                       }
[15:32:23.854]                       invisible(muffled)
[15:32:23.854]                     }
[15:32:23.854]                     muffleCondition(cond, pattern = "^muffle")
[15:32:23.854]                   }
[15:32:23.854]                 }
[15:32:23.854]             }
[15:32:23.854]         }))
[15:32:23.854]     }, error = function(ex) {
[15:32:23.854]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:23.854]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:23.854]                 ...future.rng), started = ...future.startTime, 
[15:32:23.854]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:23.854]             version = "1.8"), class = "FutureResult")
[15:32:23.854]     }, finally = {
[15:32:23.854]         if (!identical(...future.workdir, getwd())) 
[15:32:23.854]             setwd(...future.workdir)
[15:32:23.854]         {
[15:32:23.854]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:23.854]                 ...future.oldOptions$nwarnings <- NULL
[15:32:23.854]             }
[15:32:23.854]             base::options(...future.oldOptions)
[15:32:23.854]             if (.Platform$OS.type == "windows") {
[15:32:23.854]                 old_names <- names(...future.oldEnvVars)
[15:32:23.854]                 envs <- base::Sys.getenv()
[15:32:23.854]                 names <- names(envs)
[15:32:23.854]                 common <- intersect(names, old_names)
[15:32:23.854]                 added <- setdiff(names, old_names)
[15:32:23.854]                 removed <- setdiff(old_names, names)
[15:32:23.854]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:23.854]                   envs[common]]
[15:32:23.854]                 NAMES <- toupper(changed)
[15:32:23.854]                 args <- list()
[15:32:23.854]                 for (kk in seq_along(NAMES)) {
[15:32:23.854]                   name <- changed[[kk]]
[15:32:23.854]                   NAME <- NAMES[[kk]]
[15:32:23.854]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:23.854]                     next
[15:32:23.854]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:23.854]                 }
[15:32:23.854]                 NAMES <- toupper(added)
[15:32:23.854]                 for (kk in seq_along(NAMES)) {
[15:32:23.854]                   name <- added[[kk]]
[15:32:23.854]                   NAME <- NAMES[[kk]]
[15:32:23.854]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:23.854]                     next
[15:32:23.854]                   args[[name]] <- ""
[15:32:23.854]                 }
[15:32:23.854]                 NAMES <- toupper(removed)
[15:32:23.854]                 for (kk in seq_along(NAMES)) {
[15:32:23.854]                   name <- removed[[kk]]
[15:32:23.854]                   NAME <- NAMES[[kk]]
[15:32:23.854]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:23.854]                     next
[15:32:23.854]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:23.854]                 }
[15:32:23.854]                 if (length(args) > 0) 
[15:32:23.854]                   base::do.call(base::Sys.setenv, args = args)
[15:32:23.854]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:23.854]             }
[15:32:23.854]             else {
[15:32:23.854]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:23.854]             }
[15:32:23.854]             {
[15:32:23.854]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:23.854]                   0L) {
[15:32:23.854]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:23.854]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:23.854]                   base::options(opts)
[15:32:23.854]                 }
[15:32:23.854]                 {
[15:32:23.854]                   {
[15:32:23.854]                     NULL
[15:32:23.854]                     RNGkind("Mersenne-Twister")
[15:32:23.854]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:23.854]                       inherits = FALSE)
[15:32:23.854]                   }
[15:32:23.854]                   options(future.plan = NULL)
[15:32:23.854]                   if (is.na(NA_character_)) 
[15:32:23.854]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:23.854]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:23.854]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:23.854]                     .init = FALSE)
[15:32:23.854]                 }
[15:32:23.854]             }
[15:32:23.854]         }
[15:32:23.854]     })
[15:32:23.854]     if (TRUE) {
[15:32:23.854]         base::sink(type = "output", split = FALSE)
[15:32:23.854]         if (TRUE) {
[15:32:23.854]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:23.854]         }
[15:32:23.854]         else {
[15:32:23.854]             ...future.result["stdout"] <- base::list(NULL)
[15:32:23.854]         }
[15:32:23.854]         base::close(...future.stdout)
[15:32:23.854]         ...future.stdout <- NULL
[15:32:23.854]     }
[15:32:23.854]     ...future.result$conditions <- ...future.conditions
[15:32:23.854]     ...future.result$finished <- base::Sys.time()
[15:32:23.854]     ...future.result
[15:32:23.854] }
[15:32:23.858] assign_globals() ...
[15:32:23.858] List of 5
[15:32:23.858]  $ ...future.FUN            :function (x, ...)  
[15:32:23.858]  $ future.call.arguments    : list()
[15:32:23.858]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:23.858]  $ ...future.elements_ii    :List of 3
[15:32:23.858]   ..$ : chr "a"
[15:32:23.858]   ..$ : chr "b"
[15:32:23.858]   ..$ : chr "c"
[15:32:23.858]  $ ...future.seeds_ii       : NULL
[15:32:23.858]  $ ...future.globals.maxSize: NULL
[15:32:23.858]  - attr(*, "where")=List of 5
[15:32:23.858]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:23.858]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:23.858]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:23.858]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:23.858]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:23.858]  - attr(*, "resolved")= logi FALSE
[15:32:23.858]  - attr(*, "total_size")= num 1248
[15:32:23.858]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:23.858]  - attr(*, "already-done")= logi TRUE
[15:32:23.867] - copied '...future.FUN' to environment
[15:32:23.868] - copied 'future.call.arguments' to environment
[15:32:23.868] - copied '...future.elements_ii' to environment
[15:32:23.868] - copied '...future.seeds_ii' to environment
[15:32:23.869] - copied '...future.globals.maxSize' to environment
[15:32:23.869] assign_globals() ... done
[15:32:23.869] plan(): Setting new future strategy stack:
[15:32:23.870] List of future strategies:
[15:32:23.870] 1. sequential:
[15:32:23.870]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:23.870]    - tweaked: FALSE
[15:32:23.870]    - call: NULL
[15:32:23.870] plan(): nbrOfWorkers() = 1
[15:32:23.872] plan(): Setting new future strategy stack:
[15:32:23.873] List of future strategies:
[15:32:23.873] 1. sequential:
[15:32:23.873]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:23.873]    - tweaked: FALSE
[15:32:23.873]    - call: plan(strategy)
[15:32:23.873] plan(): nbrOfWorkers() = 1
[15:32:23.874] SequentialFuture started (and completed)
[15:32:23.874] - Launch lazy future ... done
[15:32:23.874] run() for 'SequentialFuture' ... done
[15:32:23.875] Created future:
[15:32:23.875] SequentialFuture:
[15:32:23.875] Label: 'future_sapply-1'
[15:32:23.875] Expression:
[15:32:23.875] {
[15:32:23.875]     do.call(function(...) {
[15:32:23.875]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:23.875]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:23.875]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:23.875]             on.exit(options(oopts), add = TRUE)
[15:32:23.875]         }
[15:32:23.875]         {
[15:32:23.875]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:23.875]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:23.875]                 ...future.FUN(...future.X_jj, ...)
[15:32:23.875]             })
[15:32:23.875]         }
[15:32:23.875]     }, args = future.call.arguments)
[15:32:23.875] }
[15:32:23.875] Lazy evaluation: FALSE
[15:32:23.875] Asynchronous evaluation: FALSE
[15:32:23.875] Local evaluation: TRUE
[15:32:23.875] Environment: R_GlobalEnv
[15:32:23.875] Capture standard output: TRUE
[15:32:23.875] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:23.875] Globals: 5 objects totaling 1.55 KiB (function '...future.FUN' of 1.22 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 336 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:23.875] Packages: <none>
[15:32:23.875] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:23.875] Resolved: TRUE
[15:32:23.875] Value: 840 bytes of class 'list'
[15:32:23.875] Early signaling: FALSE
[15:32:23.875] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:23.875] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:23.877] Chunk #1 of 1 ... DONE
[15:32:23.877] Launching 1 futures (chunks) ... DONE
[15:32:23.878] Resolving 1 futures (chunks) ...
[15:32:23.878] resolve() on list ...
[15:32:23.878]  recursive: 0
[15:32:23.879]  length: 1
[15:32:23.879] 
[15:32:23.879] resolved() for 'SequentialFuture' ...
[15:32:23.879] - state: 'finished'
[15:32:23.880] - run: TRUE
[15:32:23.880] - result: 'FutureResult'
[15:32:23.880] resolved() for 'SequentialFuture' ... done
[15:32:23.880] Future #1
[15:32:23.881] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:23.881] - nx: 1
[15:32:23.881] - relay: TRUE
[15:32:23.881] - stdout: TRUE
[15:32:23.881] - signal: TRUE
[15:32:23.882] - resignal: FALSE
[15:32:23.882] - force: TRUE
[15:32:23.882] - relayed: [n=1] FALSE
[15:32:23.882] - queued futures: [n=1] FALSE
[15:32:23.882]  - until=1
[15:32:23.883]  - relaying element #1
[15:32:23.883] - relayed: [n=1] TRUE
[15:32:23.883] - queued futures: [n=1] TRUE
[15:32:23.883] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:23.884]  length: 0 (resolved future 1)
[15:32:23.884] Relaying remaining futures
[15:32:23.884] signalConditionsASAP(NULL, pos=0) ...
[15:32:23.884] - nx: 1
[15:32:23.884] - relay: TRUE
[15:32:23.885] - stdout: TRUE
[15:32:23.885] - signal: TRUE
[15:32:23.885] - resignal: FALSE
[15:32:23.885] - force: TRUE
[15:32:23.885] - relayed: [n=1] TRUE
[15:32:23.886] - queued futures: [n=1] TRUE
 - flush all
[15:32:23.886] - relayed: [n=1] TRUE
[15:32:23.886] - queued futures: [n=1] TRUE
[15:32:23.887] signalConditionsASAP(NULL, pos=0) ... done
[15:32:23.887] resolve() on list ... DONE
[15:32:23.887]  - Number of value chunks collected: 1
[15:32:23.887] Resolving 1 futures (chunks) ... DONE
[15:32:23.888] Reducing values from 1 chunks ...
[15:32:23.888]  - Number of values collected after concatenation: 3
[15:32:23.888]  - Number of values expected: 3
[15:32:23.888] Reducing values from 1 chunks ... DONE
[15:32:23.888] future_lapply() ... DONE
List of 2
 $ y0: Named chr [1:3] "a" "b" "c"
  ..- attr(*, "names")= chr [1:3] "a" "b" "c"
 $ y1: Named chr [1:3] "a" "b" "c"
  ..- attr(*, "names")= chr [1:3] "a" "b" "c"
[15:32:23.891] future_lapply() ...
[15:32:23.892] Number of chunks: 1
[15:32:23.892] getGlobalsAndPackagesXApply() ...
[15:32:23.892]  - future.globals: TRUE
[15:32:23.893] getGlobalsAndPackages() ...
[15:32:23.893] Searching for globals...
[15:32:23.894] - globals found: [1] 'FUN'
[15:32:23.895] Searching for globals ... DONE
[15:32:23.895] Resolving globals: FALSE
[15:32:23.895] The total size of the 1 globals is 848 bytes (848 bytes)
[15:32:23.896] The total size of the 1 globals exported for future expression ('FUN()') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:32:23.896] - globals: [1] 'FUN'
[15:32:23.897] 
[15:32:23.897] getGlobalsAndPackages() ... DONE
[15:32:23.897]  - globals found/used: [n=1] 'FUN'
[15:32:23.897]  - needed namespaces: [n=0] 
[15:32:23.897] Finding globals ... DONE
[15:32:23.898]  - use_args: TRUE
[15:32:23.898]  - Getting '...' globals ...
[15:32:23.898] resolve() on list ...
[15:32:23.899]  recursive: 0
[15:32:23.899]  length: 1
[15:32:23.899]  elements: '...'
[15:32:23.899]  length: 0 (resolved future 1)
[15:32:23.899] resolve() on list ... DONE
[15:32:23.900]    - '...' content: [n=0] 
[15:32:23.900] List of 1
[15:32:23.900]  $ ...: list()
[15:32:23.900]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:23.900]  - attr(*, "where")=List of 1
[15:32:23.900]   ..$ ...:<environment: 0x00000276e575aaf8> 
[15:32:23.900]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:23.900]  - attr(*, "resolved")= logi TRUE
[15:32:23.900]  - attr(*, "total_size")= num NA
[15:32:23.904]  - Getting '...' globals ... DONE
[15:32:23.905] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:23.905] List of 2
[15:32:23.905]  $ ...future.FUN:function (x)  
[15:32:23.905]  $ ...          : list()
[15:32:23.905]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:23.905]  - attr(*, "where")=List of 2
[15:32:23.905]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:23.905]   ..$ ...          :<environment: 0x00000276e575aaf8> 
[15:32:23.905]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:23.905]  - attr(*, "resolved")= logi FALSE
[15:32:23.905]  - attr(*, "total_size")= num 848
[15:32:23.912] Packages to be attached in all futures: [n=0] 
[15:32:23.912] getGlobalsAndPackagesXApply() ... DONE
[15:32:23.912] Number of futures (= number of chunks): 1
[15:32:23.913] Launching 1 futures (chunks) ...
[15:32:23.913] Chunk #1 of 1 ...
[15:32:23.913]  - Finding globals in 'X' for chunk #1 ...
[15:32:23.913] getGlobalsAndPackages() ...
[15:32:23.913] Searching for globals...
[15:32:23.914] 
[15:32:23.914] Searching for globals ... DONE
[15:32:23.914] - globals: [0] <none>
[15:32:23.914] getGlobalsAndPackages() ... DONE
[15:32:23.914]    + additional globals found: [n=0] 
[15:32:23.915]    + additional namespaces needed: [n=0] 
[15:32:23.915]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:23.915]  - seeds: <none>
[15:32:23.915]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:23.915] getGlobalsAndPackages() ...
[15:32:23.916] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:23.916] Resolving globals: FALSE
[15:32:23.916] Tweak future expression to call with '...' arguments ...
[15:32:23.916] {
[15:32:23.916]     do.call(function(...) {
[15:32:23.916]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:23.916]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:23.916]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:23.916]             on.exit(options(oopts), add = TRUE)
[15:32:23.916]         }
[15:32:23.916]         {
[15:32:23.916]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:23.916]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:23.916]                 ...future.FUN(...future.X_jj, ...)
[15:32:23.916]             })
[15:32:23.916]         }
[15:32:23.916]     }, args = future.call.arguments)
[15:32:23.916] }
[15:32:23.917] Tweak future expression to call with '...' arguments ... DONE
[15:32:23.917] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:23.917] 
[15:32:23.917] getGlobalsAndPackages() ... DONE
[15:32:23.918] run() for 'Future' ...
[15:32:23.918] - state: 'created'
[15:32:23.918] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:23.919] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:23.919] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:23.919]   - Field: 'label'
[15:32:23.919]   - Field: 'local'
[15:32:23.920]   - Field: 'owner'
[15:32:23.920]   - Field: 'envir'
[15:32:23.920]   - Field: 'packages'
[15:32:23.920]   - Field: 'gc'
[15:32:23.920]   - Field: 'conditions'
[15:32:23.920]   - Field: 'expr'
[15:32:23.921]   - Field: 'uuid'
[15:32:23.921]   - Field: 'seed'
[15:32:23.921]   - Field: 'version'
[15:32:23.921]   - Field: 'result'
[15:32:23.921]   - Field: 'asynchronous'
[15:32:23.922]   - Field: 'calls'
[15:32:23.922]   - Field: 'globals'
[15:32:23.922]   - Field: 'stdout'
[15:32:23.922]   - Field: 'earlySignal'
[15:32:23.922]   - Field: 'lazy'
[15:32:23.922]   - Field: 'state'
[15:32:23.923] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:23.923] - Launch lazy future ...
[15:32:23.923] Packages needed by the future expression (n = 0): <none>
[15:32:23.923] Packages needed by future strategies (n = 0): <none>
[15:32:23.924] {
[15:32:23.924]     {
[15:32:23.924]         {
[15:32:23.924]             ...future.startTime <- base::Sys.time()
[15:32:23.924]             {
[15:32:23.924]                 {
[15:32:23.924]                   {
[15:32:23.924]                     base::local({
[15:32:23.924]                       has_future <- base::requireNamespace("future", 
[15:32:23.924]                         quietly = TRUE)
[15:32:23.924]                       if (has_future) {
[15:32:23.924]                         ns <- base::getNamespace("future")
[15:32:23.924]                         version <- ns[[".package"]][["version"]]
[15:32:23.924]                         if (is.null(version)) 
[15:32:23.924]                           version <- utils::packageVersion("future")
[15:32:23.924]                       }
[15:32:23.924]                       else {
[15:32:23.924]                         version <- NULL
[15:32:23.924]                       }
[15:32:23.924]                       if (!has_future || version < "1.8.0") {
[15:32:23.924]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:23.924]                           "", base::R.version$version.string), 
[15:32:23.924]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:23.924]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:23.924]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:23.924]                             "release", "version")], collapse = " "), 
[15:32:23.924]                           hostname = base::Sys.info()[["nodename"]])
[15:32:23.924]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:23.924]                           info)
[15:32:23.924]                         info <- base::paste(info, collapse = "; ")
[15:32:23.924]                         if (!has_future) {
[15:32:23.924]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:23.924]                             info)
[15:32:23.924]                         }
[15:32:23.924]                         else {
[15:32:23.924]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:23.924]                             info, version)
[15:32:23.924]                         }
[15:32:23.924]                         base::stop(msg)
[15:32:23.924]                       }
[15:32:23.924]                     })
[15:32:23.924]                   }
[15:32:23.924]                   ...future.strategy.old <- future::plan("list")
[15:32:23.924]                   options(future.plan = NULL)
[15:32:23.924]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:23.924]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:23.924]                 }
[15:32:23.924]                 ...future.workdir <- getwd()
[15:32:23.924]             }
[15:32:23.924]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:23.924]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:23.924]         }
[15:32:23.924]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:23.924]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:23.924]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:23.924]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:23.924]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:23.924]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:23.924]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:23.924]             base::names(...future.oldOptions))
[15:32:23.924]     }
[15:32:23.924]     if (FALSE) {
[15:32:23.924]     }
[15:32:23.924]     else {
[15:32:23.924]         if (TRUE) {
[15:32:23.924]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:23.924]                 open = "w")
[15:32:23.924]         }
[15:32:23.924]         else {
[15:32:23.924]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:23.924]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:23.924]         }
[15:32:23.924]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:23.924]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:23.924]             base::sink(type = "output", split = FALSE)
[15:32:23.924]             base::close(...future.stdout)
[15:32:23.924]         }, add = TRUE)
[15:32:23.924]     }
[15:32:23.924]     ...future.frame <- base::sys.nframe()
[15:32:23.924]     ...future.conditions <- base::list()
[15:32:23.924]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:23.924]     if (FALSE) {
[15:32:23.924]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:23.924]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:23.924]     }
[15:32:23.924]     ...future.result <- base::tryCatch({
[15:32:23.924]         base::withCallingHandlers({
[15:32:23.924]             ...future.value <- base::withVisible(base::local({
[15:32:23.924]                 do.call(function(...) {
[15:32:23.924]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:23.924]                   if (!identical(...future.globals.maxSize.org, 
[15:32:23.924]                     ...future.globals.maxSize)) {
[15:32:23.924]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:23.924]                     on.exit(options(oopts), add = TRUE)
[15:32:23.924]                   }
[15:32:23.924]                   {
[15:32:23.924]                     lapply(seq_along(...future.elements_ii), 
[15:32:23.924]                       FUN = function(jj) {
[15:32:23.924]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:23.924]                         ...future.FUN(...future.X_jj, ...)
[15:32:23.924]                       })
[15:32:23.924]                   }
[15:32:23.924]                 }, args = future.call.arguments)
[15:32:23.924]             }))
[15:32:23.924]             future::FutureResult(value = ...future.value$value, 
[15:32:23.924]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:23.924]                   ...future.rng), globalenv = if (FALSE) 
[15:32:23.924]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:23.924]                     ...future.globalenv.names))
[15:32:23.924]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:23.924]         }, condition = base::local({
[15:32:23.924]             c <- base::c
[15:32:23.924]             inherits <- base::inherits
[15:32:23.924]             invokeRestart <- base::invokeRestart
[15:32:23.924]             length <- base::length
[15:32:23.924]             list <- base::list
[15:32:23.924]             seq.int <- base::seq.int
[15:32:23.924]             signalCondition <- base::signalCondition
[15:32:23.924]             sys.calls <- base::sys.calls
[15:32:23.924]             `[[` <- base::`[[`
[15:32:23.924]             `+` <- base::`+`
[15:32:23.924]             `<<-` <- base::`<<-`
[15:32:23.924]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:23.924]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:23.924]                   3L)]
[15:32:23.924]             }
[15:32:23.924]             function(cond) {
[15:32:23.924]                 is_error <- inherits(cond, "error")
[15:32:23.924]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:23.924]                   NULL)
[15:32:23.924]                 if (is_error) {
[15:32:23.924]                   sessionInformation <- function() {
[15:32:23.924]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:23.924]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:23.924]                       search = base::search(), system = base::Sys.info())
[15:32:23.924]                   }
[15:32:23.924]                   ...future.conditions[[length(...future.conditions) + 
[15:32:23.924]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:23.924]                     cond$call), session = sessionInformation(), 
[15:32:23.924]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:23.924]                   signalCondition(cond)
[15:32:23.924]                 }
[15:32:23.924]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:23.924]                 "immediateCondition"))) {
[15:32:23.924]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:23.924]                   ...future.conditions[[length(...future.conditions) + 
[15:32:23.924]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:23.924]                   if (TRUE && !signal) {
[15:32:23.924]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:23.924]                     {
[15:32:23.924]                       inherits <- base::inherits
[15:32:23.924]                       invokeRestart <- base::invokeRestart
[15:32:23.924]                       is.null <- base::is.null
[15:32:23.924]                       muffled <- FALSE
[15:32:23.924]                       if (inherits(cond, "message")) {
[15:32:23.924]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:23.924]                         if (muffled) 
[15:32:23.924]                           invokeRestart("muffleMessage")
[15:32:23.924]                       }
[15:32:23.924]                       else if (inherits(cond, "warning")) {
[15:32:23.924]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:23.924]                         if (muffled) 
[15:32:23.924]                           invokeRestart("muffleWarning")
[15:32:23.924]                       }
[15:32:23.924]                       else if (inherits(cond, "condition")) {
[15:32:23.924]                         if (!is.null(pattern)) {
[15:32:23.924]                           computeRestarts <- base::computeRestarts
[15:32:23.924]                           grepl <- base::grepl
[15:32:23.924]                           restarts <- computeRestarts(cond)
[15:32:23.924]                           for (restart in restarts) {
[15:32:23.924]                             name <- restart$name
[15:32:23.924]                             if (is.null(name)) 
[15:32:23.924]                               next
[15:32:23.924]                             if (!grepl(pattern, name)) 
[15:32:23.924]                               next
[15:32:23.924]                             invokeRestart(restart)
[15:32:23.924]                             muffled <- TRUE
[15:32:23.924]                             break
[15:32:23.924]                           }
[15:32:23.924]                         }
[15:32:23.924]                       }
[15:32:23.924]                       invisible(muffled)
[15:32:23.924]                     }
[15:32:23.924]                     muffleCondition(cond, pattern = "^muffle")
[15:32:23.924]                   }
[15:32:23.924]                 }
[15:32:23.924]                 else {
[15:32:23.924]                   if (TRUE) {
[15:32:23.924]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:23.924]                     {
[15:32:23.924]                       inherits <- base::inherits
[15:32:23.924]                       invokeRestart <- base::invokeRestart
[15:32:23.924]                       is.null <- base::is.null
[15:32:23.924]                       muffled <- FALSE
[15:32:23.924]                       if (inherits(cond, "message")) {
[15:32:23.924]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:23.924]                         if (muffled) 
[15:32:23.924]                           invokeRestart("muffleMessage")
[15:32:23.924]                       }
[15:32:23.924]                       else if (inherits(cond, "warning")) {
[15:32:23.924]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:23.924]                         if (muffled) 
[15:32:23.924]                           invokeRestart("muffleWarning")
[15:32:23.924]                       }
[15:32:23.924]                       else if (inherits(cond, "condition")) {
[15:32:23.924]                         if (!is.null(pattern)) {
[15:32:23.924]                           computeRestarts <- base::computeRestarts
[15:32:23.924]                           grepl <- base::grepl
[15:32:23.924]                           restarts <- computeRestarts(cond)
[15:32:23.924]                           for (restart in restarts) {
[15:32:23.924]                             name <- restart$name
[15:32:23.924]                             if (is.null(name)) 
[15:32:23.924]                               next
[15:32:23.924]                             if (!grepl(pattern, name)) 
[15:32:23.924]                               next
[15:32:23.924]                             invokeRestart(restart)
[15:32:23.924]                             muffled <- TRUE
[15:32:23.924]                             break
[15:32:23.924]                           }
[15:32:23.924]                         }
[15:32:23.924]                       }
[15:32:23.924]                       invisible(muffled)
[15:32:23.924]                     }
[15:32:23.924]                     muffleCondition(cond, pattern = "^muffle")
[15:32:23.924]                   }
[15:32:23.924]                 }
[15:32:23.924]             }
[15:32:23.924]         }))
[15:32:23.924]     }, error = function(ex) {
[15:32:23.924]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:23.924]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:23.924]                 ...future.rng), started = ...future.startTime, 
[15:32:23.924]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:23.924]             version = "1.8"), class = "FutureResult")
[15:32:23.924]     }, finally = {
[15:32:23.924]         if (!identical(...future.workdir, getwd())) 
[15:32:23.924]             setwd(...future.workdir)
[15:32:23.924]         {
[15:32:23.924]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:23.924]                 ...future.oldOptions$nwarnings <- NULL
[15:32:23.924]             }
[15:32:23.924]             base::options(...future.oldOptions)
[15:32:23.924]             if (.Platform$OS.type == "windows") {
[15:32:23.924]                 old_names <- names(...future.oldEnvVars)
[15:32:23.924]                 envs <- base::Sys.getenv()
[15:32:23.924]                 names <- names(envs)
[15:32:23.924]                 common <- intersect(names, old_names)
[15:32:23.924]                 added <- setdiff(names, old_names)
[15:32:23.924]                 removed <- setdiff(old_names, names)
[15:32:23.924]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:23.924]                   envs[common]]
[15:32:23.924]                 NAMES <- toupper(changed)
[15:32:23.924]                 args <- list()
[15:32:23.924]                 for (kk in seq_along(NAMES)) {
[15:32:23.924]                   name <- changed[[kk]]
[15:32:23.924]                   NAME <- NAMES[[kk]]
[15:32:23.924]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:23.924]                     next
[15:32:23.924]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:23.924]                 }
[15:32:23.924]                 NAMES <- toupper(added)
[15:32:23.924]                 for (kk in seq_along(NAMES)) {
[15:32:23.924]                   name <- added[[kk]]
[15:32:23.924]                   NAME <- NAMES[[kk]]
[15:32:23.924]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:23.924]                     next
[15:32:23.924]                   args[[name]] <- ""
[15:32:23.924]                 }
[15:32:23.924]                 NAMES <- toupper(removed)
[15:32:23.924]                 for (kk in seq_along(NAMES)) {
[15:32:23.924]                   name <- removed[[kk]]
[15:32:23.924]                   NAME <- NAMES[[kk]]
[15:32:23.924]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:23.924]                     next
[15:32:23.924]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:23.924]                 }
[15:32:23.924]                 if (length(args) > 0) 
[15:32:23.924]                   base::do.call(base::Sys.setenv, args = args)
[15:32:23.924]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:23.924]             }
[15:32:23.924]             else {
[15:32:23.924]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:23.924]             }
[15:32:23.924]             {
[15:32:23.924]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:23.924]                   0L) {
[15:32:23.924]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:23.924]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:23.924]                   base::options(opts)
[15:32:23.924]                 }
[15:32:23.924]                 {
[15:32:23.924]                   {
[15:32:23.924]                     NULL
[15:32:23.924]                     RNGkind("Mersenne-Twister")
[15:32:23.924]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:23.924]                       inherits = FALSE)
[15:32:23.924]                   }
[15:32:23.924]                   options(future.plan = NULL)
[15:32:23.924]                   if (is.na(NA_character_)) 
[15:32:23.924]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:23.924]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:23.924]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:23.924]                     .init = FALSE)
[15:32:23.924]                 }
[15:32:23.924]             }
[15:32:23.924]         }
[15:32:23.924]     })
[15:32:23.924]     if (TRUE) {
[15:32:23.924]         base::sink(type = "output", split = FALSE)
[15:32:23.924]         if (TRUE) {
[15:32:23.924]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:23.924]         }
[15:32:23.924]         else {
[15:32:23.924]             ...future.result["stdout"] <- base::list(NULL)
[15:32:23.924]         }
[15:32:23.924]         base::close(...future.stdout)
[15:32:23.924]         ...future.stdout <- NULL
[15:32:23.924]     }
[15:32:23.924]     ...future.result$conditions <- ...future.conditions
[15:32:23.924]     ...future.result$finished <- base::Sys.time()
[15:32:23.924]     ...future.result
[15:32:23.924] }
[15:32:23.928] assign_globals() ...
[15:32:23.928] List of 5
[15:32:23.928]  $ ...future.FUN            :function (x)  
[15:32:23.928]  $ future.call.arguments    : list()
[15:32:23.928]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:23.928]  $ ...future.elements_ii    :List of 3
[15:32:23.928]   ..$ : chr "a"
[15:32:23.928]   ..$ : chr "b"
[15:32:23.928]   ..$ : chr "c"
[15:32:23.928]  $ ...future.seeds_ii       : NULL
[15:32:23.928]  $ ...future.globals.maxSize: NULL
[15:32:23.928]  - attr(*, "where")=List of 5
[15:32:23.928]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:23.928]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:23.928]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:23.928]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:23.928]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:23.928]  - attr(*, "resolved")= logi FALSE
[15:32:23.928]  - attr(*, "total_size")= num 848
[15:32:23.928]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:23.928]  - attr(*, "already-done")= logi TRUE
[15:32:23.935] - copied '...future.FUN' to environment
[15:32:23.935] - copied 'future.call.arguments' to environment
[15:32:23.935] - copied '...future.elements_ii' to environment
[15:32:23.936] - copied '...future.seeds_ii' to environment
[15:32:23.936] - copied '...future.globals.maxSize' to environment
[15:32:23.936] assign_globals() ... done
[15:32:23.936] plan(): Setting new future strategy stack:
[15:32:23.937] List of future strategies:
[15:32:23.937] 1. sequential:
[15:32:23.937]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:23.937]    - tweaked: FALSE
[15:32:23.937]    - call: NULL
[15:32:23.937] plan(): nbrOfWorkers() = 1
[15:32:23.939] plan(): Setting new future strategy stack:
[15:32:23.939] List of future strategies:
[15:32:23.939] 1. sequential:
[15:32:23.939]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:23.939]    - tweaked: FALSE
[15:32:23.939]    - call: plan(strategy)
[15:32:23.940] plan(): nbrOfWorkers() = 1
[15:32:23.940] SequentialFuture started (and completed)
[15:32:23.940] - Launch lazy future ... done
[15:32:23.940] run() for 'SequentialFuture' ... done
[15:32:23.941] Created future:
[15:32:23.941] SequentialFuture:
[15:32:23.941] Label: 'future_sapply-1'
[15:32:23.941] Expression:
[15:32:23.941] {
[15:32:23.941]     do.call(function(...) {
[15:32:23.941]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:23.941]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:23.941]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:23.941]             on.exit(options(oopts), add = TRUE)
[15:32:23.941]         }
[15:32:23.941]         {
[15:32:23.941]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:23.941]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:23.941]                 ...future.FUN(...future.X_jj, ...)
[15:32:23.941]             })
[15:32:23.941]         }
[15:32:23.941]     }, args = future.call.arguments)
[15:32:23.941] }
[15:32:23.941] Lazy evaluation: FALSE
[15:32:23.941] Asynchronous evaluation: FALSE
[15:32:23.941] Local evaluation: TRUE
[15:32:23.941] Environment: R_GlobalEnv
[15:32:23.941] Capture standard output: TRUE
[15:32:23.941] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:23.941] Globals: 5 objects totaling 1.16 KiB (function '...future.FUN' of 848 bytes, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 336 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:23.941] Packages: <none>
[15:32:23.941] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:23.941] Resolved: TRUE
[15:32:23.941] Value: 336 bytes of class 'list'
[15:32:23.941] Early signaling: FALSE
[15:32:23.941] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:23.941] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:23.942] Chunk #1 of 1 ... DONE
[15:32:23.942] Launching 1 futures (chunks) ... DONE
[15:32:23.943] Resolving 1 futures (chunks) ...
[15:32:23.943] resolve() on list ...
[15:32:23.943]  recursive: 0
[15:32:23.943]  length: 1
[15:32:23.943] 
[15:32:23.944] resolved() for 'SequentialFuture' ...
[15:32:23.944] - state: 'finished'
[15:32:23.944] - run: TRUE
[15:32:23.944] - result: 'FutureResult'
[15:32:23.944] resolved() for 'SequentialFuture' ... done
[15:32:23.944] Future #1
[15:32:23.945] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:23.945] - nx: 1
[15:32:23.945] - relay: TRUE
[15:32:23.945] - stdout: TRUE
[15:32:23.945] - signal: TRUE
[15:32:23.946] - resignal: FALSE
[15:32:23.946] - force: TRUE
[15:32:23.946] - relayed: [n=1] FALSE
[15:32:23.946] - queued futures: [n=1] FALSE
[15:32:23.946]  - until=1
[15:32:23.946]  - relaying element #1
[15:32:23.947] - relayed: [n=1] TRUE
[15:32:23.947] - queued futures: [n=1] TRUE
[15:32:23.947] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:23.947]  length: 0 (resolved future 1)
[15:32:23.947] Relaying remaining futures
[15:32:23.948] signalConditionsASAP(NULL, pos=0) ...
[15:32:23.948] - nx: 1
[15:32:23.948] - relay: TRUE
[15:32:23.948] - stdout: TRUE
[15:32:23.948] - signal: TRUE
[15:32:23.948] - resignal: FALSE
[15:32:23.949] - force: TRUE
[15:32:23.949] - relayed: [n=1] TRUE
[15:32:23.949] - queued futures: [n=1] TRUE
 - flush all
[15:32:23.949] - relayed: [n=1] TRUE
[15:32:23.949] - queued futures: [n=1] TRUE
[15:32:23.950] signalConditionsASAP(NULL, pos=0) ... done
[15:32:23.950] resolve() on list ... DONE
[15:32:23.950]  - Number of value chunks collected: 1
[15:32:23.950] Resolving 1 futures (chunks) ... DONE
[15:32:23.950] Reducing values from 1 chunks ...
[15:32:23.950]  - Number of values collected after concatenation: 3
[15:32:23.951]  - Number of values expected: 3
[15:32:23.951] Reducing values from 1 chunks ... DONE
[15:32:23.951] future_lapply() ... DONE
List of 2
 $ y0: Named chr [1:3] "a" "b" "c"
  ..- attr(*, "names")= chr [1:3] "a" "b" "c"
 $ y1: Named chr [1:3] "a" "b" "c"
  ..- attr(*, "names")= chr [1:3] "a" "b" "c"
[15:32:23.953] future_lapply() ...
[15:32:23.954] Number of chunks: 1
[15:32:23.954] getGlobalsAndPackagesXApply() ...
[15:32:23.954]  - future.globals: TRUE
[15:32:23.955] getGlobalsAndPackages() ...
[15:32:23.955] Searching for globals...
[15:32:23.956] - globals found: [2] 'FUN', 'UseMethod'
[15:32:23.957] Searching for globals ... DONE
[15:32:23.957] Resolving globals: FALSE
[15:32:23.957] The total size of the 1 globals is 1.22 KiB (1248 bytes)
[15:32:23.958] The total size of the 1 globals exported for future expression ('FUN()') is 1.22 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.22 KiB of class 'function')
[15:32:23.958] - globals: [1] 'FUN'
[15:32:23.958] 
[15:32:23.958] getGlobalsAndPackages() ... DONE
[15:32:23.959]  - globals found/used: [n=1] 'FUN'
[15:32:23.959]  - needed namespaces: [n=0] 
[15:32:23.959] Finding globals ... DONE
[15:32:23.960]  - use_args: TRUE
[15:32:23.960]  - Getting '...' globals ...
[15:32:23.961] resolve() on list ...
[15:32:23.961]  recursive: 0
[15:32:23.961]  length: 1
[15:32:23.962]  elements: '...'
[15:32:23.962]  length: 0 (resolved future 1)
[15:32:23.962] resolve() on list ... DONE
[15:32:23.962]    - '...' content: [n=0] 
[15:32:23.963] List of 1
[15:32:23.963]  $ ...: list()
[15:32:23.963]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:23.963]  - attr(*, "where")=List of 1
[15:32:23.963]   ..$ ...:<environment: 0x00000276de92fc68> 
[15:32:23.963]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:23.963]  - attr(*, "resolved")= logi TRUE
[15:32:23.963]  - attr(*, "total_size")= num NA
[15:32:23.968]  - Getting '...' globals ... DONE
[15:32:23.969] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:23.969] List of 2
[15:32:23.969]  $ ...future.FUN:function (x, ...)  
[15:32:23.969]  $ ...          : list()
[15:32:23.969]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:23.969]  - attr(*, "where")=List of 2
[15:32:23.969]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:23.969]   ..$ ...          :<environment: 0x00000276de92fc68> 
[15:32:23.969]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:23.969]  - attr(*, "resolved")= logi FALSE
[15:32:23.969]  - attr(*, "total_size")= num 1248
[15:32:23.975] Packages to be attached in all futures: [n=0] 
[15:32:23.975] getGlobalsAndPackagesXApply() ... DONE
[15:32:23.976] Number of futures (= number of chunks): 1
[15:32:23.976] Launching 1 futures (chunks) ...
[15:32:23.976] Chunk #1 of 1 ...
[15:32:23.977]  - Finding globals in 'X' for chunk #1 ...
[15:32:23.977] getGlobalsAndPackages() ...
[15:32:23.977] Searching for globals...
[15:32:23.978] 
[15:32:23.978] Searching for globals ... DONE
[15:32:23.979] - globals: [0] <none>
[15:32:23.979] getGlobalsAndPackages() ... DONE
[15:32:23.979]    + additional globals found: [n=0] 
[15:32:23.980]    + additional namespaces needed: [n=0] 
[15:32:23.980]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:23.980]  - seeds: <none>
[15:32:23.980]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:23.981] getGlobalsAndPackages() ...
[15:32:23.981] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:23.981] Resolving globals: FALSE
[15:32:23.982] Tweak future expression to call with '...' arguments ...
[15:32:23.982] {
[15:32:23.982]     do.call(function(...) {
[15:32:23.982]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:23.982]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:23.982]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:23.982]             on.exit(options(oopts), add = TRUE)
[15:32:23.982]         }
[15:32:23.982]         {
[15:32:23.982]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:23.982]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:23.982]                 ...future.FUN(...future.X_jj, ...)
[15:32:23.982]             })
[15:32:23.982]         }
[15:32:23.982]     }, args = future.call.arguments)
[15:32:23.982] }
[15:32:23.983] Tweak future expression to call with '...' arguments ... DONE
[15:32:23.984] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:23.984] 
[15:32:23.984] getGlobalsAndPackages() ... DONE
[15:32:23.985] run() for 'Future' ...
[15:32:23.985] - state: 'created'
[15:32:23.986] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:23.987] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:23.987] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:23.987]   - Field: 'label'
[15:32:23.988]   - Field: 'local'
[15:32:23.988]   - Field: 'owner'
[15:32:23.988]   - Field: 'envir'
[15:32:23.989]   - Field: 'packages'
[15:32:23.989]   - Field: 'gc'
[15:32:23.989]   - Field: 'conditions'
[15:32:23.990]   - Field: 'expr'
[15:32:23.990]   - Field: 'uuid'
[15:32:23.990]   - Field: 'seed'
[15:32:23.991]   - Field: 'version'
[15:32:23.991]   - Field: 'result'
[15:32:23.991]   - Field: 'asynchronous'
[15:32:23.992]   - Field: 'calls'
[15:32:23.992]   - Field: 'globals'
[15:32:23.992]   - Field: 'stdout'
[15:32:23.992]   - Field: 'earlySignal'
[15:32:23.993]   - Field: 'lazy'
[15:32:23.993]   - Field: 'state'
[15:32:23.993] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:23.994] - Launch lazy future ...
[15:32:23.994] Packages needed by the future expression (n = 0): <none>
[15:32:23.995] Packages needed by future strategies (n = 0): <none>
[15:32:23.996] {
[15:32:23.996]     {
[15:32:23.996]         {
[15:32:23.996]             ...future.startTime <- base::Sys.time()
[15:32:23.996]             {
[15:32:23.996]                 {
[15:32:23.996]                   {
[15:32:23.996]                     base::local({
[15:32:23.996]                       has_future <- base::requireNamespace("future", 
[15:32:23.996]                         quietly = TRUE)
[15:32:23.996]                       if (has_future) {
[15:32:23.996]                         ns <- base::getNamespace("future")
[15:32:23.996]                         version <- ns[[".package"]][["version"]]
[15:32:23.996]                         if (is.null(version)) 
[15:32:23.996]                           version <- utils::packageVersion("future")
[15:32:23.996]                       }
[15:32:23.996]                       else {
[15:32:23.996]                         version <- NULL
[15:32:23.996]                       }
[15:32:23.996]                       if (!has_future || version < "1.8.0") {
[15:32:23.996]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:23.996]                           "", base::R.version$version.string), 
[15:32:23.996]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:23.996]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:23.996]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:23.996]                             "release", "version")], collapse = " "), 
[15:32:23.996]                           hostname = base::Sys.info()[["nodename"]])
[15:32:23.996]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:23.996]                           info)
[15:32:23.996]                         info <- base::paste(info, collapse = "; ")
[15:32:23.996]                         if (!has_future) {
[15:32:23.996]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:23.996]                             info)
[15:32:23.996]                         }
[15:32:23.996]                         else {
[15:32:23.996]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:23.996]                             info, version)
[15:32:23.996]                         }
[15:32:23.996]                         base::stop(msg)
[15:32:23.996]                       }
[15:32:23.996]                     })
[15:32:23.996]                   }
[15:32:23.996]                   ...future.strategy.old <- future::plan("list")
[15:32:23.996]                   options(future.plan = NULL)
[15:32:23.996]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:23.996]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:23.996]                 }
[15:32:23.996]                 ...future.workdir <- getwd()
[15:32:23.996]             }
[15:32:23.996]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:23.996]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:23.996]         }
[15:32:23.996]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:23.996]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:23.996]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:23.996]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:23.996]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:23.996]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:23.996]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:23.996]             base::names(...future.oldOptions))
[15:32:23.996]     }
[15:32:23.996]     if (FALSE) {
[15:32:23.996]     }
[15:32:23.996]     else {
[15:32:23.996]         if (TRUE) {
[15:32:23.996]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:23.996]                 open = "w")
[15:32:23.996]         }
[15:32:23.996]         else {
[15:32:23.996]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:23.996]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:23.996]         }
[15:32:23.996]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:23.996]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:23.996]             base::sink(type = "output", split = FALSE)
[15:32:23.996]             base::close(...future.stdout)
[15:32:23.996]         }, add = TRUE)
[15:32:23.996]     }
[15:32:23.996]     ...future.frame <- base::sys.nframe()
[15:32:23.996]     ...future.conditions <- base::list()
[15:32:23.996]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:23.996]     if (FALSE) {
[15:32:23.996]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:23.996]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:23.996]     }
[15:32:23.996]     ...future.result <- base::tryCatch({
[15:32:23.996]         base::withCallingHandlers({
[15:32:23.996]             ...future.value <- base::withVisible(base::local({
[15:32:23.996]                 do.call(function(...) {
[15:32:23.996]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:23.996]                   if (!identical(...future.globals.maxSize.org, 
[15:32:23.996]                     ...future.globals.maxSize)) {
[15:32:23.996]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:23.996]                     on.exit(options(oopts), add = TRUE)
[15:32:23.996]                   }
[15:32:23.996]                   {
[15:32:23.996]                     lapply(seq_along(...future.elements_ii), 
[15:32:23.996]                       FUN = function(jj) {
[15:32:23.996]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:23.996]                         ...future.FUN(...future.X_jj, ...)
[15:32:23.996]                       })
[15:32:23.996]                   }
[15:32:23.996]                 }, args = future.call.arguments)
[15:32:23.996]             }))
[15:32:23.996]             future::FutureResult(value = ...future.value$value, 
[15:32:23.996]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:23.996]                   ...future.rng), globalenv = if (FALSE) 
[15:32:23.996]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:23.996]                     ...future.globalenv.names))
[15:32:23.996]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:23.996]         }, condition = base::local({
[15:32:23.996]             c <- base::c
[15:32:23.996]             inherits <- base::inherits
[15:32:23.996]             invokeRestart <- base::invokeRestart
[15:32:23.996]             length <- base::length
[15:32:23.996]             list <- base::list
[15:32:23.996]             seq.int <- base::seq.int
[15:32:23.996]             signalCondition <- base::signalCondition
[15:32:23.996]             sys.calls <- base::sys.calls
[15:32:23.996]             `[[` <- base::`[[`
[15:32:23.996]             `+` <- base::`+`
[15:32:23.996]             `<<-` <- base::`<<-`
[15:32:23.996]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:23.996]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:23.996]                   3L)]
[15:32:23.996]             }
[15:32:23.996]             function(cond) {
[15:32:23.996]                 is_error <- inherits(cond, "error")
[15:32:23.996]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:23.996]                   NULL)
[15:32:23.996]                 if (is_error) {
[15:32:23.996]                   sessionInformation <- function() {
[15:32:23.996]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:23.996]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:23.996]                       search = base::search(), system = base::Sys.info())
[15:32:23.996]                   }
[15:32:23.996]                   ...future.conditions[[length(...future.conditions) + 
[15:32:23.996]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:23.996]                     cond$call), session = sessionInformation(), 
[15:32:23.996]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:23.996]                   signalCondition(cond)
[15:32:23.996]                 }
[15:32:23.996]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:23.996]                 "immediateCondition"))) {
[15:32:23.996]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:23.996]                   ...future.conditions[[length(...future.conditions) + 
[15:32:23.996]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:23.996]                   if (TRUE && !signal) {
[15:32:23.996]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:23.996]                     {
[15:32:23.996]                       inherits <- base::inherits
[15:32:23.996]                       invokeRestart <- base::invokeRestart
[15:32:23.996]                       is.null <- base::is.null
[15:32:23.996]                       muffled <- FALSE
[15:32:23.996]                       if (inherits(cond, "message")) {
[15:32:23.996]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:23.996]                         if (muffled) 
[15:32:23.996]                           invokeRestart("muffleMessage")
[15:32:23.996]                       }
[15:32:23.996]                       else if (inherits(cond, "warning")) {
[15:32:23.996]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:23.996]                         if (muffled) 
[15:32:23.996]                           invokeRestart("muffleWarning")
[15:32:23.996]                       }
[15:32:23.996]                       else if (inherits(cond, "condition")) {
[15:32:23.996]                         if (!is.null(pattern)) {
[15:32:23.996]                           computeRestarts <- base::computeRestarts
[15:32:23.996]                           grepl <- base::grepl
[15:32:23.996]                           restarts <- computeRestarts(cond)
[15:32:23.996]                           for (restart in restarts) {
[15:32:23.996]                             name <- restart$name
[15:32:23.996]                             if (is.null(name)) 
[15:32:23.996]                               next
[15:32:23.996]                             if (!grepl(pattern, name)) 
[15:32:23.996]                               next
[15:32:23.996]                             invokeRestart(restart)
[15:32:23.996]                             muffled <- TRUE
[15:32:23.996]                             break
[15:32:23.996]                           }
[15:32:23.996]                         }
[15:32:23.996]                       }
[15:32:23.996]                       invisible(muffled)
[15:32:23.996]                     }
[15:32:23.996]                     muffleCondition(cond, pattern = "^muffle")
[15:32:23.996]                   }
[15:32:23.996]                 }
[15:32:23.996]                 else {
[15:32:23.996]                   if (TRUE) {
[15:32:23.996]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:23.996]                     {
[15:32:23.996]                       inherits <- base::inherits
[15:32:23.996]                       invokeRestart <- base::invokeRestart
[15:32:23.996]                       is.null <- base::is.null
[15:32:23.996]                       muffled <- FALSE
[15:32:23.996]                       if (inherits(cond, "message")) {
[15:32:23.996]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:23.996]                         if (muffled) 
[15:32:23.996]                           invokeRestart("muffleMessage")
[15:32:23.996]                       }
[15:32:23.996]                       else if (inherits(cond, "warning")) {
[15:32:23.996]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:23.996]                         if (muffled) 
[15:32:23.996]                           invokeRestart("muffleWarning")
[15:32:23.996]                       }
[15:32:23.996]                       else if (inherits(cond, "condition")) {
[15:32:23.996]                         if (!is.null(pattern)) {
[15:32:23.996]                           computeRestarts <- base::computeRestarts
[15:32:23.996]                           grepl <- base::grepl
[15:32:23.996]                           restarts <- computeRestarts(cond)
[15:32:23.996]                           for (restart in restarts) {
[15:32:23.996]                             name <- restart$name
[15:32:23.996]                             if (is.null(name)) 
[15:32:23.996]                               next
[15:32:23.996]                             if (!grepl(pattern, name)) 
[15:32:23.996]                               next
[15:32:23.996]                             invokeRestart(restart)
[15:32:23.996]                             muffled <- TRUE
[15:32:23.996]                             break
[15:32:23.996]                           }
[15:32:23.996]                         }
[15:32:23.996]                       }
[15:32:23.996]                       invisible(muffled)
[15:32:23.996]                     }
[15:32:23.996]                     muffleCondition(cond, pattern = "^muffle")
[15:32:23.996]                   }
[15:32:23.996]                 }
[15:32:23.996]             }
[15:32:23.996]         }))
[15:32:23.996]     }, error = function(ex) {
[15:32:23.996]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:23.996]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:23.996]                 ...future.rng), started = ...future.startTime, 
[15:32:23.996]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:23.996]             version = "1.8"), class = "FutureResult")
[15:32:23.996]     }, finally = {
[15:32:23.996]         if (!identical(...future.workdir, getwd())) 
[15:32:23.996]             setwd(...future.workdir)
[15:32:23.996]         {
[15:32:23.996]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:23.996]                 ...future.oldOptions$nwarnings <- NULL
[15:32:23.996]             }
[15:32:23.996]             base::options(...future.oldOptions)
[15:32:23.996]             if (.Platform$OS.type == "windows") {
[15:32:23.996]                 old_names <- names(...future.oldEnvVars)
[15:32:23.996]                 envs <- base::Sys.getenv()
[15:32:23.996]                 names <- names(envs)
[15:32:23.996]                 common <- intersect(names, old_names)
[15:32:23.996]                 added <- setdiff(names, old_names)
[15:32:23.996]                 removed <- setdiff(old_names, names)
[15:32:23.996]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:23.996]                   envs[common]]
[15:32:23.996]                 NAMES <- toupper(changed)
[15:32:23.996]                 args <- list()
[15:32:23.996]                 for (kk in seq_along(NAMES)) {
[15:32:23.996]                   name <- changed[[kk]]
[15:32:23.996]                   NAME <- NAMES[[kk]]
[15:32:23.996]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:23.996]                     next
[15:32:23.996]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:23.996]                 }
[15:32:23.996]                 NAMES <- toupper(added)
[15:32:23.996]                 for (kk in seq_along(NAMES)) {
[15:32:23.996]                   name <- added[[kk]]
[15:32:23.996]                   NAME <- NAMES[[kk]]
[15:32:23.996]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:23.996]                     next
[15:32:23.996]                   args[[name]] <- ""
[15:32:23.996]                 }
[15:32:23.996]                 NAMES <- toupper(removed)
[15:32:23.996]                 for (kk in seq_along(NAMES)) {
[15:32:23.996]                   name <- removed[[kk]]
[15:32:23.996]                   NAME <- NAMES[[kk]]
[15:32:23.996]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:23.996]                     next
[15:32:23.996]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:23.996]                 }
[15:32:23.996]                 if (length(args) > 0) 
[15:32:23.996]                   base::do.call(base::Sys.setenv, args = args)
[15:32:23.996]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:23.996]             }
[15:32:23.996]             else {
[15:32:23.996]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:23.996]             }
[15:32:23.996]             {
[15:32:23.996]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:23.996]                   0L) {
[15:32:23.996]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:23.996]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:23.996]                   base::options(opts)
[15:32:23.996]                 }
[15:32:23.996]                 {
[15:32:23.996]                   {
[15:32:23.996]                     NULL
[15:32:23.996]                     RNGkind("Mersenne-Twister")
[15:32:23.996]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:23.996]                       inherits = FALSE)
[15:32:23.996]                   }
[15:32:23.996]                   options(future.plan = NULL)
[15:32:23.996]                   if (is.na(NA_character_)) 
[15:32:23.996]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:23.996]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:23.996]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:23.996]                     .init = FALSE)
[15:32:23.996]                 }
[15:32:23.996]             }
[15:32:23.996]         }
[15:32:23.996]     })
[15:32:23.996]     if (TRUE) {
[15:32:23.996]         base::sink(type = "output", split = FALSE)
[15:32:23.996]         if (TRUE) {
[15:32:23.996]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:23.996]         }
[15:32:23.996]         else {
[15:32:23.996]             ...future.result["stdout"] <- base::list(NULL)
[15:32:23.996]         }
[15:32:23.996]         base::close(...future.stdout)
[15:32:23.996]         ...future.stdout <- NULL
[15:32:23.996]     }
[15:32:23.996]     ...future.result$conditions <- ...future.conditions
[15:32:23.996]     ...future.result$finished <- base::Sys.time()
[15:32:23.996]     ...future.result
[15:32:23.996] }
[15:32:24.003] assign_globals() ...
[15:32:24.003] List of 5
[15:32:24.003]  $ ...future.FUN            :function (x, ...)  
[15:32:24.003]  $ future.call.arguments    : list()
[15:32:24.003]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:24.003]  $ ...future.elements_ii    :List of 3
[15:32:24.003]   ..$ : chr "a"
[15:32:24.003]   ..$ : chr "b"
[15:32:24.003]   ..$ : chr "c"
[15:32:24.003]  $ ...future.seeds_ii       : NULL
[15:32:24.003]  $ ...future.globals.maxSize: NULL
[15:32:24.003]  - attr(*, "where")=List of 5
[15:32:24.003]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:24.003]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:24.003]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:24.003]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:24.003]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:24.003]  - attr(*, "resolved")= logi FALSE
[15:32:24.003]  - attr(*, "total_size")= num 1248
[15:32:24.003]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:24.003]  - attr(*, "already-done")= logi TRUE
[15:32:24.013] - copied '...future.FUN' to environment
[15:32:24.013] - copied 'future.call.arguments' to environment
[15:32:24.013] - copied '...future.elements_ii' to environment
[15:32:24.013] - copied '...future.seeds_ii' to environment
[15:32:24.014] - copied '...future.globals.maxSize' to environment
[15:32:24.014] assign_globals() ... done
[15:32:24.015] plan(): Setting new future strategy stack:
[15:32:24.015] List of future strategies:
[15:32:24.015] 1. sequential:
[15:32:24.015]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:24.015]    - tweaked: FALSE
[15:32:24.015]    - call: NULL
[15:32:24.016] plan(): nbrOfWorkers() = 1
[15:32:24.018] plan(): Setting new future strategy stack:
[15:32:24.018] List of future strategies:
[15:32:24.018] 1. sequential:
[15:32:24.018]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:24.018]    - tweaked: FALSE
[15:32:24.018]    - call: plan(strategy)
[15:32:24.019] plan(): nbrOfWorkers() = 1
[15:32:24.019] SequentialFuture started (and completed)
[15:32:24.019] - Launch lazy future ... done
[15:32:24.020] run() for 'SequentialFuture' ... done
[15:32:24.020] Created future:
[15:32:24.020] SequentialFuture:
[15:32:24.020] Label: 'future_sapply-1'
[15:32:24.020] Expression:
[15:32:24.020] {
[15:32:24.020]     do.call(function(...) {
[15:32:24.020]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:24.020]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:24.020]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:24.020]             on.exit(options(oopts), add = TRUE)
[15:32:24.020]         }
[15:32:24.020]         {
[15:32:24.020]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:24.020]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:24.020]                 ...future.FUN(...future.X_jj, ...)
[15:32:24.020]             })
[15:32:24.020]         }
[15:32:24.020]     }, args = future.call.arguments)
[15:32:24.020] }
[15:32:24.020] Lazy evaluation: FALSE
[15:32:24.020] Asynchronous evaluation: FALSE
[15:32:24.020] Local evaluation: TRUE
[15:32:24.020] Environment: R_GlobalEnv
[15:32:24.020] Capture standard output: TRUE
[15:32:24.020] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:24.020] Globals: 5 objects totaling 1.55 KiB (function '...future.FUN' of 1.22 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 336 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:24.020] Packages: <none>
[15:32:24.020] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:24.020] Resolved: TRUE
[15:32:24.020] Value: 840 bytes of class 'list'
[15:32:24.020] Early signaling: FALSE
[15:32:24.020] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:24.020] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:24.022] Chunk #1 of 1 ... DONE
[15:32:24.022] Launching 1 futures (chunks) ... DONE
[15:32:24.022] Resolving 1 futures (chunks) ...
[15:32:24.023] resolve() on list ...
[15:32:24.023]  recursive: 0
[15:32:24.023]  length: 1
[15:32:24.023] 
[15:32:24.024] resolved() for 'SequentialFuture' ...
[15:32:24.024] - state: 'finished'
[15:32:24.024] - run: TRUE
[15:32:24.024] - result: 'FutureResult'
[15:32:24.025] resolved() for 'SequentialFuture' ... done
[15:32:24.025] Future #1
[15:32:24.025] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:24.026] - nx: 1
[15:32:24.026] - relay: TRUE
[15:32:24.026] - stdout: TRUE
[15:32:24.026] - signal: TRUE
[15:32:24.026] - resignal: FALSE
[15:32:24.027] - force: TRUE
[15:32:24.027] - relayed: [n=1] FALSE
[15:32:24.027] - queued futures: [n=1] FALSE
[15:32:24.027]  - until=1
[15:32:24.028]  - relaying element #1
[15:32:24.028] - relayed: [n=1] TRUE
[15:32:24.028] - queued futures: [n=1] TRUE
[15:32:24.028] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:24.029]  length: 0 (resolved future 1)
[15:32:24.029] Relaying remaining futures
[15:32:24.029] signalConditionsASAP(NULL, pos=0) ...
[15:32:24.029] - nx: 1
[15:32:24.030] - relay: TRUE
[15:32:24.030] - stdout: TRUE
[15:32:24.030] - signal: TRUE
[15:32:24.030] - resignal: FALSE
[15:32:24.031] - force: TRUE
[15:32:24.031] - relayed: [n=1] TRUE
[15:32:24.031] - queued futures: [n=1] TRUE
 - flush all
[15:32:24.031] - relayed: [n=1] TRUE
[15:32:24.032] - queued futures: [n=1] TRUE
[15:32:24.032] signalConditionsASAP(NULL, pos=0) ... done
[15:32:24.032] resolve() on list ... DONE
[15:32:24.032]  - Number of value chunks collected: 1
[15:32:24.033] Resolving 1 futures (chunks) ... DONE
[15:32:24.033] Reducing values from 1 chunks ...
[15:32:24.033]  - Number of values collected after concatenation: 3
[15:32:24.033]  - Number of values expected: 3
[15:32:24.034] Reducing values from 1 chunks ... DONE
[15:32:24.034] future_lapply() ... DONE
List of 2
 $ y0: Named chr [1:3] "a" "b" "c"
  ..- attr(*, "names")= chr [1:3] "a" "b" "c"
 $ y1: Named chr [1:3] "a" "b" "c"
  ..- attr(*, "names")= chr [1:3] "a" "b" "c"
[15:32:24.036] future_lapply() ...
[15:32:24.037] Number of chunks: 1
[15:32:24.038] getGlobalsAndPackagesXApply() ...
[15:32:24.038]  - future.globals: TRUE
[15:32:24.038] getGlobalsAndPackages() ...
[15:32:24.038] Searching for globals...
[15:32:24.040] - globals found: [1] 'FUN'
[15:32:24.040] Searching for globals ... DONE
[15:32:24.041] Resolving globals: FALSE
[15:32:24.041] The total size of the 1 globals is 848 bytes (848 bytes)
[15:32:24.042] The total size of the 1 globals exported for future expression ('FUN()') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:32:24.042] - globals: [1] 'FUN'
[15:32:24.042] 
[15:32:24.043] getGlobalsAndPackages() ... DONE
[15:32:24.043]  - globals found/used: [n=1] 'FUN'
[15:32:24.043]  - needed namespaces: [n=0] 
[15:32:24.043] Finding globals ... DONE
[15:32:24.043]  - use_args: TRUE
[15:32:24.044]  - Getting '...' globals ...
[15:32:24.044] resolve() on list ...
[15:32:24.045]  recursive: 0
[15:32:24.045]  length: 1
[15:32:24.045]  elements: '...'
[15:32:24.045]  length: 0 (resolved future 1)
[15:32:24.046] resolve() on list ... DONE
[15:32:24.046]    - '...' content: [n=0] 
[15:32:24.046] List of 1
[15:32:24.046]  $ ...: list()
[15:32:24.046]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:24.046]  - attr(*, "where")=List of 1
[15:32:24.046]   ..$ ...:<environment: 0x00000276e544d068> 
[15:32:24.046]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:24.046]  - attr(*, "resolved")= logi TRUE
[15:32:24.046]  - attr(*, "total_size")= num NA
[15:32:24.050]  - Getting '...' globals ... DONE
[15:32:24.051] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:24.051] List of 2
[15:32:24.051]  $ ...future.FUN:function (x)  
[15:32:24.051]  $ ...          : list()
[15:32:24.051]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:24.051]  - attr(*, "where")=List of 2
[15:32:24.051]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:24.051]   ..$ ...          :<environment: 0x00000276e544d068> 
[15:32:24.051]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:24.051]  - attr(*, "resolved")= logi FALSE
[15:32:24.051]  - attr(*, "total_size")= num 848
[15:32:24.056] Packages to be attached in all futures: [n=0] 
[15:32:24.056] getGlobalsAndPackagesXApply() ... DONE
[15:32:24.057] Number of futures (= number of chunks): 1
[15:32:24.057] Launching 1 futures (chunks) ...
[15:32:24.057] Chunk #1 of 1 ...
[15:32:24.057]  - Finding globals in 'X' for chunk #1 ...
[15:32:24.058] getGlobalsAndPackages() ...
[15:32:24.058] Searching for globals...
[15:32:24.058] 
[15:32:24.059] Searching for globals ... DONE
[15:32:24.059] - globals: [0] <none>
[15:32:24.059] getGlobalsAndPackages() ... DONE
[15:32:24.059]    + additional globals found: [n=0] 
[15:32:24.060]    + additional namespaces needed: [n=0] 
[15:32:24.060]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:24.060]  - seeds: <none>
[15:32:24.060]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:24.061] getGlobalsAndPackages() ...
[15:32:24.061] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:24.062] Resolving globals: FALSE
[15:32:24.062] Tweak future expression to call with '...' arguments ...
[15:32:24.062] {
[15:32:24.062]     do.call(function(...) {
[15:32:24.062]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:24.062]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:24.062]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:24.062]             on.exit(options(oopts), add = TRUE)
[15:32:24.062]         }
[15:32:24.062]         {
[15:32:24.062]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:24.062]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:24.062]                 ...future.FUN(...future.X_jj, ...)
[15:32:24.062]             })
[15:32:24.062]         }
[15:32:24.062]     }, args = future.call.arguments)
[15:32:24.062] }
[15:32:24.062] Tweak future expression to call with '...' arguments ... DONE
[15:32:24.063] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:24.063] 
[15:32:24.063] getGlobalsAndPackages() ... DONE
[15:32:24.064] run() for 'Future' ...
[15:32:24.064] - state: 'created'
[15:32:24.064] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:24.065] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:24.065] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:24.068]   - Field: 'label'
[15:32:24.068]   - Field: 'local'
[15:32:24.068]   - Field: 'owner'
[15:32:24.068]   - Field: 'envir'
[15:32:24.068]   - Field: 'packages'
[15:32:24.068]   - Field: 'gc'
[15:32:24.069]   - Field: 'conditions'
[15:32:24.069]   - Field: 'expr'
[15:32:24.069]   - Field: 'uuid'
[15:32:24.069]   - Field: 'seed'
[15:32:24.069]   - Field: 'version'
[15:32:24.069]   - Field: 'result'
[15:32:24.070]   - Field: 'asynchronous'
[15:32:24.070]   - Field: 'calls'
[15:32:24.070]   - Field: 'globals'
[15:32:24.070]   - Field: 'stdout'
[15:32:24.070]   - Field: 'earlySignal'
[15:32:24.070]   - Field: 'lazy'
[15:32:24.071]   - Field: 'state'
[15:32:24.071] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:24.071] - Launch lazy future ...
[15:32:24.071] Packages needed by the future expression (n = 0): <none>
[15:32:24.071] Packages needed by future strategies (n = 0): <none>
[15:32:24.072] {
[15:32:24.072]     {
[15:32:24.072]         {
[15:32:24.072]             ...future.startTime <- base::Sys.time()
[15:32:24.072]             {
[15:32:24.072]                 {
[15:32:24.072]                   {
[15:32:24.072]                     base::local({
[15:32:24.072]                       has_future <- base::requireNamespace("future", 
[15:32:24.072]                         quietly = TRUE)
[15:32:24.072]                       if (has_future) {
[15:32:24.072]                         ns <- base::getNamespace("future")
[15:32:24.072]                         version <- ns[[".package"]][["version"]]
[15:32:24.072]                         if (is.null(version)) 
[15:32:24.072]                           version <- utils::packageVersion("future")
[15:32:24.072]                       }
[15:32:24.072]                       else {
[15:32:24.072]                         version <- NULL
[15:32:24.072]                       }
[15:32:24.072]                       if (!has_future || version < "1.8.0") {
[15:32:24.072]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:24.072]                           "", base::R.version$version.string), 
[15:32:24.072]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:24.072]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:24.072]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:24.072]                             "release", "version")], collapse = " "), 
[15:32:24.072]                           hostname = base::Sys.info()[["nodename"]])
[15:32:24.072]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:24.072]                           info)
[15:32:24.072]                         info <- base::paste(info, collapse = "; ")
[15:32:24.072]                         if (!has_future) {
[15:32:24.072]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:24.072]                             info)
[15:32:24.072]                         }
[15:32:24.072]                         else {
[15:32:24.072]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:24.072]                             info, version)
[15:32:24.072]                         }
[15:32:24.072]                         base::stop(msg)
[15:32:24.072]                       }
[15:32:24.072]                     })
[15:32:24.072]                   }
[15:32:24.072]                   ...future.strategy.old <- future::plan("list")
[15:32:24.072]                   options(future.plan = NULL)
[15:32:24.072]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:24.072]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:24.072]                 }
[15:32:24.072]                 ...future.workdir <- getwd()
[15:32:24.072]             }
[15:32:24.072]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:24.072]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:24.072]         }
[15:32:24.072]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:24.072]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:24.072]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:24.072]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:24.072]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:24.072]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:24.072]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:24.072]             base::names(...future.oldOptions))
[15:32:24.072]     }
[15:32:24.072]     if (FALSE) {
[15:32:24.072]     }
[15:32:24.072]     else {
[15:32:24.072]         if (TRUE) {
[15:32:24.072]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:24.072]                 open = "w")
[15:32:24.072]         }
[15:32:24.072]         else {
[15:32:24.072]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:24.072]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:24.072]         }
[15:32:24.072]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:24.072]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:24.072]             base::sink(type = "output", split = FALSE)
[15:32:24.072]             base::close(...future.stdout)
[15:32:24.072]         }, add = TRUE)
[15:32:24.072]     }
[15:32:24.072]     ...future.frame <- base::sys.nframe()
[15:32:24.072]     ...future.conditions <- base::list()
[15:32:24.072]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:24.072]     if (FALSE) {
[15:32:24.072]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:24.072]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:24.072]     }
[15:32:24.072]     ...future.result <- base::tryCatch({
[15:32:24.072]         base::withCallingHandlers({
[15:32:24.072]             ...future.value <- base::withVisible(base::local({
[15:32:24.072]                 do.call(function(...) {
[15:32:24.072]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:24.072]                   if (!identical(...future.globals.maxSize.org, 
[15:32:24.072]                     ...future.globals.maxSize)) {
[15:32:24.072]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:24.072]                     on.exit(options(oopts), add = TRUE)
[15:32:24.072]                   }
[15:32:24.072]                   {
[15:32:24.072]                     lapply(seq_along(...future.elements_ii), 
[15:32:24.072]                       FUN = function(jj) {
[15:32:24.072]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:24.072]                         ...future.FUN(...future.X_jj, ...)
[15:32:24.072]                       })
[15:32:24.072]                   }
[15:32:24.072]                 }, args = future.call.arguments)
[15:32:24.072]             }))
[15:32:24.072]             future::FutureResult(value = ...future.value$value, 
[15:32:24.072]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:24.072]                   ...future.rng), globalenv = if (FALSE) 
[15:32:24.072]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:24.072]                     ...future.globalenv.names))
[15:32:24.072]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:24.072]         }, condition = base::local({
[15:32:24.072]             c <- base::c
[15:32:24.072]             inherits <- base::inherits
[15:32:24.072]             invokeRestart <- base::invokeRestart
[15:32:24.072]             length <- base::length
[15:32:24.072]             list <- base::list
[15:32:24.072]             seq.int <- base::seq.int
[15:32:24.072]             signalCondition <- base::signalCondition
[15:32:24.072]             sys.calls <- base::sys.calls
[15:32:24.072]             `[[` <- base::`[[`
[15:32:24.072]             `+` <- base::`+`
[15:32:24.072]             `<<-` <- base::`<<-`
[15:32:24.072]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:24.072]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:24.072]                   3L)]
[15:32:24.072]             }
[15:32:24.072]             function(cond) {
[15:32:24.072]                 is_error <- inherits(cond, "error")
[15:32:24.072]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:24.072]                   NULL)
[15:32:24.072]                 if (is_error) {
[15:32:24.072]                   sessionInformation <- function() {
[15:32:24.072]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:24.072]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:24.072]                       search = base::search(), system = base::Sys.info())
[15:32:24.072]                   }
[15:32:24.072]                   ...future.conditions[[length(...future.conditions) + 
[15:32:24.072]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:24.072]                     cond$call), session = sessionInformation(), 
[15:32:24.072]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:24.072]                   signalCondition(cond)
[15:32:24.072]                 }
[15:32:24.072]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:24.072]                 "immediateCondition"))) {
[15:32:24.072]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:24.072]                   ...future.conditions[[length(...future.conditions) + 
[15:32:24.072]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:24.072]                   if (TRUE && !signal) {
[15:32:24.072]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:24.072]                     {
[15:32:24.072]                       inherits <- base::inherits
[15:32:24.072]                       invokeRestart <- base::invokeRestart
[15:32:24.072]                       is.null <- base::is.null
[15:32:24.072]                       muffled <- FALSE
[15:32:24.072]                       if (inherits(cond, "message")) {
[15:32:24.072]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:24.072]                         if (muffled) 
[15:32:24.072]                           invokeRestart("muffleMessage")
[15:32:24.072]                       }
[15:32:24.072]                       else if (inherits(cond, "warning")) {
[15:32:24.072]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:24.072]                         if (muffled) 
[15:32:24.072]                           invokeRestart("muffleWarning")
[15:32:24.072]                       }
[15:32:24.072]                       else if (inherits(cond, "condition")) {
[15:32:24.072]                         if (!is.null(pattern)) {
[15:32:24.072]                           computeRestarts <- base::computeRestarts
[15:32:24.072]                           grepl <- base::grepl
[15:32:24.072]                           restarts <- computeRestarts(cond)
[15:32:24.072]                           for (restart in restarts) {
[15:32:24.072]                             name <- restart$name
[15:32:24.072]                             if (is.null(name)) 
[15:32:24.072]                               next
[15:32:24.072]                             if (!grepl(pattern, name)) 
[15:32:24.072]                               next
[15:32:24.072]                             invokeRestart(restart)
[15:32:24.072]                             muffled <- TRUE
[15:32:24.072]                             break
[15:32:24.072]                           }
[15:32:24.072]                         }
[15:32:24.072]                       }
[15:32:24.072]                       invisible(muffled)
[15:32:24.072]                     }
[15:32:24.072]                     muffleCondition(cond, pattern = "^muffle")
[15:32:24.072]                   }
[15:32:24.072]                 }
[15:32:24.072]                 else {
[15:32:24.072]                   if (TRUE) {
[15:32:24.072]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:24.072]                     {
[15:32:24.072]                       inherits <- base::inherits
[15:32:24.072]                       invokeRestart <- base::invokeRestart
[15:32:24.072]                       is.null <- base::is.null
[15:32:24.072]                       muffled <- FALSE
[15:32:24.072]                       if (inherits(cond, "message")) {
[15:32:24.072]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:24.072]                         if (muffled) 
[15:32:24.072]                           invokeRestart("muffleMessage")
[15:32:24.072]                       }
[15:32:24.072]                       else if (inherits(cond, "warning")) {
[15:32:24.072]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:24.072]                         if (muffled) 
[15:32:24.072]                           invokeRestart("muffleWarning")
[15:32:24.072]                       }
[15:32:24.072]                       else if (inherits(cond, "condition")) {
[15:32:24.072]                         if (!is.null(pattern)) {
[15:32:24.072]                           computeRestarts <- base::computeRestarts
[15:32:24.072]                           grepl <- base::grepl
[15:32:24.072]                           restarts <- computeRestarts(cond)
[15:32:24.072]                           for (restart in restarts) {
[15:32:24.072]                             name <- restart$name
[15:32:24.072]                             if (is.null(name)) 
[15:32:24.072]                               next
[15:32:24.072]                             if (!grepl(pattern, name)) 
[15:32:24.072]                               next
[15:32:24.072]                             invokeRestart(restart)
[15:32:24.072]                             muffled <- TRUE
[15:32:24.072]                             break
[15:32:24.072]                           }
[15:32:24.072]                         }
[15:32:24.072]                       }
[15:32:24.072]                       invisible(muffled)
[15:32:24.072]                     }
[15:32:24.072]                     muffleCondition(cond, pattern = "^muffle")
[15:32:24.072]                   }
[15:32:24.072]                 }
[15:32:24.072]             }
[15:32:24.072]         }))
[15:32:24.072]     }, error = function(ex) {
[15:32:24.072]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:24.072]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:24.072]                 ...future.rng), started = ...future.startTime, 
[15:32:24.072]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:24.072]             version = "1.8"), class = "FutureResult")
[15:32:24.072]     }, finally = {
[15:32:24.072]         if (!identical(...future.workdir, getwd())) 
[15:32:24.072]             setwd(...future.workdir)
[15:32:24.072]         {
[15:32:24.072]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:24.072]                 ...future.oldOptions$nwarnings <- NULL
[15:32:24.072]             }
[15:32:24.072]             base::options(...future.oldOptions)
[15:32:24.072]             if (.Platform$OS.type == "windows") {
[15:32:24.072]                 old_names <- names(...future.oldEnvVars)
[15:32:24.072]                 envs <- base::Sys.getenv()
[15:32:24.072]                 names <- names(envs)
[15:32:24.072]                 common <- intersect(names, old_names)
[15:32:24.072]                 added <- setdiff(names, old_names)
[15:32:24.072]                 removed <- setdiff(old_names, names)
[15:32:24.072]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:24.072]                   envs[common]]
[15:32:24.072]                 NAMES <- toupper(changed)
[15:32:24.072]                 args <- list()
[15:32:24.072]                 for (kk in seq_along(NAMES)) {
[15:32:24.072]                   name <- changed[[kk]]
[15:32:24.072]                   NAME <- NAMES[[kk]]
[15:32:24.072]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:24.072]                     next
[15:32:24.072]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:24.072]                 }
[15:32:24.072]                 NAMES <- toupper(added)
[15:32:24.072]                 for (kk in seq_along(NAMES)) {
[15:32:24.072]                   name <- added[[kk]]
[15:32:24.072]                   NAME <- NAMES[[kk]]
[15:32:24.072]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:24.072]                     next
[15:32:24.072]                   args[[name]] <- ""
[15:32:24.072]                 }
[15:32:24.072]                 NAMES <- toupper(removed)
[15:32:24.072]                 for (kk in seq_along(NAMES)) {
[15:32:24.072]                   name <- removed[[kk]]
[15:32:24.072]                   NAME <- NAMES[[kk]]
[15:32:24.072]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:24.072]                     next
[15:32:24.072]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:24.072]                 }
[15:32:24.072]                 if (length(args) > 0) 
[15:32:24.072]                   base::do.call(base::Sys.setenv, args = args)
[15:32:24.072]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:24.072]             }
[15:32:24.072]             else {
[15:32:24.072]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:24.072]             }
[15:32:24.072]             {
[15:32:24.072]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:24.072]                   0L) {
[15:32:24.072]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:24.072]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:24.072]                   base::options(opts)
[15:32:24.072]                 }
[15:32:24.072]                 {
[15:32:24.072]                   {
[15:32:24.072]                     NULL
[15:32:24.072]                     RNGkind("Mersenne-Twister")
[15:32:24.072]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:24.072]                       inherits = FALSE)
[15:32:24.072]                   }
[15:32:24.072]                   options(future.plan = NULL)
[15:32:24.072]                   if (is.na(NA_character_)) 
[15:32:24.072]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:24.072]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:24.072]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:24.072]                     .init = FALSE)
[15:32:24.072]                 }
[15:32:24.072]             }
[15:32:24.072]         }
[15:32:24.072]     })
[15:32:24.072]     if (TRUE) {
[15:32:24.072]         base::sink(type = "output", split = FALSE)
[15:32:24.072]         if (TRUE) {
[15:32:24.072]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:24.072]         }
[15:32:24.072]         else {
[15:32:24.072]             ...future.result["stdout"] <- base::list(NULL)
[15:32:24.072]         }
[15:32:24.072]         base::close(...future.stdout)
[15:32:24.072]         ...future.stdout <- NULL
[15:32:24.072]     }
[15:32:24.072]     ...future.result$conditions <- ...future.conditions
[15:32:24.072]     ...future.result$finished <- base::Sys.time()
[15:32:24.072]     ...future.result
[15:32:24.072] }
[15:32:24.076] assign_globals() ...
[15:32:24.076] List of 5
[15:32:24.076]  $ ...future.FUN            :function (x)  
[15:32:24.076]  $ future.call.arguments    : list()
[15:32:24.076]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:24.076]  $ ...future.elements_ii    :List of 4
[15:32:24.076]   ..$ A: num 50
[15:32:24.076]   ..$ B: num 60
[15:32:24.076]   ..$ C: num 70
[15:32:24.076]   ..$ D: num 80
[15:32:24.076]  $ ...future.seeds_ii       : NULL
[15:32:24.076]  $ ...future.globals.maxSize: NULL
[15:32:24.076]  - attr(*, "where")=List of 5
[15:32:24.076]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:24.076]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:24.076]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:24.076]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:24.076]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:24.076]  - attr(*, "resolved")= logi FALSE
[15:32:24.076]  - attr(*, "total_size")= num 848
[15:32:24.076]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:24.076]  - attr(*, "already-done")= logi TRUE
[15:32:24.084] - copied '...future.FUN' to environment
[15:32:24.084] - copied 'future.call.arguments' to environment
[15:32:24.084] - copied '...future.elements_ii' to environment
[15:32:24.085] - copied '...future.seeds_ii' to environment
[15:32:24.085] - copied '...future.globals.maxSize' to environment
[15:32:24.085] assign_globals() ... done
[15:32:24.085] plan(): Setting new future strategy stack:
[15:32:24.085] List of future strategies:
[15:32:24.085] 1. sequential:
[15:32:24.085]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:24.085]    - tweaked: FALSE
[15:32:24.085]    - call: NULL
[15:32:24.086] plan(): nbrOfWorkers() = 1
[15:32:24.087] plan(): Setting new future strategy stack:
[15:32:24.087] List of future strategies:
[15:32:24.087] 1. sequential:
[15:32:24.087]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:24.087]    - tweaked: FALSE
[15:32:24.087]    - call: plan(strategy)
[15:32:24.088] plan(): nbrOfWorkers() = 1
[15:32:24.089] SequentialFuture started (and completed)
[15:32:24.089] - Launch lazy future ... done
[15:32:24.089] run() for 'SequentialFuture' ... done
[15:32:24.089] Created future:
[15:32:24.090] SequentialFuture:
[15:32:24.090] Label: 'future_sapply-1'
[15:32:24.090] Expression:
[15:32:24.090] {
[15:32:24.090]     do.call(function(...) {
[15:32:24.090]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:24.090]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:24.090]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:24.090]             on.exit(options(oopts), add = TRUE)
[15:32:24.090]         }
[15:32:24.090]         {
[15:32:24.090]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:24.090]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:24.090]                 ...future.FUN(...future.X_jj, ...)
[15:32:24.090]             })
[15:32:24.090]         }
[15:32:24.090]     }, args = future.call.arguments)
[15:32:24.090] }
[15:32:24.090] Lazy evaluation: FALSE
[15:32:24.090] Asynchronous evaluation: FALSE
[15:32:24.090] Local evaluation: TRUE
[15:32:24.090] Environment: R_GlobalEnv
[15:32:24.090] Capture standard output: TRUE
[15:32:24.090] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:24.090] Globals: 5 objects totaling 1.05 KiB (function '...future.FUN' of 848 bytes, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 224 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:24.090] Packages: <none>
[15:32:24.090] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:24.090] Resolved: TRUE
[15:32:24.090] Value: 224 bytes of class 'list'
[15:32:24.090] Early signaling: FALSE
[15:32:24.090] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:24.090] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:24.091] Chunk #1 of 1 ... DONE
[15:32:24.092] Launching 1 futures (chunks) ... DONE
[15:32:24.092] Resolving 1 futures (chunks) ...
[15:32:24.092] resolve() on list ...
[15:32:24.093]  recursive: 0
[15:32:24.093]  length: 1
[15:32:24.093] 
[15:32:24.093] resolved() for 'SequentialFuture' ...
[15:32:24.094] - state: 'finished'
[15:32:24.094] - run: TRUE
[15:32:24.094] - result: 'FutureResult'
[15:32:24.095] resolved() for 'SequentialFuture' ... done
[15:32:24.095] Future #1
[15:32:24.095] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:24.096] - nx: 1
[15:32:24.096] - relay: TRUE
[15:32:24.096] - stdout: TRUE
[15:32:24.096] - signal: TRUE
[15:32:24.097] - resignal: FALSE
[15:32:24.097] - force: TRUE
[15:32:24.097] - relayed: [n=1] FALSE
[15:32:24.098] - queued futures: [n=1] FALSE
[15:32:24.098]  - until=1
[15:32:24.098]  - relaying element #1
[15:32:24.099] - relayed: [n=1] TRUE
[15:32:24.099] - queued futures: [n=1] TRUE
[15:32:24.099] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:24.099]  length: 0 (resolved future 1)
[15:32:24.100] Relaying remaining futures
[15:32:24.100] signalConditionsASAP(NULL, pos=0) ...
[15:32:24.100] - nx: 1
[15:32:24.100] - relay: TRUE
[15:32:24.101] - stdout: TRUE
[15:32:24.101] - signal: TRUE
[15:32:24.101] - resignal: FALSE
[15:32:24.101] - force: TRUE
[15:32:24.102] - relayed: [n=1] TRUE
[15:32:24.102] - queued futures: [n=1] TRUE
 - flush all
[15:32:24.103] - relayed: [n=1] TRUE
[15:32:24.103] - queued futures: [n=1] TRUE
[15:32:24.103] signalConditionsASAP(NULL, pos=0) ... done
[15:32:24.103] resolve() on list ... DONE
[15:32:24.104]  - Number of value chunks collected: 1
[15:32:24.104] Resolving 1 futures (chunks) ... DONE
[15:32:24.104] Reducing values from 1 chunks ...
[15:32:24.105]  - Number of values collected after concatenation: 4
[15:32:24.105]  - Number of values expected: 4
[15:32:24.105] Reducing values from 1 chunks ... DONE
[15:32:24.105] future_lapply() ... DONE
List of 2
 $ y0:List of 4
  ..$ A: num 50
  ..$ B: num 60
  ..$ C: num 70
  ..$ D: num 80
 $ y1:List of 4
  ..$ A: num 50
  ..$ B: num 60
  ..$ C: num 70
  ..$ D: num 80
List of 2
 $ y0:List of 4
  ..$ A: num 50
  ..$ B: num 60
  ..$ C: num 70
  ..$ D: num 80
 $ y2:List of 4
  ..$ A: num 50
  ..$ B: num 60
  ..$ C: num 70
  ..$ D: num 80
[15:32:24.118] future_lapply() ...
[15:32:24.119] Number of chunks: 1
[15:32:24.120] getGlobalsAndPackagesXApply() ...
[15:32:24.120]  - future.globals: TRUE
[15:32:24.120] getGlobalsAndPackages() ...
[15:32:24.120] Searching for globals...
[15:32:24.122] - globals found: [2] 'FUN', 'UseMethod'
[15:32:24.123] Searching for globals ... DONE
[15:32:24.123] Resolving globals: FALSE
[15:32:24.124] The total size of the 1 globals is 1.22 KiB (1248 bytes)
[15:32:24.124] The total size of the 1 globals exported for future expression ('FUN()') is 1.22 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.22 KiB of class 'function')
[15:32:24.125] - globals: [1] 'FUN'
[15:32:24.125] 
[15:32:24.125] getGlobalsAndPackages() ... DONE
[15:32:24.126]  - globals found/used: [n=1] 'FUN'
[15:32:24.126]  - needed namespaces: [n=0] 
[15:32:24.126] Finding globals ... DONE
[15:32:24.126]  - use_args: TRUE
[15:32:24.127]  - Getting '...' globals ...
[15:32:24.127] resolve() on list ...
[15:32:24.128]  recursive: 0
[15:32:24.128]  length: 1
[15:32:24.128]  elements: '...'
[15:32:24.129]  length: 0 (resolved future 1)
[15:32:24.129] resolve() on list ... DONE
[15:32:24.129]    - '...' content: [n=0] 
[15:32:24.129] List of 1
[15:32:24.129]  $ ...: list()
[15:32:24.129]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:24.129]  - attr(*, "where")=List of 1
[15:32:24.129]   ..$ ...:<environment: 0x00000276e4056568> 
[15:32:24.129]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:24.129]  - attr(*, "resolved")= logi TRUE
[15:32:24.129]  - attr(*, "total_size")= num NA
[15:32:24.134]  - Getting '...' globals ... DONE
[15:32:24.134] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:24.135] List of 2
[15:32:24.135]  $ ...future.FUN:function (x, ...)  
[15:32:24.135]  $ ...          : list()
[15:32:24.135]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:24.135]  - attr(*, "where")=List of 2
[15:32:24.135]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:24.135]   ..$ ...          :<environment: 0x00000276e4056568> 
[15:32:24.135]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:24.135]  - attr(*, "resolved")= logi FALSE
[15:32:24.135]  - attr(*, "total_size")= num 1248
[15:32:24.140] Packages to be attached in all futures: [n=0] 
[15:32:24.140] getGlobalsAndPackagesXApply() ... DONE
[15:32:24.141] Number of futures (= number of chunks): 1
[15:32:24.141] Launching 1 futures (chunks) ...
[15:32:24.141] Chunk #1 of 1 ...
[15:32:24.141]  - Finding globals in 'X' for chunk #1 ...
[15:32:24.142] getGlobalsAndPackages() ...
[15:32:24.142] Searching for globals...
[15:32:24.143] 
[15:32:24.143] Searching for globals ... DONE
[15:32:24.143] - globals: [0] <none>
[15:32:24.143] getGlobalsAndPackages() ... DONE
[15:32:24.144]    + additional globals found: [n=0] 
[15:32:24.144]    + additional namespaces needed: [n=0] 
[15:32:24.144]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:24.144]  - seeds: <none>
[15:32:24.145]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:24.145] getGlobalsAndPackages() ...
[15:32:24.145] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:24.146] Resolving globals: FALSE
[15:32:24.146] Tweak future expression to call with '...' arguments ...
[15:32:24.146] {
[15:32:24.146]     do.call(function(...) {
[15:32:24.146]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:24.146]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:24.146]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:24.146]             on.exit(options(oopts), add = TRUE)
[15:32:24.146]         }
[15:32:24.146]         {
[15:32:24.146]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:24.146]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:24.146]                 ...future.FUN(...future.X_jj, ...)
[15:32:24.146]             })
[15:32:24.146]         }
[15:32:24.146]     }, args = future.call.arguments)
[15:32:24.146] }
[15:32:24.147] Tweak future expression to call with '...' arguments ... DONE
[15:32:24.148] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:24.148] 
[15:32:24.148] getGlobalsAndPackages() ... DONE
[15:32:24.149] run() for 'Future' ...
[15:32:24.149] - state: 'created'
[15:32:24.150] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:24.150] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:24.151] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:24.151]   - Field: 'label'
[15:32:24.151]   - Field: 'local'
[15:32:24.151]   - Field: 'owner'
[15:32:24.152]   - Field: 'envir'
[15:32:24.152]   - Field: 'packages'
[15:32:24.152]   - Field: 'gc'
[15:32:24.153]   - Field: 'conditions'
[15:32:24.153]   - Field: 'expr'
[15:32:24.153]   - Field: 'uuid'
[15:32:24.154]   - Field: 'seed'
[15:32:24.154]   - Field: 'version'
[15:32:24.154]   - Field: 'result'
[15:32:24.154]   - Field: 'asynchronous'
[15:32:24.155]   - Field: 'calls'
[15:32:24.155]   - Field: 'globals'
[15:32:24.155]   - Field: 'stdout'
[15:32:24.156]   - Field: 'earlySignal'
[15:32:24.156]   - Field: 'lazy'
[15:32:24.156]   - Field: 'state'
[15:32:24.157] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:24.157] - Launch lazy future ...
[15:32:24.157] Packages needed by the future expression (n = 0): <none>
[15:32:24.158] Packages needed by future strategies (n = 0): <none>
[15:32:24.159] {
[15:32:24.159]     {
[15:32:24.159]         {
[15:32:24.159]             ...future.startTime <- base::Sys.time()
[15:32:24.159]             {
[15:32:24.159]                 {
[15:32:24.159]                   {
[15:32:24.159]                     base::local({
[15:32:24.159]                       has_future <- base::requireNamespace("future", 
[15:32:24.159]                         quietly = TRUE)
[15:32:24.159]                       if (has_future) {
[15:32:24.159]                         ns <- base::getNamespace("future")
[15:32:24.159]                         version <- ns[[".package"]][["version"]]
[15:32:24.159]                         if (is.null(version)) 
[15:32:24.159]                           version <- utils::packageVersion("future")
[15:32:24.159]                       }
[15:32:24.159]                       else {
[15:32:24.159]                         version <- NULL
[15:32:24.159]                       }
[15:32:24.159]                       if (!has_future || version < "1.8.0") {
[15:32:24.159]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:24.159]                           "", base::R.version$version.string), 
[15:32:24.159]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:24.159]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:24.159]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:24.159]                             "release", "version")], collapse = " "), 
[15:32:24.159]                           hostname = base::Sys.info()[["nodename"]])
[15:32:24.159]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:24.159]                           info)
[15:32:24.159]                         info <- base::paste(info, collapse = "; ")
[15:32:24.159]                         if (!has_future) {
[15:32:24.159]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:24.159]                             info)
[15:32:24.159]                         }
[15:32:24.159]                         else {
[15:32:24.159]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:24.159]                             info, version)
[15:32:24.159]                         }
[15:32:24.159]                         base::stop(msg)
[15:32:24.159]                       }
[15:32:24.159]                     })
[15:32:24.159]                   }
[15:32:24.159]                   ...future.strategy.old <- future::plan("list")
[15:32:24.159]                   options(future.plan = NULL)
[15:32:24.159]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:24.159]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:24.159]                 }
[15:32:24.159]                 ...future.workdir <- getwd()
[15:32:24.159]             }
[15:32:24.159]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:24.159]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:24.159]         }
[15:32:24.159]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:24.159]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:24.159]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:24.159]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:24.159]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:24.159]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:24.159]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:24.159]             base::names(...future.oldOptions))
[15:32:24.159]     }
[15:32:24.159]     if (FALSE) {
[15:32:24.159]     }
[15:32:24.159]     else {
[15:32:24.159]         if (TRUE) {
[15:32:24.159]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:24.159]                 open = "w")
[15:32:24.159]         }
[15:32:24.159]         else {
[15:32:24.159]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:24.159]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:24.159]         }
[15:32:24.159]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:24.159]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:24.159]             base::sink(type = "output", split = FALSE)
[15:32:24.159]             base::close(...future.stdout)
[15:32:24.159]         }, add = TRUE)
[15:32:24.159]     }
[15:32:24.159]     ...future.frame <- base::sys.nframe()
[15:32:24.159]     ...future.conditions <- base::list()
[15:32:24.159]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:24.159]     if (FALSE) {
[15:32:24.159]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:24.159]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:24.159]     }
[15:32:24.159]     ...future.result <- base::tryCatch({
[15:32:24.159]         base::withCallingHandlers({
[15:32:24.159]             ...future.value <- base::withVisible(base::local({
[15:32:24.159]                 do.call(function(...) {
[15:32:24.159]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:24.159]                   if (!identical(...future.globals.maxSize.org, 
[15:32:24.159]                     ...future.globals.maxSize)) {
[15:32:24.159]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:24.159]                     on.exit(options(oopts), add = TRUE)
[15:32:24.159]                   }
[15:32:24.159]                   {
[15:32:24.159]                     lapply(seq_along(...future.elements_ii), 
[15:32:24.159]                       FUN = function(jj) {
[15:32:24.159]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:24.159]                         ...future.FUN(...future.X_jj, ...)
[15:32:24.159]                       })
[15:32:24.159]                   }
[15:32:24.159]                 }, args = future.call.arguments)
[15:32:24.159]             }))
[15:32:24.159]             future::FutureResult(value = ...future.value$value, 
[15:32:24.159]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:24.159]                   ...future.rng), globalenv = if (FALSE) 
[15:32:24.159]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:24.159]                     ...future.globalenv.names))
[15:32:24.159]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:24.159]         }, condition = base::local({
[15:32:24.159]             c <- base::c
[15:32:24.159]             inherits <- base::inherits
[15:32:24.159]             invokeRestart <- base::invokeRestart
[15:32:24.159]             length <- base::length
[15:32:24.159]             list <- base::list
[15:32:24.159]             seq.int <- base::seq.int
[15:32:24.159]             signalCondition <- base::signalCondition
[15:32:24.159]             sys.calls <- base::sys.calls
[15:32:24.159]             `[[` <- base::`[[`
[15:32:24.159]             `+` <- base::`+`
[15:32:24.159]             `<<-` <- base::`<<-`
[15:32:24.159]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:24.159]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:24.159]                   3L)]
[15:32:24.159]             }
[15:32:24.159]             function(cond) {
[15:32:24.159]                 is_error <- inherits(cond, "error")
[15:32:24.159]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:24.159]                   NULL)
[15:32:24.159]                 if (is_error) {
[15:32:24.159]                   sessionInformation <- function() {
[15:32:24.159]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:24.159]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:24.159]                       search = base::search(), system = base::Sys.info())
[15:32:24.159]                   }
[15:32:24.159]                   ...future.conditions[[length(...future.conditions) + 
[15:32:24.159]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:24.159]                     cond$call), session = sessionInformation(), 
[15:32:24.159]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:24.159]                   signalCondition(cond)
[15:32:24.159]                 }
[15:32:24.159]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:24.159]                 "immediateCondition"))) {
[15:32:24.159]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:24.159]                   ...future.conditions[[length(...future.conditions) + 
[15:32:24.159]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:24.159]                   if (TRUE && !signal) {
[15:32:24.159]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:24.159]                     {
[15:32:24.159]                       inherits <- base::inherits
[15:32:24.159]                       invokeRestart <- base::invokeRestart
[15:32:24.159]                       is.null <- base::is.null
[15:32:24.159]                       muffled <- FALSE
[15:32:24.159]                       if (inherits(cond, "message")) {
[15:32:24.159]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:24.159]                         if (muffled) 
[15:32:24.159]                           invokeRestart("muffleMessage")
[15:32:24.159]                       }
[15:32:24.159]                       else if (inherits(cond, "warning")) {
[15:32:24.159]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:24.159]                         if (muffled) 
[15:32:24.159]                           invokeRestart("muffleWarning")
[15:32:24.159]                       }
[15:32:24.159]                       else if (inherits(cond, "condition")) {
[15:32:24.159]                         if (!is.null(pattern)) {
[15:32:24.159]                           computeRestarts <- base::computeRestarts
[15:32:24.159]                           grepl <- base::grepl
[15:32:24.159]                           restarts <- computeRestarts(cond)
[15:32:24.159]                           for (restart in restarts) {
[15:32:24.159]                             name <- restart$name
[15:32:24.159]                             if (is.null(name)) 
[15:32:24.159]                               next
[15:32:24.159]                             if (!grepl(pattern, name)) 
[15:32:24.159]                               next
[15:32:24.159]                             invokeRestart(restart)
[15:32:24.159]                             muffled <- TRUE
[15:32:24.159]                             break
[15:32:24.159]                           }
[15:32:24.159]                         }
[15:32:24.159]                       }
[15:32:24.159]                       invisible(muffled)
[15:32:24.159]                     }
[15:32:24.159]                     muffleCondition(cond, pattern = "^muffle")
[15:32:24.159]                   }
[15:32:24.159]                 }
[15:32:24.159]                 else {
[15:32:24.159]                   if (TRUE) {
[15:32:24.159]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:24.159]                     {
[15:32:24.159]                       inherits <- base::inherits
[15:32:24.159]                       invokeRestart <- base::invokeRestart
[15:32:24.159]                       is.null <- base::is.null
[15:32:24.159]                       muffled <- FALSE
[15:32:24.159]                       if (inherits(cond, "message")) {
[15:32:24.159]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:24.159]                         if (muffled) 
[15:32:24.159]                           invokeRestart("muffleMessage")
[15:32:24.159]                       }
[15:32:24.159]                       else if (inherits(cond, "warning")) {
[15:32:24.159]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:24.159]                         if (muffled) 
[15:32:24.159]                           invokeRestart("muffleWarning")
[15:32:24.159]                       }
[15:32:24.159]                       else if (inherits(cond, "condition")) {
[15:32:24.159]                         if (!is.null(pattern)) {
[15:32:24.159]                           computeRestarts <- base::computeRestarts
[15:32:24.159]                           grepl <- base::grepl
[15:32:24.159]                           restarts <- computeRestarts(cond)
[15:32:24.159]                           for (restart in restarts) {
[15:32:24.159]                             name <- restart$name
[15:32:24.159]                             if (is.null(name)) 
[15:32:24.159]                               next
[15:32:24.159]                             if (!grepl(pattern, name)) 
[15:32:24.159]                               next
[15:32:24.159]                             invokeRestart(restart)
[15:32:24.159]                             muffled <- TRUE
[15:32:24.159]                             break
[15:32:24.159]                           }
[15:32:24.159]                         }
[15:32:24.159]                       }
[15:32:24.159]                       invisible(muffled)
[15:32:24.159]                     }
[15:32:24.159]                     muffleCondition(cond, pattern = "^muffle")
[15:32:24.159]                   }
[15:32:24.159]                 }
[15:32:24.159]             }
[15:32:24.159]         }))
[15:32:24.159]     }, error = function(ex) {
[15:32:24.159]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:24.159]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:24.159]                 ...future.rng), started = ...future.startTime, 
[15:32:24.159]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:24.159]             version = "1.8"), class = "FutureResult")
[15:32:24.159]     }, finally = {
[15:32:24.159]         if (!identical(...future.workdir, getwd())) 
[15:32:24.159]             setwd(...future.workdir)
[15:32:24.159]         {
[15:32:24.159]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:24.159]                 ...future.oldOptions$nwarnings <- NULL
[15:32:24.159]             }
[15:32:24.159]             base::options(...future.oldOptions)
[15:32:24.159]             if (.Platform$OS.type == "windows") {
[15:32:24.159]                 old_names <- names(...future.oldEnvVars)
[15:32:24.159]                 envs <- base::Sys.getenv()
[15:32:24.159]                 names <- names(envs)
[15:32:24.159]                 common <- intersect(names, old_names)
[15:32:24.159]                 added <- setdiff(names, old_names)
[15:32:24.159]                 removed <- setdiff(old_names, names)
[15:32:24.159]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:24.159]                   envs[common]]
[15:32:24.159]                 NAMES <- toupper(changed)
[15:32:24.159]                 args <- list()
[15:32:24.159]                 for (kk in seq_along(NAMES)) {
[15:32:24.159]                   name <- changed[[kk]]
[15:32:24.159]                   NAME <- NAMES[[kk]]
[15:32:24.159]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:24.159]                     next
[15:32:24.159]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:24.159]                 }
[15:32:24.159]                 NAMES <- toupper(added)
[15:32:24.159]                 for (kk in seq_along(NAMES)) {
[15:32:24.159]                   name <- added[[kk]]
[15:32:24.159]                   NAME <- NAMES[[kk]]
[15:32:24.159]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:24.159]                     next
[15:32:24.159]                   args[[name]] <- ""
[15:32:24.159]                 }
[15:32:24.159]                 NAMES <- toupper(removed)
[15:32:24.159]                 for (kk in seq_along(NAMES)) {
[15:32:24.159]                   name <- removed[[kk]]
[15:32:24.159]                   NAME <- NAMES[[kk]]
[15:32:24.159]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:24.159]                     next
[15:32:24.159]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:24.159]                 }
[15:32:24.159]                 if (length(args) > 0) 
[15:32:24.159]                   base::do.call(base::Sys.setenv, args = args)
[15:32:24.159]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:24.159]             }
[15:32:24.159]             else {
[15:32:24.159]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:24.159]             }
[15:32:24.159]             {
[15:32:24.159]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:24.159]                   0L) {
[15:32:24.159]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:24.159]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:24.159]                   base::options(opts)
[15:32:24.159]                 }
[15:32:24.159]                 {
[15:32:24.159]                   {
[15:32:24.159]                     NULL
[15:32:24.159]                     RNGkind("Mersenne-Twister")
[15:32:24.159]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:24.159]                       inherits = FALSE)
[15:32:24.159]                   }
[15:32:24.159]                   options(future.plan = NULL)
[15:32:24.159]                   if (is.na(NA_character_)) 
[15:32:24.159]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:24.159]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:24.159]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:24.159]                     .init = FALSE)
[15:32:24.159]                 }
[15:32:24.159]             }
[15:32:24.159]         }
[15:32:24.159]     })
[15:32:24.159]     if (TRUE) {
[15:32:24.159]         base::sink(type = "output", split = FALSE)
[15:32:24.159]         if (TRUE) {
[15:32:24.159]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:24.159]         }
[15:32:24.159]         else {
[15:32:24.159]             ...future.result["stdout"] <- base::list(NULL)
[15:32:24.159]         }
[15:32:24.159]         base::close(...future.stdout)
[15:32:24.159]         ...future.stdout <- NULL
[15:32:24.159]     }
[15:32:24.159]     ...future.result$conditions <- ...future.conditions
[15:32:24.159]     ...future.result$finished <- base::Sys.time()
[15:32:24.159]     ...future.result
[15:32:24.159] }
[15:32:24.165] assign_globals() ...
[15:32:24.165] List of 5
[15:32:24.165]  $ ...future.FUN            :function (x, ...)  
[15:32:24.165]  $ future.call.arguments    : list()
[15:32:24.165]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:24.165]  $ ...future.elements_ii    :List of 4
[15:32:24.165]   ..$ A: num 50
[15:32:24.165]   ..$ B: num 60
[15:32:24.165]   ..$ C: num 70
[15:32:24.165]   ..$ D: num 80
[15:32:24.165]  $ ...future.seeds_ii       : NULL
[15:32:24.165]  $ ...future.globals.maxSize: NULL
[15:32:24.165]  - attr(*, "where")=List of 5
[15:32:24.165]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:24.165]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:24.165]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:24.165]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:24.165]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:24.165]  - attr(*, "resolved")= logi FALSE
[15:32:24.165]  - attr(*, "total_size")= num 1248
[15:32:24.165]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:24.165]  - attr(*, "already-done")= logi TRUE
[15:32:24.176] - copied '...future.FUN' to environment
[15:32:24.176] - copied 'future.call.arguments' to environment
[15:32:24.177] - copied '...future.elements_ii' to environment
[15:32:24.177] - copied '...future.seeds_ii' to environment
[15:32:24.177] - copied '...future.globals.maxSize' to environment
[15:32:24.177] assign_globals() ... done
[15:32:24.178] plan(): Setting new future strategy stack:
[15:32:24.178] List of future strategies:
[15:32:24.178] 1. sequential:
[15:32:24.178]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:24.178]    - tweaked: FALSE
[15:32:24.178]    - call: NULL
[15:32:24.179] plan(): nbrOfWorkers() = 1
[15:32:24.181] plan(): Setting new future strategy stack:
[15:32:24.182] List of future strategies:
[15:32:24.182] 1. sequential:
[15:32:24.182]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:24.182]    - tweaked: FALSE
[15:32:24.182]    - call: plan(strategy)
[15:32:24.183] plan(): nbrOfWorkers() = 1
[15:32:24.183] SequentialFuture started (and completed)
[15:32:24.183] - Launch lazy future ... done
[15:32:24.184] run() for 'SequentialFuture' ... done
[15:32:24.184] Created future:
[15:32:24.184] SequentialFuture:
[15:32:24.184] Label: 'future_sapply-1'
[15:32:24.184] Expression:
[15:32:24.184] {
[15:32:24.184]     do.call(function(...) {
[15:32:24.184]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:24.184]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:24.184]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:24.184]             on.exit(options(oopts), add = TRUE)
[15:32:24.184]         }
[15:32:24.184]         {
[15:32:24.184]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:24.184]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:24.184]                 ...future.FUN(...future.X_jj, ...)
[15:32:24.184]             })
[15:32:24.184]         }
[15:32:24.184]     }, args = future.call.arguments)
[15:32:24.184] }
[15:32:24.184] Lazy evaluation: FALSE
[15:32:24.184] Asynchronous evaluation: FALSE
[15:32:24.184] Local evaluation: TRUE
[15:32:24.184] Environment: R_GlobalEnv
[15:32:24.184] Capture standard output: TRUE
[15:32:24.184] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:24.184] Globals: 5 objects totaling 1.44 KiB (function '...future.FUN' of 1.22 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 224 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:24.184] Packages: <none>
[15:32:24.184] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:24.184] Resolved: TRUE
[15:32:24.184] Value: 896 bytes of class 'list'
[15:32:24.184] Early signaling: FALSE
[15:32:24.184] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:24.184] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:24.186] Chunk #1 of 1 ... DONE
[15:32:24.187] Launching 1 futures (chunks) ... DONE
[15:32:24.187] Resolving 1 futures (chunks) ...
[15:32:24.187] resolve() on list ...
[15:32:24.187]  recursive: 0
[15:32:24.188]  length: 1
[15:32:24.188] 
[15:32:24.188] resolved() for 'SequentialFuture' ...
[15:32:24.188] - state: 'finished'
[15:32:24.189] - run: TRUE
[15:32:24.189] - result: 'FutureResult'
[15:32:24.189] resolved() for 'SequentialFuture' ... done
[15:32:24.190] Future #1
[15:32:24.190] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:24.190] - nx: 1
[15:32:24.191] - relay: TRUE
[15:32:24.191] - stdout: TRUE
[15:32:24.191] - signal: TRUE
[15:32:24.191] - resignal: FALSE
[15:32:24.192] - force: TRUE
[15:32:24.192] - relayed: [n=1] FALSE
[15:32:24.192] - queued futures: [n=1] FALSE
[15:32:24.192]  - until=1
[15:32:24.193]  - relaying element #1
[15:32:24.193] - relayed: [n=1] TRUE
[15:32:24.193] - queued futures: [n=1] TRUE
[15:32:24.194] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:24.194]  length: 0 (resolved future 1)
[15:32:24.194] Relaying remaining futures
[15:32:24.195] signalConditionsASAP(NULL, pos=0) ...
[15:32:24.195] - nx: 1
[15:32:24.195] - relay: TRUE
[15:32:24.195] - stdout: TRUE
[15:32:24.196] - signal: TRUE
[15:32:24.196] - resignal: FALSE
[15:32:24.196] - force: TRUE
[15:32:24.196] - relayed: [n=1] TRUE
[15:32:24.197] - queued futures: [n=1] TRUE
 - flush all
[15:32:24.197] - relayed: [n=1] TRUE
[15:32:24.197] - queued futures: [n=1] TRUE
[15:32:24.198] signalConditionsASAP(NULL, pos=0) ... done
[15:32:24.198] resolve() on list ... DONE
[15:32:24.198]  - Number of value chunks collected: 1
[15:32:24.199] Resolving 1 futures (chunks) ... DONE
[15:32:24.199] Reducing values from 1 chunks ...
[15:32:24.199]  - Number of values collected after concatenation: 4
[15:32:24.199]  - Number of values expected: 4
[15:32:24.200] Reducing values from 1 chunks ... DONE
[15:32:24.200] future_lapply() ... DONE
List of 2
 $ y0:List of 4
  ..$ A: num [1, 1] 50
  ..$ B: num [1, 1] 60
  ..$ C: num [1, 1] 70
  ..$ D: num [1, 1] 80
 $ y1:List of 4
  ..$ A: num [1, 1] 50
  ..$ B: num [1, 1] 60
  ..$ C: num [1, 1] 70
  ..$ D: num [1, 1] 80
List of 2
 $ y0:List of 4
  ..$ A: num [1, 1] 50
  ..$ B: num [1, 1] 60
  ..$ C: num [1, 1] 70
  ..$ D: num [1, 1] 80
 $ y2:List of 4
  ..$ A: num [1, 1] 50
  ..$ B: num [1, 1] 60
  ..$ C: num [1, 1] 70
  ..$ D: num [1, 1] 80
[15:32:24.214] future_lapply() ...
[15:32:24.216] Number of chunks: 1
[15:32:24.216] getGlobalsAndPackagesXApply() ...
[15:32:24.217]  - future.globals: TRUE
[15:32:24.217] getGlobalsAndPackages() ...
[15:32:24.217] Searching for globals...
[15:32:24.220] - globals found: [5] 'FUN', '*', ':', 'outer', 'rep'
[15:32:24.220] Searching for globals ... DONE
[15:32:24.220] Resolving globals: FALSE
[15:32:24.221] The total size of the 1 globals is 4.62 KiB (4728 bytes)
[15:32:24.222] The total size of the 1 globals exported for future expression ('FUN()') is 4.62 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.62 KiB of class 'function')
[15:32:24.222] - globals: [1] 'FUN'
[15:32:24.223] 
[15:32:24.223] getGlobalsAndPackages() ... DONE
[15:32:24.223]  - globals found/used: [n=1] 'FUN'
[15:32:24.223]  - needed namespaces: [n=0] 
[15:32:24.224] Finding globals ... DONE
[15:32:24.224]  - use_args: TRUE
[15:32:24.224]  - Getting '...' globals ...
[15:32:24.225] resolve() on list ...
[15:32:24.225]  recursive: 0
[15:32:24.225]  length: 1
[15:32:24.226]  elements: '...'
[15:32:24.226]  length: 0 (resolved future 1)
[15:32:24.226] resolve() on list ... DONE
[15:32:24.226]    - '...' content: [n=0] 
[15:32:24.227] List of 1
[15:32:24.227]  $ ...: list()
[15:32:24.227]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:24.227]  - attr(*, "where")=List of 1
[15:32:24.227]   ..$ ...:<environment: 0x00000276e599f958> 
[15:32:24.227]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:24.227]  - attr(*, "resolved")= logi TRUE
[15:32:24.227]  - attr(*, "total_size")= num NA
[15:32:24.234]  - Getting '...' globals ... DONE
[15:32:24.234] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:24.235] List of 2
[15:32:24.235]  $ ...future.FUN:function (x, y = 2 * 1:5)  
[15:32:24.235]  $ ...          : list()
[15:32:24.235]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:24.235]  - attr(*, "where")=List of 2
[15:32:24.235]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:24.235]   ..$ ...          :<environment: 0x00000276e599f958> 
[15:32:24.235]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:24.235]  - attr(*, "resolved")= logi FALSE
[15:32:24.235]  - attr(*, "total_size")= num 4728
[15:32:24.239] Packages to be attached in all futures: [n=0] 
[15:32:24.240] getGlobalsAndPackagesXApply() ... DONE
[15:32:24.240] Number of futures (= number of chunks): 1
[15:32:24.240] Launching 1 futures (chunks) ...
[15:32:24.241] Chunk #1 of 1 ...
[15:32:24.241]  - Finding globals in 'X' for chunk #1 ...
[15:32:24.241] getGlobalsAndPackages() ...
[15:32:24.242] Searching for globals...
[15:32:24.242] 
[15:32:24.242] Searching for globals ... DONE
[15:32:24.243] - globals: [0] <none>
[15:32:24.243] getGlobalsAndPackages() ... DONE
[15:32:24.243]    + additional globals found: [n=0] 
[15:32:24.243]    + additional namespaces needed: [n=0] 
[15:32:24.244]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:24.244]  - seeds: <none>
[15:32:24.244]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:24.244] getGlobalsAndPackages() ...
[15:32:24.245] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:24.245] Resolving globals: FALSE
[15:32:24.245] Tweak future expression to call with '...' arguments ...
[15:32:24.246] {
[15:32:24.246]     do.call(function(...) {
[15:32:24.246]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:24.246]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:24.246]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:24.246]             on.exit(options(oopts), add = TRUE)
[15:32:24.246]         }
[15:32:24.246]         {
[15:32:24.246]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:24.246]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:24.246]                 ...future.FUN(...future.X_jj, ...)
[15:32:24.246]             })
[15:32:24.246]         }
[15:32:24.246]     }, args = future.call.arguments)
[15:32:24.246] }
[15:32:24.246] Tweak future expression to call with '...' arguments ... DONE
[15:32:24.247] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:24.247] 
[15:32:24.247] getGlobalsAndPackages() ... DONE
[15:32:24.248] run() for 'Future' ...
[15:32:24.248] - state: 'created'
[15:32:24.249] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:24.249] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:24.250] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:24.250]   - Field: 'label'
[15:32:24.250]   - Field: 'local'
[15:32:24.250]   - Field: 'owner'
[15:32:24.251]   - Field: 'envir'
[15:32:24.251]   - Field: 'packages'
[15:32:24.251]   - Field: 'gc'
[15:32:24.252]   - Field: 'conditions'
[15:32:24.252]   - Field: 'expr'
[15:32:24.252]   - Field: 'uuid'
[15:32:24.252]   - Field: 'seed'
[15:32:24.253]   - Field: 'version'
[15:32:24.253]   - Field: 'result'
[15:32:24.253]   - Field: 'asynchronous'
[15:32:24.254]   - Field: 'calls'
[15:32:24.254]   - Field: 'globals'
[15:32:24.254]   - Field: 'stdout'
[15:32:24.254]   - Field: 'earlySignal'
[15:32:24.255]   - Field: 'lazy'
[15:32:24.255]   - Field: 'state'
[15:32:24.255] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:24.256] - Launch lazy future ...
[15:32:24.256] Packages needed by the future expression (n = 0): <none>
[15:32:24.256] Packages needed by future strategies (n = 0): <none>
[15:32:24.257] {
[15:32:24.257]     {
[15:32:24.257]         {
[15:32:24.257]             ...future.startTime <- base::Sys.time()
[15:32:24.257]             {
[15:32:24.257]                 {
[15:32:24.257]                   {
[15:32:24.257]                     base::local({
[15:32:24.257]                       has_future <- base::requireNamespace("future", 
[15:32:24.257]                         quietly = TRUE)
[15:32:24.257]                       if (has_future) {
[15:32:24.257]                         ns <- base::getNamespace("future")
[15:32:24.257]                         version <- ns[[".package"]][["version"]]
[15:32:24.257]                         if (is.null(version)) 
[15:32:24.257]                           version <- utils::packageVersion("future")
[15:32:24.257]                       }
[15:32:24.257]                       else {
[15:32:24.257]                         version <- NULL
[15:32:24.257]                       }
[15:32:24.257]                       if (!has_future || version < "1.8.0") {
[15:32:24.257]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:24.257]                           "", base::R.version$version.string), 
[15:32:24.257]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:24.257]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:24.257]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:24.257]                             "release", "version")], collapse = " "), 
[15:32:24.257]                           hostname = base::Sys.info()[["nodename"]])
[15:32:24.257]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:24.257]                           info)
[15:32:24.257]                         info <- base::paste(info, collapse = "; ")
[15:32:24.257]                         if (!has_future) {
[15:32:24.257]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:24.257]                             info)
[15:32:24.257]                         }
[15:32:24.257]                         else {
[15:32:24.257]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:24.257]                             info, version)
[15:32:24.257]                         }
[15:32:24.257]                         base::stop(msg)
[15:32:24.257]                       }
[15:32:24.257]                     })
[15:32:24.257]                   }
[15:32:24.257]                   ...future.strategy.old <- future::plan("list")
[15:32:24.257]                   options(future.plan = NULL)
[15:32:24.257]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:24.257]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:24.257]                 }
[15:32:24.257]                 ...future.workdir <- getwd()
[15:32:24.257]             }
[15:32:24.257]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:24.257]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:24.257]         }
[15:32:24.257]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:24.257]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:24.257]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:24.257]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:24.257]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:24.257]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:24.257]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:24.257]             base::names(...future.oldOptions))
[15:32:24.257]     }
[15:32:24.257]     if (FALSE) {
[15:32:24.257]     }
[15:32:24.257]     else {
[15:32:24.257]         if (TRUE) {
[15:32:24.257]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:24.257]                 open = "w")
[15:32:24.257]         }
[15:32:24.257]         else {
[15:32:24.257]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:24.257]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:24.257]         }
[15:32:24.257]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:24.257]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:24.257]             base::sink(type = "output", split = FALSE)
[15:32:24.257]             base::close(...future.stdout)
[15:32:24.257]         }, add = TRUE)
[15:32:24.257]     }
[15:32:24.257]     ...future.frame <- base::sys.nframe()
[15:32:24.257]     ...future.conditions <- base::list()
[15:32:24.257]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:24.257]     if (FALSE) {
[15:32:24.257]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:24.257]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:24.257]     }
[15:32:24.257]     ...future.result <- base::tryCatch({
[15:32:24.257]         base::withCallingHandlers({
[15:32:24.257]             ...future.value <- base::withVisible(base::local({
[15:32:24.257]                 do.call(function(...) {
[15:32:24.257]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:24.257]                   if (!identical(...future.globals.maxSize.org, 
[15:32:24.257]                     ...future.globals.maxSize)) {
[15:32:24.257]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:24.257]                     on.exit(options(oopts), add = TRUE)
[15:32:24.257]                   }
[15:32:24.257]                   {
[15:32:24.257]                     lapply(seq_along(...future.elements_ii), 
[15:32:24.257]                       FUN = function(jj) {
[15:32:24.257]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:24.257]                         ...future.FUN(...future.X_jj, ...)
[15:32:24.257]                       })
[15:32:24.257]                   }
[15:32:24.257]                 }, args = future.call.arguments)
[15:32:24.257]             }))
[15:32:24.257]             future::FutureResult(value = ...future.value$value, 
[15:32:24.257]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:24.257]                   ...future.rng), globalenv = if (FALSE) 
[15:32:24.257]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:24.257]                     ...future.globalenv.names))
[15:32:24.257]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:24.257]         }, condition = base::local({
[15:32:24.257]             c <- base::c
[15:32:24.257]             inherits <- base::inherits
[15:32:24.257]             invokeRestart <- base::invokeRestart
[15:32:24.257]             length <- base::length
[15:32:24.257]             list <- base::list
[15:32:24.257]             seq.int <- base::seq.int
[15:32:24.257]             signalCondition <- base::signalCondition
[15:32:24.257]             sys.calls <- base::sys.calls
[15:32:24.257]             `[[` <- base::`[[`
[15:32:24.257]             `+` <- base::`+`
[15:32:24.257]             `<<-` <- base::`<<-`
[15:32:24.257]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:24.257]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:24.257]                   3L)]
[15:32:24.257]             }
[15:32:24.257]             function(cond) {
[15:32:24.257]                 is_error <- inherits(cond, "error")
[15:32:24.257]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:24.257]                   NULL)
[15:32:24.257]                 if (is_error) {
[15:32:24.257]                   sessionInformation <- function() {
[15:32:24.257]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:24.257]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:24.257]                       search = base::search(), system = base::Sys.info())
[15:32:24.257]                   }
[15:32:24.257]                   ...future.conditions[[length(...future.conditions) + 
[15:32:24.257]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:24.257]                     cond$call), session = sessionInformation(), 
[15:32:24.257]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:24.257]                   signalCondition(cond)
[15:32:24.257]                 }
[15:32:24.257]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:24.257]                 "immediateCondition"))) {
[15:32:24.257]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:24.257]                   ...future.conditions[[length(...future.conditions) + 
[15:32:24.257]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:24.257]                   if (TRUE && !signal) {
[15:32:24.257]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:24.257]                     {
[15:32:24.257]                       inherits <- base::inherits
[15:32:24.257]                       invokeRestart <- base::invokeRestart
[15:32:24.257]                       is.null <- base::is.null
[15:32:24.257]                       muffled <- FALSE
[15:32:24.257]                       if (inherits(cond, "message")) {
[15:32:24.257]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:24.257]                         if (muffled) 
[15:32:24.257]                           invokeRestart("muffleMessage")
[15:32:24.257]                       }
[15:32:24.257]                       else if (inherits(cond, "warning")) {
[15:32:24.257]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:24.257]                         if (muffled) 
[15:32:24.257]                           invokeRestart("muffleWarning")
[15:32:24.257]                       }
[15:32:24.257]                       else if (inherits(cond, "condition")) {
[15:32:24.257]                         if (!is.null(pattern)) {
[15:32:24.257]                           computeRestarts <- base::computeRestarts
[15:32:24.257]                           grepl <- base::grepl
[15:32:24.257]                           restarts <- computeRestarts(cond)
[15:32:24.257]                           for (restart in restarts) {
[15:32:24.257]                             name <- restart$name
[15:32:24.257]                             if (is.null(name)) 
[15:32:24.257]                               next
[15:32:24.257]                             if (!grepl(pattern, name)) 
[15:32:24.257]                               next
[15:32:24.257]                             invokeRestart(restart)
[15:32:24.257]                             muffled <- TRUE
[15:32:24.257]                             break
[15:32:24.257]                           }
[15:32:24.257]                         }
[15:32:24.257]                       }
[15:32:24.257]                       invisible(muffled)
[15:32:24.257]                     }
[15:32:24.257]                     muffleCondition(cond, pattern = "^muffle")
[15:32:24.257]                   }
[15:32:24.257]                 }
[15:32:24.257]                 else {
[15:32:24.257]                   if (TRUE) {
[15:32:24.257]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:24.257]                     {
[15:32:24.257]                       inherits <- base::inherits
[15:32:24.257]                       invokeRestart <- base::invokeRestart
[15:32:24.257]                       is.null <- base::is.null
[15:32:24.257]                       muffled <- FALSE
[15:32:24.257]                       if (inherits(cond, "message")) {
[15:32:24.257]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:24.257]                         if (muffled) 
[15:32:24.257]                           invokeRestart("muffleMessage")
[15:32:24.257]                       }
[15:32:24.257]                       else if (inherits(cond, "warning")) {
[15:32:24.257]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:24.257]                         if (muffled) 
[15:32:24.257]                           invokeRestart("muffleWarning")
[15:32:24.257]                       }
[15:32:24.257]                       else if (inherits(cond, "condition")) {
[15:32:24.257]                         if (!is.null(pattern)) {
[15:32:24.257]                           computeRestarts <- base::computeRestarts
[15:32:24.257]                           grepl <- base::grepl
[15:32:24.257]                           restarts <- computeRestarts(cond)
[15:32:24.257]                           for (restart in restarts) {
[15:32:24.257]                             name <- restart$name
[15:32:24.257]                             if (is.null(name)) 
[15:32:24.257]                               next
[15:32:24.257]                             if (!grepl(pattern, name)) 
[15:32:24.257]                               next
[15:32:24.257]                             invokeRestart(restart)
[15:32:24.257]                             muffled <- TRUE
[15:32:24.257]                             break
[15:32:24.257]                           }
[15:32:24.257]                         }
[15:32:24.257]                       }
[15:32:24.257]                       invisible(muffled)
[15:32:24.257]                     }
[15:32:24.257]                     muffleCondition(cond, pattern = "^muffle")
[15:32:24.257]                   }
[15:32:24.257]                 }
[15:32:24.257]             }
[15:32:24.257]         }))
[15:32:24.257]     }, error = function(ex) {
[15:32:24.257]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:24.257]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:24.257]                 ...future.rng), started = ...future.startTime, 
[15:32:24.257]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:24.257]             version = "1.8"), class = "FutureResult")
[15:32:24.257]     }, finally = {
[15:32:24.257]         if (!identical(...future.workdir, getwd())) 
[15:32:24.257]             setwd(...future.workdir)
[15:32:24.257]         {
[15:32:24.257]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:24.257]                 ...future.oldOptions$nwarnings <- NULL
[15:32:24.257]             }
[15:32:24.257]             base::options(...future.oldOptions)
[15:32:24.257]             if (.Platform$OS.type == "windows") {
[15:32:24.257]                 old_names <- names(...future.oldEnvVars)
[15:32:24.257]                 envs <- base::Sys.getenv()
[15:32:24.257]                 names <- names(envs)
[15:32:24.257]                 common <- intersect(names, old_names)
[15:32:24.257]                 added <- setdiff(names, old_names)
[15:32:24.257]                 removed <- setdiff(old_names, names)
[15:32:24.257]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:24.257]                   envs[common]]
[15:32:24.257]                 NAMES <- toupper(changed)
[15:32:24.257]                 args <- list()
[15:32:24.257]                 for (kk in seq_along(NAMES)) {
[15:32:24.257]                   name <- changed[[kk]]
[15:32:24.257]                   NAME <- NAMES[[kk]]
[15:32:24.257]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:24.257]                     next
[15:32:24.257]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:24.257]                 }
[15:32:24.257]                 NAMES <- toupper(added)
[15:32:24.257]                 for (kk in seq_along(NAMES)) {
[15:32:24.257]                   name <- added[[kk]]
[15:32:24.257]                   NAME <- NAMES[[kk]]
[15:32:24.257]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:24.257]                     next
[15:32:24.257]                   args[[name]] <- ""
[15:32:24.257]                 }
[15:32:24.257]                 NAMES <- toupper(removed)
[15:32:24.257]                 for (kk in seq_along(NAMES)) {
[15:32:24.257]                   name <- removed[[kk]]
[15:32:24.257]                   NAME <- NAMES[[kk]]
[15:32:24.257]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:24.257]                     next
[15:32:24.257]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:24.257]                 }
[15:32:24.257]                 if (length(args) > 0) 
[15:32:24.257]                   base::do.call(base::Sys.setenv, args = args)
[15:32:24.257]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:24.257]             }
[15:32:24.257]             else {
[15:32:24.257]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:24.257]             }
[15:32:24.257]             {
[15:32:24.257]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:24.257]                   0L) {
[15:32:24.257]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:24.257]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:24.257]                   base::options(opts)
[15:32:24.257]                 }
[15:32:24.257]                 {
[15:32:24.257]                   {
[15:32:24.257]                     NULL
[15:32:24.257]                     RNGkind("Mersenne-Twister")
[15:32:24.257]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:24.257]                       inherits = FALSE)
[15:32:24.257]                   }
[15:32:24.257]                   options(future.plan = NULL)
[15:32:24.257]                   if (is.na(NA_character_)) 
[15:32:24.257]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:24.257]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:24.257]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:24.257]                     .init = FALSE)
[15:32:24.257]                 }
[15:32:24.257]             }
[15:32:24.257]         }
[15:32:24.257]     })
[15:32:24.257]     if (TRUE) {
[15:32:24.257]         base::sink(type = "output", split = FALSE)
[15:32:24.257]         if (TRUE) {
[15:32:24.257]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:24.257]         }
[15:32:24.257]         else {
[15:32:24.257]             ...future.result["stdout"] <- base::list(NULL)
[15:32:24.257]         }
[15:32:24.257]         base::close(...future.stdout)
[15:32:24.257]         ...future.stdout <- NULL
[15:32:24.257]     }
[15:32:24.257]     ...future.result$conditions <- ...future.conditions
[15:32:24.257]     ...future.result$finished <- base::Sys.time()
[15:32:24.257]     ...future.result
[15:32:24.257] }
[15:32:24.263] assign_globals() ...
[15:32:24.264] List of 5
[15:32:24.264]  $ ...future.FUN            :function (x, y = 2 * 1:5)  
[15:32:24.264]  $ future.call.arguments    : list()
[15:32:24.264]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:24.264]  $ ...future.elements_ii    :List of 4
[15:32:24.264]   ..$ A: num 50
[15:32:24.264]   ..$ B: num 60
[15:32:24.264]   ..$ C: num 70
[15:32:24.264]   ..$ D: num 80
[15:32:24.264]  $ ...future.seeds_ii       : NULL
[15:32:24.264]  $ ...future.globals.maxSize: NULL
[15:32:24.264]  - attr(*, "where")=List of 5
[15:32:24.264]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:24.264]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:24.264]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:24.264]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:24.264]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:24.264]  - attr(*, "resolved")= logi FALSE
[15:32:24.264]  - attr(*, "total_size")= num 4728
[15:32:24.264]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:24.264]  - attr(*, "already-done")= logi TRUE
[15:32:24.274] - reassign environment for '...future.FUN'
[15:32:24.274] - copied '...future.FUN' to environment
[15:32:24.274] - copied 'future.call.arguments' to environment
[15:32:24.275] - copied '...future.elements_ii' to environment
[15:32:24.275] - copied '...future.seeds_ii' to environment
[15:32:24.275] - copied '...future.globals.maxSize' to environment
[15:32:24.276] assign_globals() ... done
[15:32:24.276] plan(): Setting new future strategy stack:
[15:32:24.276] List of future strategies:
[15:32:24.276] 1. sequential:
[15:32:24.276]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:24.276]    - tweaked: FALSE
[15:32:24.276]    - call: NULL
[15:32:24.277] plan(): nbrOfWorkers() = 1
[15:32:24.279] plan(): Setting new future strategy stack:
[15:32:24.280] List of future strategies:
[15:32:24.280] 1. sequential:
[15:32:24.280]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:24.280]    - tweaked: FALSE
[15:32:24.280]    - call: plan(strategy)
[15:32:24.281] plan(): nbrOfWorkers() = 1
[15:32:24.281] SequentialFuture started (and completed)
[15:32:24.281] - Launch lazy future ... done
[15:32:24.282] run() for 'SequentialFuture' ... done
[15:32:24.282] Created future:
[15:32:24.282] SequentialFuture:
[15:32:24.282] Label: 'future_sapply-1'
[15:32:24.282] Expression:
[15:32:24.282] {
[15:32:24.282]     do.call(function(...) {
[15:32:24.282]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:24.282]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:24.282]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:24.282]             on.exit(options(oopts), add = TRUE)
[15:32:24.282]         }
[15:32:24.282]         {
[15:32:24.282]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:24.282]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:24.282]                 ...future.FUN(...future.X_jj, ...)
[15:32:24.282]             })
[15:32:24.282]         }
[15:32:24.282]     }, args = future.call.arguments)
[15:32:24.282] }
[15:32:24.282] Lazy evaluation: FALSE
[15:32:24.282] Asynchronous evaluation: FALSE
[15:32:24.282] Local evaluation: TRUE
[15:32:24.282] Environment: R_GlobalEnv
[15:32:24.282] Capture standard output: TRUE
[15:32:24.282] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:24.282] Globals: 5 objects totaling 4.84 KiB (function '...future.FUN' of 4.62 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 224 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:24.282] Packages: <none>
[15:32:24.282] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:24.282] Resolved: TRUE
[15:32:24.282] Value: 1.34 KiB of class 'list'
[15:32:24.282] Early signaling: FALSE
[15:32:24.282] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:24.282] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:24.284] Chunk #1 of 1 ... DONE
[15:32:24.284] Launching 1 futures (chunks) ... DONE
[15:32:24.285] Resolving 1 futures (chunks) ...
[15:32:24.285] resolve() on list ...
[15:32:24.285]  recursive: 0
[15:32:24.285]  length: 1
[15:32:24.286] 
[15:32:24.286] resolved() for 'SequentialFuture' ...
[15:32:24.286] - state: 'finished'
[15:32:24.287] - run: TRUE
[15:32:24.287] - result: 'FutureResult'
[15:32:24.287] resolved() for 'SequentialFuture' ... done
[15:32:24.287] Future #1
[15:32:24.288] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:24.288] - nx: 1
[15:32:24.288] - relay: TRUE
[15:32:24.289] - stdout: TRUE
[15:32:24.289] - signal: TRUE
[15:32:24.289] - resignal: FALSE
[15:32:24.289] - force: TRUE
[15:32:24.290] - relayed: [n=1] FALSE
[15:32:24.290] - queued futures: [n=1] FALSE
[15:32:24.290]  - until=1
[15:32:24.290]  - relaying element #1
[15:32:24.291] - relayed: [n=1] TRUE
[15:32:24.291] - queued futures: [n=1] TRUE
[15:32:24.291] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:24.292]  length: 0 (resolved future 1)
[15:32:24.292] Relaying remaining futures
[15:32:24.292] signalConditionsASAP(NULL, pos=0) ...
[15:32:24.292] - nx: 1
[15:32:24.293] - relay: TRUE
[15:32:24.293] - stdout: TRUE
[15:32:24.293] - signal: TRUE
[15:32:24.293] - resignal: FALSE
[15:32:24.294] - force: TRUE
[15:32:24.294] - relayed: [n=1] TRUE
[15:32:24.294] - queued futures: [n=1] TRUE
 - flush all
[15:32:24.295] - relayed: [n=1] TRUE
[15:32:24.295] - queued futures: [n=1] TRUE
[15:32:24.295] signalConditionsASAP(NULL, pos=0) ... done
[15:32:24.295] resolve() on list ... DONE
[15:32:24.296]  - Number of value chunks collected: 1
[15:32:24.296] Resolving 1 futures (chunks) ... DONE
[15:32:24.296] Reducing values from 1 chunks ...
[15:32:24.297]  - Number of values collected after concatenation: 4
[15:32:24.297]  - Number of values expected: 4
[15:32:24.297] Reducing values from 1 chunks ... DONE
[15:32:24.297] future_lapply() ... DONE
List of 2
 $ y0:List of 4
  ..$ A: num [1:3, 1:5] 100 100 100 200 200 200 300 300 300 400 ...
  ..$ B: num [1:3, 1:5] 120 120 120 240 240 240 360 360 360 480 ...
  ..$ C: num [1:3, 1:5] 140 140 140 280 280 280 420 420 420 560 ...
  ..$ D: num [1:3, 1:5] 160 160 160 320 320 320 480 480 480 640 ...
 $ y1:List of 4
  ..$ A: num [1:3, 1:5] 100 100 100 200 200 200 300 300 300 400 ...
  ..$ B: num [1:3, 1:5] 120 120 120 240 240 240 360 360 360 480 ...
  ..$ C: num [1:3, 1:5] 140 140 140 280 280 280 420 420 420 560 ...
  ..$ D: num [1:3, 1:5] 160 160 160 320 320 320 480 480 480 640 ...
List of 2
 $ y0:List of 4
  ..$ A: num [1:3, 1:5] 100 100 100 200 200 200 300 300 300 400 ...
  ..$ B: num [1:3, 1:5] 120 120 120 240 240 240 360 360 360 480 ...
  ..$ C: num [1:3, 1:5] 140 140 140 280 280 280 420 420 420 560 ...
  ..$ D: num [1:3, 1:5] 160 160 160 320 320 320 480 480 480 640 ...
 $ y2:List of 4
  ..$ A: num [1:3, 1:5] 100 100 100 200 200 200 300 300 300 400 ...
  ..$ B: num [1:3, 1:5] 120 120 120 240 240 240 360 360 360 480 ...
  ..$ C: num [1:3, 1:5] 140 140 140 280 280 280 420 420 420 560 ...
  ..$ D: num [1:3, 1:5] 160 160 160 320 320 320 480 480 480 640 ...
[15:32:24.312] future_lapply() ...
[15:32:24.313] Number of chunks: 1
[15:32:24.313] getGlobalsAndPackagesXApply() ...
[15:32:24.313]  - future.globals: TRUE
[15:32:24.314] getGlobalsAndPackages() ...
[15:32:24.314] Searching for globals...
[15:32:24.316] - globals found: [1] 'FUN'
[15:32:24.316] Searching for globals ... DONE
[15:32:24.316] Resolving globals: FALSE
[15:32:24.317] The total size of the 1 globals is 848 bytes (848 bytes)
[15:32:24.318] The total size of the 1 globals exported for future expression ('FUN()') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:32:24.318] - globals: [1] 'FUN'
[15:32:24.318] 
[15:32:24.319] getGlobalsAndPackages() ... DONE
[15:32:24.319]  - globals found/used: [n=1] 'FUN'
[15:32:24.319]  - needed namespaces: [n=0] 
[15:32:24.319] Finding globals ... DONE
[15:32:24.320]  - use_args: TRUE
[15:32:24.320]  - Getting '...' globals ...
[15:32:24.321] resolve() on list ...
[15:32:24.321]  recursive: 0
[15:32:24.321]  length: 1
[15:32:24.321]  elements: '...'
[15:32:24.322]  length: 0 (resolved future 1)
[15:32:24.322] resolve() on list ... DONE
[15:32:24.322]    - '...' content: [n=0] 
[15:32:24.322] List of 1
[15:32:24.322]  $ ...: list()
[15:32:24.322]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:24.322]  - attr(*, "where")=List of 1
[15:32:24.322]   ..$ ...:<environment: 0x00000276e479b488> 
[15:32:24.322]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:24.322]  - attr(*, "resolved")= logi TRUE
[15:32:24.322]  - attr(*, "total_size")= num NA
[15:32:24.327]  - Getting '...' globals ... DONE
[15:32:24.328] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:24.328] List of 2
[15:32:24.328]  $ ...future.FUN:function (x)  
[15:32:24.328]  $ ...          : list()
[15:32:24.328]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:24.328]  - attr(*, "where")=List of 2
[15:32:24.328]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:24.328]   ..$ ...          :<environment: 0x00000276e479b488> 
[15:32:24.328]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:24.328]  - attr(*, "resolved")= logi FALSE
[15:32:24.328]  - attr(*, "total_size")= num 848
[15:32:24.333] Packages to be attached in all futures: [n=0] 
[15:32:24.333] getGlobalsAndPackagesXApply() ... DONE
[15:32:24.334] Number of futures (= number of chunks): 1
[15:32:24.334] Launching 1 futures (chunks) ...
[15:32:24.334] Chunk #1 of 1 ...
[15:32:24.335]  - Finding globals in 'X' for chunk #1 ...
[15:32:24.335] getGlobalsAndPackages() ...
[15:32:24.335] Searching for globals...
[15:32:24.336] 
[15:32:24.336] Searching for globals ... DONE
[15:32:24.336] - globals: [0] <none>
[15:32:24.336] getGlobalsAndPackages() ... DONE
[15:32:24.337]    + additional globals found: [n=0] 
[15:32:24.337]    + additional namespaces needed: [n=0] 
[15:32:24.337]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:24.337]  - seeds: <none>
[15:32:24.338]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:24.338] getGlobalsAndPackages() ...
[15:32:24.338] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:24.339] Resolving globals: FALSE
[15:32:24.339] Tweak future expression to call with '...' arguments ...
[15:32:24.339] {
[15:32:24.339]     do.call(function(...) {
[15:32:24.339]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:24.339]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:24.339]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:24.339]             on.exit(options(oopts), add = TRUE)
[15:32:24.339]         }
[15:32:24.339]         {
[15:32:24.339]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:24.339]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:24.339]                 ...future.FUN(...future.X_jj, ...)
[15:32:24.339]             })
[15:32:24.339]         }
[15:32:24.339]     }, args = future.call.arguments)
[15:32:24.339] }
[15:32:24.340] Tweak future expression to call with '...' arguments ... DONE
[15:32:24.341] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:24.341] 
[15:32:24.341] getGlobalsAndPackages() ... DONE
[15:32:24.342] run() for 'Future' ...
[15:32:24.342] - state: 'created'
[15:32:24.342] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:24.343] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:24.343] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:24.344]   - Field: 'label'
[15:32:24.344]   - Field: 'local'
[15:32:24.344]   - Field: 'owner'
[15:32:24.344]   - Field: 'envir'
[15:32:24.345]   - Field: 'packages'
[15:32:24.345]   - Field: 'gc'
[15:32:24.345]   - Field: 'conditions'
[15:32:24.346]   - Field: 'expr'
[15:32:24.346]   - Field: 'uuid'
[15:32:24.346]   - Field: 'seed'
[15:32:24.346]   - Field: 'version'
[15:32:24.347]   - Field: 'result'
[15:32:24.347]   - Field: 'asynchronous'
[15:32:24.347]   - Field: 'calls'
[15:32:24.348]   - Field: 'globals'
[15:32:24.348]   - Field: 'stdout'
[15:32:24.348]   - Field: 'earlySignal'
[15:32:24.348]   - Field: 'lazy'
[15:32:24.349]   - Field: 'state'
[15:32:24.349] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:24.349] - Launch lazy future ...
[15:32:24.350] Packages needed by the future expression (n = 0): <none>
[15:32:24.350] Packages needed by future strategies (n = 0): <none>
[15:32:24.351] {
[15:32:24.351]     {
[15:32:24.351]         {
[15:32:24.351]             ...future.startTime <- base::Sys.time()
[15:32:24.351]             {
[15:32:24.351]                 {
[15:32:24.351]                   {
[15:32:24.351]                     base::local({
[15:32:24.351]                       has_future <- base::requireNamespace("future", 
[15:32:24.351]                         quietly = TRUE)
[15:32:24.351]                       if (has_future) {
[15:32:24.351]                         ns <- base::getNamespace("future")
[15:32:24.351]                         version <- ns[[".package"]][["version"]]
[15:32:24.351]                         if (is.null(version)) 
[15:32:24.351]                           version <- utils::packageVersion("future")
[15:32:24.351]                       }
[15:32:24.351]                       else {
[15:32:24.351]                         version <- NULL
[15:32:24.351]                       }
[15:32:24.351]                       if (!has_future || version < "1.8.0") {
[15:32:24.351]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:24.351]                           "", base::R.version$version.string), 
[15:32:24.351]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:24.351]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:24.351]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:24.351]                             "release", "version")], collapse = " "), 
[15:32:24.351]                           hostname = base::Sys.info()[["nodename"]])
[15:32:24.351]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:24.351]                           info)
[15:32:24.351]                         info <- base::paste(info, collapse = "; ")
[15:32:24.351]                         if (!has_future) {
[15:32:24.351]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:24.351]                             info)
[15:32:24.351]                         }
[15:32:24.351]                         else {
[15:32:24.351]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:24.351]                             info, version)
[15:32:24.351]                         }
[15:32:24.351]                         base::stop(msg)
[15:32:24.351]                       }
[15:32:24.351]                     })
[15:32:24.351]                   }
[15:32:24.351]                   ...future.strategy.old <- future::plan("list")
[15:32:24.351]                   options(future.plan = NULL)
[15:32:24.351]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:24.351]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:24.351]                 }
[15:32:24.351]                 ...future.workdir <- getwd()
[15:32:24.351]             }
[15:32:24.351]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:24.351]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:24.351]         }
[15:32:24.351]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:24.351]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:24.351]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:24.351]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:24.351]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:24.351]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:24.351]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:24.351]             base::names(...future.oldOptions))
[15:32:24.351]     }
[15:32:24.351]     if (FALSE) {
[15:32:24.351]     }
[15:32:24.351]     else {
[15:32:24.351]         if (TRUE) {
[15:32:24.351]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:24.351]                 open = "w")
[15:32:24.351]         }
[15:32:24.351]         else {
[15:32:24.351]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:24.351]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:24.351]         }
[15:32:24.351]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:24.351]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:24.351]             base::sink(type = "output", split = FALSE)
[15:32:24.351]             base::close(...future.stdout)
[15:32:24.351]         }, add = TRUE)
[15:32:24.351]     }
[15:32:24.351]     ...future.frame <- base::sys.nframe()
[15:32:24.351]     ...future.conditions <- base::list()
[15:32:24.351]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:24.351]     if (FALSE) {
[15:32:24.351]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:24.351]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:24.351]     }
[15:32:24.351]     ...future.result <- base::tryCatch({
[15:32:24.351]         base::withCallingHandlers({
[15:32:24.351]             ...future.value <- base::withVisible(base::local({
[15:32:24.351]                 do.call(function(...) {
[15:32:24.351]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:24.351]                   if (!identical(...future.globals.maxSize.org, 
[15:32:24.351]                     ...future.globals.maxSize)) {
[15:32:24.351]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:24.351]                     on.exit(options(oopts), add = TRUE)
[15:32:24.351]                   }
[15:32:24.351]                   {
[15:32:24.351]                     lapply(seq_along(...future.elements_ii), 
[15:32:24.351]                       FUN = function(jj) {
[15:32:24.351]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:24.351]                         ...future.FUN(...future.X_jj, ...)
[15:32:24.351]                       })
[15:32:24.351]                   }
[15:32:24.351]                 }, args = future.call.arguments)
[15:32:24.351]             }))
[15:32:24.351]             future::FutureResult(value = ...future.value$value, 
[15:32:24.351]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:24.351]                   ...future.rng), globalenv = if (FALSE) 
[15:32:24.351]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:24.351]                     ...future.globalenv.names))
[15:32:24.351]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:24.351]         }, condition = base::local({
[15:32:24.351]             c <- base::c
[15:32:24.351]             inherits <- base::inherits
[15:32:24.351]             invokeRestart <- base::invokeRestart
[15:32:24.351]             length <- base::length
[15:32:24.351]             list <- base::list
[15:32:24.351]             seq.int <- base::seq.int
[15:32:24.351]             signalCondition <- base::signalCondition
[15:32:24.351]             sys.calls <- base::sys.calls
[15:32:24.351]             `[[` <- base::`[[`
[15:32:24.351]             `+` <- base::`+`
[15:32:24.351]             `<<-` <- base::`<<-`
[15:32:24.351]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:24.351]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:24.351]                   3L)]
[15:32:24.351]             }
[15:32:24.351]             function(cond) {
[15:32:24.351]                 is_error <- inherits(cond, "error")
[15:32:24.351]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:24.351]                   NULL)
[15:32:24.351]                 if (is_error) {
[15:32:24.351]                   sessionInformation <- function() {
[15:32:24.351]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:24.351]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:24.351]                       search = base::search(), system = base::Sys.info())
[15:32:24.351]                   }
[15:32:24.351]                   ...future.conditions[[length(...future.conditions) + 
[15:32:24.351]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:24.351]                     cond$call), session = sessionInformation(), 
[15:32:24.351]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:24.351]                   signalCondition(cond)
[15:32:24.351]                 }
[15:32:24.351]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:24.351]                 "immediateCondition"))) {
[15:32:24.351]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:24.351]                   ...future.conditions[[length(...future.conditions) + 
[15:32:24.351]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:24.351]                   if (TRUE && !signal) {
[15:32:24.351]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:24.351]                     {
[15:32:24.351]                       inherits <- base::inherits
[15:32:24.351]                       invokeRestart <- base::invokeRestart
[15:32:24.351]                       is.null <- base::is.null
[15:32:24.351]                       muffled <- FALSE
[15:32:24.351]                       if (inherits(cond, "message")) {
[15:32:24.351]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:24.351]                         if (muffled) 
[15:32:24.351]                           invokeRestart("muffleMessage")
[15:32:24.351]                       }
[15:32:24.351]                       else if (inherits(cond, "warning")) {
[15:32:24.351]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:24.351]                         if (muffled) 
[15:32:24.351]                           invokeRestart("muffleWarning")
[15:32:24.351]                       }
[15:32:24.351]                       else if (inherits(cond, "condition")) {
[15:32:24.351]                         if (!is.null(pattern)) {
[15:32:24.351]                           computeRestarts <- base::computeRestarts
[15:32:24.351]                           grepl <- base::grepl
[15:32:24.351]                           restarts <- computeRestarts(cond)
[15:32:24.351]                           for (restart in restarts) {
[15:32:24.351]                             name <- restart$name
[15:32:24.351]                             if (is.null(name)) 
[15:32:24.351]                               next
[15:32:24.351]                             if (!grepl(pattern, name)) 
[15:32:24.351]                               next
[15:32:24.351]                             invokeRestart(restart)
[15:32:24.351]                             muffled <- TRUE
[15:32:24.351]                             break
[15:32:24.351]                           }
[15:32:24.351]                         }
[15:32:24.351]                       }
[15:32:24.351]                       invisible(muffled)
[15:32:24.351]                     }
[15:32:24.351]                     muffleCondition(cond, pattern = "^muffle")
[15:32:24.351]                   }
[15:32:24.351]                 }
[15:32:24.351]                 else {
[15:32:24.351]                   if (TRUE) {
[15:32:24.351]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:24.351]                     {
[15:32:24.351]                       inherits <- base::inherits
[15:32:24.351]                       invokeRestart <- base::invokeRestart
[15:32:24.351]                       is.null <- base::is.null
[15:32:24.351]                       muffled <- FALSE
[15:32:24.351]                       if (inherits(cond, "message")) {
[15:32:24.351]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:24.351]                         if (muffled) 
[15:32:24.351]                           invokeRestart("muffleMessage")
[15:32:24.351]                       }
[15:32:24.351]                       else if (inherits(cond, "warning")) {
[15:32:24.351]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:24.351]                         if (muffled) 
[15:32:24.351]                           invokeRestart("muffleWarning")
[15:32:24.351]                       }
[15:32:24.351]                       else if (inherits(cond, "condition")) {
[15:32:24.351]                         if (!is.null(pattern)) {
[15:32:24.351]                           computeRestarts <- base::computeRestarts
[15:32:24.351]                           grepl <- base::grepl
[15:32:24.351]                           restarts <- computeRestarts(cond)
[15:32:24.351]                           for (restart in restarts) {
[15:32:24.351]                             name <- restart$name
[15:32:24.351]                             if (is.null(name)) 
[15:32:24.351]                               next
[15:32:24.351]                             if (!grepl(pattern, name)) 
[15:32:24.351]                               next
[15:32:24.351]                             invokeRestart(restart)
[15:32:24.351]                             muffled <- TRUE
[15:32:24.351]                             break
[15:32:24.351]                           }
[15:32:24.351]                         }
[15:32:24.351]                       }
[15:32:24.351]                       invisible(muffled)
[15:32:24.351]                     }
[15:32:24.351]                     muffleCondition(cond, pattern = "^muffle")
[15:32:24.351]                   }
[15:32:24.351]                 }
[15:32:24.351]             }
[15:32:24.351]         }))
[15:32:24.351]     }, error = function(ex) {
[15:32:24.351]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:24.351]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:24.351]                 ...future.rng), started = ...future.startTime, 
[15:32:24.351]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:24.351]             version = "1.8"), class = "FutureResult")
[15:32:24.351]     }, finally = {
[15:32:24.351]         if (!identical(...future.workdir, getwd())) 
[15:32:24.351]             setwd(...future.workdir)
[15:32:24.351]         {
[15:32:24.351]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:24.351]                 ...future.oldOptions$nwarnings <- NULL
[15:32:24.351]             }
[15:32:24.351]             base::options(...future.oldOptions)
[15:32:24.351]             if (.Platform$OS.type == "windows") {
[15:32:24.351]                 old_names <- names(...future.oldEnvVars)
[15:32:24.351]                 envs <- base::Sys.getenv()
[15:32:24.351]                 names <- names(envs)
[15:32:24.351]                 common <- intersect(names, old_names)
[15:32:24.351]                 added <- setdiff(names, old_names)
[15:32:24.351]                 removed <- setdiff(old_names, names)
[15:32:24.351]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:24.351]                   envs[common]]
[15:32:24.351]                 NAMES <- toupper(changed)
[15:32:24.351]                 args <- list()
[15:32:24.351]                 for (kk in seq_along(NAMES)) {
[15:32:24.351]                   name <- changed[[kk]]
[15:32:24.351]                   NAME <- NAMES[[kk]]
[15:32:24.351]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:24.351]                     next
[15:32:24.351]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:24.351]                 }
[15:32:24.351]                 NAMES <- toupper(added)
[15:32:24.351]                 for (kk in seq_along(NAMES)) {
[15:32:24.351]                   name <- added[[kk]]
[15:32:24.351]                   NAME <- NAMES[[kk]]
[15:32:24.351]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:24.351]                     next
[15:32:24.351]                   args[[name]] <- ""
[15:32:24.351]                 }
[15:32:24.351]                 NAMES <- toupper(removed)
[15:32:24.351]                 for (kk in seq_along(NAMES)) {
[15:32:24.351]                   name <- removed[[kk]]
[15:32:24.351]                   NAME <- NAMES[[kk]]
[15:32:24.351]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:24.351]                     next
[15:32:24.351]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:24.351]                 }
[15:32:24.351]                 if (length(args) > 0) 
[15:32:24.351]                   base::do.call(base::Sys.setenv, args = args)
[15:32:24.351]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:24.351]             }
[15:32:24.351]             else {
[15:32:24.351]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:24.351]             }
[15:32:24.351]             {
[15:32:24.351]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:24.351]                   0L) {
[15:32:24.351]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:24.351]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:24.351]                   base::options(opts)
[15:32:24.351]                 }
[15:32:24.351]                 {
[15:32:24.351]                   {
[15:32:24.351]                     NULL
[15:32:24.351]                     RNGkind("Mersenne-Twister")
[15:32:24.351]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:24.351]                       inherits = FALSE)
[15:32:24.351]                   }
[15:32:24.351]                   options(future.plan = NULL)
[15:32:24.351]                   if (is.na(NA_character_)) 
[15:32:24.351]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:24.351]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:24.351]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:24.351]                     .init = FALSE)
[15:32:24.351]                 }
[15:32:24.351]             }
[15:32:24.351]         }
[15:32:24.351]     })
[15:32:24.351]     if (TRUE) {
[15:32:24.351]         base::sink(type = "output", split = FALSE)
[15:32:24.351]         if (TRUE) {
[15:32:24.351]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:24.351]         }
[15:32:24.351]         else {
[15:32:24.351]             ...future.result["stdout"] <- base::list(NULL)
[15:32:24.351]         }
[15:32:24.351]         base::close(...future.stdout)
[15:32:24.351]         ...future.stdout <- NULL
[15:32:24.351]     }
[15:32:24.351]     ...future.result$conditions <- ...future.conditions
[15:32:24.351]     ...future.result$finished <- base::Sys.time()
[15:32:24.351]     ...future.result
[15:32:24.351] }
[15:32:24.357] assign_globals() ...
[15:32:24.357] List of 5
[15:32:24.357]  $ ...future.FUN            :function (x)  
[15:32:24.357]  $ future.call.arguments    : list()
[15:32:24.357]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:24.357]  $ ...future.elements_ii    :List of 4
[15:32:24.357]   ..$ A: num 50
[15:32:24.357]   ..$ B: num 60
[15:32:24.357]   ..$ C: num 70
[15:32:24.357]   ..$ D: num 80
[15:32:24.357]  $ ...future.seeds_ii       : NULL
[15:32:24.357]  $ ...future.globals.maxSize: NULL
[15:32:24.357]  - attr(*, "where")=List of 5
[15:32:24.357]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:24.357]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:24.357]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:24.357]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:24.357]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:24.357]  - attr(*, "resolved")= logi FALSE
[15:32:24.357]  - attr(*, "total_size")= num 848
[15:32:24.357]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:24.357]  - attr(*, "already-done")= logi TRUE
[15:32:24.363] - copied '...future.FUN' to environment
[15:32:24.363] - copied 'future.call.arguments' to environment
[15:32:24.364] - copied '...future.elements_ii' to environment
[15:32:24.364] - copied '...future.seeds_ii' to environment
[15:32:24.364] - copied '...future.globals.maxSize' to environment
[15:32:24.364] assign_globals() ... done
[15:32:24.364] plan(): Setting new future strategy stack:
[15:32:24.365] List of future strategies:
[15:32:24.365] 1. sequential:
[15:32:24.365]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:24.365]    - tweaked: FALSE
[15:32:24.365]    - call: NULL
[15:32:24.365] plan(): nbrOfWorkers() = 1
[15:32:24.366] plan(): Setting new future strategy stack:
[15:32:24.367] List of future strategies:
[15:32:24.367] 1. sequential:
[15:32:24.367]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:24.367]    - tweaked: FALSE
[15:32:24.367]    - call: plan(strategy)
[15:32:24.367] plan(): nbrOfWorkers() = 1
[15:32:24.367] SequentialFuture started (and completed)
[15:32:24.368] - Launch lazy future ... done
[15:32:24.368] run() for 'SequentialFuture' ... done
[15:32:24.368] Created future:
[15:32:24.368] SequentialFuture:
[15:32:24.368] Label: 'future_sapply-1'
[15:32:24.368] Expression:
[15:32:24.368] {
[15:32:24.368]     do.call(function(...) {
[15:32:24.368]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:24.368]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:24.368]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:24.368]             on.exit(options(oopts), add = TRUE)
[15:32:24.368]         }
[15:32:24.368]         {
[15:32:24.368]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:24.368]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:24.368]                 ...future.FUN(...future.X_jj, ...)
[15:32:24.368]             })
[15:32:24.368]         }
[15:32:24.368]     }, args = future.call.arguments)
[15:32:24.368] }
[15:32:24.368] Lazy evaluation: FALSE
[15:32:24.368] Asynchronous evaluation: FALSE
[15:32:24.368] Local evaluation: TRUE
[15:32:24.368] Environment: R_GlobalEnv
[15:32:24.368] Capture standard output: TRUE
[15:32:24.368] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:24.368] Globals: 5 objects totaling 1.05 KiB (function '...future.FUN' of 848 bytes, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 224 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:24.368] Packages: <none>
[15:32:24.368] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:24.368] Resolved: TRUE
[15:32:24.368] Value: 224 bytes of class 'list'
[15:32:24.368] Early signaling: FALSE
[15:32:24.368] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:24.368] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:24.369] Chunk #1 of 1 ... DONE
[15:32:24.370] Launching 1 futures (chunks) ... DONE
[15:32:24.370] Resolving 1 futures (chunks) ...
[15:32:24.370] resolve() on list ...
[15:32:24.370]  recursive: 0
[15:32:24.370]  length: 1
[15:32:24.370] 
[15:32:24.370] resolved() for 'SequentialFuture' ...
[15:32:24.371] - state: 'finished'
[15:32:24.371] - run: TRUE
[15:32:24.371] - result: 'FutureResult'
[15:32:24.371] resolved() for 'SequentialFuture' ... done
[15:32:24.371] Future #1
[15:32:24.372] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:24.372] - nx: 1
[15:32:24.372] - relay: TRUE
[15:32:24.372] - stdout: TRUE
[15:32:24.372] - signal: TRUE
[15:32:24.372] - resignal: FALSE
[15:32:24.372] - force: TRUE
[15:32:24.373] - relayed: [n=1] FALSE
[15:32:24.373] - queued futures: [n=1] FALSE
[15:32:24.373]  - until=1
[15:32:24.373]  - relaying element #1
[15:32:24.373] - relayed: [n=1] TRUE
[15:32:24.373] - queued futures: [n=1] TRUE
[15:32:24.374] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:24.374]  length: 0 (resolved future 1)
[15:32:24.374] Relaying remaining futures
[15:32:24.374] signalConditionsASAP(NULL, pos=0) ...
[15:32:24.374] - nx: 1
[15:32:24.374] - relay: TRUE
[15:32:24.375] - stdout: TRUE
[15:32:24.375] - signal: TRUE
[15:32:24.375] - resignal: FALSE
[15:32:24.375] - force: TRUE
[15:32:24.375] - relayed: [n=1] TRUE
[15:32:24.376] - queued futures: [n=1] TRUE
 - flush all
[15:32:24.376] - relayed: [n=1] TRUE
[15:32:24.376] - queued futures: [n=1] TRUE
[15:32:24.376] signalConditionsASAP(NULL, pos=0) ... done
[15:32:24.377] resolve() on list ... DONE
[15:32:24.377]  - Number of value chunks collected: 1
[15:32:24.377] Resolving 1 futures (chunks) ... DONE
[15:32:24.378] Reducing values from 1 chunks ...
[15:32:24.378]  - Number of values collected after concatenation: 4
[15:32:24.378]  - Number of values expected: 4
[15:32:24.378] Reducing values from 1 chunks ... DONE
[15:32:24.378] future_lapply() ... DONE
List of 2
 $ y0: Named num [1:4] 50 60 70 80
  ..- attr(*, "names")= chr [1:4] "A" "B" "C" "D"
 $ y1: Named num [1:4] 50 60 70 80
  ..- attr(*, "names")= chr [1:4] "A" "B" "C" "D"
[15:32:24.381] future_lapply() ...
[15:32:24.382] Number of chunks: 1
[15:32:24.383] getGlobalsAndPackagesXApply() ...
[15:32:24.383]  - future.globals: TRUE
[15:32:24.383] getGlobalsAndPackages() ...
[15:32:24.383] Searching for globals...
[15:32:24.387] - globals found: [2] 'FUN', 'UseMethod'
[15:32:24.387] Searching for globals ... DONE
[15:32:24.387] Resolving globals: FALSE
[15:32:24.388] The total size of the 1 globals is 1.22 KiB (1248 bytes)
[15:32:24.388] The total size of the 1 globals exported for future expression ('FUN()') is 1.22 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.22 KiB of class 'function')
[15:32:24.388] - globals: [1] 'FUN'
[15:32:24.388] 
[15:32:24.389] getGlobalsAndPackages() ... DONE
[15:32:24.389]  - globals found/used: [n=1] 'FUN'
[15:32:24.389]  - needed namespaces: [n=0] 
[15:32:24.389] Finding globals ... DONE
[15:32:24.389]  - use_args: TRUE
[15:32:24.389]  - Getting '...' globals ...
[15:32:24.390] resolve() on list ...
[15:32:24.390]  recursive: 0
[15:32:24.390]  length: 1
[15:32:24.390]  elements: '...'
[15:32:24.391]  length: 0 (resolved future 1)
[15:32:24.391] resolve() on list ... DONE
[15:32:24.391]    - '...' content: [n=0] 
[15:32:24.391] List of 1
[15:32:24.391]  $ ...: list()
[15:32:24.391]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:24.391]  - attr(*, "where")=List of 1
[15:32:24.391]   ..$ ...:<environment: 0x00000276e5c596f8> 
[15:32:24.391]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:24.391]  - attr(*, "resolved")= logi TRUE
[15:32:24.391]  - attr(*, "total_size")= num NA
[15:32:24.395]  - Getting '...' globals ... DONE
[15:32:24.396] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:24.396] List of 2
[15:32:24.396]  $ ...future.FUN:function (x, ...)  
[15:32:24.396]  $ ...          : list()
[15:32:24.396]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:24.396]  - attr(*, "where")=List of 2
[15:32:24.396]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:24.396]   ..$ ...          :<environment: 0x00000276e5c596f8> 
[15:32:24.396]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:24.396]  - attr(*, "resolved")= logi FALSE
[15:32:24.396]  - attr(*, "total_size")= num 1248
[15:32:24.400] Packages to be attached in all futures: [n=0] 
[15:32:24.400] getGlobalsAndPackagesXApply() ... DONE
[15:32:24.400] Number of futures (= number of chunks): 1
[15:32:24.400] Launching 1 futures (chunks) ...
[15:32:24.400] Chunk #1 of 1 ...
[15:32:24.401]  - Finding globals in 'X' for chunk #1 ...
[15:32:24.401] getGlobalsAndPackages() ...
[15:32:24.401] Searching for globals...
[15:32:24.401] 
[15:32:24.401] Searching for globals ... DONE
[15:32:24.402] - globals: [0] <none>
[15:32:24.402] getGlobalsAndPackages() ... DONE
[15:32:24.402]    + additional globals found: [n=0] 
[15:32:24.402]    + additional namespaces needed: [n=0] 
[15:32:24.402]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:24.402]  - seeds: <none>
[15:32:24.403]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:24.403] getGlobalsAndPackages() ...
[15:32:24.403] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:24.403] Resolving globals: FALSE
[15:32:24.404] Tweak future expression to call with '...' arguments ...
[15:32:24.404] {
[15:32:24.404]     do.call(function(...) {
[15:32:24.404]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:24.404]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:24.404]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:24.404]             on.exit(options(oopts), add = TRUE)
[15:32:24.404]         }
[15:32:24.404]         {
[15:32:24.404]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:24.404]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:24.404]                 ...future.FUN(...future.X_jj, ...)
[15:32:24.404]             })
[15:32:24.404]         }
[15:32:24.404]     }, args = future.call.arguments)
[15:32:24.404] }
[15:32:24.404] Tweak future expression to call with '...' arguments ... DONE
[15:32:24.405] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:24.405] 
[15:32:24.406] getGlobalsAndPackages() ... DONE
[15:32:24.406] run() for 'Future' ...
[15:32:24.407] - state: 'created'
[15:32:24.407] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:24.407] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:24.408] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:24.408]   - Field: 'label'
[15:32:24.408]   - Field: 'local'
[15:32:24.408]   - Field: 'owner'
[15:32:24.408]   - Field: 'envir'
[15:32:24.408]   - Field: 'packages'
[15:32:24.409]   - Field: 'gc'
[15:32:24.409]   - Field: 'conditions'
[15:32:24.409]   - Field: 'expr'
[15:32:24.409]   - Field: 'uuid'
[15:32:24.409]   - Field: 'seed'
[15:32:24.410]   - Field: 'version'
[15:32:24.410]   - Field: 'result'
[15:32:24.410]   - Field: 'asynchronous'
[15:32:24.410]   - Field: 'calls'
[15:32:24.410]   - Field: 'globals'
[15:32:24.410]   - Field: 'stdout'
[15:32:24.411]   - Field: 'earlySignal'
[15:32:24.411]   - Field: 'lazy'
[15:32:24.411]   - Field: 'state'
[15:32:24.411] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:24.411] - Launch lazy future ...
[15:32:24.412] Packages needed by the future expression (n = 0): <none>
[15:32:24.412] Packages needed by future strategies (n = 0): <none>
[15:32:24.412] {
[15:32:24.412]     {
[15:32:24.412]         {
[15:32:24.412]             ...future.startTime <- base::Sys.time()
[15:32:24.412]             {
[15:32:24.412]                 {
[15:32:24.412]                   {
[15:32:24.412]                     base::local({
[15:32:24.412]                       has_future <- base::requireNamespace("future", 
[15:32:24.412]                         quietly = TRUE)
[15:32:24.412]                       if (has_future) {
[15:32:24.412]                         ns <- base::getNamespace("future")
[15:32:24.412]                         version <- ns[[".package"]][["version"]]
[15:32:24.412]                         if (is.null(version)) 
[15:32:24.412]                           version <- utils::packageVersion("future")
[15:32:24.412]                       }
[15:32:24.412]                       else {
[15:32:24.412]                         version <- NULL
[15:32:24.412]                       }
[15:32:24.412]                       if (!has_future || version < "1.8.0") {
[15:32:24.412]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:24.412]                           "", base::R.version$version.string), 
[15:32:24.412]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:24.412]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:24.412]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:24.412]                             "release", "version")], collapse = " "), 
[15:32:24.412]                           hostname = base::Sys.info()[["nodename"]])
[15:32:24.412]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:24.412]                           info)
[15:32:24.412]                         info <- base::paste(info, collapse = "; ")
[15:32:24.412]                         if (!has_future) {
[15:32:24.412]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:24.412]                             info)
[15:32:24.412]                         }
[15:32:24.412]                         else {
[15:32:24.412]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:24.412]                             info, version)
[15:32:24.412]                         }
[15:32:24.412]                         base::stop(msg)
[15:32:24.412]                       }
[15:32:24.412]                     })
[15:32:24.412]                   }
[15:32:24.412]                   ...future.strategy.old <- future::plan("list")
[15:32:24.412]                   options(future.plan = NULL)
[15:32:24.412]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:24.412]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:24.412]                 }
[15:32:24.412]                 ...future.workdir <- getwd()
[15:32:24.412]             }
[15:32:24.412]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:24.412]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:24.412]         }
[15:32:24.412]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:24.412]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:24.412]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:24.412]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:24.412]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:24.412]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:24.412]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:24.412]             base::names(...future.oldOptions))
[15:32:24.412]     }
[15:32:24.412]     if (FALSE) {
[15:32:24.412]     }
[15:32:24.412]     else {
[15:32:24.412]         if (TRUE) {
[15:32:24.412]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:24.412]                 open = "w")
[15:32:24.412]         }
[15:32:24.412]         else {
[15:32:24.412]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:24.412]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:24.412]         }
[15:32:24.412]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:24.412]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:24.412]             base::sink(type = "output", split = FALSE)
[15:32:24.412]             base::close(...future.stdout)
[15:32:24.412]         }, add = TRUE)
[15:32:24.412]     }
[15:32:24.412]     ...future.frame <- base::sys.nframe()
[15:32:24.412]     ...future.conditions <- base::list()
[15:32:24.412]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:24.412]     if (FALSE) {
[15:32:24.412]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:24.412]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:24.412]     }
[15:32:24.412]     ...future.result <- base::tryCatch({
[15:32:24.412]         base::withCallingHandlers({
[15:32:24.412]             ...future.value <- base::withVisible(base::local({
[15:32:24.412]                 do.call(function(...) {
[15:32:24.412]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:24.412]                   if (!identical(...future.globals.maxSize.org, 
[15:32:24.412]                     ...future.globals.maxSize)) {
[15:32:24.412]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:24.412]                     on.exit(options(oopts), add = TRUE)
[15:32:24.412]                   }
[15:32:24.412]                   {
[15:32:24.412]                     lapply(seq_along(...future.elements_ii), 
[15:32:24.412]                       FUN = function(jj) {
[15:32:24.412]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:24.412]                         ...future.FUN(...future.X_jj, ...)
[15:32:24.412]                       })
[15:32:24.412]                   }
[15:32:24.412]                 }, args = future.call.arguments)
[15:32:24.412]             }))
[15:32:24.412]             future::FutureResult(value = ...future.value$value, 
[15:32:24.412]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:24.412]                   ...future.rng), globalenv = if (FALSE) 
[15:32:24.412]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:24.412]                     ...future.globalenv.names))
[15:32:24.412]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:24.412]         }, condition = base::local({
[15:32:24.412]             c <- base::c
[15:32:24.412]             inherits <- base::inherits
[15:32:24.412]             invokeRestart <- base::invokeRestart
[15:32:24.412]             length <- base::length
[15:32:24.412]             list <- base::list
[15:32:24.412]             seq.int <- base::seq.int
[15:32:24.412]             signalCondition <- base::signalCondition
[15:32:24.412]             sys.calls <- base::sys.calls
[15:32:24.412]             `[[` <- base::`[[`
[15:32:24.412]             `+` <- base::`+`
[15:32:24.412]             `<<-` <- base::`<<-`
[15:32:24.412]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:24.412]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:24.412]                   3L)]
[15:32:24.412]             }
[15:32:24.412]             function(cond) {
[15:32:24.412]                 is_error <- inherits(cond, "error")
[15:32:24.412]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:24.412]                   NULL)
[15:32:24.412]                 if (is_error) {
[15:32:24.412]                   sessionInformation <- function() {
[15:32:24.412]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:24.412]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:24.412]                       search = base::search(), system = base::Sys.info())
[15:32:24.412]                   }
[15:32:24.412]                   ...future.conditions[[length(...future.conditions) + 
[15:32:24.412]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:24.412]                     cond$call), session = sessionInformation(), 
[15:32:24.412]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:24.412]                   signalCondition(cond)
[15:32:24.412]                 }
[15:32:24.412]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:24.412]                 "immediateCondition"))) {
[15:32:24.412]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:24.412]                   ...future.conditions[[length(...future.conditions) + 
[15:32:24.412]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:24.412]                   if (TRUE && !signal) {
[15:32:24.412]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:24.412]                     {
[15:32:24.412]                       inherits <- base::inherits
[15:32:24.412]                       invokeRestart <- base::invokeRestart
[15:32:24.412]                       is.null <- base::is.null
[15:32:24.412]                       muffled <- FALSE
[15:32:24.412]                       if (inherits(cond, "message")) {
[15:32:24.412]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:24.412]                         if (muffled) 
[15:32:24.412]                           invokeRestart("muffleMessage")
[15:32:24.412]                       }
[15:32:24.412]                       else if (inherits(cond, "warning")) {
[15:32:24.412]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:24.412]                         if (muffled) 
[15:32:24.412]                           invokeRestart("muffleWarning")
[15:32:24.412]                       }
[15:32:24.412]                       else if (inherits(cond, "condition")) {
[15:32:24.412]                         if (!is.null(pattern)) {
[15:32:24.412]                           computeRestarts <- base::computeRestarts
[15:32:24.412]                           grepl <- base::grepl
[15:32:24.412]                           restarts <- computeRestarts(cond)
[15:32:24.412]                           for (restart in restarts) {
[15:32:24.412]                             name <- restart$name
[15:32:24.412]                             if (is.null(name)) 
[15:32:24.412]                               next
[15:32:24.412]                             if (!grepl(pattern, name)) 
[15:32:24.412]                               next
[15:32:24.412]                             invokeRestart(restart)
[15:32:24.412]                             muffled <- TRUE
[15:32:24.412]                             break
[15:32:24.412]                           }
[15:32:24.412]                         }
[15:32:24.412]                       }
[15:32:24.412]                       invisible(muffled)
[15:32:24.412]                     }
[15:32:24.412]                     muffleCondition(cond, pattern = "^muffle")
[15:32:24.412]                   }
[15:32:24.412]                 }
[15:32:24.412]                 else {
[15:32:24.412]                   if (TRUE) {
[15:32:24.412]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:24.412]                     {
[15:32:24.412]                       inherits <- base::inherits
[15:32:24.412]                       invokeRestart <- base::invokeRestart
[15:32:24.412]                       is.null <- base::is.null
[15:32:24.412]                       muffled <- FALSE
[15:32:24.412]                       if (inherits(cond, "message")) {
[15:32:24.412]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:24.412]                         if (muffled) 
[15:32:24.412]                           invokeRestart("muffleMessage")
[15:32:24.412]                       }
[15:32:24.412]                       else if (inherits(cond, "warning")) {
[15:32:24.412]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:24.412]                         if (muffled) 
[15:32:24.412]                           invokeRestart("muffleWarning")
[15:32:24.412]                       }
[15:32:24.412]                       else if (inherits(cond, "condition")) {
[15:32:24.412]                         if (!is.null(pattern)) {
[15:32:24.412]                           computeRestarts <- base::computeRestarts
[15:32:24.412]                           grepl <- base::grepl
[15:32:24.412]                           restarts <- computeRestarts(cond)
[15:32:24.412]                           for (restart in restarts) {
[15:32:24.412]                             name <- restart$name
[15:32:24.412]                             if (is.null(name)) 
[15:32:24.412]                               next
[15:32:24.412]                             if (!grepl(pattern, name)) 
[15:32:24.412]                               next
[15:32:24.412]                             invokeRestart(restart)
[15:32:24.412]                             muffled <- TRUE
[15:32:24.412]                             break
[15:32:24.412]                           }
[15:32:24.412]                         }
[15:32:24.412]                       }
[15:32:24.412]                       invisible(muffled)
[15:32:24.412]                     }
[15:32:24.412]                     muffleCondition(cond, pattern = "^muffle")
[15:32:24.412]                   }
[15:32:24.412]                 }
[15:32:24.412]             }
[15:32:24.412]         }))
[15:32:24.412]     }, error = function(ex) {
[15:32:24.412]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:24.412]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:24.412]                 ...future.rng), started = ...future.startTime, 
[15:32:24.412]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:24.412]             version = "1.8"), class = "FutureResult")
[15:32:24.412]     }, finally = {
[15:32:24.412]         if (!identical(...future.workdir, getwd())) 
[15:32:24.412]             setwd(...future.workdir)
[15:32:24.412]         {
[15:32:24.412]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:24.412]                 ...future.oldOptions$nwarnings <- NULL
[15:32:24.412]             }
[15:32:24.412]             base::options(...future.oldOptions)
[15:32:24.412]             if (.Platform$OS.type == "windows") {
[15:32:24.412]                 old_names <- names(...future.oldEnvVars)
[15:32:24.412]                 envs <- base::Sys.getenv()
[15:32:24.412]                 names <- names(envs)
[15:32:24.412]                 common <- intersect(names, old_names)
[15:32:24.412]                 added <- setdiff(names, old_names)
[15:32:24.412]                 removed <- setdiff(old_names, names)
[15:32:24.412]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:24.412]                   envs[common]]
[15:32:24.412]                 NAMES <- toupper(changed)
[15:32:24.412]                 args <- list()
[15:32:24.412]                 for (kk in seq_along(NAMES)) {
[15:32:24.412]                   name <- changed[[kk]]
[15:32:24.412]                   NAME <- NAMES[[kk]]
[15:32:24.412]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:24.412]                     next
[15:32:24.412]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:24.412]                 }
[15:32:24.412]                 NAMES <- toupper(added)
[15:32:24.412]                 for (kk in seq_along(NAMES)) {
[15:32:24.412]                   name <- added[[kk]]
[15:32:24.412]                   NAME <- NAMES[[kk]]
[15:32:24.412]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:24.412]                     next
[15:32:24.412]                   args[[name]] <- ""
[15:32:24.412]                 }
[15:32:24.412]                 NAMES <- toupper(removed)
[15:32:24.412]                 for (kk in seq_along(NAMES)) {
[15:32:24.412]                   name <- removed[[kk]]
[15:32:24.412]                   NAME <- NAMES[[kk]]
[15:32:24.412]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:24.412]                     next
[15:32:24.412]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:24.412]                 }
[15:32:24.412]                 if (length(args) > 0) 
[15:32:24.412]                   base::do.call(base::Sys.setenv, args = args)
[15:32:24.412]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:24.412]             }
[15:32:24.412]             else {
[15:32:24.412]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:24.412]             }
[15:32:24.412]             {
[15:32:24.412]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:24.412]                   0L) {
[15:32:24.412]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:24.412]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:24.412]                   base::options(opts)
[15:32:24.412]                 }
[15:32:24.412]                 {
[15:32:24.412]                   {
[15:32:24.412]                     NULL
[15:32:24.412]                     RNGkind("Mersenne-Twister")
[15:32:24.412]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:24.412]                       inherits = FALSE)
[15:32:24.412]                   }
[15:32:24.412]                   options(future.plan = NULL)
[15:32:24.412]                   if (is.na(NA_character_)) 
[15:32:24.412]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:24.412]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:24.412]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:24.412]                     .init = FALSE)
[15:32:24.412]                 }
[15:32:24.412]             }
[15:32:24.412]         }
[15:32:24.412]     })
[15:32:24.412]     if (TRUE) {
[15:32:24.412]         base::sink(type = "output", split = FALSE)
[15:32:24.412]         if (TRUE) {
[15:32:24.412]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:24.412]         }
[15:32:24.412]         else {
[15:32:24.412]             ...future.result["stdout"] <- base::list(NULL)
[15:32:24.412]         }
[15:32:24.412]         base::close(...future.stdout)
[15:32:24.412]         ...future.stdout <- NULL
[15:32:24.412]     }
[15:32:24.412]     ...future.result$conditions <- ...future.conditions
[15:32:24.412]     ...future.result$finished <- base::Sys.time()
[15:32:24.412]     ...future.result
[15:32:24.412] }
[15:32:24.417] assign_globals() ...
[15:32:24.417] List of 5
[15:32:24.417]  $ ...future.FUN            :function (x, ...)  
[15:32:24.417]  $ future.call.arguments    : list()
[15:32:24.417]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:24.417]  $ ...future.elements_ii    :List of 4
[15:32:24.417]   ..$ A: num 50
[15:32:24.417]   ..$ B: num 60
[15:32:24.417]   ..$ C: num 70
[15:32:24.417]   ..$ D: num 80
[15:32:24.417]  $ ...future.seeds_ii       : NULL
[15:32:24.417]  $ ...future.globals.maxSize: NULL
[15:32:24.417]  - attr(*, "where")=List of 5
[15:32:24.417]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:24.417]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:24.417]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:24.417]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:24.417]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:24.417]  - attr(*, "resolved")= logi FALSE
[15:32:24.417]  - attr(*, "total_size")= num 1248
[15:32:24.417]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:24.417]  - attr(*, "already-done")= logi TRUE
[15:32:24.424] - copied '...future.FUN' to environment
[15:32:24.425] - copied 'future.call.arguments' to environment
[15:32:24.425] - copied '...future.elements_ii' to environment
[15:32:24.425] - copied '...future.seeds_ii' to environment
[15:32:24.425] - copied '...future.globals.maxSize' to environment
[15:32:24.425] assign_globals() ... done
[15:32:24.426] plan(): Setting new future strategy stack:
[15:32:24.426] List of future strategies:
[15:32:24.426] 1. sequential:
[15:32:24.426]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:24.426]    - tweaked: FALSE
[15:32:24.426]    - call: NULL
[15:32:24.427] plan(): nbrOfWorkers() = 1
[15:32:24.428] plan(): Setting new future strategy stack:
[15:32:24.428] List of future strategies:
[15:32:24.428] 1. sequential:
[15:32:24.428]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:24.428]    - tweaked: FALSE
[15:32:24.428]    - call: plan(strategy)
[15:32:24.429] plan(): nbrOfWorkers() = 1
[15:32:24.429] SequentialFuture started (and completed)
[15:32:24.429] - Launch lazy future ... done
[15:32:24.430] run() for 'SequentialFuture' ... done
[15:32:24.430] Created future:
[15:32:24.430] SequentialFuture:
[15:32:24.430] Label: 'future_sapply-1'
[15:32:24.430] Expression:
[15:32:24.430] {
[15:32:24.430]     do.call(function(...) {
[15:32:24.430]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:24.430]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:24.430]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:24.430]             on.exit(options(oopts), add = TRUE)
[15:32:24.430]         }
[15:32:24.430]         {
[15:32:24.430]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:24.430]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:24.430]                 ...future.FUN(...future.X_jj, ...)
[15:32:24.430]             })
[15:32:24.430]         }
[15:32:24.430]     }, args = future.call.arguments)
[15:32:24.430] }
[15:32:24.430] Lazy evaluation: FALSE
[15:32:24.430] Asynchronous evaluation: FALSE
[15:32:24.430] Local evaluation: TRUE
[15:32:24.430] Environment: R_GlobalEnv
[15:32:24.430] Capture standard output: TRUE
[15:32:24.430] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:24.430] Globals: 5 objects totaling 1.44 KiB (function '...future.FUN' of 1.22 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 224 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:24.430] Packages: <none>
[15:32:24.430] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:24.430] Resolved: TRUE
[15:32:24.430] Value: 896 bytes of class 'list'
[15:32:24.430] Early signaling: FALSE
[15:32:24.430] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:24.430] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:24.432] Chunk #1 of 1 ... DONE
[15:32:24.432] Launching 1 futures (chunks) ... DONE
[15:32:24.432] Resolving 1 futures (chunks) ...
[15:32:24.432] resolve() on list ...
[15:32:24.432]  recursive: 0
[15:32:24.432]  length: 1
[15:32:24.433] 
[15:32:24.433] resolved() for 'SequentialFuture' ...
[15:32:24.433] - state: 'finished'
[15:32:24.433] - run: TRUE
[15:32:24.433] - result: 'FutureResult'
[15:32:24.434] resolved() for 'SequentialFuture' ... done
[15:32:24.434] Future #1
[15:32:24.434] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:24.434] - nx: 1
[15:32:24.434] - relay: TRUE
[15:32:24.434] - stdout: TRUE
[15:32:24.435] - signal: TRUE
[15:32:24.435] - resignal: FALSE
[15:32:24.435] - force: TRUE
[15:32:24.435] - relayed: [n=1] FALSE
[15:32:24.435] - queued futures: [n=1] FALSE
[15:32:24.435]  - until=1
[15:32:24.436]  - relaying element #1
[15:32:24.436] - relayed: [n=1] TRUE
[15:32:24.436] - queued futures: [n=1] TRUE
[15:32:24.436] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:24.436]  length: 0 (resolved future 1)
[15:32:24.437] Relaying remaining futures
[15:32:24.437] signalConditionsASAP(NULL, pos=0) ...
[15:32:24.437] - nx: 1
[15:32:24.437] - relay: TRUE
[15:32:24.437] - stdout: TRUE
[15:32:24.437] - signal: TRUE
[15:32:24.438] - resignal: FALSE
[15:32:24.438] - force: TRUE
[15:32:24.438] - relayed: [n=1] TRUE
[15:32:24.438] - queued futures: [n=1] TRUE
 - flush all
[15:32:24.438] - relayed: [n=1] TRUE
[15:32:24.438] - queued futures: [n=1] TRUE
[15:32:24.439] signalConditionsASAP(NULL, pos=0) ... done
[15:32:24.439] resolve() on list ... DONE
[15:32:24.439]  - Number of value chunks collected: 1
[15:32:24.439] Resolving 1 futures (chunks) ... DONE
[15:32:24.439] Reducing values from 1 chunks ...
[15:32:24.440]  - Number of values collected after concatenation: 4
[15:32:24.440]  - Number of values expected: 4
[15:32:24.440] Reducing values from 1 chunks ... DONE
[15:32:24.440] future_lapply() ... DONE
List of 2
 $ y0: Named num [1:4] 50 60 70 80
  ..- attr(*, "names")= chr [1:4] "A" "B" "C" "D"
 $ y1: Named num [1:4] 50 60 70 80
  ..- attr(*, "names")= chr [1:4] "A" "B" "C" "D"
[15:32:24.442] future_lapply() ...
[15:32:24.444] Number of chunks: 1
[15:32:24.444] getGlobalsAndPackagesXApply() ...
[15:32:24.444]  - future.globals: TRUE
[15:32:24.444] getGlobalsAndPackages() ...
[15:32:24.444] Searching for globals...
[15:32:24.446] - globals found: [5] 'FUN', '*', ':', 'outer', 'rep'
[15:32:24.446] Searching for globals ... DONE
[15:32:24.447] Resolving globals: FALSE
[15:32:24.447] The total size of the 1 globals is 4.62 KiB (4728 bytes)
[15:32:24.448] The total size of the 1 globals exported for future expression ('FUN()') is 4.62 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.62 KiB of class 'function')
[15:32:24.448] - globals: [1] 'FUN'
[15:32:24.448] 
[15:32:24.448] getGlobalsAndPackages() ... DONE
[15:32:24.448]  - globals found/used: [n=1] 'FUN'
[15:32:24.449]  - needed namespaces: [n=0] 
[15:32:24.449] Finding globals ... DONE
[15:32:24.449]  - use_args: TRUE
[15:32:24.449]  - Getting '...' globals ...
[15:32:24.450] resolve() on list ...
[15:32:24.450]  recursive: 0
[15:32:24.450]  length: 1
[15:32:24.450]  elements: '...'
[15:32:24.450]  length: 0 (resolved future 1)
[15:32:24.450] resolve() on list ... DONE
[15:32:24.451]    - '...' content: [n=0] 
[15:32:24.451] List of 1
[15:32:24.451]  $ ...: list()
[15:32:24.451]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:24.451]  - attr(*, "where")=List of 1
[15:32:24.451]   ..$ ...:<environment: 0x00000276e4637b18> 
[15:32:24.451]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:24.451]  - attr(*, "resolved")= logi TRUE
[15:32:24.451]  - attr(*, "total_size")= num NA
[15:32:24.455]  - Getting '...' globals ... DONE
[15:32:24.455] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:24.456] List of 2
[15:32:24.456]  $ ...future.FUN:function (x, y = 2 * 1:5)  
[15:32:24.456]  $ ...          : list()
[15:32:24.456]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:24.456]  - attr(*, "where")=List of 2
[15:32:24.456]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:24.456]   ..$ ...          :<environment: 0x00000276e4637b18> 
[15:32:24.456]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:24.456]  - attr(*, "resolved")= logi FALSE
[15:32:24.456]  - attr(*, "total_size")= num 4728
[15:32:24.461] Packages to be attached in all futures: [n=0] 
[15:32:24.461] getGlobalsAndPackagesXApply() ... DONE
[15:32:24.462] Number of futures (= number of chunks): 1
[15:32:24.462] Launching 1 futures (chunks) ...
[15:32:24.462] Chunk #1 of 1 ...
[15:32:24.462]  - Finding globals in 'X' for chunk #1 ...
[15:32:24.463] getGlobalsAndPackages() ...
[15:32:24.463] Searching for globals...
[15:32:24.464] 
[15:32:24.464] Searching for globals ... DONE
[15:32:24.464] - globals: [0] <none>
[15:32:24.464] getGlobalsAndPackages() ... DONE
[15:32:24.465]    + additional globals found: [n=0] 
[15:32:24.465]    + additional namespaces needed: [n=0] 
[15:32:24.465]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:24.465]  - seeds: <none>
[15:32:24.466]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:24.466] getGlobalsAndPackages() ...
[15:32:24.466] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:24.467] Resolving globals: FALSE
[15:32:24.467] Tweak future expression to call with '...' arguments ...
[15:32:24.467] {
[15:32:24.467]     do.call(function(...) {
[15:32:24.467]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:24.467]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:24.467]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:24.467]             on.exit(options(oopts), add = TRUE)
[15:32:24.467]         }
[15:32:24.467]         {
[15:32:24.467]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:24.467]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:24.467]                 ...future.FUN(...future.X_jj, ...)
[15:32:24.467]             })
[15:32:24.467]         }
[15:32:24.467]     }, args = future.call.arguments)
[15:32:24.467] }
[15:32:24.468] Tweak future expression to call with '...' arguments ... DONE
[15:32:24.469] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:24.469] 
[15:32:24.469] getGlobalsAndPackages() ... DONE
[15:32:24.470] run() for 'Future' ...
[15:32:24.470] - state: 'created'
[15:32:24.471] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:24.471] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:24.472] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:24.472]   - Field: 'label'
[15:32:24.472]   - Field: 'local'
[15:32:24.472]   - Field: 'owner'
[15:32:24.473]   - Field: 'envir'
[15:32:24.473]   - Field: 'packages'
[15:32:24.473]   - Field: 'gc'
[15:32:24.473]   - Field: 'conditions'
[15:32:24.474]   - Field: 'expr'
[15:32:24.474]   - Field: 'uuid'
[15:32:24.474]   - Field: 'seed'
[15:32:24.474]   - Field: 'version'
[15:32:24.475]   - Field: 'result'
[15:32:24.475]   - Field: 'asynchronous'
[15:32:24.475]   - Field: 'calls'
[15:32:24.476]   - Field: 'globals'
[15:32:24.476]   - Field: 'stdout'
[15:32:24.476]   - Field: 'earlySignal'
[15:32:24.476]   - Field: 'lazy'
[15:32:24.477]   - Field: 'state'
[15:32:24.477] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:24.477] - Launch lazy future ...
[15:32:24.478] Packages needed by the future expression (n = 0): <none>
[15:32:24.478] Packages needed by future strategies (n = 0): <none>
[15:32:24.479] {
[15:32:24.479]     {
[15:32:24.479]         {
[15:32:24.479]             ...future.startTime <- base::Sys.time()
[15:32:24.479]             {
[15:32:24.479]                 {
[15:32:24.479]                   {
[15:32:24.479]                     base::local({
[15:32:24.479]                       has_future <- base::requireNamespace("future", 
[15:32:24.479]                         quietly = TRUE)
[15:32:24.479]                       if (has_future) {
[15:32:24.479]                         ns <- base::getNamespace("future")
[15:32:24.479]                         version <- ns[[".package"]][["version"]]
[15:32:24.479]                         if (is.null(version)) 
[15:32:24.479]                           version <- utils::packageVersion("future")
[15:32:24.479]                       }
[15:32:24.479]                       else {
[15:32:24.479]                         version <- NULL
[15:32:24.479]                       }
[15:32:24.479]                       if (!has_future || version < "1.8.0") {
[15:32:24.479]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:24.479]                           "", base::R.version$version.string), 
[15:32:24.479]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:24.479]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:24.479]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:24.479]                             "release", "version")], collapse = " "), 
[15:32:24.479]                           hostname = base::Sys.info()[["nodename"]])
[15:32:24.479]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:24.479]                           info)
[15:32:24.479]                         info <- base::paste(info, collapse = "; ")
[15:32:24.479]                         if (!has_future) {
[15:32:24.479]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:24.479]                             info)
[15:32:24.479]                         }
[15:32:24.479]                         else {
[15:32:24.479]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:24.479]                             info, version)
[15:32:24.479]                         }
[15:32:24.479]                         base::stop(msg)
[15:32:24.479]                       }
[15:32:24.479]                     })
[15:32:24.479]                   }
[15:32:24.479]                   ...future.strategy.old <- future::plan("list")
[15:32:24.479]                   options(future.plan = NULL)
[15:32:24.479]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:24.479]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:24.479]                 }
[15:32:24.479]                 ...future.workdir <- getwd()
[15:32:24.479]             }
[15:32:24.479]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:24.479]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:24.479]         }
[15:32:24.479]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:24.479]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:24.479]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:24.479]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:24.479]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:24.479]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:24.479]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:24.479]             base::names(...future.oldOptions))
[15:32:24.479]     }
[15:32:24.479]     if (FALSE) {
[15:32:24.479]     }
[15:32:24.479]     else {
[15:32:24.479]         if (TRUE) {
[15:32:24.479]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:24.479]                 open = "w")
[15:32:24.479]         }
[15:32:24.479]         else {
[15:32:24.479]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:24.479]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:24.479]         }
[15:32:24.479]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:24.479]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:24.479]             base::sink(type = "output", split = FALSE)
[15:32:24.479]             base::close(...future.stdout)
[15:32:24.479]         }, add = TRUE)
[15:32:24.479]     }
[15:32:24.479]     ...future.frame <- base::sys.nframe()
[15:32:24.479]     ...future.conditions <- base::list()
[15:32:24.479]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:24.479]     if (FALSE) {
[15:32:24.479]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:24.479]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:24.479]     }
[15:32:24.479]     ...future.result <- base::tryCatch({
[15:32:24.479]         base::withCallingHandlers({
[15:32:24.479]             ...future.value <- base::withVisible(base::local({
[15:32:24.479]                 do.call(function(...) {
[15:32:24.479]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:24.479]                   if (!identical(...future.globals.maxSize.org, 
[15:32:24.479]                     ...future.globals.maxSize)) {
[15:32:24.479]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:24.479]                     on.exit(options(oopts), add = TRUE)
[15:32:24.479]                   }
[15:32:24.479]                   {
[15:32:24.479]                     lapply(seq_along(...future.elements_ii), 
[15:32:24.479]                       FUN = function(jj) {
[15:32:24.479]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:24.479]                         ...future.FUN(...future.X_jj, ...)
[15:32:24.479]                       })
[15:32:24.479]                   }
[15:32:24.479]                 }, args = future.call.arguments)
[15:32:24.479]             }))
[15:32:24.479]             future::FutureResult(value = ...future.value$value, 
[15:32:24.479]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:24.479]                   ...future.rng), globalenv = if (FALSE) 
[15:32:24.479]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:24.479]                     ...future.globalenv.names))
[15:32:24.479]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:24.479]         }, condition = base::local({
[15:32:24.479]             c <- base::c
[15:32:24.479]             inherits <- base::inherits
[15:32:24.479]             invokeRestart <- base::invokeRestart
[15:32:24.479]             length <- base::length
[15:32:24.479]             list <- base::list
[15:32:24.479]             seq.int <- base::seq.int
[15:32:24.479]             signalCondition <- base::signalCondition
[15:32:24.479]             sys.calls <- base::sys.calls
[15:32:24.479]             `[[` <- base::`[[`
[15:32:24.479]             `+` <- base::`+`
[15:32:24.479]             `<<-` <- base::`<<-`
[15:32:24.479]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:24.479]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:24.479]                   3L)]
[15:32:24.479]             }
[15:32:24.479]             function(cond) {
[15:32:24.479]                 is_error <- inherits(cond, "error")
[15:32:24.479]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:24.479]                   NULL)
[15:32:24.479]                 if (is_error) {
[15:32:24.479]                   sessionInformation <- function() {
[15:32:24.479]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:24.479]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:24.479]                       search = base::search(), system = base::Sys.info())
[15:32:24.479]                   }
[15:32:24.479]                   ...future.conditions[[length(...future.conditions) + 
[15:32:24.479]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:24.479]                     cond$call), session = sessionInformation(), 
[15:32:24.479]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:24.479]                   signalCondition(cond)
[15:32:24.479]                 }
[15:32:24.479]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:24.479]                 "immediateCondition"))) {
[15:32:24.479]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:24.479]                   ...future.conditions[[length(...future.conditions) + 
[15:32:24.479]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:24.479]                   if (TRUE && !signal) {
[15:32:24.479]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:24.479]                     {
[15:32:24.479]                       inherits <- base::inherits
[15:32:24.479]                       invokeRestart <- base::invokeRestart
[15:32:24.479]                       is.null <- base::is.null
[15:32:24.479]                       muffled <- FALSE
[15:32:24.479]                       if (inherits(cond, "message")) {
[15:32:24.479]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:24.479]                         if (muffled) 
[15:32:24.479]                           invokeRestart("muffleMessage")
[15:32:24.479]                       }
[15:32:24.479]                       else if (inherits(cond, "warning")) {
[15:32:24.479]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:24.479]                         if (muffled) 
[15:32:24.479]                           invokeRestart("muffleWarning")
[15:32:24.479]                       }
[15:32:24.479]                       else if (inherits(cond, "condition")) {
[15:32:24.479]                         if (!is.null(pattern)) {
[15:32:24.479]                           computeRestarts <- base::computeRestarts
[15:32:24.479]                           grepl <- base::grepl
[15:32:24.479]                           restarts <- computeRestarts(cond)
[15:32:24.479]                           for (restart in restarts) {
[15:32:24.479]                             name <- restart$name
[15:32:24.479]                             if (is.null(name)) 
[15:32:24.479]                               next
[15:32:24.479]                             if (!grepl(pattern, name)) 
[15:32:24.479]                               next
[15:32:24.479]                             invokeRestart(restart)
[15:32:24.479]                             muffled <- TRUE
[15:32:24.479]                             break
[15:32:24.479]                           }
[15:32:24.479]                         }
[15:32:24.479]                       }
[15:32:24.479]                       invisible(muffled)
[15:32:24.479]                     }
[15:32:24.479]                     muffleCondition(cond, pattern = "^muffle")
[15:32:24.479]                   }
[15:32:24.479]                 }
[15:32:24.479]                 else {
[15:32:24.479]                   if (TRUE) {
[15:32:24.479]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:24.479]                     {
[15:32:24.479]                       inherits <- base::inherits
[15:32:24.479]                       invokeRestart <- base::invokeRestart
[15:32:24.479]                       is.null <- base::is.null
[15:32:24.479]                       muffled <- FALSE
[15:32:24.479]                       if (inherits(cond, "message")) {
[15:32:24.479]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:24.479]                         if (muffled) 
[15:32:24.479]                           invokeRestart("muffleMessage")
[15:32:24.479]                       }
[15:32:24.479]                       else if (inherits(cond, "warning")) {
[15:32:24.479]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:24.479]                         if (muffled) 
[15:32:24.479]                           invokeRestart("muffleWarning")
[15:32:24.479]                       }
[15:32:24.479]                       else if (inherits(cond, "condition")) {
[15:32:24.479]                         if (!is.null(pattern)) {
[15:32:24.479]                           computeRestarts <- base::computeRestarts
[15:32:24.479]                           grepl <- base::grepl
[15:32:24.479]                           restarts <- computeRestarts(cond)
[15:32:24.479]                           for (restart in restarts) {
[15:32:24.479]                             name <- restart$name
[15:32:24.479]                             if (is.null(name)) 
[15:32:24.479]                               next
[15:32:24.479]                             if (!grepl(pattern, name)) 
[15:32:24.479]                               next
[15:32:24.479]                             invokeRestart(restart)
[15:32:24.479]                             muffled <- TRUE
[15:32:24.479]                             break
[15:32:24.479]                           }
[15:32:24.479]                         }
[15:32:24.479]                       }
[15:32:24.479]                       invisible(muffled)
[15:32:24.479]                     }
[15:32:24.479]                     muffleCondition(cond, pattern = "^muffle")
[15:32:24.479]                   }
[15:32:24.479]                 }
[15:32:24.479]             }
[15:32:24.479]         }))
[15:32:24.479]     }, error = function(ex) {
[15:32:24.479]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:24.479]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:24.479]                 ...future.rng), started = ...future.startTime, 
[15:32:24.479]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:24.479]             version = "1.8"), class = "FutureResult")
[15:32:24.479]     }, finally = {
[15:32:24.479]         if (!identical(...future.workdir, getwd())) 
[15:32:24.479]             setwd(...future.workdir)
[15:32:24.479]         {
[15:32:24.479]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:24.479]                 ...future.oldOptions$nwarnings <- NULL
[15:32:24.479]             }
[15:32:24.479]             base::options(...future.oldOptions)
[15:32:24.479]             if (.Platform$OS.type == "windows") {
[15:32:24.479]                 old_names <- names(...future.oldEnvVars)
[15:32:24.479]                 envs <- base::Sys.getenv()
[15:32:24.479]                 names <- names(envs)
[15:32:24.479]                 common <- intersect(names, old_names)
[15:32:24.479]                 added <- setdiff(names, old_names)
[15:32:24.479]                 removed <- setdiff(old_names, names)
[15:32:24.479]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:24.479]                   envs[common]]
[15:32:24.479]                 NAMES <- toupper(changed)
[15:32:24.479]                 args <- list()
[15:32:24.479]                 for (kk in seq_along(NAMES)) {
[15:32:24.479]                   name <- changed[[kk]]
[15:32:24.479]                   NAME <- NAMES[[kk]]
[15:32:24.479]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:24.479]                     next
[15:32:24.479]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:24.479]                 }
[15:32:24.479]                 NAMES <- toupper(added)
[15:32:24.479]                 for (kk in seq_along(NAMES)) {
[15:32:24.479]                   name <- added[[kk]]
[15:32:24.479]                   NAME <- NAMES[[kk]]
[15:32:24.479]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:24.479]                     next
[15:32:24.479]                   args[[name]] <- ""
[15:32:24.479]                 }
[15:32:24.479]                 NAMES <- toupper(removed)
[15:32:24.479]                 for (kk in seq_along(NAMES)) {
[15:32:24.479]                   name <- removed[[kk]]
[15:32:24.479]                   NAME <- NAMES[[kk]]
[15:32:24.479]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:24.479]                     next
[15:32:24.479]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:24.479]                 }
[15:32:24.479]                 if (length(args) > 0) 
[15:32:24.479]                   base::do.call(base::Sys.setenv, args = args)
[15:32:24.479]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:24.479]             }
[15:32:24.479]             else {
[15:32:24.479]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:24.479]             }
[15:32:24.479]             {
[15:32:24.479]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:24.479]                   0L) {
[15:32:24.479]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:24.479]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:24.479]                   base::options(opts)
[15:32:24.479]                 }
[15:32:24.479]                 {
[15:32:24.479]                   {
[15:32:24.479]                     NULL
[15:32:24.479]                     RNGkind("Mersenne-Twister")
[15:32:24.479]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:24.479]                       inherits = FALSE)
[15:32:24.479]                   }
[15:32:24.479]                   options(future.plan = NULL)
[15:32:24.479]                   if (is.na(NA_character_)) 
[15:32:24.479]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:24.479]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:24.479]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:24.479]                     .init = FALSE)
[15:32:24.479]                 }
[15:32:24.479]             }
[15:32:24.479]         }
[15:32:24.479]     })
[15:32:24.479]     if (TRUE) {
[15:32:24.479]         base::sink(type = "output", split = FALSE)
[15:32:24.479]         if (TRUE) {
[15:32:24.479]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:24.479]         }
[15:32:24.479]         else {
[15:32:24.479]             ...future.result["stdout"] <- base::list(NULL)
[15:32:24.479]         }
[15:32:24.479]         base::close(...future.stdout)
[15:32:24.479]         ...future.stdout <- NULL
[15:32:24.479]     }
[15:32:24.479]     ...future.result$conditions <- ...future.conditions
[15:32:24.479]     ...future.result$finished <- base::Sys.time()
[15:32:24.479]     ...future.result
[15:32:24.479] }
[15:32:24.486] assign_globals() ...
[15:32:24.486] List of 5
[15:32:24.486]  $ ...future.FUN            :function (x, y = 2 * 1:5)  
[15:32:24.486]  $ future.call.arguments    : list()
[15:32:24.486]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:24.486]  $ ...future.elements_ii    :List of 4
[15:32:24.486]   ..$ A: num 50
[15:32:24.486]   ..$ B: num 60
[15:32:24.486]   ..$ C: num 70
[15:32:24.486]   ..$ D: num 80
[15:32:24.486]  $ ...future.seeds_ii       : NULL
[15:32:24.486]  $ ...future.globals.maxSize: NULL
[15:32:24.486]  - attr(*, "where")=List of 5
[15:32:24.486]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:24.486]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:24.486]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:24.486]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:24.486]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:24.486]  - attr(*, "resolved")= logi FALSE
[15:32:24.486]  - attr(*, "total_size")= num 4728
[15:32:24.486]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:24.486]  - attr(*, "already-done")= logi TRUE
[15:32:24.497] - reassign environment for '...future.FUN'
[15:32:24.498] - copied '...future.FUN' to environment
[15:32:24.498] - copied 'future.call.arguments' to environment
[15:32:24.498] - copied '...future.elements_ii' to environment
[15:32:24.498] - copied '...future.seeds_ii' to environment
[15:32:24.499] - copied '...future.globals.maxSize' to environment
[15:32:24.499] assign_globals() ... done
[15:32:24.500] plan(): Setting new future strategy stack:
[15:32:24.500] List of future strategies:
[15:32:24.500] 1. sequential:
[15:32:24.500]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:24.500]    - tweaked: FALSE
[15:32:24.500]    - call: NULL
[15:32:24.501] plan(): nbrOfWorkers() = 1
[15:32:24.503] plan(): Setting new future strategy stack:
[15:32:24.503] List of future strategies:
[15:32:24.503] 1. sequential:
[15:32:24.503]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:24.503]    - tweaked: FALSE
[15:32:24.503]    - call: plan(strategy)
[15:32:24.504] plan(): nbrOfWorkers() = 1
[15:32:24.504] SequentialFuture started (and completed)
[15:32:24.504] - Launch lazy future ... done
[15:32:24.505] run() for 'SequentialFuture' ... done
[15:32:24.505] Created future:
[15:32:24.505] SequentialFuture:
[15:32:24.505] Label: 'future_sapply-1'
[15:32:24.505] Expression:
[15:32:24.505] {
[15:32:24.505]     do.call(function(...) {
[15:32:24.505]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:24.505]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:24.505]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:24.505]             on.exit(options(oopts), add = TRUE)
[15:32:24.505]         }
[15:32:24.505]         {
[15:32:24.505]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:24.505]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:24.505]                 ...future.FUN(...future.X_jj, ...)
[15:32:24.505]             })
[15:32:24.505]         }
[15:32:24.505]     }, args = future.call.arguments)
[15:32:24.505] }
[15:32:24.505] Lazy evaluation: FALSE
[15:32:24.505] Asynchronous evaluation: FALSE
[15:32:24.505] Local evaluation: TRUE
[15:32:24.505] Environment: R_GlobalEnv
[15:32:24.505] Capture standard output: TRUE
[15:32:24.505] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:24.505] Globals: 5 objects totaling 4.84 KiB (function '...future.FUN' of 4.62 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 224 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:24.505] Packages: <none>
[15:32:24.505] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:24.505] Resolved: TRUE
[15:32:24.505] Value: 1.34 KiB of class 'list'
[15:32:24.505] Early signaling: FALSE
[15:32:24.505] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:24.505] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:24.507] Chunk #1 of 1 ... DONE
[15:32:24.508] Launching 1 futures (chunks) ... DONE
[15:32:24.508] Resolving 1 futures (chunks) ...
[15:32:24.508] resolve() on list ...
[15:32:24.509]  recursive: 0
[15:32:24.509]  length: 1
[15:32:24.509] 
[15:32:24.509] resolved() for 'SequentialFuture' ...
[15:32:24.510] - state: 'finished'
[15:32:24.510] - run: TRUE
[15:32:24.510] - result: 'FutureResult'
[15:32:24.511] resolved() for 'SequentialFuture' ... done
[15:32:24.511] Future #1
[15:32:24.511] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:24.512] - nx: 1
[15:32:24.512] - relay: TRUE
[15:32:24.512] - stdout: TRUE
[15:32:24.512] - signal: TRUE
[15:32:24.512] - resignal: FALSE
[15:32:24.512] - force: TRUE
[15:32:24.513] - relayed: [n=1] FALSE
[15:32:24.513] - queued futures: [n=1] FALSE
[15:32:24.513]  - until=1
[15:32:24.513]  - relaying element #1
[15:32:24.513] - relayed: [n=1] TRUE
[15:32:24.514] - queued futures: [n=1] TRUE
[15:32:24.514] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:24.514]  length: 0 (resolved future 1)
[15:32:24.514] Relaying remaining futures
[15:32:24.514] signalConditionsASAP(NULL, pos=0) ...
[15:32:24.514] - nx: 1
[15:32:24.515] - relay: TRUE
[15:32:24.515] - stdout: TRUE
[15:32:24.515] - signal: TRUE
[15:32:24.515] - resignal: FALSE
[15:32:24.516] - force: TRUE
[15:32:24.516] - relayed: [n=1] TRUE
[15:32:24.516] - queued futures: [n=1] TRUE
 - flush all
[15:32:24.517] - relayed: [n=1] TRUE
[15:32:24.517] - queued futures: [n=1] TRUE
[15:32:24.517] signalConditionsASAP(NULL, pos=0) ... done
[15:32:24.517] resolve() on list ... DONE
[15:32:24.518]  - Number of value chunks collected: 1
[15:32:24.518] Resolving 1 futures (chunks) ... DONE
[15:32:24.518] Reducing values from 1 chunks ...
[15:32:24.519]  - Number of values collected after concatenation: 4
[15:32:24.519]  - Number of values expected: 4
[15:32:24.519] Reducing values from 1 chunks ... DONE
[15:32:24.519] future_lapply() ... DONE
List of 2
 $ y0: num [1:15, 1:4] 100 100 100 200 200 200 300 300 300 400 ...
  ..- attr(*, "dimnames")=List of 2
  .. ..$ : NULL
  .. ..$ : chr [1:4] "A" "B" "C" "D"
 $ y1: num [1:15, 1:4] 100 100 100 200 200 200 300 300 300 400 ...
  ..- attr(*, "dimnames")=List of 2
  .. ..$ : NULL
  .. ..$ : chr [1:4] "A" "B" "C" "D"
[15:32:24.525] future_lapply() ...
[15:32:24.526] Number of chunks: 1
[15:32:24.526] getGlobalsAndPackagesXApply() ...
[15:32:24.526]  - future.globals: TRUE
[15:32:24.527] getGlobalsAndPackages() ...
[15:32:24.527] Searching for globals...
[15:32:24.532] - globals found: [1] 'FUN'
[15:32:24.532] Searching for globals ... DONE
[15:32:24.533] Resolving globals: FALSE
[15:32:24.533] The total size of the 1 globals is 848 bytes (848 bytes)
[15:32:24.534] The total size of the 1 globals exported for future expression ('FUN()') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:32:24.534] - globals: [1] 'FUN'
[15:32:24.534] 
[15:32:24.535] getGlobalsAndPackages() ... DONE
[15:32:24.535]  - globals found/used: [n=1] 'FUN'
[15:32:24.535]  - needed namespaces: [n=0] 
[15:32:24.535] Finding globals ... DONE
[15:32:24.536]  - use_args: TRUE
[15:32:24.536]  - Getting '...' globals ...
[15:32:24.537] resolve() on list ...
[15:32:24.537]  recursive: 0
[15:32:24.537]  length: 1
[15:32:24.537]  elements: '...'
[15:32:24.538]  length: 0 (resolved future 1)
[15:32:24.538] resolve() on list ... DONE
[15:32:24.538]    - '...' content: [n=0] 
[15:32:24.539] List of 1
[15:32:24.539]  $ ...: list()
[15:32:24.539]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:24.539]  - attr(*, "where")=List of 1
[15:32:24.539]   ..$ ...:<environment: 0x00000276e5c34500> 
[15:32:24.539]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:24.539]  - attr(*, "resolved")= logi TRUE
[15:32:24.539]  - attr(*, "total_size")= num NA
[15:32:24.543]  - Getting '...' globals ... DONE
[15:32:24.544] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:24.544] List of 2
[15:32:24.544]  $ ...future.FUN:function (x)  
[15:32:24.544]  $ ...          : list()
[15:32:24.544]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:24.544]  - attr(*, "where")=List of 2
[15:32:24.544]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:24.544]   ..$ ...          :<environment: 0x00000276e5c34500> 
[15:32:24.544]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:24.544]  - attr(*, "resolved")= logi FALSE
[15:32:24.544]  - attr(*, "total_size")= num 848
[15:32:24.549] Packages to be attached in all futures: [n=0] 
[15:32:24.549] getGlobalsAndPackagesXApply() ... DONE
[15:32:24.549] Number of futures (= number of chunks): 1
[15:32:24.550] Launching 1 futures (chunks) ...
[15:32:24.550] Chunk #1 of 1 ...
[15:32:24.550]  - Finding globals in 'X' for chunk #1 ...
[15:32:24.551] getGlobalsAndPackages() ...
[15:32:24.551] Searching for globals...
[15:32:24.551] 
[15:32:24.552] Searching for globals ... DONE
[15:32:24.552] - globals: [0] <none>
[15:32:24.552] getGlobalsAndPackages() ... DONE
[15:32:24.552]    + additional globals found: [n=0] 
[15:32:24.553]    + additional namespaces needed: [n=0] 
[15:32:24.553]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:24.553]  - seeds: <none>
[15:32:24.554]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:24.554] getGlobalsAndPackages() ...
[15:32:24.554] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:24.554] Resolving globals: FALSE
[15:32:24.555] Tweak future expression to call with '...' arguments ...
[15:32:24.555] {
[15:32:24.555]     do.call(function(...) {
[15:32:24.555]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:24.555]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:24.555]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:24.555]             on.exit(options(oopts), add = TRUE)
[15:32:24.555]         }
[15:32:24.555]         {
[15:32:24.555]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:24.555]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:24.555]                 ...future.FUN(...future.X_jj, ...)
[15:32:24.555]             })
[15:32:24.555]         }
[15:32:24.555]     }, args = future.call.arguments)
[15:32:24.555] }
[15:32:24.556] Tweak future expression to call with '...' arguments ... DONE
[15:32:24.557] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:24.557] 
[15:32:24.557] getGlobalsAndPackages() ... DONE
[15:32:24.558] run() for 'Future' ...
[15:32:24.558] - state: 'created'
[15:32:24.558] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:24.559] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:24.559] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:24.559]   - Field: 'label'
[15:32:24.560]   - Field: 'local'
[15:32:24.560]   - Field: 'owner'
[15:32:24.560]   - Field: 'envir'
[15:32:24.561]   - Field: 'packages'
[15:32:24.561]   - Field: 'gc'
[15:32:24.561]   - Field: 'conditions'
[15:32:24.561]   - Field: 'expr'
[15:32:24.562]   - Field: 'uuid'
[15:32:24.562]   - Field: 'seed'
[15:32:24.562]   - Field: 'version'
[15:32:24.563]   - Field: 'result'
[15:32:24.563]   - Field: 'asynchronous'
[15:32:24.563]   - Field: 'calls'
[15:32:24.563]   - Field: 'globals'
[15:32:24.564]   - Field: 'stdout'
[15:32:24.564]   - Field: 'earlySignal'
[15:32:24.564]   - Field: 'lazy'
[15:32:24.565]   - Field: 'state'
[15:32:24.565] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:24.565] - Launch lazy future ...
[15:32:24.566] Packages needed by the future expression (n = 0): <none>
[15:32:24.566] Packages needed by future strategies (n = 0): <none>
[15:32:24.567] {
[15:32:24.567]     {
[15:32:24.567]         {
[15:32:24.567]             ...future.startTime <- base::Sys.time()
[15:32:24.567]             {
[15:32:24.567]                 {
[15:32:24.567]                   {
[15:32:24.567]                     base::local({
[15:32:24.567]                       has_future <- base::requireNamespace("future", 
[15:32:24.567]                         quietly = TRUE)
[15:32:24.567]                       if (has_future) {
[15:32:24.567]                         ns <- base::getNamespace("future")
[15:32:24.567]                         version <- ns[[".package"]][["version"]]
[15:32:24.567]                         if (is.null(version)) 
[15:32:24.567]                           version <- utils::packageVersion("future")
[15:32:24.567]                       }
[15:32:24.567]                       else {
[15:32:24.567]                         version <- NULL
[15:32:24.567]                       }
[15:32:24.567]                       if (!has_future || version < "1.8.0") {
[15:32:24.567]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:24.567]                           "", base::R.version$version.string), 
[15:32:24.567]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:24.567]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:24.567]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:24.567]                             "release", "version")], collapse = " "), 
[15:32:24.567]                           hostname = base::Sys.info()[["nodename"]])
[15:32:24.567]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:24.567]                           info)
[15:32:24.567]                         info <- base::paste(info, collapse = "; ")
[15:32:24.567]                         if (!has_future) {
[15:32:24.567]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:24.567]                             info)
[15:32:24.567]                         }
[15:32:24.567]                         else {
[15:32:24.567]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:24.567]                             info, version)
[15:32:24.567]                         }
[15:32:24.567]                         base::stop(msg)
[15:32:24.567]                       }
[15:32:24.567]                     })
[15:32:24.567]                   }
[15:32:24.567]                   ...future.strategy.old <- future::plan("list")
[15:32:24.567]                   options(future.plan = NULL)
[15:32:24.567]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:24.567]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:24.567]                 }
[15:32:24.567]                 ...future.workdir <- getwd()
[15:32:24.567]             }
[15:32:24.567]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:24.567]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:24.567]         }
[15:32:24.567]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:24.567]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:24.567]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:24.567]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:24.567]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:24.567]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:24.567]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:24.567]             base::names(...future.oldOptions))
[15:32:24.567]     }
[15:32:24.567]     if (FALSE) {
[15:32:24.567]     }
[15:32:24.567]     else {
[15:32:24.567]         if (TRUE) {
[15:32:24.567]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:24.567]                 open = "w")
[15:32:24.567]         }
[15:32:24.567]         else {
[15:32:24.567]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:24.567]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:24.567]         }
[15:32:24.567]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:24.567]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:24.567]             base::sink(type = "output", split = FALSE)
[15:32:24.567]             base::close(...future.stdout)
[15:32:24.567]         }, add = TRUE)
[15:32:24.567]     }
[15:32:24.567]     ...future.frame <- base::sys.nframe()
[15:32:24.567]     ...future.conditions <- base::list()
[15:32:24.567]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:24.567]     if (FALSE) {
[15:32:24.567]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:24.567]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:24.567]     }
[15:32:24.567]     ...future.result <- base::tryCatch({
[15:32:24.567]         base::withCallingHandlers({
[15:32:24.567]             ...future.value <- base::withVisible(base::local({
[15:32:24.567]                 do.call(function(...) {
[15:32:24.567]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:24.567]                   if (!identical(...future.globals.maxSize.org, 
[15:32:24.567]                     ...future.globals.maxSize)) {
[15:32:24.567]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:24.567]                     on.exit(options(oopts), add = TRUE)
[15:32:24.567]                   }
[15:32:24.567]                   {
[15:32:24.567]                     lapply(seq_along(...future.elements_ii), 
[15:32:24.567]                       FUN = function(jj) {
[15:32:24.567]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:24.567]                         ...future.FUN(...future.X_jj, ...)
[15:32:24.567]                       })
[15:32:24.567]                   }
[15:32:24.567]                 }, args = future.call.arguments)
[15:32:24.567]             }))
[15:32:24.567]             future::FutureResult(value = ...future.value$value, 
[15:32:24.567]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:24.567]                   ...future.rng), globalenv = if (FALSE) 
[15:32:24.567]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:24.567]                     ...future.globalenv.names))
[15:32:24.567]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:24.567]         }, condition = base::local({
[15:32:24.567]             c <- base::c
[15:32:24.567]             inherits <- base::inherits
[15:32:24.567]             invokeRestart <- base::invokeRestart
[15:32:24.567]             length <- base::length
[15:32:24.567]             list <- base::list
[15:32:24.567]             seq.int <- base::seq.int
[15:32:24.567]             signalCondition <- base::signalCondition
[15:32:24.567]             sys.calls <- base::sys.calls
[15:32:24.567]             `[[` <- base::`[[`
[15:32:24.567]             `+` <- base::`+`
[15:32:24.567]             `<<-` <- base::`<<-`
[15:32:24.567]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:24.567]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:24.567]                   3L)]
[15:32:24.567]             }
[15:32:24.567]             function(cond) {
[15:32:24.567]                 is_error <- inherits(cond, "error")
[15:32:24.567]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:24.567]                   NULL)
[15:32:24.567]                 if (is_error) {
[15:32:24.567]                   sessionInformation <- function() {
[15:32:24.567]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:24.567]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:24.567]                       search = base::search(), system = base::Sys.info())
[15:32:24.567]                   }
[15:32:24.567]                   ...future.conditions[[length(...future.conditions) + 
[15:32:24.567]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:24.567]                     cond$call), session = sessionInformation(), 
[15:32:24.567]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:24.567]                   signalCondition(cond)
[15:32:24.567]                 }
[15:32:24.567]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:24.567]                 "immediateCondition"))) {
[15:32:24.567]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:24.567]                   ...future.conditions[[length(...future.conditions) + 
[15:32:24.567]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:24.567]                   if (TRUE && !signal) {
[15:32:24.567]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:24.567]                     {
[15:32:24.567]                       inherits <- base::inherits
[15:32:24.567]                       invokeRestart <- base::invokeRestart
[15:32:24.567]                       is.null <- base::is.null
[15:32:24.567]                       muffled <- FALSE
[15:32:24.567]                       if (inherits(cond, "message")) {
[15:32:24.567]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:24.567]                         if (muffled) 
[15:32:24.567]                           invokeRestart("muffleMessage")
[15:32:24.567]                       }
[15:32:24.567]                       else if (inherits(cond, "warning")) {
[15:32:24.567]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:24.567]                         if (muffled) 
[15:32:24.567]                           invokeRestart("muffleWarning")
[15:32:24.567]                       }
[15:32:24.567]                       else if (inherits(cond, "condition")) {
[15:32:24.567]                         if (!is.null(pattern)) {
[15:32:24.567]                           computeRestarts <- base::computeRestarts
[15:32:24.567]                           grepl <- base::grepl
[15:32:24.567]                           restarts <- computeRestarts(cond)
[15:32:24.567]                           for (restart in restarts) {
[15:32:24.567]                             name <- restart$name
[15:32:24.567]                             if (is.null(name)) 
[15:32:24.567]                               next
[15:32:24.567]                             if (!grepl(pattern, name)) 
[15:32:24.567]                               next
[15:32:24.567]                             invokeRestart(restart)
[15:32:24.567]                             muffled <- TRUE
[15:32:24.567]                             break
[15:32:24.567]                           }
[15:32:24.567]                         }
[15:32:24.567]                       }
[15:32:24.567]                       invisible(muffled)
[15:32:24.567]                     }
[15:32:24.567]                     muffleCondition(cond, pattern = "^muffle")
[15:32:24.567]                   }
[15:32:24.567]                 }
[15:32:24.567]                 else {
[15:32:24.567]                   if (TRUE) {
[15:32:24.567]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:24.567]                     {
[15:32:24.567]                       inherits <- base::inherits
[15:32:24.567]                       invokeRestart <- base::invokeRestart
[15:32:24.567]                       is.null <- base::is.null
[15:32:24.567]                       muffled <- FALSE
[15:32:24.567]                       if (inherits(cond, "message")) {
[15:32:24.567]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:24.567]                         if (muffled) 
[15:32:24.567]                           invokeRestart("muffleMessage")
[15:32:24.567]                       }
[15:32:24.567]                       else if (inherits(cond, "warning")) {
[15:32:24.567]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:24.567]                         if (muffled) 
[15:32:24.567]                           invokeRestart("muffleWarning")
[15:32:24.567]                       }
[15:32:24.567]                       else if (inherits(cond, "condition")) {
[15:32:24.567]                         if (!is.null(pattern)) {
[15:32:24.567]                           computeRestarts <- base::computeRestarts
[15:32:24.567]                           grepl <- base::grepl
[15:32:24.567]                           restarts <- computeRestarts(cond)
[15:32:24.567]                           for (restart in restarts) {
[15:32:24.567]                             name <- restart$name
[15:32:24.567]                             if (is.null(name)) 
[15:32:24.567]                               next
[15:32:24.567]                             if (!grepl(pattern, name)) 
[15:32:24.567]                               next
[15:32:24.567]                             invokeRestart(restart)
[15:32:24.567]                             muffled <- TRUE
[15:32:24.567]                             break
[15:32:24.567]                           }
[15:32:24.567]                         }
[15:32:24.567]                       }
[15:32:24.567]                       invisible(muffled)
[15:32:24.567]                     }
[15:32:24.567]                     muffleCondition(cond, pattern = "^muffle")
[15:32:24.567]                   }
[15:32:24.567]                 }
[15:32:24.567]             }
[15:32:24.567]         }))
[15:32:24.567]     }, error = function(ex) {
[15:32:24.567]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:24.567]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:24.567]                 ...future.rng), started = ...future.startTime, 
[15:32:24.567]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:24.567]             version = "1.8"), class = "FutureResult")
[15:32:24.567]     }, finally = {
[15:32:24.567]         if (!identical(...future.workdir, getwd())) 
[15:32:24.567]             setwd(...future.workdir)
[15:32:24.567]         {
[15:32:24.567]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:24.567]                 ...future.oldOptions$nwarnings <- NULL
[15:32:24.567]             }
[15:32:24.567]             base::options(...future.oldOptions)
[15:32:24.567]             if (.Platform$OS.type == "windows") {
[15:32:24.567]                 old_names <- names(...future.oldEnvVars)
[15:32:24.567]                 envs <- base::Sys.getenv()
[15:32:24.567]                 names <- names(envs)
[15:32:24.567]                 common <- intersect(names, old_names)
[15:32:24.567]                 added <- setdiff(names, old_names)
[15:32:24.567]                 removed <- setdiff(old_names, names)
[15:32:24.567]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:24.567]                   envs[common]]
[15:32:24.567]                 NAMES <- toupper(changed)
[15:32:24.567]                 args <- list()
[15:32:24.567]                 for (kk in seq_along(NAMES)) {
[15:32:24.567]                   name <- changed[[kk]]
[15:32:24.567]                   NAME <- NAMES[[kk]]
[15:32:24.567]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:24.567]                     next
[15:32:24.567]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:24.567]                 }
[15:32:24.567]                 NAMES <- toupper(added)
[15:32:24.567]                 for (kk in seq_along(NAMES)) {
[15:32:24.567]                   name <- added[[kk]]
[15:32:24.567]                   NAME <- NAMES[[kk]]
[15:32:24.567]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:24.567]                     next
[15:32:24.567]                   args[[name]] <- ""
[15:32:24.567]                 }
[15:32:24.567]                 NAMES <- toupper(removed)
[15:32:24.567]                 for (kk in seq_along(NAMES)) {
[15:32:24.567]                   name <- removed[[kk]]
[15:32:24.567]                   NAME <- NAMES[[kk]]
[15:32:24.567]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:24.567]                     next
[15:32:24.567]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:24.567]                 }
[15:32:24.567]                 if (length(args) > 0) 
[15:32:24.567]                   base::do.call(base::Sys.setenv, args = args)
[15:32:24.567]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:24.567]             }
[15:32:24.567]             else {
[15:32:24.567]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:24.567]             }
[15:32:24.567]             {
[15:32:24.567]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:24.567]                   0L) {
[15:32:24.567]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:24.567]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:24.567]                   base::options(opts)
[15:32:24.567]                 }
[15:32:24.567]                 {
[15:32:24.567]                   {
[15:32:24.567]                     NULL
[15:32:24.567]                     RNGkind("Mersenne-Twister")
[15:32:24.567]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:24.567]                       inherits = FALSE)
[15:32:24.567]                   }
[15:32:24.567]                   options(future.plan = NULL)
[15:32:24.567]                   if (is.na(NA_character_)) 
[15:32:24.567]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:24.567]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:24.567]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:24.567]                     .init = FALSE)
[15:32:24.567]                 }
[15:32:24.567]             }
[15:32:24.567]         }
[15:32:24.567]     })
[15:32:24.567]     if (TRUE) {
[15:32:24.567]         base::sink(type = "output", split = FALSE)
[15:32:24.567]         if (TRUE) {
[15:32:24.567]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:24.567]         }
[15:32:24.567]         else {
[15:32:24.567]             ...future.result["stdout"] <- base::list(NULL)
[15:32:24.567]         }
[15:32:24.567]         base::close(...future.stdout)
[15:32:24.567]         ...future.stdout <- NULL
[15:32:24.567]     }
[15:32:24.567]     ...future.result$conditions <- ...future.conditions
[15:32:24.567]     ...future.result$finished <- base::Sys.time()
[15:32:24.567]     ...future.result
[15:32:24.567] }
[15:32:24.573] assign_globals() ...
[15:32:24.573] List of 5
[15:32:24.573]  $ ...future.FUN            :function (x)  
[15:32:24.573]  $ future.call.arguments    : list()
[15:32:24.573]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:24.573]  $ ...future.elements_ii    :List of 4
[15:32:24.573]   ..$ A: num 50
[15:32:24.573]   ..$ B: num 60
[15:32:24.573]   ..$ C: num 70
[15:32:24.573]   ..$ D: num 80
[15:32:24.573]  $ ...future.seeds_ii       : NULL
[15:32:24.573]  $ ...future.globals.maxSize: NULL
[15:32:24.573]  - attr(*, "where")=List of 5
[15:32:24.573]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:24.573]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:24.573]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:24.573]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:24.573]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:24.573]  - attr(*, "resolved")= logi FALSE
[15:32:24.573]  - attr(*, "total_size")= num 848
[15:32:24.573]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:24.573]  - attr(*, "already-done")= logi TRUE
[15:32:24.583] - copied '...future.FUN' to environment
[15:32:24.584] - copied 'future.call.arguments' to environment
[15:32:24.584] - copied '...future.elements_ii' to environment
[15:32:24.584] - copied '...future.seeds_ii' to environment
[15:32:24.584] - copied '...future.globals.maxSize' to environment
[15:32:24.585] assign_globals() ... done
[15:32:24.585] plan(): Setting new future strategy stack:
[15:32:24.585] List of future strategies:
[15:32:24.585] 1. sequential:
[15:32:24.585]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:24.585]    - tweaked: FALSE
[15:32:24.585]    - call: NULL
[15:32:24.586] plan(): nbrOfWorkers() = 1
[15:32:24.588] plan(): Setting new future strategy stack:
[15:32:24.588] List of future strategies:
[15:32:24.588] 1. sequential:
[15:32:24.588]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:24.588]    - tweaked: FALSE
[15:32:24.588]    - call: plan(strategy)
[15:32:24.589] plan(): nbrOfWorkers() = 1
[15:32:24.590] SequentialFuture started (and completed)
[15:32:24.590] - Launch lazy future ... done
[15:32:24.590] run() for 'SequentialFuture' ... done
[15:32:24.591] Created future:
[15:32:24.591] SequentialFuture:
[15:32:24.591] Label: 'future_sapply-1'
[15:32:24.591] Expression:
[15:32:24.591] {
[15:32:24.591]     do.call(function(...) {
[15:32:24.591]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:24.591]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:24.591]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:24.591]             on.exit(options(oopts), add = TRUE)
[15:32:24.591]         }
[15:32:24.591]         {
[15:32:24.591]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:24.591]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:24.591]                 ...future.FUN(...future.X_jj, ...)
[15:32:24.591]             })
[15:32:24.591]         }
[15:32:24.591]     }, args = future.call.arguments)
[15:32:24.591] }
[15:32:24.591] Lazy evaluation: FALSE
[15:32:24.591] Asynchronous evaluation: FALSE
[15:32:24.591] Local evaluation: TRUE
[15:32:24.591] Environment: R_GlobalEnv
[15:32:24.591] Capture standard output: TRUE
[15:32:24.591] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:24.591] Globals: 5 objects totaling 1.05 KiB (function '...future.FUN' of 848 bytes, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 224 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:24.591] Packages: <none>
[15:32:24.591] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:24.591] Resolved: TRUE
[15:32:24.591] Value: 224 bytes of class 'list'
[15:32:24.591] Early signaling: FALSE
[15:32:24.591] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:24.591] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:24.593] Chunk #1 of 1 ... DONE
[15:32:24.593] Launching 1 futures (chunks) ... DONE
[15:32:24.593] Resolving 1 futures (chunks) ...
[15:32:24.594] resolve() on list ...
[15:32:24.594]  recursive: 0
[15:32:24.594]  length: 1
[15:32:24.594] 
[15:32:24.595] resolved() for 'SequentialFuture' ...
[15:32:24.595] - state: 'finished'
[15:32:24.595] - run: TRUE
[15:32:24.595] - result: 'FutureResult'
[15:32:24.596] resolved() for 'SequentialFuture' ... done
[15:32:24.596] Future #1
[15:32:24.596] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:24.597] - nx: 1
[15:32:24.597] - relay: TRUE
[15:32:24.597] - stdout: TRUE
[15:32:24.597] - signal: TRUE
[15:32:24.598] - resignal: FALSE
[15:32:24.598] - force: TRUE
[15:32:24.598] - relayed: [n=1] FALSE
[15:32:24.598] - queued futures: [n=1] FALSE
[15:32:24.599]  - until=1
[15:32:24.599]  - relaying element #1
[15:32:24.599] - relayed: [n=1] TRUE
[15:32:24.600] - queued futures: [n=1] TRUE
[15:32:24.600] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:24.600]  length: 0 (resolved future 1)
[15:32:24.600] Relaying remaining futures
[15:32:24.601] signalConditionsASAP(NULL, pos=0) ...
[15:32:24.601] - nx: 1
[15:32:24.601] - relay: TRUE
[15:32:24.602] - stdout: TRUE
[15:32:24.602] - signal: TRUE
[15:32:24.602] - resignal: FALSE
[15:32:24.602] - force: TRUE
[15:32:24.603] - relayed: [n=1] TRUE
[15:32:24.603] - queued futures: [n=1] TRUE
 - flush all
[15:32:24.603] - relayed: [n=1] TRUE
[15:32:24.604] - queued futures: [n=1] TRUE
[15:32:24.604] signalConditionsASAP(NULL, pos=0) ... done
[15:32:24.604] resolve() on list ... DONE
[15:32:24.605]  - Number of value chunks collected: 1
[15:32:24.605] Resolving 1 futures (chunks) ... DONE
[15:32:24.605] Reducing values from 1 chunks ...
[15:32:24.605]  - Number of values collected after concatenation: 4
[15:32:24.606]  - Number of values expected: 4
[15:32:24.606] Reducing values from 1 chunks ... DONE
[15:32:24.606] future_lapply() ... DONE
List of 2
 $ y0: Named num [1:4] 50 60 70 80
  ..- attr(*, "names")= chr [1:4] "A" "B" "C" "D"
 $ y1: Named num [1:4] 50 60 70 80
  ..- attr(*, "names")= chr [1:4] "A" "B" "C" "D"
[15:32:24.609] future_lapply() ...
[15:32:24.610] Number of chunks: 1
[15:32:24.611] getGlobalsAndPackagesXApply() ...
[15:32:24.611]  - future.globals: TRUE
[15:32:24.611] getGlobalsAndPackages() ...
[15:32:24.611] Searching for globals...
[15:32:24.613] - globals found: [2] 'FUN', 'UseMethod'
[15:32:24.614] Searching for globals ... DONE
[15:32:24.614] Resolving globals: FALSE
[15:32:24.615] The total size of the 1 globals is 1.22 KiB (1248 bytes)
[15:32:24.615] The total size of the 1 globals exported for future expression ('FUN()') is 1.22 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.22 KiB of class 'function')
[15:32:24.616] - globals: [1] 'FUN'
[15:32:24.616] 
[15:32:24.616] getGlobalsAndPackages() ... DONE
[15:32:24.616]  - globals found/used: [n=1] 'FUN'
[15:32:24.617]  - needed namespaces: [n=0] 
[15:32:24.617] Finding globals ... DONE
[15:32:24.617]  - use_args: TRUE
[15:32:24.617]  - Getting '...' globals ...
[15:32:24.618] resolve() on list ...
[15:32:24.618]  recursive: 0
[15:32:24.619]  length: 1
[15:32:24.619]  elements: '...'
[15:32:24.619]  length: 0 (resolved future 1)
[15:32:24.619] resolve() on list ... DONE
[15:32:24.620]    - '...' content: [n=0] 
[15:32:24.620] List of 1
[15:32:24.620]  $ ...: list()
[15:32:24.620]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:24.620]  - attr(*, "where")=List of 1
[15:32:24.620]   ..$ ...:<environment: 0x00000276e4610a08> 
[15:32:24.620]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:24.620]  - attr(*, "resolved")= logi TRUE
[15:32:24.620]  - attr(*, "total_size")= num NA
[15:32:24.624]  - Getting '...' globals ... DONE
[15:32:24.625] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:24.625] List of 2
[15:32:24.625]  $ ...future.FUN:function (x, ...)  
[15:32:24.625]  $ ...          : list()
[15:32:24.625]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:24.625]  - attr(*, "where")=List of 2
[15:32:24.625]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:24.625]   ..$ ...          :<environment: 0x00000276e4610a08> 
[15:32:24.625]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:24.625]  - attr(*, "resolved")= logi FALSE
[15:32:24.625]  - attr(*, "total_size")= num 1248
[15:32:24.630] Packages to be attached in all futures: [n=0] 
[15:32:24.630] getGlobalsAndPackagesXApply() ... DONE
[15:32:24.630] Number of futures (= number of chunks): 1
[15:32:24.631] Launching 1 futures (chunks) ...
[15:32:24.631] Chunk #1 of 1 ...
[15:32:24.631]  - Finding globals in 'X' for chunk #1 ...
[15:32:24.631] getGlobalsAndPackages() ...
[15:32:24.632] Searching for globals...
[15:32:24.632] 
[15:32:24.632] Searching for globals ... DONE
[15:32:24.633] - globals: [0] <none>
[15:32:24.633] getGlobalsAndPackages() ... DONE
[15:32:24.633]    + additional globals found: [n=0] 
[15:32:24.633]    + additional namespaces needed: [n=0] 
[15:32:24.634]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:24.634]  - seeds: <none>
[15:32:24.634]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:24.634] getGlobalsAndPackages() ...
[15:32:24.635] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:24.635] Resolving globals: FALSE
[15:32:24.635] Tweak future expression to call with '...' arguments ...
[15:32:24.636] {
[15:32:24.636]     do.call(function(...) {
[15:32:24.636]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:24.636]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:24.636]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:24.636]             on.exit(options(oopts), add = TRUE)
[15:32:24.636]         }
[15:32:24.636]         {
[15:32:24.636]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:24.636]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:24.636]                 ...future.FUN(...future.X_jj, ...)
[15:32:24.636]             })
[15:32:24.636]         }
[15:32:24.636]     }, args = future.call.arguments)
[15:32:24.636] }
[15:32:24.636] Tweak future expression to call with '...' arguments ... DONE
[15:32:24.637] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:24.637] 
[15:32:24.637] getGlobalsAndPackages() ... DONE
[15:32:24.638] run() for 'Future' ...
[15:32:24.638] - state: 'created'
[15:32:24.639] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:24.639] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:24.640] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:24.640]   - Field: 'label'
[15:32:24.640]   - Field: 'local'
[15:32:24.640]   - Field: 'owner'
[15:32:24.641]   - Field: 'envir'
[15:32:24.641]   - Field: 'packages'
[15:32:24.641]   - Field: 'gc'
[15:32:24.641]   - Field: 'conditions'
[15:32:24.642]   - Field: 'expr'
[15:32:24.642]   - Field: 'uuid'
[15:32:24.642]   - Field: 'seed'
[15:32:24.643]   - Field: 'version'
[15:32:24.643]   - Field: 'result'
[15:32:24.643]   - Field: 'asynchronous'
[15:32:24.643]   - Field: 'calls'
[15:32:24.643]   - Field: 'globals'
[15:32:24.644]   - Field: 'stdout'
[15:32:24.644]   - Field: 'earlySignal'
[15:32:24.644]   - Field: 'lazy'
[15:32:24.644]   - Field: 'state'
[15:32:24.644] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:24.644] - Launch lazy future ...
[15:32:24.645] Packages needed by the future expression (n = 0): <none>
[15:32:24.645] Packages needed by future strategies (n = 0): <none>
[15:32:24.646] {
[15:32:24.646]     {
[15:32:24.646]         {
[15:32:24.646]             ...future.startTime <- base::Sys.time()
[15:32:24.646]             {
[15:32:24.646]                 {
[15:32:24.646]                   {
[15:32:24.646]                     base::local({
[15:32:24.646]                       has_future <- base::requireNamespace("future", 
[15:32:24.646]                         quietly = TRUE)
[15:32:24.646]                       if (has_future) {
[15:32:24.646]                         ns <- base::getNamespace("future")
[15:32:24.646]                         version <- ns[[".package"]][["version"]]
[15:32:24.646]                         if (is.null(version)) 
[15:32:24.646]                           version <- utils::packageVersion("future")
[15:32:24.646]                       }
[15:32:24.646]                       else {
[15:32:24.646]                         version <- NULL
[15:32:24.646]                       }
[15:32:24.646]                       if (!has_future || version < "1.8.0") {
[15:32:24.646]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:24.646]                           "", base::R.version$version.string), 
[15:32:24.646]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:24.646]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:24.646]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:24.646]                             "release", "version")], collapse = " "), 
[15:32:24.646]                           hostname = base::Sys.info()[["nodename"]])
[15:32:24.646]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:24.646]                           info)
[15:32:24.646]                         info <- base::paste(info, collapse = "; ")
[15:32:24.646]                         if (!has_future) {
[15:32:24.646]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:24.646]                             info)
[15:32:24.646]                         }
[15:32:24.646]                         else {
[15:32:24.646]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:24.646]                             info, version)
[15:32:24.646]                         }
[15:32:24.646]                         base::stop(msg)
[15:32:24.646]                       }
[15:32:24.646]                     })
[15:32:24.646]                   }
[15:32:24.646]                   ...future.strategy.old <- future::plan("list")
[15:32:24.646]                   options(future.plan = NULL)
[15:32:24.646]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:24.646]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:24.646]                 }
[15:32:24.646]                 ...future.workdir <- getwd()
[15:32:24.646]             }
[15:32:24.646]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:24.646]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:24.646]         }
[15:32:24.646]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:24.646]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:24.646]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:24.646]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:24.646]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:24.646]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:24.646]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:24.646]             base::names(...future.oldOptions))
[15:32:24.646]     }
[15:32:24.646]     if (FALSE) {
[15:32:24.646]     }
[15:32:24.646]     else {
[15:32:24.646]         if (TRUE) {
[15:32:24.646]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:24.646]                 open = "w")
[15:32:24.646]         }
[15:32:24.646]         else {
[15:32:24.646]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:24.646]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:24.646]         }
[15:32:24.646]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:24.646]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:24.646]             base::sink(type = "output", split = FALSE)
[15:32:24.646]             base::close(...future.stdout)
[15:32:24.646]         }, add = TRUE)
[15:32:24.646]     }
[15:32:24.646]     ...future.frame <- base::sys.nframe()
[15:32:24.646]     ...future.conditions <- base::list()
[15:32:24.646]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:24.646]     if (FALSE) {
[15:32:24.646]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:24.646]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:24.646]     }
[15:32:24.646]     ...future.result <- base::tryCatch({
[15:32:24.646]         base::withCallingHandlers({
[15:32:24.646]             ...future.value <- base::withVisible(base::local({
[15:32:24.646]                 do.call(function(...) {
[15:32:24.646]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:24.646]                   if (!identical(...future.globals.maxSize.org, 
[15:32:24.646]                     ...future.globals.maxSize)) {
[15:32:24.646]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:24.646]                     on.exit(options(oopts), add = TRUE)
[15:32:24.646]                   }
[15:32:24.646]                   {
[15:32:24.646]                     lapply(seq_along(...future.elements_ii), 
[15:32:24.646]                       FUN = function(jj) {
[15:32:24.646]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:24.646]                         ...future.FUN(...future.X_jj, ...)
[15:32:24.646]                       })
[15:32:24.646]                   }
[15:32:24.646]                 }, args = future.call.arguments)
[15:32:24.646]             }))
[15:32:24.646]             future::FutureResult(value = ...future.value$value, 
[15:32:24.646]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:24.646]                   ...future.rng), globalenv = if (FALSE) 
[15:32:24.646]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:24.646]                     ...future.globalenv.names))
[15:32:24.646]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:24.646]         }, condition = base::local({
[15:32:24.646]             c <- base::c
[15:32:24.646]             inherits <- base::inherits
[15:32:24.646]             invokeRestart <- base::invokeRestart
[15:32:24.646]             length <- base::length
[15:32:24.646]             list <- base::list
[15:32:24.646]             seq.int <- base::seq.int
[15:32:24.646]             signalCondition <- base::signalCondition
[15:32:24.646]             sys.calls <- base::sys.calls
[15:32:24.646]             `[[` <- base::`[[`
[15:32:24.646]             `+` <- base::`+`
[15:32:24.646]             `<<-` <- base::`<<-`
[15:32:24.646]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:24.646]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:24.646]                   3L)]
[15:32:24.646]             }
[15:32:24.646]             function(cond) {
[15:32:24.646]                 is_error <- inherits(cond, "error")
[15:32:24.646]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:24.646]                   NULL)
[15:32:24.646]                 if (is_error) {
[15:32:24.646]                   sessionInformation <- function() {
[15:32:24.646]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:24.646]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:24.646]                       search = base::search(), system = base::Sys.info())
[15:32:24.646]                   }
[15:32:24.646]                   ...future.conditions[[length(...future.conditions) + 
[15:32:24.646]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:24.646]                     cond$call), session = sessionInformation(), 
[15:32:24.646]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:24.646]                   signalCondition(cond)
[15:32:24.646]                 }
[15:32:24.646]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:24.646]                 "immediateCondition"))) {
[15:32:24.646]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:24.646]                   ...future.conditions[[length(...future.conditions) + 
[15:32:24.646]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:24.646]                   if (TRUE && !signal) {
[15:32:24.646]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:24.646]                     {
[15:32:24.646]                       inherits <- base::inherits
[15:32:24.646]                       invokeRestart <- base::invokeRestart
[15:32:24.646]                       is.null <- base::is.null
[15:32:24.646]                       muffled <- FALSE
[15:32:24.646]                       if (inherits(cond, "message")) {
[15:32:24.646]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:24.646]                         if (muffled) 
[15:32:24.646]                           invokeRestart("muffleMessage")
[15:32:24.646]                       }
[15:32:24.646]                       else if (inherits(cond, "warning")) {
[15:32:24.646]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:24.646]                         if (muffled) 
[15:32:24.646]                           invokeRestart("muffleWarning")
[15:32:24.646]                       }
[15:32:24.646]                       else if (inherits(cond, "condition")) {
[15:32:24.646]                         if (!is.null(pattern)) {
[15:32:24.646]                           computeRestarts <- base::computeRestarts
[15:32:24.646]                           grepl <- base::grepl
[15:32:24.646]                           restarts <- computeRestarts(cond)
[15:32:24.646]                           for (restart in restarts) {
[15:32:24.646]                             name <- restart$name
[15:32:24.646]                             if (is.null(name)) 
[15:32:24.646]                               next
[15:32:24.646]                             if (!grepl(pattern, name)) 
[15:32:24.646]                               next
[15:32:24.646]                             invokeRestart(restart)
[15:32:24.646]                             muffled <- TRUE
[15:32:24.646]                             break
[15:32:24.646]                           }
[15:32:24.646]                         }
[15:32:24.646]                       }
[15:32:24.646]                       invisible(muffled)
[15:32:24.646]                     }
[15:32:24.646]                     muffleCondition(cond, pattern = "^muffle")
[15:32:24.646]                   }
[15:32:24.646]                 }
[15:32:24.646]                 else {
[15:32:24.646]                   if (TRUE) {
[15:32:24.646]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:24.646]                     {
[15:32:24.646]                       inherits <- base::inherits
[15:32:24.646]                       invokeRestart <- base::invokeRestart
[15:32:24.646]                       is.null <- base::is.null
[15:32:24.646]                       muffled <- FALSE
[15:32:24.646]                       if (inherits(cond, "message")) {
[15:32:24.646]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:24.646]                         if (muffled) 
[15:32:24.646]                           invokeRestart("muffleMessage")
[15:32:24.646]                       }
[15:32:24.646]                       else if (inherits(cond, "warning")) {
[15:32:24.646]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:24.646]                         if (muffled) 
[15:32:24.646]                           invokeRestart("muffleWarning")
[15:32:24.646]                       }
[15:32:24.646]                       else if (inherits(cond, "condition")) {
[15:32:24.646]                         if (!is.null(pattern)) {
[15:32:24.646]                           computeRestarts <- base::computeRestarts
[15:32:24.646]                           grepl <- base::grepl
[15:32:24.646]                           restarts <- computeRestarts(cond)
[15:32:24.646]                           for (restart in restarts) {
[15:32:24.646]                             name <- restart$name
[15:32:24.646]                             if (is.null(name)) 
[15:32:24.646]                               next
[15:32:24.646]                             if (!grepl(pattern, name)) 
[15:32:24.646]                               next
[15:32:24.646]                             invokeRestart(restart)
[15:32:24.646]                             muffled <- TRUE
[15:32:24.646]                             break
[15:32:24.646]                           }
[15:32:24.646]                         }
[15:32:24.646]                       }
[15:32:24.646]                       invisible(muffled)
[15:32:24.646]                     }
[15:32:24.646]                     muffleCondition(cond, pattern = "^muffle")
[15:32:24.646]                   }
[15:32:24.646]                 }
[15:32:24.646]             }
[15:32:24.646]         }))
[15:32:24.646]     }, error = function(ex) {
[15:32:24.646]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:24.646]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:24.646]                 ...future.rng), started = ...future.startTime, 
[15:32:24.646]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:24.646]             version = "1.8"), class = "FutureResult")
[15:32:24.646]     }, finally = {
[15:32:24.646]         if (!identical(...future.workdir, getwd())) 
[15:32:24.646]             setwd(...future.workdir)
[15:32:24.646]         {
[15:32:24.646]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:24.646]                 ...future.oldOptions$nwarnings <- NULL
[15:32:24.646]             }
[15:32:24.646]             base::options(...future.oldOptions)
[15:32:24.646]             if (.Platform$OS.type == "windows") {
[15:32:24.646]                 old_names <- names(...future.oldEnvVars)
[15:32:24.646]                 envs <- base::Sys.getenv()
[15:32:24.646]                 names <- names(envs)
[15:32:24.646]                 common <- intersect(names, old_names)
[15:32:24.646]                 added <- setdiff(names, old_names)
[15:32:24.646]                 removed <- setdiff(old_names, names)
[15:32:24.646]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:24.646]                   envs[common]]
[15:32:24.646]                 NAMES <- toupper(changed)
[15:32:24.646]                 args <- list()
[15:32:24.646]                 for (kk in seq_along(NAMES)) {
[15:32:24.646]                   name <- changed[[kk]]
[15:32:24.646]                   NAME <- NAMES[[kk]]
[15:32:24.646]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:24.646]                     next
[15:32:24.646]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:24.646]                 }
[15:32:24.646]                 NAMES <- toupper(added)
[15:32:24.646]                 for (kk in seq_along(NAMES)) {
[15:32:24.646]                   name <- added[[kk]]
[15:32:24.646]                   NAME <- NAMES[[kk]]
[15:32:24.646]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:24.646]                     next
[15:32:24.646]                   args[[name]] <- ""
[15:32:24.646]                 }
[15:32:24.646]                 NAMES <- toupper(removed)
[15:32:24.646]                 for (kk in seq_along(NAMES)) {
[15:32:24.646]                   name <- removed[[kk]]
[15:32:24.646]                   NAME <- NAMES[[kk]]
[15:32:24.646]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:24.646]                     next
[15:32:24.646]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:24.646]                 }
[15:32:24.646]                 if (length(args) > 0) 
[15:32:24.646]                   base::do.call(base::Sys.setenv, args = args)
[15:32:24.646]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:24.646]             }
[15:32:24.646]             else {
[15:32:24.646]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:24.646]             }
[15:32:24.646]             {
[15:32:24.646]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:24.646]                   0L) {
[15:32:24.646]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:24.646]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:24.646]                   base::options(opts)
[15:32:24.646]                 }
[15:32:24.646]                 {
[15:32:24.646]                   {
[15:32:24.646]                     NULL
[15:32:24.646]                     RNGkind("Mersenne-Twister")
[15:32:24.646]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:24.646]                       inherits = FALSE)
[15:32:24.646]                   }
[15:32:24.646]                   options(future.plan = NULL)
[15:32:24.646]                   if (is.na(NA_character_)) 
[15:32:24.646]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:24.646]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:24.646]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:24.646]                     .init = FALSE)
[15:32:24.646]                 }
[15:32:24.646]             }
[15:32:24.646]         }
[15:32:24.646]     })
[15:32:24.646]     if (TRUE) {
[15:32:24.646]         base::sink(type = "output", split = FALSE)
[15:32:24.646]         if (TRUE) {
[15:32:24.646]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:24.646]         }
[15:32:24.646]         else {
[15:32:24.646]             ...future.result["stdout"] <- base::list(NULL)
[15:32:24.646]         }
[15:32:24.646]         base::close(...future.stdout)
[15:32:24.646]         ...future.stdout <- NULL
[15:32:24.646]     }
[15:32:24.646]     ...future.result$conditions <- ...future.conditions
[15:32:24.646]     ...future.result$finished <- base::Sys.time()
[15:32:24.646]     ...future.result
[15:32:24.646] }
[15:32:24.652] assign_globals() ...
[15:32:24.652] List of 5
[15:32:24.652]  $ ...future.FUN            :function (x, ...)  
[15:32:24.652]  $ future.call.arguments    : list()
[15:32:24.652]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:24.652]  $ ...future.elements_ii    :List of 4
[15:32:24.652]   ..$ A: num 50
[15:32:24.652]   ..$ B: num 60
[15:32:24.652]   ..$ C: num 70
[15:32:24.652]   ..$ D: num 80
[15:32:24.652]  $ ...future.seeds_ii       : NULL
[15:32:24.652]  $ ...future.globals.maxSize: NULL
[15:32:24.652]  - attr(*, "where")=List of 5
[15:32:24.652]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:24.652]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:24.652]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:24.652]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:24.652]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:24.652]  - attr(*, "resolved")= logi FALSE
[15:32:24.652]  - attr(*, "total_size")= num 1248
[15:32:24.652]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:24.652]  - attr(*, "already-done")= logi TRUE
[15:32:24.662] - copied '...future.FUN' to environment
[15:32:24.662] - copied 'future.call.arguments' to environment
[15:32:24.662] - copied '...future.elements_ii' to environment
[15:32:24.663] - copied '...future.seeds_ii' to environment
[15:32:24.663] - copied '...future.globals.maxSize' to environment
[15:32:24.663] assign_globals() ... done
[15:32:24.664] plan(): Setting new future strategy stack:
[15:32:24.664] List of future strategies:
[15:32:24.664] 1. sequential:
[15:32:24.664]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:24.664]    - tweaked: FALSE
[15:32:24.664]    - call: NULL
[15:32:24.665] plan(): nbrOfWorkers() = 1
[15:32:24.667] plan(): Setting new future strategy stack:
[15:32:24.667] List of future strategies:
[15:32:24.667] 1. sequential:
[15:32:24.667]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:24.667]    - tweaked: FALSE
[15:32:24.667]    - call: plan(strategy)
[15:32:24.668] plan(): nbrOfWorkers() = 1
[15:32:24.668] SequentialFuture started (and completed)
[15:32:24.668] - Launch lazy future ... done
[15:32:24.669] run() for 'SequentialFuture' ... done
[15:32:24.669] Created future:
[15:32:24.669] SequentialFuture:
[15:32:24.669] Label: 'future_sapply-1'
[15:32:24.669] Expression:
[15:32:24.669] {
[15:32:24.669]     do.call(function(...) {
[15:32:24.669]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:24.669]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:24.669]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:24.669]             on.exit(options(oopts), add = TRUE)
[15:32:24.669]         }
[15:32:24.669]         {
[15:32:24.669]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:24.669]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:24.669]                 ...future.FUN(...future.X_jj, ...)
[15:32:24.669]             })
[15:32:24.669]         }
[15:32:24.669]     }, args = future.call.arguments)
[15:32:24.669] }
[15:32:24.669] Lazy evaluation: FALSE
[15:32:24.669] Asynchronous evaluation: FALSE
[15:32:24.669] Local evaluation: TRUE
[15:32:24.669] Environment: R_GlobalEnv
[15:32:24.669] Capture standard output: TRUE
[15:32:24.669] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:24.669] Globals: 5 objects totaling 1.44 KiB (function '...future.FUN' of 1.22 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 224 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:24.669] Packages: <none>
[15:32:24.669] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:24.669] Resolved: TRUE
[15:32:24.669] Value: 896 bytes of class 'list'
[15:32:24.669] Early signaling: FALSE
[15:32:24.669] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:24.669] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:24.671] Chunk #1 of 1 ... DONE
[15:32:24.672] Launching 1 futures (chunks) ... DONE
[15:32:24.672] Resolving 1 futures (chunks) ...
[15:32:24.672] resolve() on list ...
[15:32:24.672]  recursive: 0
[15:32:24.673]  length: 1
[15:32:24.673] 
[15:32:24.673] resolved() for 'SequentialFuture' ...
[15:32:24.674] - state: 'finished'
[15:32:24.674] - run: TRUE
[15:32:24.674] - result: 'FutureResult'
[15:32:24.674] resolved() for 'SequentialFuture' ... done
[15:32:24.675] Future #1
[15:32:24.675] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:24.675] - nx: 1
[15:32:24.675] - relay: TRUE
[15:32:24.676] - stdout: TRUE
[15:32:24.676] - signal: TRUE
[15:32:24.676] - resignal: FALSE
[15:32:24.676] - force: TRUE
[15:32:24.677] - relayed: [n=1] FALSE
[15:32:24.677] - queued futures: [n=1] FALSE
[15:32:24.677]  - until=1
[15:32:24.677]  - relaying element #1
[15:32:24.678] - relayed: [n=1] TRUE
[15:32:24.678] - queued futures: [n=1] TRUE
[15:32:24.678] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:24.679]  length: 0 (resolved future 1)
[15:32:24.679] Relaying remaining futures
[15:32:24.679] signalConditionsASAP(NULL, pos=0) ...
[15:32:24.679] - nx: 1
[15:32:24.679] - relay: TRUE
[15:32:24.679] - stdout: TRUE
[15:32:24.679] - signal: TRUE
[15:32:24.680] - resignal: FALSE
[15:32:24.680] - force: TRUE
[15:32:24.680] - relayed: [n=1] TRUE
[15:32:24.680] - queued futures: [n=1] TRUE
 - flush all
[15:32:24.680] - relayed: [n=1] TRUE
[15:32:24.680] - queued futures: [n=1] TRUE
[15:32:24.681] signalConditionsASAP(NULL, pos=0) ... done
[15:32:24.681] resolve() on list ... DONE
[15:32:24.681]  - Number of value chunks collected: 1
[15:32:24.681] Resolving 1 futures (chunks) ... DONE
[15:32:24.681] Reducing values from 1 chunks ...
[15:32:24.682]  - Number of values collected after concatenation: 4
[15:32:24.682]  - Number of values expected: 4
[15:32:24.682] Reducing values from 1 chunks ... DONE
[15:32:24.682] future_lapply() ... DONE
List of 2
 $ y0: Named num [1:4] 50 60 70 80
  ..- attr(*, "names")= chr [1:4] "A" "B" "C" "D"
 $ y1: Named num [1:4] 50 60 70 80
  ..- attr(*, "names")= chr [1:4] "A" "B" "C" "D"
[15:32:24.686] future_lapply() ...
[15:32:24.687] Number of chunks: 1
[15:32:24.688] getGlobalsAndPackagesXApply() ...
[15:32:24.688]  - future.globals: TRUE
[15:32:24.688] getGlobalsAndPackages() ...
[15:32:24.688] Searching for globals...
[15:32:24.691] - globals found: [5] 'FUN', '*', ':', 'outer', 'rep'
[15:32:24.691] Searching for globals ... DONE
[15:32:24.691] Resolving globals: FALSE
[15:32:24.694] The total size of the 1 globals is 4.62 KiB (4728 bytes)
[15:32:24.694] The total size of the 1 globals exported for future expression ('FUN()') is 4.62 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.62 KiB of class 'function')
[15:32:24.694] - globals: [1] 'FUN'
[15:32:24.695] 
[15:32:24.695] getGlobalsAndPackages() ... DONE
[15:32:24.695]  - globals found/used: [n=1] 'FUN'
[15:32:24.695]  - needed namespaces: [n=0] 
[15:32:24.695] Finding globals ... DONE
[15:32:24.695]  - use_args: TRUE
[15:32:24.696]  - Getting '...' globals ...
[15:32:24.696] resolve() on list ...
[15:32:24.696]  recursive: 0
[15:32:24.696]  length: 1
[15:32:24.696]  elements: '...'
[15:32:24.697]  length: 0 (resolved future 1)
[15:32:24.697] resolve() on list ... DONE
[15:32:24.697]    - '...' content: [n=0] 
[15:32:24.697] List of 1
[15:32:24.697]  $ ...: list()
[15:32:24.697]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:24.697]  - attr(*, "where")=List of 1
[15:32:24.697]   ..$ ...:<environment: 0x00000276e5aa68b8> 
[15:32:24.697]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:24.697]  - attr(*, "resolved")= logi TRUE
[15:32:24.697]  - attr(*, "total_size")= num NA
[15:32:24.700]  - Getting '...' globals ... DONE
[15:32:24.700] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:24.701] List of 2
[15:32:24.701]  $ ...future.FUN:function (x, y = 2 * 1:5)  
[15:32:24.701]  $ ...          : list()
[15:32:24.701]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:24.701]  - attr(*, "where")=List of 2
[15:32:24.701]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:24.701]   ..$ ...          :<environment: 0x00000276e5aa68b8> 
[15:32:24.701]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:24.701]  - attr(*, "resolved")= logi FALSE
[15:32:24.701]  - attr(*, "total_size")= num 4728
[15:32:24.705] Packages to be attached in all futures: [n=0] 
[15:32:24.705] getGlobalsAndPackagesXApply() ... DONE
[15:32:24.705] Number of futures (= number of chunks): 1
[15:32:24.706] Launching 1 futures (chunks) ...
[15:32:24.706] Chunk #1 of 1 ...
[15:32:24.706]  - Finding globals in 'X' for chunk #1 ...
[15:32:24.706] getGlobalsAndPackages() ...
[15:32:24.707] Searching for globals...
[15:32:24.707] 
[15:32:24.707] Searching for globals ... DONE
[15:32:24.707] - globals: [0] <none>
[15:32:24.708] getGlobalsAndPackages() ... DONE
[15:32:24.708]    + additional globals found: [n=0] 
[15:32:24.708]    + additional namespaces needed: [n=0] 
[15:32:24.708]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:24.708]  - seeds: <none>
[15:32:24.709]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:24.709] getGlobalsAndPackages() ...
[15:32:24.709] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:24.709] Resolving globals: FALSE
[15:32:24.710] Tweak future expression to call with '...' arguments ...
[15:32:24.710] {
[15:32:24.710]     do.call(function(...) {
[15:32:24.710]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:24.710]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:24.710]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:24.710]             on.exit(options(oopts), add = TRUE)
[15:32:24.710]         }
[15:32:24.710]         {
[15:32:24.710]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:24.710]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:24.710]                 ...future.FUN(...future.X_jj, ...)
[15:32:24.710]             })
[15:32:24.710]         }
[15:32:24.710]     }, args = future.call.arguments)
[15:32:24.710] }
[15:32:24.710] Tweak future expression to call with '...' arguments ... DONE
[15:32:24.711] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:24.711] 
[15:32:24.712] getGlobalsAndPackages() ... DONE
[15:32:24.712] run() for 'Future' ...
[15:32:24.712] - state: 'created'
[15:32:24.713] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:24.713] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:24.713] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:24.714]   - Field: 'label'
[15:32:24.714]   - Field: 'local'
[15:32:24.714]   - Field: 'owner'
[15:32:24.714]   - Field: 'envir'
[15:32:24.715]   - Field: 'packages'
[15:32:24.715]   - Field: 'gc'
[15:32:24.715]   - Field: 'conditions'
[15:32:24.715]   - Field: 'expr'
[15:32:24.715]   - Field: 'uuid'
[15:32:24.716]   - Field: 'seed'
[15:32:24.716]   - Field: 'version'
[15:32:24.716]   - Field: 'result'
[15:32:24.716]   - Field: 'asynchronous'
[15:32:24.717]   - Field: 'calls'
[15:32:24.717]   - Field: 'globals'
[15:32:24.717]   - Field: 'stdout'
[15:32:24.717]   - Field: 'earlySignal'
[15:32:24.718]   - Field: 'lazy'
[15:32:24.718]   - Field: 'state'
[15:32:24.718] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:24.718] - Launch lazy future ...
[15:32:24.719] Packages needed by the future expression (n = 0): <none>
[15:32:24.719] Packages needed by future strategies (n = 0): <none>
[15:32:24.720] {
[15:32:24.720]     {
[15:32:24.720]         {
[15:32:24.720]             ...future.startTime <- base::Sys.time()
[15:32:24.720]             {
[15:32:24.720]                 {
[15:32:24.720]                   {
[15:32:24.720]                     base::local({
[15:32:24.720]                       has_future <- base::requireNamespace("future", 
[15:32:24.720]                         quietly = TRUE)
[15:32:24.720]                       if (has_future) {
[15:32:24.720]                         ns <- base::getNamespace("future")
[15:32:24.720]                         version <- ns[[".package"]][["version"]]
[15:32:24.720]                         if (is.null(version)) 
[15:32:24.720]                           version <- utils::packageVersion("future")
[15:32:24.720]                       }
[15:32:24.720]                       else {
[15:32:24.720]                         version <- NULL
[15:32:24.720]                       }
[15:32:24.720]                       if (!has_future || version < "1.8.0") {
[15:32:24.720]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:24.720]                           "", base::R.version$version.string), 
[15:32:24.720]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:24.720]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:24.720]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:24.720]                             "release", "version")], collapse = " "), 
[15:32:24.720]                           hostname = base::Sys.info()[["nodename"]])
[15:32:24.720]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:24.720]                           info)
[15:32:24.720]                         info <- base::paste(info, collapse = "; ")
[15:32:24.720]                         if (!has_future) {
[15:32:24.720]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:24.720]                             info)
[15:32:24.720]                         }
[15:32:24.720]                         else {
[15:32:24.720]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:24.720]                             info, version)
[15:32:24.720]                         }
[15:32:24.720]                         base::stop(msg)
[15:32:24.720]                       }
[15:32:24.720]                     })
[15:32:24.720]                   }
[15:32:24.720]                   ...future.strategy.old <- future::plan("list")
[15:32:24.720]                   options(future.plan = NULL)
[15:32:24.720]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:24.720]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:24.720]                 }
[15:32:24.720]                 ...future.workdir <- getwd()
[15:32:24.720]             }
[15:32:24.720]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:24.720]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:24.720]         }
[15:32:24.720]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:24.720]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:24.720]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:24.720]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:24.720]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:24.720]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:24.720]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:24.720]             base::names(...future.oldOptions))
[15:32:24.720]     }
[15:32:24.720]     if (FALSE) {
[15:32:24.720]     }
[15:32:24.720]     else {
[15:32:24.720]         if (TRUE) {
[15:32:24.720]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:24.720]                 open = "w")
[15:32:24.720]         }
[15:32:24.720]         else {
[15:32:24.720]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:24.720]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:24.720]         }
[15:32:24.720]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:24.720]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:24.720]             base::sink(type = "output", split = FALSE)
[15:32:24.720]             base::close(...future.stdout)
[15:32:24.720]         }, add = TRUE)
[15:32:24.720]     }
[15:32:24.720]     ...future.frame <- base::sys.nframe()
[15:32:24.720]     ...future.conditions <- base::list()
[15:32:24.720]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:24.720]     if (FALSE) {
[15:32:24.720]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:24.720]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:24.720]     }
[15:32:24.720]     ...future.result <- base::tryCatch({
[15:32:24.720]         base::withCallingHandlers({
[15:32:24.720]             ...future.value <- base::withVisible(base::local({
[15:32:24.720]                 do.call(function(...) {
[15:32:24.720]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:24.720]                   if (!identical(...future.globals.maxSize.org, 
[15:32:24.720]                     ...future.globals.maxSize)) {
[15:32:24.720]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:24.720]                     on.exit(options(oopts), add = TRUE)
[15:32:24.720]                   }
[15:32:24.720]                   {
[15:32:24.720]                     lapply(seq_along(...future.elements_ii), 
[15:32:24.720]                       FUN = function(jj) {
[15:32:24.720]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:24.720]                         ...future.FUN(...future.X_jj, ...)
[15:32:24.720]                       })
[15:32:24.720]                   }
[15:32:24.720]                 }, args = future.call.arguments)
[15:32:24.720]             }))
[15:32:24.720]             future::FutureResult(value = ...future.value$value, 
[15:32:24.720]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:24.720]                   ...future.rng), globalenv = if (FALSE) 
[15:32:24.720]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:24.720]                     ...future.globalenv.names))
[15:32:24.720]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:24.720]         }, condition = base::local({
[15:32:24.720]             c <- base::c
[15:32:24.720]             inherits <- base::inherits
[15:32:24.720]             invokeRestart <- base::invokeRestart
[15:32:24.720]             length <- base::length
[15:32:24.720]             list <- base::list
[15:32:24.720]             seq.int <- base::seq.int
[15:32:24.720]             signalCondition <- base::signalCondition
[15:32:24.720]             sys.calls <- base::sys.calls
[15:32:24.720]             `[[` <- base::`[[`
[15:32:24.720]             `+` <- base::`+`
[15:32:24.720]             `<<-` <- base::`<<-`
[15:32:24.720]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:24.720]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:24.720]                   3L)]
[15:32:24.720]             }
[15:32:24.720]             function(cond) {
[15:32:24.720]                 is_error <- inherits(cond, "error")
[15:32:24.720]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:24.720]                   NULL)
[15:32:24.720]                 if (is_error) {
[15:32:24.720]                   sessionInformation <- function() {
[15:32:24.720]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:24.720]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:24.720]                       search = base::search(), system = base::Sys.info())
[15:32:24.720]                   }
[15:32:24.720]                   ...future.conditions[[length(...future.conditions) + 
[15:32:24.720]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:24.720]                     cond$call), session = sessionInformation(), 
[15:32:24.720]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:24.720]                   signalCondition(cond)
[15:32:24.720]                 }
[15:32:24.720]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:24.720]                 "immediateCondition"))) {
[15:32:24.720]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:24.720]                   ...future.conditions[[length(...future.conditions) + 
[15:32:24.720]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:24.720]                   if (TRUE && !signal) {
[15:32:24.720]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:24.720]                     {
[15:32:24.720]                       inherits <- base::inherits
[15:32:24.720]                       invokeRestart <- base::invokeRestart
[15:32:24.720]                       is.null <- base::is.null
[15:32:24.720]                       muffled <- FALSE
[15:32:24.720]                       if (inherits(cond, "message")) {
[15:32:24.720]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:24.720]                         if (muffled) 
[15:32:24.720]                           invokeRestart("muffleMessage")
[15:32:24.720]                       }
[15:32:24.720]                       else if (inherits(cond, "warning")) {
[15:32:24.720]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:24.720]                         if (muffled) 
[15:32:24.720]                           invokeRestart("muffleWarning")
[15:32:24.720]                       }
[15:32:24.720]                       else if (inherits(cond, "condition")) {
[15:32:24.720]                         if (!is.null(pattern)) {
[15:32:24.720]                           computeRestarts <- base::computeRestarts
[15:32:24.720]                           grepl <- base::grepl
[15:32:24.720]                           restarts <- computeRestarts(cond)
[15:32:24.720]                           for (restart in restarts) {
[15:32:24.720]                             name <- restart$name
[15:32:24.720]                             if (is.null(name)) 
[15:32:24.720]                               next
[15:32:24.720]                             if (!grepl(pattern, name)) 
[15:32:24.720]                               next
[15:32:24.720]                             invokeRestart(restart)
[15:32:24.720]                             muffled <- TRUE
[15:32:24.720]                             break
[15:32:24.720]                           }
[15:32:24.720]                         }
[15:32:24.720]                       }
[15:32:24.720]                       invisible(muffled)
[15:32:24.720]                     }
[15:32:24.720]                     muffleCondition(cond, pattern = "^muffle")
[15:32:24.720]                   }
[15:32:24.720]                 }
[15:32:24.720]                 else {
[15:32:24.720]                   if (TRUE) {
[15:32:24.720]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:24.720]                     {
[15:32:24.720]                       inherits <- base::inherits
[15:32:24.720]                       invokeRestart <- base::invokeRestart
[15:32:24.720]                       is.null <- base::is.null
[15:32:24.720]                       muffled <- FALSE
[15:32:24.720]                       if (inherits(cond, "message")) {
[15:32:24.720]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:24.720]                         if (muffled) 
[15:32:24.720]                           invokeRestart("muffleMessage")
[15:32:24.720]                       }
[15:32:24.720]                       else if (inherits(cond, "warning")) {
[15:32:24.720]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:24.720]                         if (muffled) 
[15:32:24.720]                           invokeRestart("muffleWarning")
[15:32:24.720]                       }
[15:32:24.720]                       else if (inherits(cond, "condition")) {
[15:32:24.720]                         if (!is.null(pattern)) {
[15:32:24.720]                           computeRestarts <- base::computeRestarts
[15:32:24.720]                           grepl <- base::grepl
[15:32:24.720]                           restarts <- computeRestarts(cond)
[15:32:24.720]                           for (restart in restarts) {
[15:32:24.720]                             name <- restart$name
[15:32:24.720]                             if (is.null(name)) 
[15:32:24.720]                               next
[15:32:24.720]                             if (!grepl(pattern, name)) 
[15:32:24.720]                               next
[15:32:24.720]                             invokeRestart(restart)
[15:32:24.720]                             muffled <- TRUE
[15:32:24.720]                             break
[15:32:24.720]                           }
[15:32:24.720]                         }
[15:32:24.720]                       }
[15:32:24.720]                       invisible(muffled)
[15:32:24.720]                     }
[15:32:24.720]                     muffleCondition(cond, pattern = "^muffle")
[15:32:24.720]                   }
[15:32:24.720]                 }
[15:32:24.720]             }
[15:32:24.720]         }))
[15:32:24.720]     }, error = function(ex) {
[15:32:24.720]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:24.720]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:24.720]                 ...future.rng), started = ...future.startTime, 
[15:32:24.720]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:24.720]             version = "1.8"), class = "FutureResult")
[15:32:24.720]     }, finally = {
[15:32:24.720]         if (!identical(...future.workdir, getwd())) 
[15:32:24.720]             setwd(...future.workdir)
[15:32:24.720]         {
[15:32:24.720]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:24.720]                 ...future.oldOptions$nwarnings <- NULL
[15:32:24.720]             }
[15:32:24.720]             base::options(...future.oldOptions)
[15:32:24.720]             if (.Platform$OS.type == "windows") {
[15:32:24.720]                 old_names <- names(...future.oldEnvVars)
[15:32:24.720]                 envs <- base::Sys.getenv()
[15:32:24.720]                 names <- names(envs)
[15:32:24.720]                 common <- intersect(names, old_names)
[15:32:24.720]                 added <- setdiff(names, old_names)
[15:32:24.720]                 removed <- setdiff(old_names, names)
[15:32:24.720]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:24.720]                   envs[common]]
[15:32:24.720]                 NAMES <- toupper(changed)
[15:32:24.720]                 args <- list()
[15:32:24.720]                 for (kk in seq_along(NAMES)) {
[15:32:24.720]                   name <- changed[[kk]]
[15:32:24.720]                   NAME <- NAMES[[kk]]
[15:32:24.720]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:24.720]                     next
[15:32:24.720]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:24.720]                 }
[15:32:24.720]                 NAMES <- toupper(added)
[15:32:24.720]                 for (kk in seq_along(NAMES)) {
[15:32:24.720]                   name <- added[[kk]]
[15:32:24.720]                   NAME <- NAMES[[kk]]
[15:32:24.720]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:24.720]                     next
[15:32:24.720]                   args[[name]] <- ""
[15:32:24.720]                 }
[15:32:24.720]                 NAMES <- toupper(removed)
[15:32:24.720]                 for (kk in seq_along(NAMES)) {
[15:32:24.720]                   name <- removed[[kk]]
[15:32:24.720]                   NAME <- NAMES[[kk]]
[15:32:24.720]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:24.720]                     next
[15:32:24.720]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:24.720]                 }
[15:32:24.720]                 if (length(args) > 0) 
[15:32:24.720]                   base::do.call(base::Sys.setenv, args = args)
[15:32:24.720]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:24.720]             }
[15:32:24.720]             else {
[15:32:24.720]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:24.720]             }
[15:32:24.720]             {
[15:32:24.720]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:24.720]                   0L) {
[15:32:24.720]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:24.720]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:24.720]                   base::options(opts)
[15:32:24.720]                 }
[15:32:24.720]                 {
[15:32:24.720]                   {
[15:32:24.720]                     NULL
[15:32:24.720]                     RNGkind("Mersenne-Twister")
[15:32:24.720]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:24.720]                       inherits = FALSE)
[15:32:24.720]                   }
[15:32:24.720]                   options(future.plan = NULL)
[15:32:24.720]                   if (is.na(NA_character_)) 
[15:32:24.720]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:24.720]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:24.720]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:24.720]                     .init = FALSE)
[15:32:24.720]                 }
[15:32:24.720]             }
[15:32:24.720]         }
[15:32:24.720]     })
[15:32:24.720]     if (TRUE) {
[15:32:24.720]         base::sink(type = "output", split = FALSE)
[15:32:24.720]         if (TRUE) {
[15:32:24.720]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:24.720]         }
[15:32:24.720]         else {
[15:32:24.720]             ...future.result["stdout"] <- base::list(NULL)
[15:32:24.720]         }
[15:32:24.720]         base::close(...future.stdout)
[15:32:24.720]         ...future.stdout <- NULL
[15:32:24.720]     }
[15:32:24.720]     ...future.result$conditions <- ...future.conditions
[15:32:24.720]     ...future.result$finished <- base::Sys.time()
[15:32:24.720]     ...future.result
[15:32:24.720] }
[15:32:24.725] assign_globals() ...
[15:32:24.726] List of 5
[15:32:24.726]  $ ...future.FUN            :function (x, y = 2 * 1:5)  
[15:32:24.726]  $ future.call.arguments    : list()
[15:32:24.726]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:24.726]  $ ...future.elements_ii    :List of 4
[15:32:24.726]   ..$ A: num 50
[15:32:24.726]   ..$ B: num 60
[15:32:24.726]   ..$ C: num 70
[15:32:24.726]   ..$ D: num 80
[15:32:24.726]  $ ...future.seeds_ii       : NULL
[15:32:24.726]  $ ...future.globals.maxSize: NULL
[15:32:24.726]  - attr(*, "where")=List of 5
[15:32:24.726]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:24.726]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:24.726]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:24.726]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:24.726]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:24.726]  - attr(*, "resolved")= logi FALSE
[15:32:24.726]  - attr(*, "total_size")= num 4728
[15:32:24.726]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:24.726]  - attr(*, "already-done")= logi TRUE
[15:32:24.734] - reassign environment for '...future.FUN'
[15:32:24.735] - copied '...future.FUN' to environment
[15:32:24.735] - copied 'future.call.arguments' to environment
[15:32:24.735] - copied '...future.elements_ii' to environment
[15:32:24.735] - copied '...future.seeds_ii' to environment
[15:32:24.736] - copied '...future.globals.maxSize' to environment
[15:32:24.736] assign_globals() ... done
[15:32:24.736] plan(): Setting new future strategy stack:
[15:32:24.737] List of future strategies:
[15:32:24.737] 1. sequential:
[15:32:24.737]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:24.737]    - tweaked: FALSE
[15:32:24.737]    - call: NULL
[15:32:24.737] plan(): nbrOfWorkers() = 1
[15:32:24.739] plan(): Setting new future strategy stack:
[15:32:24.739] List of future strategies:
[15:32:24.739] 1. sequential:
[15:32:24.739]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:24.739]    - tweaked: FALSE
[15:32:24.739]    - call: plan(strategy)
[15:32:24.740] plan(): nbrOfWorkers() = 1
[15:32:24.741] SequentialFuture started (and completed)
[15:32:24.741] - Launch lazy future ... done
[15:32:24.741] run() for 'SequentialFuture' ... done
[15:32:24.741] Created future:
[15:32:24.742] SequentialFuture:
[15:32:24.742] Label: 'future_sapply-1'
[15:32:24.742] Expression:
[15:32:24.742] {
[15:32:24.742]     do.call(function(...) {
[15:32:24.742]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:24.742]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:24.742]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:24.742]             on.exit(options(oopts), add = TRUE)
[15:32:24.742]         }
[15:32:24.742]         {
[15:32:24.742]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:24.742]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:24.742]                 ...future.FUN(...future.X_jj, ...)
[15:32:24.742]             })
[15:32:24.742]         }
[15:32:24.742]     }, args = future.call.arguments)
[15:32:24.742] }
[15:32:24.742] Lazy evaluation: FALSE
[15:32:24.742] Asynchronous evaluation: FALSE
[15:32:24.742] Local evaluation: TRUE
[15:32:24.742] Environment: R_GlobalEnv
[15:32:24.742] Capture standard output: TRUE
[15:32:24.742] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:24.742] Globals: 5 objects totaling 4.84 KiB (function '...future.FUN' of 4.62 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 224 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:24.742] Packages: <none>
[15:32:24.742] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:24.742] Resolved: TRUE
[15:32:24.742] Value: 1.34 KiB of class 'list'
[15:32:24.742] Early signaling: FALSE
[15:32:24.742] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:24.742] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:24.743] Chunk #1 of 1 ... DONE
[15:32:24.744] Launching 1 futures (chunks) ... DONE
[15:32:24.744] Resolving 1 futures (chunks) ...
[15:32:24.744] resolve() on list ...
[15:32:24.744]  recursive: 0
[15:32:24.744]  length: 1
[15:32:24.745] 
[15:32:24.745] resolved() for 'SequentialFuture' ...
[15:32:24.745] - state: 'finished'
[15:32:24.745] - run: TRUE
[15:32:24.746] - result: 'FutureResult'
[15:32:24.746] resolved() for 'SequentialFuture' ... done
[15:32:24.746] Future #1
[15:32:24.746] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:24.747] - nx: 1
[15:32:24.747] - relay: TRUE
[15:32:24.747] - stdout: TRUE
[15:32:24.747] - signal: TRUE
[15:32:24.747] - resignal: FALSE
[15:32:24.748] - force: TRUE
[15:32:24.748] - relayed: [n=1] FALSE
[15:32:24.748] - queued futures: [n=1] FALSE
[15:32:24.748]  - until=1
[15:32:24.748]  - relaying element #1
[15:32:24.749] - relayed: [n=1] TRUE
[15:32:24.749] - queued futures: [n=1] TRUE
[15:32:24.749] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:24.750]  length: 0 (resolved future 1)
[15:32:24.750] Relaying remaining futures
[15:32:24.750] signalConditionsASAP(NULL, pos=0) ...
[15:32:24.750] - nx: 1
[15:32:24.751] - relay: TRUE
[15:32:24.751] - stdout: TRUE
[15:32:24.751] - signal: TRUE
[15:32:24.751] - resignal: FALSE
[15:32:24.751] - force: TRUE
[15:32:24.752] - relayed: [n=1] TRUE
[15:32:24.752] - queued futures: [n=1] TRUE
 - flush all
[15:32:24.752] - relayed: [n=1] TRUE
[15:32:24.753] - queued futures: [n=1] TRUE
[15:32:24.753] signalConditionsASAP(NULL, pos=0) ... done
[15:32:24.753] resolve() on list ... DONE
[15:32:24.754]  - Number of value chunks collected: 1
[15:32:24.754] Resolving 1 futures (chunks) ... DONE
[15:32:24.754] Reducing values from 1 chunks ...
[15:32:24.755]  - Number of values collected after concatenation: 4
[15:32:24.755]  - Number of values expected: 4
[15:32:24.755] Reducing values from 1 chunks ... DONE
[15:32:24.755] future_lapply() ... DONE
List of 2
 $ y0: num [1:3, 1:5, 1:4] 100 100 100 200 200 200 300 300 300 400 ...
  ..- attr(*, "dimnames")=List of 3
  .. ..$ : NULL
  .. ..$ : NULL
  .. ..$ : chr [1:4] "A" "B" "C" "D"
 $ y1: num [1:3, 1:5, 1:4] 100 100 100 200 200 200 300 300 300 400 ...
  ..- attr(*, "dimnames")=List of 3
  .. ..$ : NULL
  .. ..$ : NULL
  .. ..$ : chr [1:4] "A" "B" "C" "D"
[15:32:24.761] future_lapply() ...
[15:32:24.763] Number of chunks: 1
[15:32:24.763] getGlobalsAndPackagesXApply() ...
[15:32:24.763]  - future.globals: TRUE
[15:32:24.763] getGlobalsAndPackages() ...
[15:32:24.764] Searching for globals...
[15:32:24.766] - globals found: [1] 'FUN'
[15:32:24.766] Searching for globals ... DONE
[15:32:24.766] Resolving globals: FALSE
[15:32:24.767] The total size of the 1 globals is 848 bytes (848 bytes)
[15:32:24.768] The total size of the 1 globals exported for future expression ('FUN()') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:32:24.768] - globals: [1] 'FUN'
[15:32:24.768] 
[15:32:24.768] getGlobalsAndPackages() ... DONE
[15:32:24.769]  - globals found/used: [n=1] 'FUN'
[15:32:24.769]  - needed namespaces: [n=0] 
[15:32:24.769] Finding globals ... DONE
[15:32:24.770]  - use_args: TRUE
[15:32:24.770]  - Getting '...' globals ...
[15:32:24.770] resolve() on list ...
[15:32:24.771]  recursive: 0
[15:32:24.771]  length: 1
[15:32:24.771]  elements: '...'
[15:32:24.772]  length: 0 (resolved future 1)
[15:32:24.772] resolve() on list ... DONE
[15:32:24.772]    - '...' content: [n=0] 
[15:32:24.772] List of 1
[15:32:24.772]  $ ...: list()
[15:32:24.772]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:24.772]  - attr(*, "where")=List of 1
[15:32:24.772]   ..$ ...:<environment: 0x00000276e4657650> 
[15:32:24.772]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:24.772]  - attr(*, "resolved")= logi TRUE
[15:32:24.772]  - attr(*, "total_size")= num NA
[15:32:24.777]  - Getting '...' globals ... DONE
[15:32:24.778] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:24.778] List of 2
[15:32:24.778]  $ ...future.FUN:function (x)  
[15:32:24.778]  $ ...          : list()
[15:32:24.778]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:24.778]  - attr(*, "where")=List of 2
[15:32:24.778]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:24.778]   ..$ ...          :<environment: 0x00000276e4657650> 
[15:32:24.778]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:24.778]  - attr(*, "resolved")= logi FALSE
[15:32:24.778]  - attr(*, "total_size")= num 848
[15:32:24.783] Packages to be attached in all futures: [n=0] 
[15:32:24.784] getGlobalsAndPackagesXApply() ... DONE
[15:32:24.784] Number of futures (= number of chunks): 1
[15:32:24.784] Launching 1 futures (chunks) ...
[15:32:24.785] Chunk #1 of 1 ...
[15:32:24.785]  - Finding globals in 'X' for chunk #1 ...
[15:32:24.785] getGlobalsAndPackages() ...
[15:32:24.785] Searching for globals...
[15:32:24.786] 
[15:32:24.786] Searching for globals ... DONE
[15:32:24.787] - globals: [0] <none>
[15:32:24.787] getGlobalsAndPackages() ... DONE
[15:32:24.787]    + additional globals found: [n=0] 
[15:32:24.787]    + additional namespaces needed: [n=0] 
[15:32:24.788]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:24.788]  - seeds: <none>
[15:32:24.788]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:24.788] getGlobalsAndPackages() ...
[15:32:24.789] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:24.789] Resolving globals: FALSE
[15:32:24.789] Tweak future expression to call with '...' arguments ...
[15:32:24.790] {
[15:32:24.790]     do.call(function(...) {
[15:32:24.790]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:24.790]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:24.790]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:24.790]             on.exit(options(oopts), add = TRUE)
[15:32:24.790]         }
[15:32:24.790]         {
[15:32:24.790]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:24.790]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:24.790]                 ...future.FUN(...future.X_jj, ...)
[15:32:24.790]             })
[15:32:24.790]         }
[15:32:24.790]     }, args = future.call.arguments)
[15:32:24.790] }
[15:32:24.790] Tweak future expression to call with '...' arguments ... DONE
[15:32:24.791] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:24.791] 
[15:32:24.792] getGlobalsAndPackages() ... DONE
[15:32:24.792] run() for 'Future' ...
[15:32:24.793] - state: 'created'
[15:32:24.793] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:24.794] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:24.794] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:24.794]   - Field: 'label'
[15:32:24.795]   - Field: 'local'
[15:32:24.795]   - Field: 'owner'
[15:32:24.795]   - Field: 'envir'
[15:32:24.795]   - Field: 'packages'
[15:32:24.796]   - Field: 'gc'
[15:32:24.796]   - Field: 'conditions'
[15:32:24.796]   - Field: 'expr'
[15:32:24.797]   - Field: 'uuid'
[15:32:24.797]   - Field: 'seed'
[15:32:24.797]   - Field: 'version'
[15:32:24.797]   - Field: 'result'
[15:32:24.798]   - Field: 'asynchronous'
[15:32:24.798]   - Field: 'calls'
[15:32:24.798]   - Field: 'globals'
[15:32:24.799]   - Field: 'stdout'
[15:32:24.799]   - Field: 'earlySignal'
[15:32:24.799]   - Field: 'lazy'
[15:32:24.799]   - Field: 'state'
[15:32:24.800] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:24.800] - Launch lazy future ...
[15:32:24.800] Packages needed by the future expression (n = 0): <none>
[15:32:24.801] Packages needed by future strategies (n = 0): <none>
[15:32:24.802] {
[15:32:24.802]     {
[15:32:24.802]         {
[15:32:24.802]             ...future.startTime <- base::Sys.time()
[15:32:24.802]             {
[15:32:24.802]                 {
[15:32:24.802]                   {
[15:32:24.802]                     base::local({
[15:32:24.802]                       has_future <- base::requireNamespace("future", 
[15:32:24.802]                         quietly = TRUE)
[15:32:24.802]                       if (has_future) {
[15:32:24.802]                         ns <- base::getNamespace("future")
[15:32:24.802]                         version <- ns[[".package"]][["version"]]
[15:32:24.802]                         if (is.null(version)) 
[15:32:24.802]                           version <- utils::packageVersion("future")
[15:32:24.802]                       }
[15:32:24.802]                       else {
[15:32:24.802]                         version <- NULL
[15:32:24.802]                       }
[15:32:24.802]                       if (!has_future || version < "1.8.0") {
[15:32:24.802]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:24.802]                           "", base::R.version$version.string), 
[15:32:24.802]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:24.802]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:24.802]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:24.802]                             "release", "version")], collapse = " "), 
[15:32:24.802]                           hostname = base::Sys.info()[["nodename"]])
[15:32:24.802]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:24.802]                           info)
[15:32:24.802]                         info <- base::paste(info, collapse = "; ")
[15:32:24.802]                         if (!has_future) {
[15:32:24.802]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:24.802]                             info)
[15:32:24.802]                         }
[15:32:24.802]                         else {
[15:32:24.802]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:24.802]                             info, version)
[15:32:24.802]                         }
[15:32:24.802]                         base::stop(msg)
[15:32:24.802]                       }
[15:32:24.802]                     })
[15:32:24.802]                   }
[15:32:24.802]                   ...future.strategy.old <- future::plan("list")
[15:32:24.802]                   options(future.plan = NULL)
[15:32:24.802]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:24.802]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:24.802]                 }
[15:32:24.802]                 ...future.workdir <- getwd()
[15:32:24.802]             }
[15:32:24.802]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:24.802]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:24.802]         }
[15:32:24.802]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:24.802]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:24.802]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:24.802]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:24.802]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:24.802]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:24.802]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:24.802]             base::names(...future.oldOptions))
[15:32:24.802]     }
[15:32:24.802]     if (FALSE) {
[15:32:24.802]     }
[15:32:24.802]     else {
[15:32:24.802]         if (TRUE) {
[15:32:24.802]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:24.802]                 open = "w")
[15:32:24.802]         }
[15:32:24.802]         else {
[15:32:24.802]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:24.802]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:24.802]         }
[15:32:24.802]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:24.802]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:24.802]             base::sink(type = "output", split = FALSE)
[15:32:24.802]             base::close(...future.stdout)
[15:32:24.802]         }, add = TRUE)
[15:32:24.802]     }
[15:32:24.802]     ...future.frame <- base::sys.nframe()
[15:32:24.802]     ...future.conditions <- base::list()
[15:32:24.802]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:24.802]     if (FALSE) {
[15:32:24.802]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:24.802]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:24.802]     }
[15:32:24.802]     ...future.result <- base::tryCatch({
[15:32:24.802]         base::withCallingHandlers({
[15:32:24.802]             ...future.value <- base::withVisible(base::local({
[15:32:24.802]                 do.call(function(...) {
[15:32:24.802]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:24.802]                   if (!identical(...future.globals.maxSize.org, 
[15:32:24.802]                     ...future.globals.maxSize)) {
[15:32:24.802]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:24.802]                     on.exit(options(oopts), add = TRUE)
[15:32:24.802]                   }
[15:32:24.802]                   {
[15:32:24.802]                     lapply(seq_along(...future.elements_ii), 
[15:32:24.802]                       FUN = function(jj) {
[15:32:24.802]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:24.802]                         ...future.FUN(...future.X_jj, ...)
[15:32:24.802]                       })
[15:32:24.802]                   }
[15:32:24.802]                 }, args = future.call.arguments)
[15:32:24.802]             }))
[15:32:24.802]             future::FutureResult(value = ...future.value$value, 
[15:32:24.802]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:24.802]                   ...future.rng), globalenv = if (FALSE) 
[15:32:24.802]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:24.802]                     ...future.globalenv.names))
[15:32:24.802]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:24.802]         }, condition = base::local({
[15:32:24.802]             c <- base::c
[15:32:24.802]             inherits <- base::inherits
[15:32:24.802]             invokeRestart <- base::invokeRestart
[15:32:24.802]             length <- base::length
[15:32:24.802]             list <- base::list
[15:32:24.802]             seq.int <- base::seq.int
[15:32:24.802]             signalCondition <- base::signalCondition
[15:32:24.802]             sys.calls <- base::sys.calls
[15:32:24.802]             `[[` <- base::`[[`
[15:32:24.802]             `+` <- base::`+`
[15:32:24.802]             `<<-` <- base::`<<-`
[15:32:24.802]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:24.802]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:24.802]                   3L)]
[15:32:24.802]             }
[15:32:24.802]             function(cond) {
[15:32:24.802]                 is_error <- inherits(cond, "error")
[15:32:24.802]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:24.802]                   NULL)
[15:32:24.802]                 if (is_error) {
[15:32:24.802]                   sessionInformation <- function() {
[15:32:24.802]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:24.802]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:24.802]                       search = base::search(), system = base::Sys.info())
[15:32:24.802]                   }
[15:32:24.802]                   ...future.conditions[[length(...future.conditions) + 
[15:32:24.802]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:24.802]                     cond$call), session = sessionInformation(), 
[15:32:24.802]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:24.802]                   signalCondition(cond)
[15:32:24.802]                 }
[15:32:24.802]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:24.802]                 "immediateCondition"))) {
[15:32:24.802]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:24.802]                   ...future.conditions[[length(...future.conditions) + 
[15:32:24.802]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:24.802]                   if (TRUE && !signal) {
[15:32:24.802]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:24.802]                     {
[15:32:24.802]                       inherits <- base::inherits
[15:32:24.802]                       invokeRestart <- base::invokeRestart
[15:32:24.802]                       is.null <- base::is.null
[15:32:24.802]                       muffled <- FALSE
[15:32:24.802]                       if (inherits(cond, "message")) {
[15:32:24.802]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:24.802]                         if (muffled) 
[15:32:24.802]                           invokeRestart("muffleMessage")
[15:32:24.802]                       }
[15:32:24.802]                       else if (inherits(cond, "warning")) {
[15:32:24.802]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:24.802]                         if (muffled) 
[15:32:24.802]                           invokeRestart("muffleWarning")
[15:32:24.802]                       }
[15:32:24.802]                       else if (inherits(cond, "condition")) {
[15:32:24.802]                         if (!is.null(pattern)) {
[15:32:24.802]                           computeRestarts <- base::computeRestarts
[15:32:24.802]                           grepl <- base::grepl
[15:32:24.802]                           restarts <- computeRestarts(cond)
[15:32:24.802]                           for (restart in restarts) {
[15:32:24.802]                             name <- restart$name
[15:32:24.802]                             if (is.null(name)) 
[15:32:24.802]                               next
[15:32:24.802]                             if (!grepl(pattern, name)) 
[15:32:24.802]                               next
[15:32:24.802]                             invokeRestart(restart)
[15:32:24.802]                             muffled <- TRUE
[15:32:24.802]                             break
[15:32:24.802]                           }
[15:32:24.802]                         }
[15:32:24.802]                       }
[15:32:24.802]                       invisible(muffled)
[15:32:24.802]                     }
[15:32:24.802]                     muffleCondition(cond, pattern = "^muffle")
[15:32:24.802]                   }
[15:32:24.802]                 }
[15:32:24.802]                 else {
[15:32:24.802]                   if (TRUE) {
[15:32:24.802]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:24.802]                     {
[15:32:24.802]                       inherits <- base::inherits
[15:32:24.802]                       invokeRestart <- base::invokeRestart
[15:32:24.802]                       is.null <- base::is.null
[15:32:24.802]                       muffled <- FALSE
[15:32:24.802]                       if (inherits(cond, "message")) {
[15:32:24.802]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:24.802]                         if (muffled) 
[15:32:24.802]                           invokeRestart("muffleMessage")
[15:32:24.802]                       }
[15:32:24.802]                       else if (inherits(cond, "warning")) {
[15:32:24.802]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:24.802]                         if (muffled) 
[15:32:24.802]                           invokeRestart("muffleWarning")
[15:32:24.802]                       }
[15:32:24.802]                       else if (inherits(cond, "condition")) {
[15:32:24.802]                         if (!is.null(pattern)) {
[15:32:24.802]                           computeRestarts <- base::computeRestarts
[15:32:24.802]                           grepl <- base::grepl
[15:32:24.802]                           restarts <- computeRestarts(cond)
[15:32:24.802]                           for (restart in restarts) {
[15:32:24.802]                             name <- restart$name
[15:32:24.802]                             if (is.null(name)) 
[15:32:24.802]                               next
[15:32:24.802]                             if (!grepl(pattern, name)) 
[15:32:24.802]                               next
[15:32:24.802]                             invokeRestart(restart)
[15:32:24.802]                             muffled <- TRUE
[15:32:24.802]                             break
[15:32:24.802]                           }
[15:32:24.802]                         }
[15:32:24.802]                       }
[15:32:24.802]                       invisible(muffled)
[15:32:24.802]                     }
[15:32:24.802]                     muffleCondition(cond, pattern = "^muffle")
[15:32:24.802]                   }
[15:32:24.802]                 }
[15:32:24.802]             }
[15:32:24.802]         }))
[15:32:24.802]     }, error = function(ex) {
[15:32:24.802]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:24.802]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:24.802]                 ...future.rng), started = ...future.startTime, 
[15:32:24.802]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:24.802]             version = "1.8"), class = "FutureResult")
[15:32:24.802]     }, finally = {
[15:32:24.802]         if (!identical(...future.workdir, getwd())) 
[15:32:24.802]             setwd(...future.workdir)
[15:32:24.802]         {
[15:32:24.802]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:24.802]                 ...future.oldOptions$nwarnings <- NULL
[15:32:24.802]             }
[15:32:24.802]             base::options(...future.oldOptions)
[15:32:24.802]             if (.Platform$OS.type == "windows") {
[15:32:24.802]                 old_names <- names(...future.oldEnvVars)
[15:32:24.802]                 envs <- base::Sys.getenv()
[15:32:24.802]                 names <- names(envs)
[15:32:24.802]                 common <- intersect(names, old_names)
[15:32:24.802]                 added <- setdiff(names, old_names)
[15:32:24.802]                 removed <- setdiff(old_names, names)
[15:32:24.802]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:24.802]                   envs[common]]
[15:32:24.802]                 NAMES <- toupper(changed)
[15:32:24.802]                 args <- list()
[15:32:24.802]                 for (kk in seq_along(NAMES)) {
[15:32:24.802]                   name <- changed[[kk]]
[15:32:24.802]                   NAME <- NAMES[[kk]]
[15:32:24.802]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:24.802]                     next
[15:32:24.802]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:24.802]                 }
[15:32:24.802]                 NAMES <- toupper(added)
[15:32:24.802]                 for (kk in seq_along(NAMES)) {
[15:32:24.802]                   name <- added[[kk]]
[15:32:24.802]                   NAME <- NAMES[[kk]]
[15:32:24.802]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:24.802]                     next
[15:32:24.802]                   args[[name]] <- ""
[15:32:24.802]                 }
[15:32:24.802]                 NAMES <- toupper(removed)
[15:32:24.802]                 for (kk in seq_along(NAMES)) {
[15:32:24.802]                   name <- removed[[kk]]
[15:32:24.802]                   NAME <- NAMES[[kk]]
[15:32:24.802]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:24.802]                     next
[15:32:24.802]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:24.802]                 }
[15:32:24.802]                 if (length(args) > 0) 
[15:32:24.802]                   base::do.call(base::Sys.setenv, args = args)
[15:32:24.802]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:24.802]             }
[15:32:24.802]             else {
[15:32:24.802]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:24.802]             }
[15:32:24.802]             {
[15:32:24.802]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:24.802]                   0L) {
[15:32:24.802]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:24.802]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:24.802]                   base::options(opts)
[15:32:24.802]                 }
[15:32:24.802]                 {
[15:32:24.802]                   {
[15:32:24.802]                     NULL
[15:32:24.802]                     RNGkind("Mersenne-Twister")
[15:32:24.802]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:24.802]                       inherits = FALSE)
[15:32:24.802]                   }
[15:32:24.802]                   options(future.plan = NULL)
[15:32:24.802]                   if (is.na(NA_character_)) 
[15:32:24.802]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:24.802]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:24.802]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:24.802]                     .init = FALSE)
[15:32:24.802]                 }
[15:32:24.802]             }
[15:32:24.802]         }
[15:32:24.802]     })
[15:32:24.802]     if (TRUE) {
[15:32:24.802]         base::sink(type = "output", split = FALSE)
[15:32:24.802]         if (TRUE) {
[15:32:24.802]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:24.802]         }
[15:32:24.802]         else {
[15:32:24.802]             ...future.result["stdout"] <- base::list(NULL)
[15:32:24.802]         }
[15:32:24.802]         base::close(...future.stdout)
[15:32:24.802]         ...future.stdout <- NULL
[15:32:24.802]     }
[15:32:24.802]     ...future.result$conditions <- ...future.conditions
[15:32:24.802]     ...future.result$finished <- base::Sys.time()
[15:32:24.802]     ...future.result
[15:32:24.802] }
[15:32:24.808] assign_globals() ...
[15:32:24.809] List of 5
[15:32:24.809]  $ ...future.FUN            :function (x)  
[15:32:24.809]  $ future.call.arguments    : list()
[15:32:24.809]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:24.809]  $ ...future.elements_ii    :List of 4
[15:32:24.809]   ..$ A: num 50
[15:32:24.809]   ..$ B: num 60
[15:32:24.809]   ..$ C: num 70
[15:32:24.809]   ..$ D: num 80
[15:32:24.809]  $ ...future.seeds_ii       : NULL
[15:32:24.809]  $ ...future.globals.maxSize: NULL
[15:32:24.809]  - attr(*, "where")=List of 5
[15:32:24.809]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:24.809]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:24.809]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:24.809]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:24.809]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:24.809]  - attr(*, "resolved")= logi FALSE
[15:32:24.809]  - attr(*, "total_size")= num 848
[15:32:24.809]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:24.809]  - attr(*, "already-done")= logi TRUE
[15:32:24.820] - copied '...future.FUN' to environment
[15:32:24.820] - copied 'future.call.arguments' to environment
[15:32:24.820] - copied '...future.elements_ii' to environment
[15:32:24.820] - copied '...future.seeds_ii' to environment
[15:32:24.821] - copied '...future.globals.maxSize' to environment
[15:32:24.821] assign_globals() ... done
[15:32:24.822] plan(): Setting new future strategy stack:
[15:32:24.822] List of future strategies:
[15:32:24.822] 1. sequential:
[15:32:24.822]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:24.822]    - tweaked: FALSE
[15:32:24.822]    - call: NULL
[15:32:24.823] plan(): nbrOfWorkers() = 1
[15:32:24.825] plan(): Setting new future strategy stack:
[15:32:24.825] List of future strategies:
[15:32:24.825] 1. sequential:
[15:32:24.825]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:24.825]    - tweaked: FALSE
[15:32:24.825]    - call: plan(strategy)
[15:32:24.826] plan(): nbrOfWorkers() = 1
[15:32:24.827] SequentialFuture started (and completed)
[15:32:24.827] - Launch lazy future ... done
[15:32:24.827] run() for 'SequentialFuture' ... done
[15:32:24.828] Created future:
[15:32:24.828] SequentialFuture:
[15:32:24.828] Label: 'future_sapply-1'
[15:32:24.828] Expression:
[15:32:24.828] {
[15:32:24.828]     do.call(function(...) {
[15:32:24.828]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:24.828]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:24.828]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:24.828]             on.exit(options(oopts), add = TRUE)
[15:32:24.828]         }
[15:32:24.828]         {
[15:32:24.828]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:24.828]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:24.828]                 ...future.FUN(...future.X_jj, ...)
[15:32:24.828]             })
[15:32:24.828]         }
[15:32:24.828]     }, args = future.call.arguments)
[15:32:24.828] }
[15:32:24.828] Lazy evaluation: FALSE
[15:32:24.828] Asynchronous evaluation: FALSE
[15:32:24.828] Local evaluation: TRUE
[15:32:24.828] Environment: R_GlobalEnv
[15:32:24.828] Capture standard output: TRUE
[15:32:24.828] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:24.828] Globals: 5 objects totaling 1.05 KiB (function '...future.FUN' of 848 bytes, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 224 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:24.828] Packages: <none>
[15:32:24.828] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:24.828] Resolved: TRUE
[15:32:24.828] Value: 224 bytes of class 'list'
[15:32:24.828] Early signaling: FALSE
[15:32:24.828] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:24.828] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:24.830] Chunk #1 of 1 ... DONE
[15:32:24.830] Launching 1 futures (chunks) ... DONE
[15:32:24.831] Resolving 1 futures (chunks) ...
[15:32:24.831] resolve() on list ...
[15:32:24.831]  recursive: 0
[15:32:24.831]  length: 1
[15:32:24.832] 
[15:32:24.832] resolved() for 'SequentialFuture' ...
[15:32:24.832] - state: 'finished'
[15:32:24.832] - run: TRUE
[15:32:24.833] - result: 'FutureResult'
[15:32:24.833] resolved() for 'SequentialFuture' ... done
[15:32:24.833] Future #1
[15:32:24.834] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:24.834] - nx: 1
[15:32:24.834] - relay: TRUE
[15:32:24.834] - stdout: TRUE
[15:32:24.835] - signal: TRUE
[15:32:24.835] - resignal: FALSE
[15:32:24.835] - force: TRUE
[15:32:24.835] - relayed: [n=1] FALSE
[15:32:24.836] - queued futures: [n=1] FALSE
[15:32:24.836]  - until=1
[15:32:24.836]  - relaying element #1
[15:32:24.837] - relayed: [n=1] TRUE
[15:32:24.837] - queued futures: [n=1] TRUE
[15:32:24.837] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:24.838]  length: 0 (resolved future 1)
[15:32:24.838] Relaying remaining futures
[15:32:24.838] signalConditionsASAP(NULL, pos=0) ...
[15:32:24.838] - nx: 1
[15:32:24.839] - relay: TRUE
[15:32:24.839] - stdout: TRUE
[15:32:24.839] - signal: TRUE
[15:32:24.839] - resignal: FALSE
[15:32:24.840] - force: TRUE
[15:32:24.840] - relayed: [n=1] TRUE
[15:32:24.840] - queued futures: [n=1] TRUE
 - flush all
[15:32:24.840] - relayed: [n=1] TRUE
[15:32:24.841] - queued futures: [n=1] TRUE
[15:32:24.841] signalConditionsASAP(NULL, pos=0) ... done
[15:32:24.841] resolve() on list ... DONE
[15:32:24.842]  - Number of value chunks collected: 1
[15:32:24.842] Resolving 1 futures (chunks) ... DONE
[15:32:24.842] Reducing values from 1 chunks ...
[15:32:24.842]  - Number of values collected after concatenation: 4
[15:32:24.843]  - Number of values expected: 4
[15:32:24.843] Reducing values from 1 chunks ... DONE
[15:32:24.843] future_lapply() ... DONE
List of 2
 $ y0:List of 4
  ..$ A: num 50
  ..$ B: num 60
  ..$ C: num 70
  ..$ D: num 80
 $ y1:List of 4
  ..$ A: num 50
  ..$ B: num 60
  ..$ C: num 70
  ..$ D: num 80
List of 2
 $ y0:List of 4
  ..$ A: num 50
  ..$ B: num 60
  ..$ C: num 70
  ..$ D: num 80
 $ y2:List of 4
  ..$ A: num 50
  ..$ B: num 60
  ..$ C: num 70
  ..$ D: num 80
[15:32:24.857] future_lapply() ...
[15:32:24.857] Number of chunks: 1
[15:32:24.858] getGlobalsAndPackagesXApply() ...
[15:32:24.858]  - future.globals: TRUE
[15:32:24.858] getGlobalsAndPackages() ...
[15:32:24.858] Searching for globals...
[15:32:24.860] - globals found: [2] 'FUN', 'UseMethod'
[15:32:24.861] Searching for globals ... DONE
[15:32:24.861] Resolving globals: FALSE
[15:32:24.862] The total size of the 1 globals is 1.22 KiB (1248 bytes)
[15:32:24.863] The total size of the 1 globals exported for future expression ('FUN()') is 1.22 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.22 KiB of class 'function')
[15:32:24.863] - globals: [1] 'FUN'
[15:32:24.863] 
[15:32:24.864] getGlobalsAndPackages() ... DONE
[15:32:24.864]  - globals found/used: [n=1] 'FUN'
[15:32:24.864]  - needed namespaces: [n=0] 
[15:32:24.864] Finding globals ... DONE
[15:32:24.865]  - use_args: TRUE
[15:32:24.865]  - Getting '...' globals ...
[15:32:24.866] resolve() on list ...
[15:32:24.866]  recursive: 0
[15:32:24.866]  length: 1
[15:32:24.867]  elements: '...'
[15:32:24.867]  length: 0 (resolved future 1)
[15:32:24.867] resolve() on list ... DONE
[15:32:24.868]    - '...' content: [n=0] 
[15:32:24.868] List of 1
[15:32:24.868]  $ ...: list()
[15:32:24.868]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:24.868]  - attr(*, "where")=List of 1
[15:32:24.868]   ..$ ...:<environment: 0x00000276e29961b8> 
[15:32:24.868]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:24.868]  - attr(*, "resolved")= logi TRUE
[15:32:24.868]  - attr(*, "total_size")= num NA
[15:32:24.872]  - Getting '...' globals ... DONE
[15:32:24.873] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:24.873] List of 2
[15:32:24.873]  $ ...future.FUN:function (x, ...)  
[15:32:24.873]  $ ...          : list()
[15:32:24.873]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:24.873]  - attr(*, "where")=List of 2
[15:32:24.873]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:24.873]   ..$ ...          :<environment: 0x00000276e29961b8> 
[15:32:24.873]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:24.873]  - attr(*, "resolved")= logi FALSE
[15:32:24.873]  - attr(*, "total_size")= num 1248
[15:32:24.878] Packages to be attached in all futures: [n=0] 
[15:32:24.878] getGlobalsAndPackagesXApply() ... DONE
[15:32:24.879] Number of futures (= number of chunks): 1
[15:32:24.879] Launching 1 futures (chunks) ...
[15:32:24.880] Chunk #1 of 1 ...
[15:32:24.880]  - Finding globals in 'X' for chunk #1 ...
[15:32:24.880] getGlobalsAndPackages() ...
[15:32:24.880] Searching for globals...
[15:32:24.881] 
[15:32:24.881] Searching for globals ... DONE
[15:32:24.882] - globals: [0] <none>
[15:32:24.882] getGlobalsAndPackages() ... DONE
[15:32:24.882]    + additional globals found: [n=0] 
[15:32:24.883]    + additional namespaces needed: [n=0] 
[15:32:24.883]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:24.883]  - seeds: <none>
[15:32:24.883]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:24.884] getGlobalsAndPackages() ...
[15:32:24.884] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:24.885] Resolving globals: FALSE
[15:32:24.885] Tweak future expression to call with '...' arguments ...
[15:32:24.885] {
[15:32:24.885]     do.call(function(...) {
[15:32:24.885]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:24.885]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:24.885]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:24.885]             on.exit(options(oopts), add = TRUE)
[15:32:24.885]         }
[15:32:24.885]         {
[15:32:24.885]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:24.885]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:24.885]                 ...future.FUN(...future.X_jj, ...)
[15:32:24.885]             })
[15:32:24.885]         }
[15:32:24.885]     }, args = future.call.arguments)
[15:32:24.885] }
[15:32:24.886] Tweak future expression to call with '...' arguments ... DONE
[15:32:24.887] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:24.887] 
[15:32:24.888] getGlobalsAndPackages() ... DONE
[15:32:24.888] run() for 'Future' ...
[15:32:24.889] - state: 'created'
[15:32:24.889] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:24.890] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:24.890] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:24.890]   - Field: 'label'
[15:32:24.891]   - Field: 'local'
[15:32:24.891]   - Field: 'owner'
[15:32:24.891]   - Field: 'envir'
[15:32:24.892]   - Field: 'packages'
[15:32:24.892]   - Field: 'gc'
[15:32:24.892]   - Field: 'conditions'
[15:32:24.893]   - Field: 'expr'
[15:32:24.893]   - Field: 'uuid'
[15:32:24.893]   - Field: 'seed'
[15:32:24.893]   - Field: 'version'
[15:32:24.894]   - Field: 'result'
[15:32:24.894]   - Field: 'asynchronous'
[15:32:24.894]   - Field: 'calls'
[15:32:24.895]   - Field: 'globals'
[15:32:24.895]   - Field: 'stdout'
[15:32:24.895]   - Field: 'earlySignal'
[15:32:24.896]   - Field: 'lazy'
[15:32:24.896]   - Field: 'state'
[15:32:24.896] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:24.897] - Launch lazy future ...
[15:32:24.897] Packages needed by the future expression (n = 0): <none>
[15:32:24.898] Packages needed by future strategies (n = 0): <none>
[15:32:24.899] {
[15:32:24.899]     {
[15:32:24.899]         {
[15:32:24.899]             ...future.startTime <- base::Sys.time()
[15:32:24.899]             {
[15:32:24.899]                 {
[15:32:24.899]                   {
[15:32:24.899]                     base::local({
[15:32:24.899]                       has_future <- base::requireNamespace("future", 
[15:32:24.899]                         quietly = TRUE)
[15:32:24.899]                       if (has_future) {
[15:32:24.899]                         ns <- base::getNamespace("future")
[15:32:24.899]                         version <- ns[[".package"]][["version"]]
[15:32:24.899]                         if (is.null(version)) 
[15:32:24.899]                           version <- utils::packageVersion("future")
[15:32:24.899]                       }
[15:32:24.899]                       else {
[15:32:24.899]                         version <- NULL
[15:32:24.899]                       }
[15:32:24.899]                       if (!has_future || version < "1.8.0") {
[15:32:24.899]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:24.899]                           "", base::R.version$version.string), 
[15:32:24.899]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:24.899]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:24.899]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:24.899]                             "release", "version")], collapse = " "), 
[15:32:24.899]                           hostname = base::Sys.info()[["nodename"]])
[15:32:24.899]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:24.899]                           info)
[15:32:24.899]                         info <- base::paste(info, collapse = "; ")
[15:32:24.899]                         if (!has_future) {
[15:32:24.899]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:24.899]                             info)
[15:32:24.899]                         }
[15:32:24.899]                         else {
[15:32:24.899]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:24.899]                             info, version)
[15:32:24.899]                         }
[15:32:24.899]                         base::stop(msg)
[15:32:24.899]                       }
[15:32:24.899]                     })
[15:32:24.899]                   }
[15:32:24.899]                   ...future.strategy.old <- future::plan("list")
[15:32:24.899]                   options(future.plan = NULL)
[15:32:24.899]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:24.899]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:24.899]                 }
[15:32:24.899]                 ...future.workdir <- getwd()
[15:32:24.899]             }
[15:32:24.899]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:24.899]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:24.899]         }
[15:32:24.899]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:24.899]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:24.899]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:24.899]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:24.899]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:24.899]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:24.899]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:24.899]             base::names(...future.oldOptions))
[15:32:24.899]     }
[15:32:24.899]     if (FALSE) {
[15:32:24.899]     }
[15:32:24.899]     else {
[15:32:24.899]         if (TRUE) {
[15:32:24.899]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:24.899]                 open = "w")
[15:32:24.899]         }
[15:32:24.899]         else {
[15:32:24.899]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:24.899]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:24.899]         }
[15:32:24.899]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:24.899]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:24.899]             base::sink(type = "output", split = FALSE)
[15:32:24.899]             base::close(...future.stdout)
[15:32:24.899]         }, add = TRUE)
[15:32:24.899]     }
[15:32:24.899]     ...future.frame <- base::sys.nframe()
[15:32:24.899]     ...future.conditions <- base::list()
[15:32:24.899]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:24.899]     if (FALSE) {
[15:32:24.899]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:24.899]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:24.899]     }
[15:32:24.899]     ...future.result <- base::tryCatch({
[15:32:24.899]         base::withCallingHandlers({
[15:32:24.899]             ...future.value <- base::withVisible(base::local({
[15:32:24.899]                 do.call(function(...) {
[15:32:24.899]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:24.899]                   if (!identical(...future.globals.maxSize.org, 
[15:32:24.899]                     ...future.globals.maxSize)) {
[15:32:24.899]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:24.899]                     on.exit(options(oopts), add = TRUE)
[15:32:24.899]                   }
[15:32:24.899]                   {
[15:32:24.899]                     lapply(seq_along(...future.elements_ii), 
[15:32:24.899]                       FUN = function(jj) {
[15:32:24.899]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:24.899]                         ...future.FUN(...future.X_jj, ...)
[15:32:24.899]                       })
[15:32:24.899]                   }
[15:32:24.899]                 }, args = future.call.arguments)
[15:32:24.899]             }))
[15:32:24.899]             future::FutureResult(value = ...future.value$value, 
[15:32:24.899]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:24.899]                   ...future.rng), globalenv = if (FALSE) 
[15:32:24.899]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:24.899]                     ...future.globalenv.names))
[15:32:24.899]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:24.899]         }, condition = base::local({
[15:32:24.899]             c <- base::c
[15:32:24.899]             inherits <- base::inherits
[15:32:24.899]             invokeRestart <- base::invokeRestart
[15:32:24.899]             length <- base::length
[15:32:24.899]             list <- base::list
[15:32:24.899]             seq.int <- base::seq.int
[15:32:24.899]             signalCondition <- base::signalCondition
[15:32:24.899]             sys.calls <- base::sys.calls
[15:32:24.899]             `[[` <- base::`[[`
[15:32:24.899]             `+` <- base::`+`
[15:32:24.899]             `<<-` <- base::`<<-`
[15:32:24.899]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:24.899]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:24.899]                   3L)]
[15:32:24.899]             }
[15:32:24.899]             function(cond) {
[15:32:24.899]                 is_error <- inherits(cond, "error")
[15:32:24.899]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:24.899]                   NULL)
[15:32:24.899]                 if (is_error) {
[15:32:24.899]                   sessionInformation <- function() {
[15:32:24.899]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:24.899]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:24.899]                       search = base::search(), system = base::Sys.info())
[15:32:24.899]                   }
[15:32:24.899]                   ...future.conditions[[length(...future.conditions) + 
[15:32:24.899]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:24.899]                     cond$call), session = sessionInformation(), 
[15:32:24.899]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:24.899]                   signalCondition(cond)
[15:32:24.899]                 }
[15:32:24.899]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:24.899]                 "immediateCondition"))) {
[15:32:24.899]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:24.899]                   ...future.conditions[[length(...future.conditions) + 
[15:32:24.899]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:24.899]                   if (TRUE && !signal) {
[15:32:24.899]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:24.899]                     {
[15:32:24.899]                       inherits <- base::inherits
[15:32:24.899]                       invokeRestart <- base::invokeRestart
[15:32:24.899]                       is.null <- base::is.null
[15:32:24.899]                       muffled <- FALSE
[15:32:24.899]                       if (inherits(cond, "message")) {
[15:32:24.899]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:24.899]                         if (muffled) 
[15:32:24.899]                           invokeRestart("muffleMessage")
[15:32:24.899]                       }
[15:32:24.899]                       else if (inherits(cond, "warning")) {
[15:32:24.899]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:24.899]                         if (muffled) 
[15:32:24.899]                           invokeRestart("muffleWarning")
[15:32:24.899]                       }
[15:32:24.899]                       else if (inherits(cond, "condition")) {
[15:32:24.899]                         if (!is.null(pattern)) {
[15:32:24.899]                           computeRestarts <- base::computeRestarts
[15:32:24.899]                           grepl <- base::grepl
[15:32:24.899]                           restarts <- computeRestarts(cond)
[15:32:24.899]                           for (restart in restarts) {
[15:32:24.899]                             name <- restart$name
[15:32:24.899]                             if (is.null(name)) 
[15:32:24.899]                               next
[15:32:24.899]                             if (!grepl(pattern, name)) 
[15:32:24.899]                               next
[15:32:24.899]                             invokeRestart(restart)
[15:32:24.899]                             muffled <- TRUE
[15:32:24.899]                             break
[15:32:24.899]                           }
[15:32:24.899]                         }
[15:32:24.899]                       }
[15:32:24.899]                       invisible(muffled)
[15:32:24.899]                     }
[15:32:24.899]                     muffleCondition(cond, pattern = "^muffle")
[15:32:24.899]                   }
[15:32:24.899]                 }
[15:32:24.899]                 else {
[15:32:24.899]                   if (TRUE) {
[15:32:24.899]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:24.899]                     {
[15:32:24.899]                       inherits <- base::inherits
[15:32:24.899]                       invokeRestart <- base::invokeRestart
[15:32:24.899]                       is.null <- base::is.null
[15:32:24.899]                       muffled <- FALSE
[15:32:24.899]                       if (inherits(cond, "message")) {
[15:32:24.899]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:24.899]                         if (muffled) 
[15:32:24.899]                           invokeRestart("muffleMessage")
[15:32:24.899]                       }
[15:32:24.899]                       else if (inherits(cond, "warning")) {
[15:32:24.899]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:24.899]                         if (muffled) 
[15:32:24.899]                           invokeRestart("muffleWarning")
[15:32:24.899]                       }
[15:32:24.899]                       else if (inherits(cond, "condition")) {
[15:32:24.899]                         if (!is.null(pattern)) {
[15:32:24.899]                           computeRestarts <- base::computeRestarts
[15:32:24.899]                           grepl <- base::grepl
[15:32:24.899]                           restarts <- computeRestarts(cond)
[15:32:24.899]                           for (restart in restarts) {
[15:32:24.899]                             name <- restart$name
[15:32:24.899]                             if (is.null(name)) 
[15:32:24.899]                               next
[15:32:24.899]                             if (!grepl(pattern, name)) 
[15:32:24.899]                               next
[15:32:24.899]                             invokeRestart(restart)
[15:32:24.899]                             muffled <- TRUE
[15:32:24.899]                             break
[15:32:24.899]                           }
[15:32:24.899]                         }
[15:32:24.899]                       }
[15:32:24.899]                       invisible(muffled)
[15:32:24.899]                     }
[15:32:24.899]                     muffleCondition(cond, pattern = "^muffle")
[15:32:24.899]                   }
[15:32:24.899]                 }
[15:32:24.899]             }
[15:32:24.899]         }))
[15:32:24.899]     }, error = function(ex) {
[15:32:24.899]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:24.899]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:24.899]                 ...future.rng), started = ...future.startTime, 
[15:32:24.899]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:24.899]             version = "1.8"), class = "FutureResult")
[15:32:24.899]     }, finally = {
[15:32:24.899]         if (!identical(...future.workdir, getwd())) 
[15:32:24.899]             setwd(...future.workdir)
[15:32:24.899]         {
[15:32:24.899]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:24.899]                 ...future.oldOptions$nwarnings <- NULL
[15:32:24.899]             }
[15:32:24.899]             base::options(...future.oldOptions)
[15:32:24.899]             if (.Platform$OS.type == "windows") {
[15:32:24.899]                 old_names <- names(...future.oldEnvVars)
[15:32:24.899]                 envs <- base::Sys.getenv()
[15:32:24.899]                 names <- names(envs)
[15:32:24.899]                 common <- intersect(names, old_names)
[15:32:24.899]                 added <- setdiff(names, old_names)
[15:32:24.899]                 removed <- setdiff(old_names, names)
[15:32:24.899]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:24.899]                   envs[common]]
[15:32:24.899]                 NAMES <- toupper(changed)
[15:32:24.899]                 args <- list()
[15:32:24.899]                 for (kk in seq_along(NAMES)) {
[15:32:24.899]                   name <- changed[[kk]]
[15:32:24.899]                   NAME <- NAMES[[kk]]
[15:32:24.899]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:24.899]                     next
[15:32:24.899]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:24.899]                 }
[15:32:24.899]                 NAMES <- toupper(added)
[15:32:24.899]                 for (kk in seq_along(NAMES)) {
[15:32:24.899]                   name <- added[[kk]]
[15:32:24.899]                   NAME <- NAMES[[kk]]
[15:32:24.899]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:24.899]                     next
[15:32:24.899]                   args[[name]] <- ""
[15:32:24.899]                 }
[15:32:24.899]                 NAMES <- toupper(removed)
[15:32:24.899]                 for (kk in seq_along(NAMES)) {
[15:32:24.899]                   name <- removed[[kk]]
[15:32:24.899]                   NAME <- NAMES[[kk]]
[15:32:24.899]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:24.899]                     next
[15:32:24.899]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:24.899]                 }
[15:32:24.899]                 if (length(args) > 0) 
[15:32:24.899]                   base::do.call(base::Sys.setenv, args = args)
[15:32:24.899]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:24.899]             }
[15:32:24.899]             else {
[15:32:24.899]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:24.899]             }
[15:32:24.899]             {
[15:32:24.899]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:24.899]                   0L) {
[15:32:24.899]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:24.899]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:24.899]                   base::options(opts)
[15:32:24.899]                 }
[15:32:24.899]                 {
[15:32:24.899]                   {
[15:32:24.899]                     NULL
[15:32:24.899]                     RNGkind("Mersenne-Twister")
[15:32:24.899]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:24.899]                       inherits = FALSE)
[15:32:24.899]                   }
[15:32:24.899]                   options(future.plan = NULL)
[15:32:24.899]                   if (is.na(NA_character_)) 
[15:32:24.899]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:24.899]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:24.899]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:24.899]                     .init = FALSE)
[15:32:24.899]                 }
[15:32:24.899]             }
[15:32:24.899]         }
[15:32:24.899]     })
[15:32:24.899]     if (TRUE) {
[15:32:24.899]         base::sink(type = "output", split = FALSE)
[15:32:24.899]         if (TRUE) {
[15:32:24.899]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:24.899]         }
[15:32:24.899]         else {
[15:32:24.899]             ...future.result["stdout"] <- base::list(NULL)
[15:32:24.899]         }
[15:32:24.899]         base::close(...future.stdout)
[15:32:24.899]         ...future.stdout <- NULL
[15:32:24.899]     }
[15:32:24.899]     ...future.result$conditions <- ...future.conditions
[15:32:24.899]     ...future.result$finished <- base::Sys.time()
[15:32:24.899]     ...future.result
[15:32:24.899] }
[15:32:24.906] assign_globals() ...
[15:32:24.906] List of 5
[15:32:24.906]  $ ...future.FUN            :function (x, ...)  
[15:32:24.906]  $ future.call.arguments    : list()
[15:32:24.906]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:24.906]  $ ...future.elements_ii    :List of 4
[15:32:24.906]   ..$ A: num 50
[15:32:24.906]   ..$ B: num 60
[15:32:24.906]   ..$ C: num 70
[15:32:24.906]   ..$ D: num 80
[15:32:24.906]  $ ...future.seeds_ii       : NULL
[15:32:24.906]  $ ...future.globals.maxSize: NULL
[15:32:24.906]  - attr(*, "where")=List of 5
[15:32:24.906]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:24.906]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:24.906]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:24.906]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:24.906]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:24.906]  - attr(*, "resolved")= logi FALSE
[15:32:24.906]  - attr(*, "total_size")= num 1248
[15:32:24.906]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:24.906]  - attr(*, "already-done")= logi TRUE
[15:32:24.919] - copied '...future.FUN' to environment
[15:32:24.919] - copied 'future.call.arguments' to environment
[15:32:24.919] - copied '...future.elements_ii' to environment
[15:32:24.920] - copied '...future.seeds_ii' to environment
[15:32:24.920] - copied '...future.globals.maxSize' to environment
[15:32:24.920] assign_globals() ... done
[15:32:24.921] plan(): Setting new future strategy stack:
[15:32:24.921] List of future strategies:
[15:32:24.921] 1. sequential:
[15:32:24.921]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:24.921]    - tweaked: FALSE
[15:32:24.921]    - call: NULL
[15:32:24.922] plan(): nbrOfWorkers() = 1
[15:32:24.924] plan(): Setting new future strategy stack:
[15:32:24.925] List of future strategies:
[15:32:24.925] 1. sequential:
[15:32:24.925]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:24.925]    - tweaked: FALSE
[15:32:24.925]    - call: plan(strategy)
[15:32:24.926] plan(): nbrOfWorkers() = 1
[15:32:24.926] SequentialFuture started (and completed)
[15:32:24.927] - Launch lazy future ... done
[15:32:24.927] run() for 'SequentialFuture' ... done
[15:32:24.927] Created future:
[15:32:24.928] SequentialFuture:
[15:32:24.928] Label: 'future_sapply-1'
[15:32:24.928] Expression:
[15:32:24.928] {
[15:32:24.928]     do.call(function(...) {
[15:32:24.928]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:24.928]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:24.928]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:24.928]             on.exit(options(oopts), add = TRUE)
[15:32:24.928]         }
[15:32:24.928]         {
[15:32:24.928]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:24.928]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:24.928]                 ...future.FUN(...future.X_jj, ...)
[15:32:24.928]             })
[15:32:24.928]         }
[15:32:24.928]     }, args = future.call.arguments)
[15:32:24.928] }
[15:32:24.928] Lazy evaluation: FALSE
[15:32:24.928] Asynchronous evaluation: FALSE
[15:32:24.928] Local evaluation: TRUE
[15:32:24.928] Environment: R_GlobalEnv
[15:32:24.928] Capture standard output: TRUE
[15:32:24.928] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:24.928] Globals: 5 objects totaling 1.44 KiB (function '...future.FUN' of 1.22 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 224 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:24.928] Packages: <none>
[15:32:24.928] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:24.928] Resolved: TRUE
[15:32:24.928] Value: 896 bytes of class 'list'
[15:32:24.928] Early signaling: FALSE
[15:32:24.928] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:24.928] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:24.930] Chunk #1 of 1 ... DONE
[15:32:24.930] Launching 1 futures (chunks) ... DONE
[15:32:24.931] Resolving 1 futures (chunks) ...
[15:32:24.931] resolve() on list ...
[15:32:24.931]  recursive: 0
[15:32:24.932]  length: 1
[15:32:24.932] 
[15:32:24.932] resolved() for 'SequentialFuture' ...
[15:32:24.933] - state: 'finished'
[15:32:24.933] - run: TRUE
[15:32:24.933] - result: 'FutureResult'
[15:32:24.934] resolved() for 'SequentialFuture' ... done
[15:32:24.934] Future #1
[15:32:24.934] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:24.935] - nx: 1
[15:32:24.935] - relay: TRUE
[15:32:24.935] - stdout: TRUE
[15:32:24.936] - signal: TRUE
[15:32:24.936] - resignal: FALSE
[15:32:24.936] - force: TRUE
[15:32:24.936] - relayed: [n=1] FALSE
[15:32:24.937] - queued futures: [n=1] FALSE
[15:32:24.937]  - until=1
[15:32:24.937]  - relaying element #1
[15:32:24.938] - relayed: [n=1] TRUE
[15:32:24.938] - queued futures: [n=1] TRUE
[15:32:24.939] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:24.939]  length: 0 (resolved future 1)
[15:32:24.939] Relaying remaining futures
[15:32:24.939] signalConditionsASAP(NULL, pos=0) ...
[15:32:24.940] - nx: 1
[15:32:24.940] - relay: TRUE
[15:32:24.940] - stdout: TRUE
[15:32:24.941] - signal: TRUE
[15:32:24.941] - resignal: FALSE
[15:32:24.941] - force: TRUE
[15:32:24.941] - relayed: [n=1] TRUE
[15:32:24.942] - queued futures: [n=1] TRUE
 - flush all
[15:32:24.942] - relayed: [n=1] TRUE
[15:32:24.943] - queued futures: [n=1] TRUE
[15:32:24.943] signalConditionsASAP(NULL, pos=0) ... done
[15:32:24.943] resolve() on list ... DONE
[15:32:24.944]  - Number of value chunks collected: 1
[15:32:24.944] Resolving 1 futures (chunks) ... DONE
[15:32:24.944] Reducing values from 1 chunks ...
[15:32:24.944]  - Number of values collected after concatenation: 4
[15:32:24.945]  - Number of values expected: 4
[15:32:24.945] Reducing values from 1 chunks ... DONE
[15:32:24.945] future_lapply() ... DONE
List of 2
 $ y0:List of 4
  ..$ A: num [1, 1] 50
  ..$ B: num [1, 1] 60
  ..$ C: num [1, 1] 70
  ..$ D: num [1, 1] 80
 $ y1:List of 4
  ..$ A: num [1, 1] 50
  ..$ B: num [1, 1] 60
  ..$ C: num [1, 1] 70
  ..$ D: num [1, 1] 80
List of 2
 $ y0:List of 4
  ..$ A: num [1, 1] 50
  ..$ B: num [1, 1] 60
  ..$ C: num [1, 1] 70
  ..$ D: num [1, 1] 80
 $ y2:List of 4
  ..$ A: num [1, 1] 50
  ..$ B: num [1, 1] 60
  ..$ C: num [1, 1] 70
  ..$ D: num [1, 1] 80
[15:32:24.962] future_lapply() ...
[15:32:24.964] Number of chunks: 1
[15:32:24.964] getGlobalsAndPackagesXApply() ...
[15:32:24.964]  - future.globals: TRUE
[15:32:24.965] getGlobalsAndPackages() ...
[15:32:24.965] Searching for globals...
[15:32:24.968] - globals found: [5] 'FUN', '*', ':', 'outer', 'rep'
[15:32:24.969] Searching for globals ... DONE
[15:32:24.969] Resolving globals: FALSE
[15:32:24.970] The total size of the 1 globals is 4.62 KiB (4728 bytes)
[15:32:24.971] The total size of the 1 globals exported for future expression ('FUN()') is 4.62 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.62 KiB of class 'function')
[15:32:24.971] - globals: [1] 'FUN'
[15:32:24.971] 
[15:32:24.972] getGlobalsAndPackages() ... DONE
[15:32:24.972]  - globals found/used: [n=1] 'FUN'
[15:32:24.972]  - needed namespaces: [n=0] 
[15:32:24.973] Finding globals ... DONE
[15:32:24.973]  - use_args: TRUE
[15:32:24.973]  - Getting '...' globals ...
[15:32:24.974] resolve() on list ...
[15:32:24.974]  recursive: 0
[15:32:24.974]  length: 1
[15:32:24.975]  elements: '...'
[15:32:24.975]  length: 0 (resolved future 1)
[15:32:24.975] resolve() on list ... DONE
[15:32:24.976]    - '...' content: [n=0] 
[15:32:24.976] List of 1
[15:32:24.976]  $ ...: list()
[15:32:24.976]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:24.976]  - attr(*, "where")=List of 1
[15:32:24.976]   ..$ ...:<environment: 0x00000276e4c276d0> 
[15:32:24.976]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:24.976]  - attr(*, "resolved")= logi TRUE
[15:32:24.976]  - attr(*, "total_size")= num NA
[15:32:24.981]  - Getting '...' globals ... DONE
[15:32:24.982] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:24.982] List of 2
[15:32:24.982]  $ ...future.FUN:function (x, y = 2 * 1:5)  
[15:32:24.982]  $ ...          : list()
[15:32:24.982]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:24.982]  - attr(*, "where")=List of 2
[15:32:24.982]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:24.982]   ..$ ...          :<environment: 0x00000276e4c276d0> 
[15:32:24.982]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:24.982]  - attr(*, "resolved")= logi FALSE
[15:32:24.982]  - attr(*, "total_size")= num 4728
[15:32:24.988] Packages to be attached in all futures: [n=0] 
[15:32:24.988] getGlobalsAndPackagesXApply() ... DONE
[15:32:24.989] Number of futures (= number of chunks): 1
[15:32:24.989] Launching 1 futures (chunks) ...
[15:32:24.989] Chunk #1 of 1 ...
[15:32:24.990]  - Finding globals in 'X' for chunk #1 ...
[15:32:24.990] getGlobalsAndPackages() ...
[15:32:24.990] Searching for globals...
[15:32:24.991] 
[15:32:24.991] Searching for globals ... DONE
[15:32:24.992] - globals: [0] <none>
[15:32:24.992] getGlobalsAndPackages() ... DONE
[15:32:24.992]    + additional globals found: [n=0] 
[15:32:24.993]    + additional namespaces needed: [n=0] 
[15:32:24.993]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:24.993]  - seeds: <none>
[15:32:24.993]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:24.994] getGlobalsAndPackages() ...
[15:32:24.994] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:24.994] Resolving globals: FALSE
[15:32:24.995] Tweak future expression to call with '...' arguments ...
[15:32:24.995] {
[15:32:24.995]     do.call(function(...) {
[15:32:24.995]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:24.995]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:24.995]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:24.995]             on.exit(options(oopts), add = TRUE)
[15:32:24.995]         }
[15:32:24.995]         {
[15:32:24.995]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:24.995]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:24.995]                 ...future.FUN(...future.X_jj, ...)
[15:32:24.995]             })
[15:32:24.995]         }
[15:32:24.995]     }, args = future.call.arguments)
[15:32:24.995] }
[15:32:24.996] Tweak future expression to call with '...' arguments ... DONE
[15:32:24.997] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:24.997] 
[15:32:24.997] getGlobalsAndPackages() ... DONE
[15:32:24.998] run() for 'Future' ...
[15:32:24.998] - state: 'created'
[15:32:24.999] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:25.000] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:25.000] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:25.001]   - Field: 'label'
[15:32:25.001]   - Field: 'local'
[15:32:25.001]   - Field: 'owner'
[15:32:25.001]   - Field: 'envir'
[15:32:25.002]   - Field: 'packages'
[15:32:25.002]   - Field: 'gc'
[15:32:25.002]   - Field: 'conditions'
[15:32:25.003]   - Field: 'expr'
[15:32:25.003]   - Field: 'uuid'
[15:32:25.004]   - Field: 'seed'
[15:32:25.004]   - Field: 'version'
[15:32:25.005]   - Field: 'result'
[15:32:25.005]   - Field: 'asynchronous'
[15:32:25.005]   - Field: 'calls'
[15:32:25.006]   - Field: 'globals'
[15:32:25.006]   - Field: 'stdout'
[15:32:25.006]   - Field: 'earlySignal'
[15:32:25.007]   - Field: 'lazy'
[15:32:25.007]   - Field: 'state'
[15:32:25.007] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:25.008] - Launch lazy future ...
[15:32:25.009] Packages needed by the future expression (n = 0): <none>
[15:32:25.009] Packages needed by future strategies (n = 0): <none>
[15:32:25.010] {
[15:32:25.010]     {
[15:32:25.010]         {
[15:32:25.010]             ...future.startTime <- base::Sys.time()
[15:32:25.010]             {
[15:32:25.010]                 {
[15:32:25.010]                   {
[15:32:25.010]                     base::local({
[15:32:25.010]                       has_future <- base::requireNamespace("future", 
[15:32:25.010]                         quietly = TRUE)
[15:32:25.010]                       if (has_future) {
[15:32:25.010]                         ns <- base::getNamespace("future")
[15:32:25.010]                         version <- ns[[".package"]][["version"]]
[15:32:25.010]                         if (is.null(version)) 
[15:32:25.010]                           version <- utils::packageVersion("future")
[15:32:25.010]                       }
[15:32:25.010]                       else {
[15:32:25.010]                         version <- NULL
[15:32:25.010]                       }
[15:32:25.010]                       if (!has_future || version < "1.8.0") {
[15:32:25.010]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:25.010]                           "", base::R.version$version.string), 
[15:32:25.010]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:25.010]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:25.010]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:25.010]                             "release", "version")], collapse = " "), 
[15:32:25.010]                           hostname = base::Sys.info()[["nodename"]])
[15:32:25.010]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:25.010]                           info)
[15:32:25.010]                         info <- base::paste(info, collapse = "; ")
[15:32:25.010]                         if (!has_future) {
[15:32:25.010]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:25.010]                             info)
[15:32:25.010]                         }
[15:32:25.010]                         else {
[15:32:25.010]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:25.010]                             info, version)
[15:32:25.010]                         }
[15:32:25.010]                         base::stop(msg)
[15:32:25.010]                       }
[15:32:25.010]                     })
[15:32:25.010]                   }
[15:32:25.010]                   ...future.strategy.old <- future::plan("list")
[15:32:25.010]                   options(future.plan = NULL)
[15:32:25.010]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:25.010]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:25.010]                 }
[15:32:25.010]                 ...future.workdir <- getwd()
[15:32:25.010]             }
[15:32:25.010]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:25.010]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:25.010]         }
[15:32:25.010]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:25.010]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:25.010]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:25.010]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:25.010]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:25.010]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:25.010]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:25.010]             base::names(...future.oldOptions))
[15:32:25.010]     }
[15:32:25.010]     if (FALSE) {
[15:32:25.010]     }
[15:32:25.010]     else {
[15:32:25.010]         if (TRUE) {
[15:32:25.010]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:25.010]                 open = "w")
[15:32:25.010]         }
[15:32:25.010]         else {
[15:32:25.010]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:25.010]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:25.010]         }
[15:32:25.010]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:25.010]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:25.010]             base::sink(type = "output", split = FALSE)
[15:32:25.010]             base::close(...future.stdout)
[15:32:25.010]         }, add = TRUE)
[15:32:25.010]     }
[15:32:25.010]     ...future.frame <- base::sys.nframe()
[15:32:25.010]     ...future.conditions <- base::list()
[15:32:25.010]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:25.010]     if (FALSE) {
[15:32:25.010]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:25.010]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:25.010]     }
[15:32:25.010]     ...future.result <- base::tryCatch({
[15:32:25.010]         base::withCallingHandlers({
[15:32:25.010]             ...future.value <- base::withVisible(base::local({
[15:32:25.010]                 do.call(function(...) {
[15:32:25.010]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:25.010]                   if (!identical(...future.globals.maxSize.org, 
[15:32:25.010]                     ...future.globals.maxSize)) {
[15:32:25.010]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:25.010]                     on.exit(options(oopts), add = TRUE)
[15:32:25.010]                   }
[15:32:25.010]                   {
[15:32:25.010]                     lapply(seq_along(...future.elements_ii), 
[15:32:25.010]                       FUN = function(jj) {
[15:32:25.010]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:25.010]                         ...future.FUN(...future.X_jj, ...)
[15:32:25.010]                       })
[15:32:25.010]                   }
[15:32:25.010]                 }, args = future.call.arguments)
[15:32:25.010]             }))
[15:32:25.010]             future::FutureResult(value = ...future.value$value, 
[15:32:25.010]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:25.010]                   ...future.rng), globalenv = if (FALSE) 
[15:32:25.010]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:25.010]                     ...future.globalenv.names))
[15:32:25.010]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:25.010]         }, condition = base::local({
[15:32:25.010]             c <- base::c
[15:32:25.010]             inherits <- base::inherits
[15:32:25.010]             invokeRestart <- base::invokeRestart
[15:32:25.010]             length <- base::length
[15:32:25.010]             list <- base::list
[15:32:25.010]             seq.int <- base::seq.int
[15:32:25.010]             signalCondition <- base::signalCondition
[15:32:25.010]             sys.calls <- base::sys.calls
[15:32:25.010]             `[[` <- base::`[[`
[15:32:25.010]             `+` <- base::`+`
[15:32:25.010]             `<<-` <- base::`<<-`
[15:32:25.010]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:25.010]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:25.010]                   3L)]
[15:32:25.010]             }
[15:32:25.010]             function(cond) {
[15:32:25.010]                 is_error <- inherits(cond, "error")
[15:32:25.010]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:25.010]                   NULL)
[15:32:25.010]                 if (is_error) {
[15:32:25.010]                   sessionInformation <- function() {
[15:32:25.010]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:25.010]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:25.010]                       search = base::search(), system = base::Sys.info())
[15:32:25.010]                   }
[15:32:25.010]                   ...future.conditions[[length(...future.conditions) + 
[15:32:25.010]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:25.010]                     cond$call), session = sessionInformation(), 
[15:32:25.010]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:25.010]                   signalCondition(cond)
[15:32:25.010]                 }
[15:32:25.010]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:25.010]                 "immediateCondition"))) {
[15:32:25.010]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:25.010]                   ...future.conditions[[length(...future.conditions) + 
[15:32:25.010]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:25.010]                   if (TRUE && !signal) {
[15:32:25.010]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:25.010]                     {
[15:32:25.010]                       inherits <- base::inherits
[15:32:25.010]                       invokeRestart <- base::invokeRestart
[15:32:25.010]                       is.null <- base::is.null
[15:32:25.010]                       muffled <- FALSE
[15:32:25.010]                       if (inherits(cond, "message")) {
[15:32:25.010]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:25.010]                         if (muffled) 
[15:32:25.010]                           invokeRestart("muffleMessage")
[15:32:25.010]                       }
[15:32:25.010]                       else if (inherits(cond, "warning")) {
[15:32:25.010]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:25.010]                         if (muffled) 
[15:32:25.010]                           invokeRestart("muffleWarning")
[15:32:25.010]                       }
[15:32:25.010]                       else if (inherits(cond, "condition")) {
[15:32:25.010]                         if (!is.null(pattern)) {
[15:32:25.010]                           computeRestarts <- base::computeRestarts
[15:32:25.010]                           grepl <- base::grepl
[15:32:25.010]                           restarts <- computeRestarts(cond)
[15:32:25.010]                           for (restart in restarts) {
[15:32:25.010]                             name <- restart$name
[15:32:25.010]                             if (is.null(name)) 
[15:32:25.010]                               next
[15:32:25.010]                             if (!grepl(pattern, name)) 
[15:32:25.010]                               next
[15:32:25.010]                             invokeRestart(restart)
[15:32:25.010]                             muffled <- TRUE
[15:32:25.010]                             break
[15:32:25.010]                           }
[15:32:25.010]                         }
[15:32:25.010]                       }
[15:32:25.010]                       invisible(muffled)
[15:32:25.010]                     }
[15:32:25.010]                     muffleCondition(cond, pattern = "^muffle")
[15:32:25.010]                   }
[15:32:25.010]                 }
[15:32:25.010]                 else {
[15:32:25.010]                   if (TRUE) {
[15:32:25.010]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:25.010]                     {
[15:32:25.010]                       inherits <- base::inherits
[15:32:25.010]                       invokeRestart <- base::invokeRestart
[15:32:25.010]                       is.null <- base::is.null
[15:32:25.010]                       muffled <- FALSE
[15:32:25.010]                       if (inherits(cond, "message")) {
[15:32:25.010]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:25.010]                         if (muffled) 
[15:32:25.010]                           invokeRestart("muffleMessage")
[15:32:25.010]                       }
[15:32:25.010]                       else if (inherits(cond, "warning")) {
[15:32:25.010]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:25.010]                         if (muffled) 
[15:32:25.010]                           invokeRestart("muffleWarning")
[15:32:25.010]                       }
[15:32:25.010]                       else if (inherits(cond, "condition")) {
[15:32:25.010]                         if (!is.null(pattern)) {
[15:32:25.010]                           computeRestarts <- base::computeRestarts
[15:32:25.010]                           grepl <- base::grepl
[15:32:25.010]                           restarts <- computeRestarts(cond)
[15:32:25.010]                           for (restart in restarts) {
[15:32:25.010]                             name <- restart$name
[15:32:25.010]                             if (is.null(name)) 
[15:32:25.010]                               next
[15:32:25.010]                             if (!grepl(pattern, name)) 
[15:32:25.010]                               next
[15:32:25.010]                             invokeRestart(restart)
[15:32:25.010]                             muffled <- TRUE
[15:32:25.010]                             break
[15:32:25.010]                           }
[15:32:25.010]                         }
[15:32:25.010]                       }
[15:32:25.010]                       invisible(muffled)
[15:32:25.010]                     }
[15:32:25.010]                     muffleCondition(cond, pattern = "^muffle")
[15:32:25.010]                   }
[15:32:25.010]                 }
[15:32:25.010]             }
[15:32:25.010]         }))
[15:32:25.010]     }, error = function(ex) {
[15:32:25.010]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:25.010]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:25.010]                 ...future.rng), started = ...future.startTime, 
[15:32:25.010]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:25.010]             version = "1.8"), class = "FutureResult")
[15:32:25.010]     }, finally = {
[15:32:25.010]         if (!identical(...future.workdir, getwd())) 
[15:32:25.010]             setwd(...future.workdir)
[15:32:25.010]         {
[15:32:25.010]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:25.010]                 ...future.oldOptions$nwarnings <- NULL
[15:32:25.010]             }
[15:32:25.010]             base::options(...future.oldOptions)
[15:32:25.010]             if (.Platform$OS.type == "windows") {
[15:32:25.010]                 old_names <- names(...future.oldEnvVars)
[15:32:25.010]                 envs <- base::Sys.getenv()
[15:32:25.010]                 names <- names(envs)
[15:32:25.010]                 common <- intersect(names, old_names)
[15:32:25.010]                 added <- setdiff(names, old_names)
[15:32:25.010]                 removed <- setdiff(old_names, names)
[15:32:25.010]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:25.010]                   envs[common]]
[15:32:25.010]                 NAMES <- toupper(changed)
[15:32:25.010]                 args <- list()
[15:32:25.010]                 for (kk in seq_along(NAMES)) {
[15:32:25.010]                   name <- changed[[kk]]
[15:32:25.010]                   NAME <- NAMES[[kk]]
[15:32:25.010]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:25.010]                     next
[15:32:25.010]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:25.010]                 }
[15:32:25.010]                 NAMES <- toupper(added)
[15:32:25.010]                 for (kk in seq_along(NAMES)) {
[15:32:25.010]                   name <- added[[kk]]
[15:32:25.010]                   NAME <- NAMES[[kk]]
[15:32:25.010]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:25.010]                     next
[15:32:25.010]                   args[[name]] <- ""
[15:32:25.010]                 }
[15:32:25.010]                 NAMES <- toupper(removed)
[15:32:25.010]                 for (kk in seq_along(NAMES)) {
[15:32:25.010]                   name <- removed[[kk]]
[15:32:25.010]                   NAME <- NAMES[[kk]]
[15:32:25.010]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:25.010]                     next
[15:32:25.010]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:25.010]                 }
[15:32:25.010]                 if (length(args) > 0) 
[15:32:25.010]                   base::do.call(base::Sys.setenv, args = args)
[15:32:25.010]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:25.010]             }
[15:32:25.010]             else {
[15:32:25.010]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:25.010]             }
[15:32:25.010]             {
[15:32:25.010]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:25.010]                   0L) {
[15:32:25.010]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:25.010]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:25.010]                   base::options(opts)
[15:32:25.010]                 }
[15:32:25.010]                 {
[15:32:25.010]                   {
[15:32:25.010]                     NULL
[15:32:25.010]                     RNGkind("Mersenne-Twister")
[15:32:25.010]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:25.010]                       inherits = FALSE)
[15:32:25.010]                   }
[15:32:25.010]                   options(future.plan = NULL)
[15:32:25.010]                   if (is.na(NA_character_)) 
[15:32:25.010]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:25.010]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:25.010]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:25.010]                     .init = FALSE)
[15:32:25.010]                 }
[15:32:25.010]             }
[15:32:25.010]         }
[15:32:25.010]     })
[15:32:25.010]     if (TRUE) {
[15:32:25.010]         base::sink(type = "output", split = FALSE)
[15:32:25.010]         if (TRUE) {
[15:32:25.010]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:25.010]         }
[15:32:25.010]         else {
[15:32:25.010]             ...future.result["stdout"] <- base::list(NULL)
[15:32:25.010]         }
[15:32:25.010]         base::close(...future.stdout)
[15:32:25.010]         ...future.stdout <- NULL
[15:32:25.010]     }
[15:32:25.010]     ...future.result$conditions <- ...future.conditions
[15:32:25.010]     ...future.result$finished <- base::Sys.time()
[15:32:25.010]     ...future.result
[15:32:25.010] }
[15:32:25.017] assign_globals() ...
[15:32:25.017] List of 5
[15:32:25.017]  $ ...future.FUN            :function (x, y = 2 * 1:5)  
[15:32:25.017]  $ future.call.arguments    : list()
[15:32:25.017]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:25.017]  $ ...future.elements_ii    :List of 4
[15:32:25.017]   ..$ A: num 50
[15:32:25.017]   ..$ B: num 60
[15:32:25.017]   ..$ C: num 70
[15:32:25.017]   ..$ D: num 80
[15:32:25.017]  $ ...future.seeds_ii       : NULL
[15:32:25.017]  $ ...future.globals.maxSize: NULL
[15:32:25.017]  - attr(*, "where")=List of 5
[15:32:25.017]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:25.017]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:25.017]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:25.017]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:25.017]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:25.017]  - attr(*, "resolved")= logi FALSE
[15:32:25.017]  - attr(*, "total_size")= num 4728
[15:32:25.017]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:25.017]  - attr(*, "already-done")= logi TRUE
[15:32:25.027] - reassign environment for '...future.FUN'
[15:32:25.027] - copied '...future.FUN' to environment
[15:32:25.028] - copied 'future.call.arguments' to environment
[15:32:25.028] - copied '...future.elements_ii' to environment
[15:32:25.028] - copied '...future.seeds_ii' to environment
[15:32:25.028] - copied '...future.globals.maxSize' to environment
[15:32:25.029] assign_globals() ... done
[15:32:25.029] plan(): Setting new future strategy stack:
[15:32:25.030] List of future strategies:
[15:32:25.030] 1. sequential:
[15:32:25.030]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:25.030]    - tweaked: FALSE
[15:32:25.030]    - call: NULL
[15:32:25.030] plan(): nbrOfWorkers() = 1
[15:32:25.036] plan(): Setting new future strategy stack:
[15:32:25.036] List of future strategies:
[15:32:25.036] 1. sequential:
[15:32:25.036]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:25.036]    - tweaked: FALSE
[15:32:25.036]    - call: plan(strategy)
[15:32:25.037] plan(): nbrOfWorkers() = 1
[15:32:25.038] SequentialFuture started (and completed)
[15:32:25.038] - Launch lazy future ... done
[15:32:25.038] run() for 'SequentialFuture' ... done
[15:32:25.038] Created future:
[15:32:25.039] SequentialFuture:
[15:32:25.039] Label: 'future_sapply-1'
[15:32:25.039] Expression:
[15:32:25.039] {
[15:32:25.039]     do.call(function(...) {
[15:32:25.039]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:25.039]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:25.039]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:25.039]             on.exit(options(oopts), add = TRUE)
[15:32:25.039]         }
[15:32:25.039]         {
[15:32:25.039]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:25.039]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:25.039]                 ...future.FUN(...future.X_jj, ...)
[15:32:25.039]             })
[15:32:25.039]         }
[15:32:25.039]     }, args = future.call.arguments)
[15:32:25.039] }
[15:32:25.039] Lazy evaluation: FALSE
[15:32:25.039] Asynchronous evaluation: FALSE
[15:32:25.039] Local evaluation: TRUE
[15:32:25.039] Environment: R_GlobalEnv
[15:32:25.039] Capture standard output: TRUE
[15:32:25.039] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:25.039] Globals: 5 objects totaling 4.84 KiB (function '...future.FUN' of 4.62 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 224 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:25.039] Packages: <none>
[15:32:25.039] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:25.039] Resolved: TRUE
[15:32:25.039] Value: 1.34 KiB of class 'list'
[15:32:25.039] Early signaling: FALSE
[15:32:25.039] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:25.039] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:25.041] Chunk #1 of 1 ... DONE
[15:32:25.041] Launching 1 futures (chunks) ... DONE
[15:32:25.041] Resolving 1 futures (chunks) ...
[15:32:25.041] resolve() on list ...
[15:32:25.042]  recursive: 0
[15:32:25.042]  length: 1
[15:32:25.042] 
[15:32:25.042] resolved() for 'SequentialFuture' ...
[15:32:25.043] - state: 'finished'
[15:32:25.043] - run: TRUE
[15:32:25.043] - result: 'FutureResult'
[15:32:25.043] resolved() for 'SequentialFuture' ... done
[15:32:25.044] Future #1
[15:32:25.044] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:25.044] - nx: 1
[15:32:25.045] - relay: TRUE
[15:32:25.045] - stdout: TRUE
[15:32:25.045] - signal: TRUE
[15:32:25.045] - resignal: FALSE
[15:32:25.045] - force: TRUE
[15:32:25.046] - relayed: [n=1] FALSE
[15:32:25.046] - queued futures: [n=1] FALSE
[15:32:25.046]  - until=1
[15:32:25.046]  - relaying element #1
[15:32:25.047] - relayed: [n=1] TRUE
[15:32:25.047] - queued futures: [n=1] TRUE
[15:32:25.047] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:25.048]  length: 0 (resolved future 1)
[15:32:25.048] Relaying remaining futures
[15:32:25.048] signalConditionsASAP(NULL, pos=0) ...
[15:32:25.048] - nx: 1
[15:32:25.048] - relay: TRUE
[15:32:25.049] - stdout: TRUE
[15:32:25.049] - signal: TRUE
[15:32:25.049] - resignal: FALSE
[15:32:25.049] - force: TRUE
[15:32:25.050] - relayed: [n=1] TRUE
[15:32:25.050] - queued futures: [n=1] TRUE
 - flush all
[15:32:25.050] - relayed: [n=1] TRUE
[15:32:25.050] - queued futures: [n=1] TRUE
[15:32:25.051] signalConditionsASAP(NULL, pos=0) ... done
[15:32:25.051] resolve() on list ... DONE
[15:32:25.051]  - Number of value chunks collected: 1
[15:32:25.051] Resolving 1 futures (chunks) ... DONE
[15:32:25.052] Reducing values from 1 chunks ...
[15:32:25.052]  - Number of values collected after concatenation: 4
[15:32:25.052]  - Number of values expected: 4
[15:32:25.052] Reducing values from 1 chunks ... DONE
[15:32:25.053] future_lapply() ... DONE
List of 2
 $ y0:List of 4
  ..$ A: num [1:3, 1:5] 100 100 100 200 200 200 300 300 300 400 ...
  ..$ B: num [1:3, 1:5] 120 120 120 240 240 240 360 360 360 480 ...
  ..$ C: num [1:3, 1:5] 140 140 140 280 280 280 420 420 420 560 ...
  ..$ D: num [1:3, 1:5] 160 160 160 320 320 320 480 480 480 640 ...
 $ y1:List of 4
  ..$ A: num [1:3, 1:5] 100 100 100 200 200 200 300 300 300 400 ...
  ..$ B: num [1:3, 1:5] 120 120 120 240 240 240 360 360 360 480 ...
  ..$ C: num [1:3, 1:5] 140 140 140 280 280 280 420 420 420 560 ...
  ..$ D: num [1:3, 1:5] 160 160 160 320 320 320 480 480 480 640 ...
List of 2
 $ y0:List of 4
  ..$ A: num [1:3, 1:5] 100 100 100 200 200 200 300 300 300 400 ...
  ..$ B: num [1:3, 1:5] 120 120 120 240 240 240 360 360 360 480 ...
  ..$ C: num [1:3, 1:5] 140 140 140 280 280 280 420 420 420 560 ...
  ..$ D: num [1:3, 1:5] 160 160 160 320 320 320 480 480 480 640 ...
 $ y2:List of 4
  ..$ A: num [1:3, 1:5] 100 100 100 200 200 200 300 300 300 400 ...
  ..$ B: num [1:3, 1:5] 120 120 120 240 240 240 360 360 360 480 ...
  ..$ C: num [1:3, 1:5] 140 140 140 280 280 280 420 420 420 560 ...
  ..$ D: num [1:3, 1:5] 160 160 160 320 320 320 480 480 480 640 ...
[15:32:25.066] future_lapply() ...
[15:32:25.067] Number of chunks: 1
[15:32:25.067] getGlobalsAndPackagesXApply() ...
[15:32:25.068]  - future.globals: TRUE
[15:32:25.068] getGlobalsAndPackages() ...
[15:32:25.068] Searching for globals...
[15:32:25.070] - globals found: [1] 'FUN'
[15:32:25.070] Searching for globals ... DONE
[15:32:25.070] Resolving globals: FALSE
[15:32:25.071] The total size of the 1 globals is 848 bytes (848 bytes)
[15:32:25.071] The total size of the 1 globals exported for future expression ('FUN()') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:32:25.072] - globals: [1] 'FUN'
[15:32:25.072] 
[15:32:25.072] getGlobalsAndPackages() ... DONE
[15:32:25.072]  - globals found/used: [n=1] 'FUN'
[15:32:25.073]  - needed namespaces: [n=0] 
[15:32:25.073] Finding globals ... DONE
[15:32:25.073]  - use_args: TRUE
[15:32:25.073]  - Getting '...' globals ...
[15:32:25.074] resolve() on list ...
[15:32:25.074]  recursive: 0
[15:32:25.074]  length: 1
[15:32:25.075]  elements: '...'
[15:32:25.075]  length: 0 (resolved future 1)
[15:32:25.075] resolve() on list ... DONE
[15:32:25.075]    - '...' content: [n=0] 
[15:32:25.076] List of 1
[15:32:25.076]  $ ...: list()
[15:32:25.076]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:25.076]  - attr(*, "where")=List of 1
[15:32:25.076]   ..$ ...:<environment: 0x00000276e1b5cdb8> 
[15:32:25.076]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:25.076]  - attr(*, "resolved")= logi TRUE
[15:32:25.076]  - attr(*, "total_size")= num NA
[15:32:25.080]  - Getting '...' globals ... DONE
[15:32:25.080] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:25.081] List of 2
[15:32:25.081]  $ ...future.FUN:function (x)  
[15:32:25.081]  $ ...          : list()
[15:32:25.081]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:25.081]  - attr(*, "where")=List of 2
[15:32:25.081]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:25.081]   ..$ ...          :<environment: 0x00000276e1b5cdb8> 
[15:32:25.081]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:25.081]  - attr(*, "resolved")= logi FALSE
[15:32:25.081]  - attr(*, "total_size")= num 848
[15:32:25.085] Packages to be attached in all futures: [n=0] 
[15:32:25.085] getGlobalsAndPackagesXApply() ... DONE
[15:32:25.086] Number of futures (= number of chunks): 1
[15:32:25.086] Launching 1 futures (chunks) ...
[15:32:25.086] Chunk #1 of 1 ...
[15:32:25.087]  - Finding globals in 'X' for chunk #1 ...
[15:32:25.087] getGlobalsAndPackages() ...
[15:32:25.087] Searching for globals...
[15:32:25.088] 
[15:32:25.088] Searching for globals ... DONE
[15:32:25.088] - globals: [0] <none>
[15:32:25.088] getGlobalsAndPackages() ... DONE
[15:32:25.088]    + additional globals found: [n=0] 
[15:32:25.089]    + additional namespaces needed: [n=0] 
[15:32:25.089]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:25.089]  - seeds: <none>
[15:32:25.089]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:25.090] getGlobalsAndPackages() ...
[15:32:25.090] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:25.090] Resolving globals: FALSE
[15:32:25.090] Tweak future expression to call with '...' arguments ...
[15:32:25.091] {
[15:32:25.091]     do.call(function(...) {
[15:32:25.091]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:25.091]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:25.091]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:25.091]             on.exit(options(oopts), add = TRUE)
[15:32:25.091]         }
[15:32:25.091]         {
[15:32:25.091]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:25.091]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:25.091]                 ...future.FUN(...future.X_jj, ...)
[15:32:25.091]             })
[15:32:25.091]         }
[15:32:25.091]     }, args = future.call.arguments)
[15:32:25.091] }
[15:32:25.091] Tweak future expression to call with '...' arguments ... DONE
[15:32:25.092] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:25.092] 
[15:32:25.093] getGlobalsAndPackages() ... DONE
[15:32:25.093] run() for 'Future' ...
[15:32:25.093] - state: 'created'
[15:32:25.094] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:25.094] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:25.095] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:25.095]   - Field: 'label'
[15:32:25.095]   - Field: 'local'
[15:32:25.095]   - Field: 'owner'
[15:32:25.096]   - Field: 'envir'
[15:32:25.096]   - Field: 'packages'
[15:32:25.096]   - Field: 'gc'
[15:32:25.096]   - Field: 'conditions'
[15:32:25.097]   - Field: 'expr'
[15:32:25.097]   - Field: 'uuid'
[15:32:25.097]   - Field: 'seed'
[15:32:25.098]   - Field: 'version'
[15:32:25.098]   - Field: 'result'
[15:32:25.098]   - Field: 'asynchronous'
[15:32:25.098]   - Field: 'calls'
[15:32:25.099]   - Field: 'globals'
[15:32:25.099]   - Field: 'stdout'
[15:32:25.099]   - Field: 'earlySignal'
[15:32:25.099]   - Field: 'lazy'
[15:32:25.100]   - Field: 'state'
[15:32:25.100] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:25.100] - Launch lazy future ...
[15:32:25.101] Packages needed by the future expression (n = 0): <none>
[15:32:25.101] Packages needed by future strategies (n = 0): <none>
[15:32:25.102] {
[15:32:25.102]     {
[15:32:25.102]         {
[15:32:25.102]             ...future.startTime <- base::Sys.time()
[15:32:25.102]             {
[15:32:25.102]                 {
[15:32:25.102]                   {
[15:32:25.102]                     base::local({
[15:32:25.102]                       has_future <- base::requireNamespace("future", 
[15:32:25.102]                         quietly = TRUE)
[15:32:25.102]                       if (has_future) {
[15:32:25.102]                         ns <- base::getNamespace("future")
[15:32:25.102]                         version <- ns[[".package"]][["version"]]
[15:32:25.102]                         if (is.null(version)) 
[15:32:25.102]                           version <- utils::packageVersion("future")
[15:32:25.102]                       }
[15:32:25.102]                       else {
[15:32:25.102]                         version <- NULL
[15:32:25.102]                       }
[15:32:25.102]                       if (!has_future || version < "1.8.0") {
[15:32:25.102]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:25.102]                           "", base::R.version$version.string), 
[15:32:25.102]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:25.102]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:25.102]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:25.102]                             "release", "version")], collapse = " "), 
[15:32:25.102]                           hostname = base::Sys.info()[["nodename"]])
[15:32:25.102]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:25.102]                           info)
[15:32:25.102]                         info <- base::paste(info, collapse = "; ")
[15:32:25.102]                         if (!has_future) {
[15:32:25.102]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:25.102]                             info)
[15:32:25.102]                         }
[15:32:25.102]                         else {
[15:32:25.102]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:25.102]                             info, version)
[15:32:25.102]                         }
[15:32:25.102]                         base::stop(msg)
[15:32:25.102]                       }
[15:32:25.102]                     })
[15:32:25.102]                   }
[15:32:25.102]                   ...future.strategy.old <- future::plan("list")
[15:32:25.102]                   options(future.plan = NULL)
[15:32:25.102]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:25.102]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:25.102]                 }
[15:32:25.102]                 ...future.workdir <- getwd()
[15:32:25.102]             }
[15:32:25.102]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:25.102]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:25.102]         }
[15:32:25.102]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:25.102]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:25.102]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:25.102]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:25.102]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:25.102]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:25.102]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:25.102]             base::names(...future.oldOptions))
[15:32:25.102]     }
[15:32:25.102]     if (FALSE) {
[15:32:25.102]     }
[15:32:25.102]     else {
[15:32:25.102]         if (TRUE) {
[15:32:25.102]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:25.102]                 open = "w")
[15:32:25.102]         }
[15:32:25.102]         else {
[15:32:25.102]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:25.102]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:25.102]         }
[15:32:25.102]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:25.102]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:25.102]             base::sink(type = "output", split = FALSE)
[15:32:25.102]             base::close(...future.stdout)
[15:32:25.102]         }, add = TRUE)
[15:32:25.102]     }
[15:32:25.102]     ...future.frame <- base::sys.nframe()
[15:32:25.102]     ...future.conditions <- base::list()
[15:32:25.102]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:25.102]     if (FALSE) {
[15:32:25.102]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:25.102]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:25.102]     }
[15:32:25.102]     ...future.result <- base::tryCatch({
[15:32:25.102]         base::withCallingHandlers({
[15:32:25.102]             ...future.value <- base::withVisible(base::local({
[15:32:25.102]                 do.call(function(...) {
[15:32:25.102]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:25.102]                   if (!identical(...future.globals.maxSize.org, 
[15:32:25.102]                     ...future.globals.maxSize)) {
[15:32:25.102]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:25.102]                     on.exit(options(oopts), add = TRUE)
[15:32:25.102]                   }
[15:32:25.102]                   {
[15:32:25.102]                     lapply(seq_along(...future.elements_ii), 
[15:32:25.102]                       FUN = function(jj) {
[15:32:25.102]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:25.102]                         ...future.FUN(...future.X_jj, ...)
[15:32:25.102]                       })
[15:32:25.102]                   }
[15:32:25.102]                 }, args = future.call.arguments)
[15:32:25.102]             }))
[15:32:25.102]             future::FutureResult(value = ...future.value$value, 
[15:32:25.102]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:25.102]                   ...future.rng), globalenv = if (FALSE) 
[15:32:25.102]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:25.102]                     ...future.globalenv.names))
[15:32:25.102]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:25.102]         }, condition = base::local({
[15:32:25.102]             c <- base::c
[15:32:25.102]             inherits <- base::inherits
[15:32:25.102]             invokeRestart <- base::invokeRestart
[15:32:25.102]             length <- base::length
[15:32:25.102]             list <- base::list
[15:32:25.102]             seq.int <- base::seq.int
[15:32:25.102]             signalCondition <- base::signalCondition
[15:32:25.102]             sys.calls <- base::sys.calls
[15:32:25.102]             `[[` <- base::`[[`
[15:32:25.102]             `+` <- base::`+`
[15:32:25.102]             `<<-` <- base::`<<-`
[15:32:25.102]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:25.102]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:25.102]                   3L)]
[15:32:25.102]             }
[15:32:25.102]             function(cond) {
[15:32:25.102]                 is_error <- inherits(cond, "error")
[15:32:25.102]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:25.102]                   NULL)
[15:32:25.102]                 if (is_error) {
[15:32:25.102]                   sessionInformation <- function() {
[15:32:25.102]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:25.102]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:25.102]                       search = base::search(), system = base::Sys.info())
[15:32:25.102]                   }
[15:32:25.102]                   ...future.conditions[[length(...future.conditions) + 
[15:32:25.102]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:25.102]                     cond$call), session = sessionInformation(), 
[15:32:25.102]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:25.102]                   signalCondition(cond)
[15:32:25.102]                 }
[15:32:25.102]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:25.102]                 "immediateCondition"))) {
[15:32:25.102]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:25.102]                   ...future.conditions[[length(...future.conditions) + 
[15:32:25.102]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:25.102]                   if (TRUE && !signal) {
[15:32:25.102]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:25.102]                     {
[15:32:25.102]                       inherits <- base::inherits
[15:32:25.102]                       invokeRestart <- base::invokeRestart
[15:32:25.102]                       is.null <- base::is.null
[15:32:25.102]                       muffled <- FALSE
[15:32:25.102]                       if (inherits(cond, "message")) {
[15:32:25.102]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:25.102]                         if (muffled) 
[15:32:25.102]                           invokeRestart("muffleMessage")
[15:32:25.102]                       }
[15:32:25.102]                       else if (inherits(cond, "warning")) {
[15:32:25.102]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:25.102]                         if (muffled) 
[15:32:25.102]                           invokeRestart("muffleWarning")
[15:32:25.102]                       }
[15:32:25.102]                       else if (inherits(cond, "condition")) {
[15:32:25.102]                         if (!is.null(pattern)) {
[15:32:25.102]                           computeRestarts <- base::computeRestarts
[15:32:25.102]                           grepl <- base::grepl
[15:32:25.102]                           restarts <- computeRestarts(cond)
[15:32:25.102]                           for (restart in restarts) {
[15:32:25.102]                             name <- restart$name
[15:32:25.102]                             if (is.null(name)) 
[15:32:25.102]                               next
[15:32:25.102]                             if (!grepl(pattern, name)) 
[15:32:25.102]                               next
[15:32:25.102]                             invokeRestart(restart)
[15:32:25.102]                             muffled <- TRUE
[15:32:25.102]                             break
[15:32:25.102]                           }
[15:32:25.102]                         }
[15:32:25.102]                       }
[15:32:25.102]                       invisible(muffled)
[15:32:25.102]                     }
[15:32:25.102]                     muffleCondition(cond, pattern = "^muffle")
[15:32:25.102]                   }
[15:32:25.102]                 }
[15:32:25.102]                 else {
[15:32:25.102]                   if (TRUE) {
[15:32:25.102]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:25.102]                     {
[15:32:25.102]                       inherits <- base::inherits
[15:32:25.102]                       invokeRestart <- base::invokeRestart
[15:32:25.102]                       is.null <- base::is.null
[15:32:25.102]                       muffled <- FALSE
[15:32:25.102]                       if (inherits(cond, "message")) {
[15:32:25.102]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:25.102]                         if (muffled) 
[15:32:25.102]                           invokeRestart("muffleMessage")
[15:32:25.102]                       }
[15:32:25.102]                       else if (inherits(cond, "warning")) {
[15:32:25.102]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:25.102]                         if (muffled) 
[15:32:25.102]                           invokeRestart("muffleWarning")
[15:32:25.102]                       }
[15:32:25.102]                       else if (inherits(cond, "condition")) {
[15:32:25.102]                         if (!is.null(pattern)) {
[15:32:25.102]                           computeRestarts <- base::computeRestarts
[15:32:25.102]                           grepl <- base::grepl
[15:32:25.102]                           restarts <- computeRestarts(cond)
[15:32:25.102]                           for (restart in restarts) {
[15:32:25.102]                             name <- restart$name
[15:32:25.102]                             if (is.null(name)) 
[15:32:25.102]                               next
[15:32:25.102]                             if (!grepl(pattern, name)) 
[15:32:25.102]                               next
[15:32:25.102]                             invokeRestart(restart)
[15:32:25.102]                             muffled <- TRUE
[15:32:25.102]                             break
[15:32:25.102]                           }
[15:32:25.102]                         }
[15:32:25.102]                       }
[15:32:25.102]                       invisible(muffled)
[15:32:25.102]                     }
[15:32:25.102]                     muffleCondition(cond, pattern = "^muffle")
[15:32:25.102]                   }
[15:32:25.102]                 }
[15:32:25.102]             }
[15:32:25.102]         }))
[15:32:25.102]     }, error = function(ex) {
[15:32:25.102]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:25.102]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:25.102]                 ...future.rng), started = ...future.startTime, 
[15:32:25.102]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:25.102]             version = "1.8"), class = "FutureResult")
[15:32:25.102]     }, finally = {
[15:32:25.102]         if (!identical(...future.workdir, getwd())) 
[15:32:25.102]             setwd(...future.workdir)
[15:32:25.102]         {
[15:32:25.102]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:25.102]                 ...future.oldOptions$nwarnings <- NULL
[15:32:25.102]             }
[15:32:25.102]             base::options(...future.oldOptions)
[15:32:25.102]             if (.Platform$OS.type == "windows") {
[15:32:25.102]                 old_names <- names(...future.oldEnvVars)
[15:32:25.102]                 envs <- base::Sys.getenv()
[15:32:25.102]                 names <- names(envs)
[15:32:25.102]                 common <- intersect(names, old_names)
[15:32:25.102]                 added <- setdiff(names, old_names)
[15:32:25.102]                 removed <- setdiff(old_names, names)
[15:32:25.102]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:25.102]                   envs[common]]
[15:32:25.102]                 NAMES <- toupper(changed)
[15:32:25.102]                 args <- list()
[15:32:25.102]                 for (kk in seq_along(NAMES)) {
[15:32:25.102]                   name <- changed[[kk]]
[15:32:25.102]                   NAME <- NAMES[[kk]]
[15:32:25.102]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:25.102]                     next
[15:32:25.102]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:25.102]                 }
[15:32:25.102]                 NAMES <- toupper(added)
[15:32:25.102]                 for (kk in seq_along(NAMES)) {
[15:32:25.102]                   name <- added[[kk]]
[15:32:25.102]                   NAME <- NAMES[[kk]]
[15:32:25.102]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:25.102]                     next
[15:32:25.102]                   args[[name]] <- ""
[15:32:25.102]                 }
[15:32:25.102]                 NAMES <- toupper(removed)
[15:32:25.102]                 for (kk in seq_along(NAMES)) {
[15:32:25.102]                   name <- removed[[kk]]
[15:32:25.102]                   NAME <- NAMES[[kk]]
[15:32:25.102]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:25.102]                     next
[15:32:25.102]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:25.102]                 }
[15:32:25.102]                 if (length(args) > 0) 
[15:32:25.102]                   base::do.call(base::Sys.setenv, args = args)
[15:32:25.102]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:25.102]             }
[15:32:25.102]             else {
[15:32:25.102]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:25.102]             }
[15:32:25.102]             {
[15:32:25.102]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:25.102]                   0L) {
[15:32:25.102]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:25.102]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:25.102]                   base::options(opts)
[15:32:25.102]                 }
[15:32:25.102]                 {
[15:32:25.102]                   {
[15:32:25.102]                     NULL
[15:32:25.102]                     RNGkind("Mersenne-Twister")
[15:32:25.102]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:25.102]                       inherits = FALSE)
[15:32:25.102]                   }
[15:32:25.102]                   options(future.plan = NULL)
[15:32:25.102]                   if (is.na(NA_character_)) 
[15:32:25.102]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:25.102]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:25.102]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:25.102]                     .init = FALSE)
[15:32:25.102]                 }
[15:32:25.102]             }
[15:32:25.102]         }
[15:32:25.102]     })
[15:32:25.102]     if (TRUE) {
[15:32:25.102]         base::sink(type = "output", split = FALSE)
[15:32:25.102]         if (TRUE) {
[15:32:25.102]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:25.102]         }
[15:32:25.102]         else {
[15:32:25.102]             ...future.result["stdout"] <- base::list(NULL)
[15:32:25.102]         }
[15:32:25.102]         base::close(...future.stdout)
[15:32:25.102]         ...future.stdout <- NULL
[15:32:25.102]     }
[15:32:25.102]     ...future.result$conditions <- ...future.conditions
[15:32:25.102]     ...future.result$finished <- base::Sys.time()
[15:32:25.102]     ...future.result
[15:32:25.102] }
[15:32:25.108] assign_globals() ...
[15:32:25.108] List of 5
[15:32:25.108]  $ ...future.FUN            :function (x)  
[15:32:25.108]  $ future.call.arguments    : list()
[15:32:25.108]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:25.108]  $ ...future.elements_ii    :List of 4
[15:32:25.108]   ..$ A: num 50
[15:32:25.108]   ..$ B: num 60
[15:32:25.108]   ..$ C: num 70
[15:32:25.108]   ..$ D: num 80
[15:32:25.108]  $ ...future.seeds_ii       : NULL
[15:32:25.108]  $ ...future.globals.maxSize: NULL
[15:32:25.108]  - attr(*, "where")=List of 5
[15:32:25.108]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:25.108]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:25.108]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:25.108]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:25.108]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:25.108]  - attr(*, "resolved")= logi FALSE
[15:32:25.108]  - attr(*, "total_size")= num 848
[15:32:25.108]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:25.108]  - attr(*, "already-done")= logi TRUE
[15:32:25.119] - copied '...future.FUN' to environment
[15:32:25.119] - copied 'future.call.arguments' to environment
[15:32:25.119] - copied '...future.elements_ii' to environment
[15:32:25.120] - copied '...future.seeds_ii' to environment
[15:32:25.120] - copied '...future.globals.maxSize' to environment
[15:32:25.120] assign_globals() ... done
[15:32:25.121] plan(): Setting new future strategy stack:
[15:32:25.121] List of future strategies:
[15:32:25.121] 1. sequential:
[15:32:25.121]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:25.121]    - tweaked: FALSE
[15:32:25.121]    - call: NULL
[15:32:25.122] plan(): nbrOfWorkers() = 1
[15:32:25.125] plan(): Setting new future strategy stack:
[15:32:25.125] List of future strategies:
[15:32:25.125] 1. sequential:
[15:32:25.125]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:25.125]    - tweaked: FALSE
[15:32:25.125]    - call: plan(strategy)
[15:32:25.126] plan(): nbrOfWorkers() = 1
[15:32:25.126] SequentialFuture started (and completed)
[15:32:25.127] - Launch lazy future ... done
[15:32:25.127] run() for 'SequentialFuture' ... done
[15:32:25.127] Created future:
[15:32:25.128] SequentialFuture:
[15:32:25.128] Label: 'future_sapply-1'
[15:32:25.128] Expression:
[15:32:25.128] {
[15:32:25.128]     do.call(function(...) {
[15:32:25.128]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:25.128]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:25.128]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:25.128]             on.exit(options(oopts), add = TRUE)
[15:32:25.128]         }
[15:32:25.128]         {
[15:32:25.128]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:25.128]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:25.128]                 ...future.FUN(...future.X_jj, ...)
[15:32:25.128]             })
[15:32:25.128]         }
[15:32:25.128]     }, args = future.call.arguments)
[15:32:25.128] }
[15:32:25.128] Lazy evaluation: FALSE
[15:32:25.128] Asynchronous evaluation: FALSE
[15:32:25.128] Local evaluation: TRUE
[15:32:25.128] Environment: R_GlobalEnv
[15:32:25.128] Capture standard output: TRUE
[15:32:25.128] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:25.128] Globals: 5 objects totaling 1.05 KiB (function '...future.FUN' of 848 bytes, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 224 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:25.128] Packages: <none>
[15:32:25.128] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:25.128] Resolved: TRUE
[15:32:25.128] Value: 224 bytes of class 'list'
[15:32:25.128] Early signaling: FALSE
[15:32:25.128] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:25.128] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:25.130] Chunk #1 of 1 ... DONE
[15:32:25.130] Launching 1 futures (chunks) ... DONE
[15:32:25.131] Resolving 1 futures (chunks) ...
[15:32:25.131] resolve() on list ...
[15:32:25.131]  recursive: 0
[15:32:25.132]  length: 1
[15:32:25.132] 
[15:32:25.132] resolved() for 'SequentialFuture' ...
[15:32:25.132] - state: 'finished'
[15:32:25.133] - run: TRUE
[15:32:25.133] - result: 'FutureResult'
[15:32:25.133] resolved() for 'SequentialFuture' ... done
[15:32:25.134] Future #1
[15:32:25.134] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:25.134] - nx: 1
[15:32:25.135] - relay: TRUE
[15:32:25.135] - stdout: TRUE
[15:32:25.135] - signal: TRUE
[15:32:25.135] - resignal: FALSE
[15:32:25.136] - force: TRUE
[15:32:25.136] - relayed: [n=1] FALSE
[15:32:25.136] - queued futures: [n=1] FALSE
[15:32:25.137]  - until=1
[15:32:25.137]  - relaying element #1
[15:32:25.137] - relayed: [n=1] TRUE
[15:32:25.138] - queued futures: [n=1] TRUE
[15:32:25.138] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:25.138]  length: 0 (resolved future 1)
[15:32:25.138] Relaying remaining futures
[15:32:25.139] signalConditionsASAP(NULL, pos=0) ...
[15:32:25.139] - nx: 1
[15:32:25.139] - relay: TRUE
[15:32:25.140] - stdout: TRUE
[15:32:25.140] - signal: TRUE
[15:32:25.140] - resignal: FALSE
[15:32:25.140] - force: TRUE
[15:32:25.141] - relayed: [n=1] TRUE
[15:32:25.141] - queued futures: [n=1] TRUE
 - flush all
[15:32:25.141] - relayed: [n=1] TRUE
[15:32:25.142] - queued futures: [n=1] TRUE
[15:32:25.142] signalConditionsASAP(NULL, pos=0) ... done
[15:32:25.142] resolve() on list ... DONE
[15:32:25.143]  - Number of value chunks collected: 1
[15:32:25.143] Resolving 1 futures (chunks) ... DONE
[15:32:25.143] Reducing values from 1 chunks ...
[15:32:25.143]  - Number of values collected after concatenation: 4
[15:32:25.144]  - Number of values expected: 4
[15:32:25.144] Reducing values from 1 chunks ... DONE
[15:32:25.144] future_lapply() ... DONE
List of 2
 $ y0: Named num [1:4] 50 60 70 80
  ..- attr(*, "names")= chr [1:4] "A" "B" "C" "D"
 $ y1: Named num [1:4] 50 60 70 80
  ..- attr(*, "names")= chr [1:4] "A" "B" "C" "D"
[15:32:25.148] future_lapply() ...
[15:32:25.149] Number of chunks: 1
[15:32:25.149] getGlobalsAndPackagesXApply() ...
[15:32:25.149]  - future.globals: TRUE
[15:32:25.150] getGlobalsAndPackages() ...
[15:32:25.150] Searching for globals...
[15:32:25.152] - globals found: [2] 'FUN', 'UseMethod'
[15:32:25.152] Searching for globals ... DONE
[15:32:25.153] Resolving globals: FALSE
[15:32:25.153] The total size of the 1 globals is 1.22 KiB (1248 bytes)
[15:32:25.154] The total size of the 1 globals exported for future expression ('FUN()') is 1.22 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.22 KiB of class 'function')
[15:32:25.155] - globals: [1] 'FUN'
[15:32:25.155] 
[15:32:25.155] getGlobalsAndPackages() ... DONE
[15:32:25.155]  - globals found/used: [n=1] 'FUN'
[15:32:25.156]  - needed namespaces: [n=0] 
[15:32:25.156] Finding globals ... DONE
[15:32:25.156]  - use_args: TRUE
[15:32:25.157]  - Getting '...' globals ...
[15:32:25.157] resolve() on list ...
[15:32:25.158]  recursive: 0
[15:32:25.158]  length: 1
[15:32:25.158]  elements: '...'
[15:32:25.158]  length: 0 (resolved future 1)
[15:32:25.159] resolve() on list ... DONE
[15:32:25.159]    - '...' content: [n=0] 
[15:32:25.159] List of 1
[15:32:25.159]  $ ...: list()
[15:32:25.159]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:25.159]  - attr(*, "where")=List of 1
[15:32:25.159]   ..$ ...:<environment: 0x00000276e4f6f340> 
[15:32:25.159]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:25.159]  - attr(*, "resolved")= logi TRUE
[15:32:25.159]  - attr(*, "total_size")= num NA
[15:32:25.164]  - Getting '...' globals ... DONE
[15:32:25.164] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:25.165] List of 2
[15:32:25.165]  $ ...future.FUN:function (x, ...)  
[15:32:25.165]  $ ...          : list()
[15:32:25.165]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:25.165]  - attr(*, "where")=List of 2
[15:32:25.165]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:25.165]   ..$ ...          :<environment: 0x00000276e4f6f340> 
[15:32:25.165]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:25.165]  - attr(*, "resolved")= logi FALSE
[15:32:25.165]  - attr(*, "total_size")= num 1248
[15:32:25.170] Packages to be attached in all futures: [n=0] 
[15:32:25.170] getGlobalsAndPackagesXApply() ... DONE
[15:32:25.171] Number of futures (= number of chunks): 1
[15:32:25.171] Launching 1 futures (chunks) ...
[15:32:25.171] Chunk #1 of 1 ...
[15:32:25.172]  - Finding globals in 'X' for chunk #1 ...
[15:32:25.172] getGlobalsAndPackages() ...
[15:32:25.172] Searching for globals...
[15:32:25.173] 
[15:32:25.173] Searching for globals ... DONE
[15:32:25.173] - globals: [0] <none>
[15:32:25.174] getGlobalsAndPackages() ... DONE
[15:32:25.174]    + additional globals found: [n=0] 
[15:32:25.174]    + additional namespaces needed: [n=0] 
[15:32:25.174]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:25.175]  - seeds: <none>
[15:32:25.175]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:25.175] getGlobalsAndPackages() ...
[15:32:25.176] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:25.176] Resolving globals: FALSE
[15:32:25.176] Tweak future expression to call with '...' arguments ...
[15:32:25.177] {
[15:32:25.177]     do.call(function(...) {
[15:32:25.177]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:25.177]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:25.177]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:25.177]             on.exit(options(oopts), add = TRUE)
[15:32:25.177]         }
[15:32:25.177]         {
[15:32:25.177]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:25.177]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:25.177]                 ...future.FUN(...future.X_jj, ...)
[15:32:25.177]             })
[15:32:25.177]         }
[15:32:25.177]     }, args = future.call.arguments)
[15:32:25.177] }
[15:32:25.177] Tweak future expression to call with '...' arguments ... DONE
[15:32:25.178] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:25.179] 
[15:32:25.179] getGlobalsAndPackages() ... DONE
[15:32:25.179] run() for 'Future' ...
[15:32:25.180] - state: 'created'
[15:32:25.180] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:25.181] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:25.181] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:25.181]   - Field: 'label'
[15:32:25.182]   - Field: 'local'
[15:32:25.182]   - Field: 'owner'
[15:32:25.182]   - Field: 'envir'
[15:32:25.183]   - Field: 'packages'
[15:32:25.183]   - Field: 'gc'
[15:32:25.183]   - Field: 'conditions'
[15:32:25.184]   - Field: 'expr'
[15:32:25.184]   - Field: 'uuid'
[15:32:25.184]   - Field: 'seed'
[15:32:25.185]   - Field: 'version'
[15:32:25.185]   - Field: 'result'
[15:32:25.185]   - Field: 'asynchronous'
[15:32:25.185]   - Field: 'calls'
[15:32:25.186]   - Field: 'globals'
[15:32:25.186]   - Field: 'stdout'
[15:32:25.186]   - Field: 'earlySignal'
[15:32:25.187]   - Field: 'lazy'
[15:32:25.187]   - Field: 'state'
[15:32:25.187] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:25.188] - Launch lazy future ...
[15:32:25.188] Packages needed by the future expression (n = 0): <none>
[15:32:25.188] Packages needed by future strategies (n = 0): <none>
[15:32:25.189] {
[15:32:25.189]     {
[15:32:25.189]         {
[15:32:25.189]             ...future.startTime <- base::Sys.time()
[15:32:25.189]             {
[15:32:25.189]                 {
[15:32:25.189]                   {
[15:32:25.189]                     base::local({
[15:32:25.189]                       has_future <- base::requireNamespace("future", 
[15:32:25.189]                         quietly = TRUE)
[15:32:25.189]                       if (has_future) {
[15:32:25.189]                         ns <- base::getNamespace("future")
[15:32:25.189]                         version <- ns[[".package"]][["version"]]
[15:32:25.189]                         if (is.null(version)) 
[15:32:25.189]                           version <- utils::packageVersion("future")
[15:32:25.189]                       }
[15:32:25.189]                       else {
[15:32:25.189]                         version <- NULL
[15:32:25.189]                       }
[15:32:25.189]                       if (!has_future || version < "1.8.0") {
[15:32:25.189]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:25.189]                           "", base::R.version$version.string), 
[15:32:25.189]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:25.189]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:25.189]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:25.189]                             "release", "version")], collapse = " "), 
[15:32:25.189]                           hostname = base::Sys.info()[["nodename"]])
[15:32:25.189]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:25.189]                           info)
[15:32:25.189]                         info <- base::paste(info, collapse = "; ")
[15:32:25.189]                         if (!has_future) {
[15:32:25.189]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:25.189]                             info)
[15:32:25.189]                         }
[15:32:25.189]                         else {
[15:32:25.189]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:25.189]                             info, version)
[15:32:25.189]                         }
[15:32:25.189]                         base::stop(msg)
[15:32:25.189]                       }
[15:32:25.189]                     })
[15:32:25.189]                   }
[15:32:25.189]                   ...future.strategy.old <- future::plan("list")
[15:32:25.189]                   options(future.plan = NULL)
[15:32:25.189]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:25.189]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:25.189]                 }
[15:32:25.189]                 ...future.workdir <- getwd()
[15:32:25.189]             }
[15:32:25.189]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:25.189]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:25.189]         }
[15:32:25.189]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:25.189]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:25.189]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:25.189]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:25.189]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:25.189]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:25.189]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:25.189]             base::names(...future.oldOptions))
[15:32:25.189]     }
[15:32:25.189]     if (FALSE) {
[15:32:25.189]     }
[15:32:25.189]     else {
[15:32:25.189]         if (TRUE) {
[15:32:25.189]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:25.189]                 open = "w")
[15:32:25.189]         }
[15:32:25.189]         else {
[15:32:25.189]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:25.189]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:25.189]         }
[15:32:25.189]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:25.189]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:25.189]             base::sink(type = "output", split = FALSE)
[15:32:25.189]             base::close(...future.stdout)
[15:32:25.189]         }, add = TRUE)
[15:32:25.189]     }
[15:32:25.189]     ...future.frame <- base::sys.nframe()
[15:32:25.189]     ...future.conditions <- base::list()
[15:32:25.189]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:25.189]     if (FALSE) {
[15:32:25.189]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:25.189]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:25.189]     }
[15:32:25.189]     ...future.result <- base::tryCatch({
[15:32:25.189]         base::withCallingHandlers({
[15:32:25.189]             ...future.value <- base::withVisible(base::local({
[15:32:25.189]                 do.call(function(...) {
[15:32:25.189]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:25.189]                   if (!identical(...future.globals.maxSize.org, 
[15:32:25.189]                     ...future.globals.maxSize)) {
[15:32:25.189]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:25.189]                     on.exit(options(oopts), add = TRUE)
[15:32:25.189]                   }
[15:32:25.189]                   {
[15:32:25.189]                     lapply(seq_along(...future.elements_ii), 
[15:32:25.189]                       FUN = function(jj) {
[15:32:25.189]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:25.189]                         ...future.FUN(...future.X_jj, ...)
[15:32:25.189]                       })
[15:32:25.189]                   }
[15:32:25.189]                 }, args = future.call.arguments)
[15:32:25.189]             }))
[15:32:25.189]             future::FutureResult(value = ...future.value$value, 
[15:32:25.189]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:25.189]                   ...future.rng), globalenv = if (FALSE) 
[15:32:25.189]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:25.189]                     ...future.globalenv.names))
[15:32:25.189]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:25.189]         }, condition = base::local({
[15:32:25.189]             c <- base::c
[15:32:25.189]             inherits <- base::inherits
[15:32:25.189]             invokeRestart <- base::invokeRestart
[15:32:25.189]             length <- base::length
[15:32:25.189]             list <- base::list
[15:32:25.189]             seq.int <- base::seq.int
[15:32:25.189]             signalCondition <- base::signalCondition
[15:32:25.189]             sys.calls <- base::sys.calls
[15:32:25.189]             `[[` <- base::`[[`
[15:32:25.189]             `+` <- base::`+`
[15:32:25.189]             `<<-` <- base::`<<-`
[15:32:25.189]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:25.189]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:25.189]                   3L)]
[15:32:25.189]             }
[15:32:25.189]             function(cond) {
[15:32:25.189]                 is_error <- inherits(cond, "error")
[15:32:25.189]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:25.189]                   NULL)
[15:32:25.189]                 if (is_error) {
[15:32:25.189]                   sessionInformation <- function() {
[15:32:25.189]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:25.189]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:25.189]                       search = base::search(), system = base::Sys.info())
[15:32:25.189]                   }
[15:32:25.189]                   ...future.conditions[[length(...future.conditions) + 
[15:32:25.189]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:25.189]                     cond$call), session = sessionInformation(), 
[15:32:25.189]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:25.189]                   signalCondition(cond)
[15:32:25.189]                 }
[15:32:25.189]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:25.189]                 "immediateCondition"))) {
[15:32:25.189]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:25.189]                   ...future.conditions[[length(...future.conditions) + 
[15:32:25.189]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:25.189]                   if (TRUE && !signal) {
[15:32:25.189]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:25.189]                     {
[15:32:25.189]                       inherits <- base::inherits
[15:32:25.189]                       invokeRestart <- base::invokeRestart
[15:32:25.189]                       is.null <- base::is.null
[15:32:25.189]                       muffled <- FALSE
[15:32:25.189]                       if (inherits(cond, "message")) {
[15:32:25.189]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:25.189]                         if (muffled) 
[15:32:25.189]                           invokeRestart("muffleMessage")
[15:32:25.189]                       }
[15:32:25.189]                       else if (inherits(cond, "warning")) {
[15:32:25.189]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:25.189]                         if (muffled) 
[15:32:25.189]                           invokeRestart("muffleWarning")
[15:32:25.189]                       }
[15:32:25.189]                       else if (inherits(cond, "condition")) {
[15:32:25.189]                         if (!is.null(pattern)) {
[15:32:25.189]                           computeRestarts <- base::computeRestarts
[15:32:25.189]                           grepl <- base::grepl
[15:32:25.189]                           restarts <- computeRestarts(cond)
[15:32:25.189]                           for (restart in restarts) {
[15:32:25.189]                             name <- restart$name
[15:32:25.189]                             if (is.null(name)) 
[15:32:25.189]                               next
[15:32:25.189]                             if (!grepl(pattern, name)) 
[15:32:25.189]                               next
[15:32:25.189]                             invokeRestart(restart)
[15:32:25.189]                             muffled <- TRUE
[15:32:25.189]                             break
[15:32:25.189]                           }
[15:32:25.189]                         }
[15:32:25.189]                       }
[15:32:25.189]                       invisible(muffled)
[15:32:25.189]                     }
[15:32:25.189]                     muffleCondition(cond, pattern = "^muffle")
[15:32:25.189]                   }
[15:32:25.189]                 }
[15:32:25.189]                 else {
[15:32:25.189]                   if (TRUE) {
[15:32:25.189]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:25.189]                     {
[15:32:25.189]                       inherits <- base::inherits
[15:32:25.189]                       invokeRestart <- base::invokeRestart
[15:32:25.189]                       is.null <- base::is.null
[15:32:25.189]                       muffled <- FALSE
[15:32:25.189]                       if (inherits(cond, "message")) {
[15:32:25.189]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:25.189]                         if (muffled) 
[15:32:25.189]                           invokeRestart("muffleMessage")
[15:32:25.189]                       }
[15:32:25.189]                       else if (inherits(cond, "warning")) {
[15:32:25.189]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:25.189]                         if (muffled) 
[15:32:25.189]                           invokeRestart("muffleWarning")
[15:32:25.189]                       }
[15:32:25.189]                       else if (inherits(cond, "condition")) {
[15:32:25.189]                         if (!is.null(pattern)) {
[15:32:25.189]                           computeRestarts <- base::computeRestarts
[15:32:25.189]                           grepl <- base::grepl
[15:32:25.189]                           restarts <- computeRestarts(cond)
[15:32:25.189]                           for (restart in restarts) {
[15:32:25.189]                             name <- restart$name
[15:32:25.189]                             if (is.null(name)) 
[15:32:25.189]                               next
[15:32:25.189]                             if (!grepl(pattern, name)) 
[15:32:25.189]                               next
[15:32:25.189]                             invokeRestart(restart)
[15:32:25.189]                             muffled <- TRUE
[15:32:25.189]                             break
[15:32:25.189]                           }
[15:32:25.189]                         }
[15:32:25.189]                       }
[15:32:25.189]                       invisible(muffled)
[15:32:25.189]                     }
[15:32:25.189]                     muffleCondition(cond, pattern = "^muffle")
[15:32:25.189]                   }
[15:32:25.189]                 }
[15:32:25.189]             }
[15:32:25.189]         }))
[15:32:25.189]     }, error = function(ex) {
[15:32:25.189]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:25.189]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:25.189]                 ...future.rng), started = ...future.startTime, 
[15:32:25.189]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:25.189]             version = "1.8"), class = "FutureResult")
[15:32:25.189]     }, finally = {
[15:32:25.189]         if (!identical(...future.workdir, getwd())) 
[15:32:25.189]             setwd(...future.workdir)
[15:32:25.189]         {
[15:32:25.189]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:25.189]                 ...future.oldOptions$nwarnings <- NULL
[15:32:25.189]             }
[15:32:25.189]             base::options(...future.oldOptions)
[15:32:25.189]             if (.Platform$OS.type == "windows") {
[15:32:25.189]                 old_names <- names(...future.oldEnvVars)
[15:32:25.189]                 envs <- base::Sys.getenv()
[15:32:25.189]                 names <- names(envs)
[15:32:25.189]                 common <- intersect(names, old_names)
[15:32:25.189]                 added <- setdiff(names, old_names)
[15:32:25.189]                 removed <- setdiff(old_names, names)
[15:32:25.189]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:25.189]                   envs[common]]
[15:32:25.189]                 NAMES <- toupper(changed)
[15:32:25.189]                 args <- list()
[15:32:25.189]                 for (kk in seq_along(NAMES)) {
[15:32:25.189]                   name <- changed[[kk]]
[15:32:25.189]                   NAME <- NAMES[[kk]]
[15:32:25.189]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:25.189]                     next
[15:32:25.189]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:25.189]                 }
[15:32:25.189]                 NAMES <- toupper(added)
[15:32:25.189]                 for (kk in seq_along(NAMES)) {
[15:32:25.189]                   name <- added[[kk]]
[15:32:25.189]                   NAME <- NAMES[[kk]]
[15:32:25.189]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:25.189]                     next
[15:32:25.189]                   args[[name]] <- ""
[15:32:25.189]                 }
[15:32:25.189]                 NAMES <- toupper(removed)
[15:32:25.189]                 for (kk in seq_along(NAMES)) {
[15:32:25.189]                   name <- removed[[kk]]
[15:32:25.189]                   NAME <- NAMES[[kk]]
[15:32:25.189]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:25.189]                     next
[15:32:25.189]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:25.189]                 }
[15:32:25.189]                 if (length(args) > 0) 
[15:32:25.189]                   base::do.call(base::Sys.setenv, args = args)
[15:32:25.189]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:25.189]             }
[15:32:25.189]             else {
[15:32:25.189]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:25.189]             }
[15:32:25.189]             {
[15:32:25.189]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:25.189]                   0L) {
[15:32:25.189]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:25.189]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:25.189]                   base::options(opts)
[15:32:25.189]                 }
[15:32:25.189]                 {
[15:32:25.189]                   {
[15:32:25.189]                     NULL
[15:32:25.189]                     RNGkind("Mersenne-Twister")
[15:32:25.189]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:25.189]                       inherits = FALSE)
[15:32:25.189]                   }
[15:32:25.189]                   options(future.plan = NULL)
[15:32:25.189]                   if (is.na(NA_character_)) 
[15:32:25.189]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:25.189]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:25.189]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:25.189]                     .init = FALSE)
[15:32:25.189]                 }
[15:32:25.189]             }
[15:32:25.189]         }
[15:32:25.189]     })
[15:32:25.189]     if (TRUE) {
[15:32:25.189]         base::sink(type = "output", split = FALSE)
[15:32:25.189]         if (TRUE) {
[15:32:25.189]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:25.189]         }
[15:32:25.189]         else {
[15:32:25.189]             ...future.result["stdout"] <- base::list(NULL)
[15:32:25.189]         }
[15:32:25.189]         base::close(...future.stdout)
[15:32:25.189]         ...future.stdout <- NULL
[15:32:25.189]     }
[15:32:25.189]     ...future.result$conditions <- ...future.conditions
[15:32:25.189]     ...future.result$finished <- base::Sys.time()
[15:32:25.189]     ...future.result
[15:32:25.189] }
[15:32:25.197] assign_globals() ...
[15:32:25.197] List of 5
[15:32:25.197]  $ ...future.FUN            :function (x, ...)  
[15:32:25.197]  $ future.call.arguments    : list()
[15:32:25.197]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:25.197]  $ ...future.elements_ii    :List of 4
[15:32:25.197]   ..$ A: num 50
[15:32:25.197]   ..$ B: num 60
[15:32:25.197]   ..$ C: num 70
[15:32:25.197]   ..$ D: num 80
[15:32:25.197]  $ ...future.seeds_ii       : NULL
[15:32:25.197]  $ ...future.globals.maxSize: NULL
[15:32:25.197]  - attr(*, "where")=List of 5
[15:32:25.197]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:25.197]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:25.197]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:25.197]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:25.197]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:25.197]  - attr(*, "resolved")= logi FALSE
[15:32:25.197]  - attr(*, "total_size")= num 1248
[15:32:25.197]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:25.197]  - attr(*, "already-done")= logi TRUE
[15:32:25.213] - copied '...future.FUN' to environment
[15:32:25.214] - copied 'future.call.arguments' to environment
[15:32:25.214] - copied '...future.elements_ii' to environment
[15:32:25.214] - copied '...future.seeds_ii' to environment
[15:32:25.215] - copied '...future.globals.maxSize' to environment
[15:32:25.215] assign_globals() ... done
[15:32:25.216] plan(): Setting new future strategy stack:
[15:32:25.216] List of future strategies:
[15:32:25.216] 1. sequential:
[15:32:25.216]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:25.216]    - tweaked: FALSE
[15:32:25.216]    - call: NULL
[15:32:25.217] plan(): nbrOfWorkers() = 1
[15:32:25.219] plan(): Setting new future strategy stack:
[15:32:25.219] List of future strategies:
[15:32:25.219] 1. sequential:
[15:32:25.219]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:25.219]    - tweaked: FALSE
[15:32:25.219]    - call: plan(strategy)
[15:32:25.220] plan(): nbrOfWorkers() = 1
[15:32:25.221] SequentialFuture started (and completed)
[15:32:25.221] - Launch lazy future ... done
[15:32:25.221] run() for 'SequentialFuture' ... done
[15:32:25.222] Created future:
[15:32:25.222] SequentialFuture:
[15:32:25.222] Label: 'future_sapply-1'
[15:32:25.222] Expression:
[15:32:25.222] {
[15:32:25.222]     do.call(function(...) {
[15:32:25.222]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:25.222]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:25.222]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:25.222]             on.exit(options(oopts), add = TRUE)
[15:32:25.222]         }
[15:32:25.222]         {
[15:32:25.222]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:25.222]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:25.222]                 ...future.FUN(...future.X_jj, ...)
[15:32:25.222]             })
[15:32:25.222]         }
[15:32:25.222]     }, args = future.call.arguments)
[15:32:25.222] }
[15:32:25.222] Lazy evaluation: FALSE
[15:32:25.222] Asynchronous evaluation: FALSE
[15:32:25.222] Local evaluation: TRUE
[15:32:25.222] Environment: R_GlobalEnv
[15:32:25.222] Capture standard output: TRUE
[15:32:25.222] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:25.222] Globals: 5 objects totaling 1.44 KiB (function '...future.FUN' of 1.22 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 224 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:25.222] Packages: <none>
[15:32:25.222] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:25.222] Resolved: TRUE
[15:32:25.222] Value: 896 bytes of class 'list'
[15:32:25.222] Early signaling: FALSE
[15:32:25.222] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:25.222] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:25.225] Chunk #1 of 1 ... DONE
[15:32:25.225] Launching 1 futures (chunks) ... DONE
[15:32:25.226] Resolving 1 futures (chunks) ...
[15:32:25.226] resolve() on list ...
[15:32:25.226]  recursive: 0
[15:32:25.227]  length: 1
[15:32:25.227] 
[15:32:25.228] resolved() for 'SequentialFuture' ...
[15:32:25.228] - state: 'finished'
[15:32:25.228] - run: TRUE
[15:32:25.229] - result: 'FutureResult'
[15:32:25.229] resolved() for 'SequentialFuture' ... done
[15:32:25.229] Future #1
[15:32:25.230] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:25.230] - nx: 1
[15:32:25.230] - relay: TRUE
[15:32:25.230] - stdout: TRUE
[15:32:25.231] - signal: TRUE
[15:32:25.231] - resignal: FALSE
[15:32:25.231] - force: TRUE
[15:32:25.231] - relayed: [n=1] FALSE
[15:32:25.232] - queued futures: [n=1] FALSE
[15:32:25.232]  - until=1
[15:32:25.232]  - relaying element #1
[15:32:25.233] - relayed: [n=1] TRUE
[15:32:25.233] - queued futures: [n=1] TRUE
[15:32:25.233] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:25.234]  length: 0 (resolved future 1)
[15:32:25.234] Relaying remaining futures
[15:32:25.234] signalConditionsASAP(NULL, pos=0) ...
[15:32:25.234] - nx: 1
[15:32:25.235] - relay: TRUE
[15:32:25.235] - stdout: TRUE
[15:32:25.235] - signal: TRUE
[15:32:25.235] - resignal: FALSE
[15:32:25.236] - force: TRUE
[15:32:25.236] - relayed: [n=1] TRUE
[15:32:25.236] - queued futures: [n=1] TRUE
 - flush all
[15:32:25.237] - relayed: [n=1] TRUE
[15:32:25.237] - queued futures: [n=1] TRUE
[15:32:25.237] signalConditionsASAP(NULL, pos=0) ... done
[15:32:25.237] resolve() on list ... DONE
[15:32:25.238]  - Number of value chunks collected: 1
[15:32:25.238] Resolving 1 futures (chunks) ... DONE
[15:32:25.238] Reducing values from 1 chunks ...
[15:32:25.239]  - Number of values collected after concatenation: 4
[15:32:25.239]  - Number of values expected: 4
[15:32:25.239] Reducing values from 1 chunks ... DONE
[15:32:25.239] future_lapply() ... DONE
List of 2
 $ y0: Named num [1:4] 50 60 70 80
  ..- attr(*, "names")= chr [1:4] "A" "B" "C" "D"
 $ y1: Named num [1:4] 50 60 70 80
  ..- attr(*, "names")= chr [1:4] "A" "B" "C" "D"
[15:32:25.243] future_lapply() ...
[15:32:25.245] Number of chunks: 1
[15:32:25.245] getGlobalsAndPackagesXApply() ...
[15:32:25.245]  - future.globals: TRUE
[15:32:25.246] getGlobalsAndPackages() ...
[15:32:25.246] Searching for globals...
[15:32:25.249] - globals found: [5] 'FUN', '*', ':', 'outer', 'rep'
[15:32:25.250] Searching for globals ... DONE
[15:32:25.250] Resolving globals: FALSE
[15:32:25.251] The total size of the 1 globals is 4.62 KiB (4728 bytes)
[15:32:25.252] The total size of the 1 globals exported for future expression ('FUN()') is 4.62 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.62 KiB of class 'function')
[15:32:25.252] - globals: [1] 'FUN'
[15:32:25.252] 
[15:32:25.253] getGlobalsAndPackages() ... DONE
[15:32:25.253]  - globals found/used: [n=1] 'FUN'
[15:32:25.253]  - needed namespaces: [n=0] 
[15:32:25.253] Finding globals ... DONE
[15:32:25.254]  - use_args: TRUE
[15:32:25.254]  - Getting '...' globals ...
[15:32:25.255] resolve() on list ...
[15:32:25.255]  recursive: 0
[15:32:25.255]  length: 1
[15:32:25.256]  elements: '...'
[15:32:25.256]  length: 0 (resolved future 1)
[15:32:25.256] resolve() on list ... DONE
[15:32:25.257]    - '...' content: [n=0] 
[15:32:25.257] List of 1
[15:32:25.257]  $ ...: list()
[15:32:25.257]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:25.257]  - attr(*, "where")=List of 1
[15:32:25.257]   ..$ ...:<environment: 0x00000276e1cb6ea0> 
[15:32:25.257]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:25.257]  - attr(*, "resolved")= logi TRUE
[15:32:25.257]  - attr(*, "total_size")= num NA
[15:32:25.262]  - Getting '...' globals ... DONE
[15:32:25.263] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:25.263] List of 2
[15:32:25.263]  $ ...future.FUN:function (x, y = 2 * 1:5)  
[15:32:25.263]  $ ...          : list()
[15:32:25.263]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:25.263]  - attr(*, "where")=List of 2
[15:32:25.263]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:25.263]   ..$ ...          :<environment: 0x00000276e1cb6ea0> 
[15:32:25.263]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:25.263]  - attr(*, "resolved")= logi FALSE
[15:32:25.263]  - attr(*, "total_size")= num 4728
[15:32:25.268] Packages to be attached in all futures: [n=0] 
[15:32:25.269] getGlobalsAndPackagesXApply() ... DONE
[15:32:25.269] Number of futures (= number of chunks): 1
[15:32:25.270] Launching 1 futures (chunks) ...
[15:32:25.270] Chunk #1 of 1 ...
[15:32:25.270]  - Finding globals in 'X' for chunk #1 ...
[15:32:25.271] getGlobalsAndPackages() ...
[15:32:25.271] Searching for globals...
[15:32:25.271] 
[15:32:25.272] Searching for globals ... DONE
[15:32:25.272] - globals: [0] <none>
[15:32:25.272] getGlobalsAndPackages() ... DONE
[15:32:25.273]    + additional globals found: [n=0] 
[15:32:25.273]    + additional namespaces needed: [n=0] 
[15:32:25.273]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:25.273]  - seeds: <none>
[15:32:25.274]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:25.274] getGlobalsAndPackages() ...
[15:32:25.274] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:25.275] Resolving globals: FALSE
[15:32:25.275] Tweak future expression to call with '...' arguments ...
[15:32:25.275] {
[15:32:25.275]     do.call(function(...) {
[15:32:25.275]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:25.275]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:25.275]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:25.275]             on.exit(options(oopts), add = TRUE)
[15:32:25.275]         }
[15:32:25.275]         {
[15:32:25.275]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:25.275]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:25.275]                 ...future.FUN(...future.X_jj, ...)
[15:32:25.275]             })
[15:32:25.275]         }
[15:32:25.275]     }, args = future.call.arguments)
[15:32:25.275] }
[15:32:25.276] Tweak future expression to call with '...' arguments ... DONE
[15:32:25.277] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:25.277] 
[15:32:25.277] getGlobalsAndPackages() ... DONE
[15:32:25.278] run() for 'Future' ...
[15:32:25.279] - state: 'created'
[15:32:25.279] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:25.280] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:25.280] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:25.280]   - Field: 'label'
[15:32:25.281]   - Field: 'local'
[15:32:25.281]   - Field: 'owner'
[15:32:25.281]   - Field: 'envir'
[15:32:25.282]   - Field: 'packages'
[15:32:25.282]   - Field: 'gc'
[15:32:25.282]   - Field: 'conditions'
[15:32:25.283]   - Field: 'expr'
[15:32:25.283]   - Field: 'uuid'
[15:32:25.283]   - Field: 'seed'
[15:32:25.284]   - Field: 'version'
[15:32:25.284]   - Field: 'result'
[15:32:25.284]   - Field: 'asynchronous'
[15:32:25.285]   - Field: 'calls'
[15:32:25.285]   - Field: 'globals'
[15:32:25.285]   - Field: 'stdout'
[15:32:25.285]   - Field: 'earlySignal'
[15:32:25.286]   - Field: 'lazy'
[15:32:25.286]   - Field: 'state'
[15:32:25.286] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:25.287] - Launch lazy future ...
[15:32:25.287] Packages needed by the future expression (n = 0): <none>
[15:32:25.288] Packages needed by future strategies (n = 0): <none>
[15:32:25.289] {
[15:32:25.289]     {
[15:32:25.289]         {
[15:32:25.289]             ...future.startTime <- base::Sys.time()
[15:32:25.289]             {
[15:32:25.289]                 {
[15:32:25.289]                   {
[15:32:25.289]                     base::local({
[15:32:25.289]                       has_future <- base::requireNamespace("future", 
[15:32:25.289]                         quietly = TRUE)
[15:32:25.289]                       if (has_future) {
[15:32:25.289]                         ns <- base::getNamespace("future")
[15:32:25.289]                         version <- ns[[".package"]][["version"]]
[15:32:25.289]                         if (is.null(version)) 
[15:32:25.289]                           version <- utils::packageVersion("future")
[15:32:25.289]                       }
[15:32:25.289]                       else {
[15:32:25.289]                         version <- NULL
[15:32:25.289]                       }
[15:32:25.289]                       if (!has_future || version < "1.8.0") {
[15:32:25.289]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:25.289]                           "", base::R.version$version.string), 
[15:32:25.289]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:25.289]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:25.289]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:25.289]                             "release", "version")], collapse = " "), 
[15:32:25.289]                           hostname = base::Sys.info()[["nodename"]])
[15:32:25.289]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:25.289]                           info)
[15:32:25.289]                         info <- base::paste(info, collapse = "; ")
[15:32:25.289]                         if (!has_future) {
[15:32:25.289]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:25.289]                             info)
[15:32:25.289]                         }
[15:32:25.289]                         else {
[15:32:25.289]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:25.289]                             info, version)
[15:32:25.289]                         }
[15:32:25.289]                         base::stop(msg)
[15:32:25.289]                       }
[15:32:25.289]                     })
[15:32:25.289]                   }
[15:32:25.289]                   ...future.strategy.old <- future::plan("list")
[15:32:25.289]                   options(future.plan = NULL)
[15:32:25.289]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:25.289]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:25.289]                 }
[15:32:25.289]                 ...future.workdir <- getwd()
[15:32:25.289]             }
[15:32:25.289]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:25.289]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:25.289]         }
[15:32:25.289]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:25.289]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:25.289]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:25.289]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:25.289]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:25.289]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:25.289]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:25.289]             base::names(...future.oldOptions))
[15:32:25.289]     }
[15:32:25.289]     if (FALSE) {
[15:32:25.289]     }
[15:32:25.289]     else {
[15:32:25.289]         if (TRUE) {
[15:32:25.289]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:25.289]                 open = "w")
[15:32:25.289]         }
[15:32:25.289]         else {
[15:32:25.289]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:25.289]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:25.289]         }
[15:32:25.289]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:25.289]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:25.289]             base::sink(type = "output", split = FALSE)
[15:32:25.289]             base::close(...future.stdout)
[15:32:25.289]         }, add = TRUE)
[15:32:25.289]     }
[15:32:25.289]     ...future.frame <- base::sys.nframe()
[15:32:25.289]     ...future.conditions <- base::list()
[15:32:25.289]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:25.289]     if (FALSE) {
[15:32:25.289]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:25.289]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:25.289]     }
[15:32:25.289]     ...future.result <- base::tryCatch({
[15:32:25.289]         base::withCallingHandlers({
[15:32:25.289]             ...future.value <- base::withVisible(base::local({
[15:32:25.289]                 do.call(function(...) {
[15:32:25.289]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:25.289]                   if (!identical(...future.globals.maxSize.org, 
[15:32:25.289]                     ...future.globals.maxSize)) {
[15:32:25.289]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:25.289]                     on.exit(options(oopts), add = TRUE)
[15:32:25.289]                   }
[15:32:25.289]                   {
[15:32:25.289]                     lapply(seq_along(...future.elements_ii), 
[15:32:25.289]                       FUN = function(jj) {
[15:32:25.289]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:25.289]                         ...future.FUN(...future.X_jj, ...)
[15:32:25.289]                       })
[15:32:25.289]                   }
[15:32:25.289]                 }, args = future.call.arguments)
[15:32:25.289]             }))
[15:32:25.289]             future::FutureResult(value = ...future.value$value, 
[15:32:25.289]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:25.289]                   ...future.rng), globalenv = if (FALSE) 
[15:32:25.289]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:25.289]                     ...future.globalenv.names))
[15:32:25.289]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:25.289]         }, condition = base::local({
[15:32:25.289]             c <- base::c
[15:32:25.289]             inherits <- base::inherits
[15:32:25.289]             invokeRestart <- base::invokeRestart
[15:32:25.289]             length <- base::length
[15:32:25.289]             list <- base::list
[15:32:25.289]             seq.int <- base::seq.int
[15:32:25.289]             signalCondition <- base::signalCondition
[15:32:25.289]             sys.calls <- base::sys.calls
[15:32:25.289]             `[[` <- base::`[[`
[15:32:25.289]             `+` <- base::`+`
[15:32:25.289]             `<<-` <- base::`<<-`
[15:32:25.289]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:25.289]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:25.289]                   3L)]
[15:32:25.289]             }
[15:32:25.289]             function(cond) {
[15:32:25.289]                 is_error <- inherits(cond, "error")
[15:32:25.289]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:25.289]                   NULL)
[15:32:25.289]                 if (is_error) {
[15:32:25.289]                   sessionInformation <- function() {
[15:32:25.289]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:25.289]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:25.289]                       search = base::search(), system = base::Sys.info())
[15:32:25.289]                   }
[15:32:25.289]                   ...future.conditions[[length(...future.conditions) + 
[15:32:25.289]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:25.289]                     cond$call), session = sessionInformation(), 
[15:32:25.289]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:25.289]                   signalCondition(cond)
[15:32:25.289]                 }
[15:32:25.289]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:25.289]                 "immediateCondition"))) {
[15:32:25.289]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:25.289]                   ...future.conditions[[length(...future.conditions) + 
[15:32:25.289]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:25.289]                   if (TRUE && !signal) {
[15:32:25.289]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:25.289]                     {
[15:32:25.289]                       inherits <- base::inherits
[15:32:25.289]                       invokeRestart <- base::invokeRestart
[15:32:25.289]                       is.null <- base::is.null
[15:32:25.289]                       muffled <- FALSE
[15:32:25.289]                       if (inherits(cond, "message")) {
[15:32:25.289]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:25.289]                         if (muffled) 
[15:32:25.289]                           invokeRestart("muffleMessage")
[15:32:25.289]                       }
[15:32:25.289]                       else if (inherits(cond, "warning")) {
[15:32:25.289]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:25.289]                         if (muffled) 
[15:32:25.289]                           invokeRestart("muffleWarning")
[15:32:25.289]                       }
[15:32:25.289]                       else if (inherits(cond, "condition")) {
[15:32:25.289]                         if (!is.null(pattern)) {
[15:32:25.289]                           computeRestarts <- base::computeRestarts
[15:32:25.289]                           grepl <- base::grepl
[15:32:25.289]                           restarts <- computeRestarts(cond)
[15:32:25.289]                           for (restart in restarts) {
[15:32:25.289]                             name <- restart$name
[15:32:25.289]                             if (is.null(name)) 
[15:32:25.289]                               next
[15:32:25.289]                             if (!grepl(pattern, name)) 
[15:32:25.289]                               next
[15:32:25.289]                             invokeRestart(restart)
[15:32:25.289]                             muffled <- TRUE
[15:32:25.289]                             break
[15:32:25.289]                           }
[15:32:25.289]                         }
[15:32:25.289]                       }
[15:32:25.289]                       invisible(muffled)
[15:32:25.289]                     }
[15:32:25.289]                     muffleCondition(cond, pattern = "^muffle")
[15:32:25.289]                   }
[15:32:25.289]                 }
[15:32:25.289]                 else {
[15:32:25.289]                   if (TRUE) {
[15:32:25.289]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:25.289]                     {
[15:32:25.289]                       inherits <- base::inherits
[15:32:25.289]                       invokeRestart <- base::invokeRestart
[15:32:25.289]                       is.null <- base::is.null
[15:32:25.289]                       muffled <- FALSE
[15:32:25.289]                       if (inherits(cond, "message")) {
[15:32:25.289]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:25.289]                         if (muffled) 
[15:32:25.289]                           invokeRestart("muffleMessage")
[15:32:25.289]                       }
[15:32:25.289]                       else if (inherits(cond, "warning")) {
[15:32:25.289]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:25.289]                         if (muffled) 
[15:32:25.289]                           invokeRestart("muffleWarning")
[15:32:25.289]                       }
[15:32:25.289]                       else if (inherits(cond, "condition")) {
[15:32:25.289]                         if (!is.null(pattern)) {
[15:32:25.289]                           computeRestarts <- base::computeRestarts
[15:32:25.289]                           grepl <- base::grepl
[15:32:25.289]                           restarts <- computeRestarts(cond)
[15:32:25.289]                           for (restart in restarts) {
[15:32:25.289]                             name <- restart$name
[15:32:25.289]                             if (is.null(name)) 
[15:32:25.289]                               next
[15:32:25.289]                             if (!grepl(pattern, name)) 
[15:32:25.289]                               next
[15:32:25.289]                             invokeRestart(restart)
[15:32:25.289]                             muffled <- TRUE
[15:32:25.289]                             break
[15:32:25.289]                           }
[15:32:25.289]                         }
[15:32:25.289]                       }
[15:32:25.289]                       invisible(muffled)
[15:32:25.289]                     }
[15:32:25.289]                     muffleCondition(cond, pattern = "^muffle")
[15:32:25.289]                   }
[15:32:25.289]                 }
[15:32:25.289]             }
[15:32:25.289]         }))
[15:32:25.289]     }, error = function(ex) {
[15:32:25.289]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:25.289]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:25.289]                 ...future.rng), started = ...future.startTime, 
[15:32:25.289]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:25.289]             version = "1.8"), class = "FutureResult")
[15:32:25.289]     }, finally = {
[15:32:25.289]         if (!identical(...future.workdir, getwd())) 
[15:32:25.289]             setwd(...future.workdir)
[15:32:25.289]         {
[15:32:25.289]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:25.289]                 ...future.oldOptions$nwarnings <- NULL
[15:32:25.289]             }
[15:32:25.289]             base::options(...future.oldOptions)
[15:32:25.289]             if (.Platform$OS.type == "windows") {
[15:32:25.289]                 old_names <- names(...future.oldEnvVars)
[15:32:25.289]                 envs <- base::Sys.getenv()
[15:32:25.289]                 names <- names(envs)
[15:32:25.289]                 common <- intersect(names, old_names)
[15:32:25.289]                 added <- setdiff(names, old_names)
[15:32:25.289]                 removed <- setdiff(old_names, names)
[15:32:25.289]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:25.289]                   envs[common]]
[15:32:25.289]                 NAMES <- toupper(changed)
[15:32:25.289]                 args <- list()
[15:32:25.289]                 for (kk in seq_along(NAMES)) {
[15:32:25.289]                   name <- changed[[kk]]
[15:32:25.289]                   NAME <- NAMES[[kk]]
[15:32:25.289]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:25.289]                     next
[15:32:25.289]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:25.289]                 }
[15:32:25.289]                 NAMES <- toupper(added)
[15:32:25.289]                 for (kk in seq_along(NAMES)) {
[15:32:25.289]                   name <- added[[kk]]
[15:32:25.289]                   NAME <- NAMES[[kk]]
[15:32:25.289]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:25.289]                     next
[15:32:25.289]                   args[[name]] <- ""
[15:32:25.289]                 }
[15:32:25.289]                 NAMES <- toupper(removed)
[15:32:25.289]                 for (kk in seq_along(NAMES)) {
[15:32:25.289]                   name <- removed[[kk]]
[15:32:25.289]                   NAME <- NAMES[[kk]]
[15:32:25.289]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:25.289]                     next
[15:32:25.289]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:25.289]                 }
[15:32:25.289]                 if (length(args) > 0) 
[15:32:25.289]                   base::do.call(base::Sys.setenv, args = args)
[15:32:25.289]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:25.289]             }
[15:32:25.289]             else {
[15:32:25.289]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:25.289]             }
[15:32:25.289]             {
[15:32:25.289]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:25.289]                   0L) {
[15:32:25.289]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:25.289]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:25.289]                   base::options(opts)
[15:32:25.289]                 }
[15:32:25.289]                 {
[15:32:25.289]                   {
[15:32:25.289]                     NULL
[15:32:25.289]                     RNGkind("Mersenne-Twister")
[15:32:25.289]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:25.289]                       inherits = FALSE)
[15:32:25.289]                   }
[15:32:25.289]                   options(future.plan = NULL)
[15:32:25.289]                   if (is.na(NA_character_)) 
[15:32:25.289]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:25.289]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:25.289]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:25.289]                     .init = FALSE)
[15:32:25.289]                 }
[15:32:25.289]             }
[15:32:25.289]         }
[15:32:25.289]     })
[15:32:25.289]     if (TRUE) {
[15:32:25.289]         base::sink(type = "output", split = FALSE)
[15:32:25.289]         if (TRUE) {
[15:32:25.289]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:25.289]         }
[15:32:25.289]         else {
[15:32:25.289]             ...future.result["stdout"] <- base::list(NULL)
[15:32:25.289]         }
[15:32:25.289]         base::close(...future.stdout)
[15:32:25.289]         ...future.stdout <- NULL
[15:32:25.289]     }
[15:32:25.289]     ...future.result$conditions <- ...future.conditions
[15:32:25.289]     ...future.result$finished <- base::Sys.time()
[15:32:25.289]     ...future.result
[15:32:25.289] }
[15:32:25.296] assign_globals() ...
[15:32:25.296] List of 5
[15:32:25.296]  $ ...future.FUN            :function (x, y = 2 * 1:5)  
[15:32:25.296]  $ future.call.arguments    : list()
[15:32:25.296]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:25.296]  $ ...future.elements_ii    :List of 4
[15:32:25.296]   ..$ A: num 50
[15:32:25.296]   ..$ B: num 60
[15:32:25.296]   ..$ C: num 70
[15:32:25.296]   ..$ D: num 80
[15:32:25.296]  $ ...future.seeds_ii       : NULL
[15:32:25.296]  $ ...future.globals.maxSize: NULL
[15:32:25.296]  - attr(*, "where")=List of 5
[15:32:25.296]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:25.296]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:25.296]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:25.296]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:25.296]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:25.296]  - attr(*, "resolved")= logi FALSE
[15:32:25.296]  - attr(*, "total_size")= num 4728
[15:32:25.296]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:25.296]  - attr(*, "already-done")= logi TRUE
[15:32:25.308] - reassign environment for '...future.FUN'
[15:32:25.308] - copied '...future.FUN' to environment
[15:32:25.308] - copied 'future.call.arguments' to environment
[15:32:25.309] - copied '...future.elements_ii' to environment
[15:32:25.309] - copied '...future.seeds_ii' to environment
[15:32:25.309] - copied '...future.globals.maxSize' to environment
[15:32:25.310] assign_globals() ... done
[15:32:25.310] plan(): Setting new future strategy stack:
[15:32:25.311] List of future strategies:
[15:32:25.311] 1. sequential:
[15:32:25.311]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:25.311]    - tweaked: FALSE
[15:32:25.311]    - call: NULL
[15:32:25.312] plan(): nbrOfWorkers() = 1
[15:32:25.314] plan(): Setting new future strategy stack:
[15:32:25.314] List of future strategies:
[15:32:25.314] 1. sequential:
[15:32:25.314]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:25.314]    - tweaked: FALSE
[15:32:25.314]    - call: plan(strategy)
[15:32:25.315] plan(): nbrOfWorkers() = 1
[15:32:25.315] SequentialFuture started (and completed)
[15:32:25.316] - Launch lazy future ... done
[15:32:25.316] run() for 'SequentialFuture' ... done
[15:32:25.316] Created future:
[15:32:25.317] SequentialFuture:
[15:32:25.317] Label: 'future_sapply-1'
[15:32:25.317] Expression:
[15:32:25.317] {
[15:32:25.317]     do.call(function(...) {
[15:32:25.317]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:25.317]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:25.317]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:25.317]             on.exit(options(oopts), add = TRUE)
[15:32:25.317]         }
[15:32:25.317]         {
[15:32:25.317]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:25.317]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:25.317]                 ...future.FUN(...future.X_jj, ...)
[15:32:25.317]             })
[15:32:25.317]         }
[15:32:25.317]     }, args = future.call.arguments)
[15:32:25.317] }
[15:32:25.317] Lazy evaluation: FALSE
[15:32:25.317] Asynchronous evaluation: FALSE
[15:32:25.317] Local evaluation: TRUE
[15:32:25.317] Environment: R_GlobalEnv
[15:32:25.317] Capture standard output: TRUE
[15:32:25.317] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:25.317] Globals: 5 objects totaling 4.84 KiB (function '...future.FUN' of 4.62 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 224 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:25.317] Packages: <none>
[15:32:25.317] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:25.317] Resolved: TRUE
[15:32:25.317] Value: 1.34 KiB of class 'list'
[15:32:25.317] Early signaling: FALSE
[15:32:25.317] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:25.317] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:25.319] Chunk #1 of 1 ... DONE
[15:32:25.319] Launching 1 futures (chunks) ... DONE
[15:32:25.319] Resolving 1 futures (chunks) ...
[15:32:25.320] resolve() on list ...
[15:32:25.320]  recursive: 0
[15:32:25.320]  length: 1
[15:32:25.320] 
[15:32:25.321] resolved() for 'SequentialFuture' ...
[15:32:25.321] - state: 'finished'
[15:32:25.321] - run: TRUE
[15:32:25.322] - result: 'FutureResult'
[15:32:25.322] resolved() for 'SequentialFuture' ... done
[15:32:25.322] Future #1
[15:32:25.322] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:25.323] - nx: 1
[15:32:25.323] - relay: TRUE
[15:32:25.323] - stdout: TRUE
[15:32:25.323] - signal: TRUE
[15:32:25.324] - resignal: FALSE
[15:32:25.324] - force: TRUE
[15:32:25.324] - relayed: [n=1] FALSE
[15:32:25.324] - queued futures: [n=1] FALSE
[15:32:25.325]  - until=1
[15:32:25.325]  - relaying element #1
[15:32:25.325] - relayed: [n=1] TRUE
[15:32:25.326] - queued futures: [n=1] TRUE
[15:32:25.326] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:25.326]  length: 0 (resolved future 1)
[15:32:25.327] Relaying remaining futures
[15:32:25.327] signalConditionsASAP(NULL, pos=0) ...
[15:32:25.327] - nx: 1
[15:32:25.327] - relay: TRUE
[15:32:25.327] - stdout: TRUE
[15:32:25.328] - signal: TRUE
[15:32:25.328] - resignal: FALSE
[15:32:25.328] - force: TRUE
[15:32:25.328] - relayed: [n=1] TRUE
[15:32:25.329] - queued futures: [n=1] TRUE
 - flush all
[15:32:25.329] - relayed: [n=1] TRUE
[15:32:25.329] - queued futures: [n=1] TRUE
[15:32:25.329] signalConditionsASAP(NULL, pos=0) ... done
[15:32:25.330] resolve() on list ... DONE
[15:32:25.330]  - Number of value chunks collected: 1
[15:32:25.330] Resolving 1 futures (chunks) ... DONE
[15:32:25.331] Reducing values from 1 chunks ...
[15:32:25.331]  - Number of values collected after concatenation: 4
[15:32:25.331]  - Number of values expected: 4
[15:32:25.331] Reducing values from 1 chunks ... DONE
[15:32:25.332] future_lapply() ... DONE
List of 2
 $ y0: num [1:15, 1:4] 100 100 100 200 200 200 300 300 300 400 ...
  ..- attr(*, "dimnames")=List of 2
  .. ..$ : NULL
  .. ..$ : chr [1:4] "A" "B" "C" "D"
 $ y1: num [1:15, 1:4] 100 100 100 200 200 200 300 300 300 400 ...
  ..- attr(*, "dimnames")=List of 2
  .. ..$ : NULL
  .. ..$ : chr [1:4] "A" "B" "C" "D"
[15:32:25.337] future_lapply() ...
[15:32:25.338] Number of chunks: 1
[15:32:25.338] getGlobalsAndPackagesXApply() ...
[15:32:25.338]  - future.globals: TRUE
[15:32:25.339] getGlobalsAndPackages() ...
[15:32:25.339] Searching for globals...
[15:32:25.341] - globals found: [1] 'FUN'
[15:32:25.341] Searching for globals ... DONE
[15:32:25.341] Resolving globals: FALSE
[15:32:25.342] The total size of the 1 globals is 848 bytes (848 bytes)
[15:32:25.343] The total size of the 1 globals exported for future expression ('FUN()') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:32:25.343] - globals: [1] 'FUN'
[15:32:25.343] 
[15:32:25.343] getGlobalsAndPackages() ... DONE
[15:32:25.344]  - globals found/used: [n=1] 'FUN'
[15:32:25.344]  - needed namespaces: [n=0] 
[15:32:25.344] Finding globals ... DONE
[15:32:25.344]  - use_args: TRUE
[15:32:25.344]  - Getting '...' globals ...
[15:32:25.345] resolve() on list ...
[15:32:25.345]  recursive: 0
[15:32:25.345]  length: 1
[15:32:25.345]  elements: '...'
[15:32:25.346]  length: 0 (resolved future 1)
[15:32:25.346] resolve() on list ... DONE
[15:32:25.346]    - '...' content: [n=0] 
[15:32:25.346] List of 1
[15:32:25.346]  $ ...: list()
[15:32:25.346]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:25.346]  - attr(*, "where")=List of 1
[15:32:25.346]   ..$ ...:<environment: 0x00000276e5028180> 
[15:32:25.346]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:25.346]  - attr(*, "resolved")= logi TRUE
[15:32:25.346]  - attr(*, "total_size")= num NA
[15:32:25.349]  - Getting '...' globals ... DONE
[15:32:25.350] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:25.350] List of 2
[15:32:25.350]  $ ...future.FUN:function (x)  
[15:32:25.350]  $ ...          : list()
[15:32:25.350]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:25.350]  - attr(*, "where")=List of 2
[15:32:25.350]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:25.350]   ..$ ...          :<environment: 0x00000276e5028180> 
[15:32:25.350]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:25.350]  - attr(*, "resolved")= logi FALSE
[15:32:25.350]  - attr(*, "total_size")= num 848
[15:32:25.353] Packages to be attached in all futures: [n=0] 
[15:32:25.353] getGlobalsAndPackagesXApply() ... DONE
[15:32:25.354] Number of futures (= number of chunks): 1
[15:32:25.354] Launching 1 futures (chunks) ...
[15:32:25.354] Chunk #1 of 1 ...
[15:32:25.354]  - Finding globals in 'X' for chunk #1 ...
[15:32:25.355] getGlobalsAndPackages() ...
[15:32:25.355] Searching for globals...
[15:32:25.355] 
[15:32:25.355] Searching for globals ... DONE
[15:32:25.356] - globals: [0] <none>
[15:32:25.356] getGlobalsAndPackages() ... DONE
[15:32:25.356]    + additional globals found: [n=0] 
[15:32:25.356]    + additional namespaces needed: [n=0] 
[15:32:25.356]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:25.356]  - seeds: <none>
[15:32:25.357]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:25.357] getGlobalsAndPackages() ...
[15:32:25.357] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:25.357] Resolving globals: FALSE
[15:32:25.357] Tweak future expression to call with '...' arguments ...
[15:32:25.357] {
[15:32:25.357]     do.call(function(...) {
[15:32:25.357]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:25.357]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:25.357]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:25.357]             on.exit(options(oopts), add = TRUE)
[15:32:25.357]         }
[15:32:25.357]         {
[15:32:25.357]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:25.357]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:25.357]                 ...future.FUN(...future.X_jj, ...)
[15:32:25.357]             })
[15:32:25.357]         }
[15:32:25.357]     }, args = future.call.arguments)
[15:32:25.357] }
[15:32:25.358] Tweak future expression to call with '...' arguments ... DONE
[15:32:25.359] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:25.359] 
[15:32:25.359] getGlobalsAndPackages() ... DONE
[15:32:25.359] run() for 'Future' ...
[15:32:25.360] - state: 'created'
[15:32:25.360] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:25.360] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:25.361] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:25.361]   - Field: 'label'
[15:32:25.361]   - Field: 'local'
[15:32:25.361]   - Field: 'owner'
[15:32:25.361]   - Field: 'envir'
[15:32:25.362]   - Field: 'packages'
[15:32:25.362]   - Field: 'gc'
[15:32:25.362]   - Field: 'conditions'
[15:32:25.362]   - Field: 'expr'
[15:32:25.362]   - Field: 'uuid'
[15:32:25.363]   - Field: 'seed'
[15:32:25.363]   - Field: 'version'
[15:32:25.363]   - Field: 'result'
[15:32:25.363]   - Field: 'asynchronous'
[15:32:25.363]   - Field: 'calls'
[15:32:25.364]   - Field: 'globals'
[15:32:25.364]   - Field: 'stdout'
[15:32:25.364]   - Field: 'earlySignal'
[15:32:25.364]   - Field: 'lazy'
[15:32:25.364]   - Field: 'state'
[15:32:25.365] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:25.365] - Launch lazy future ...
[15:32:25.365] Packages needed by the future expression (n = 0): <none>
[15:32:25.365] Packages needed by future strategies (n = 0): <none>
[15:32:25.366] {
[15:32:25.366]     {
[15:32:25.366]         {
[15:32:25.366]             ...future.startTime <- base::Sys.time()
[15:32:25.366]             {
[15:32:25.366]                 {
[15:32:25.366]                   {
[15:32:25.366]                     base::local({
[15:32:25.366]                       has_future <- base::requireNamespace("future", 
[15:32:25.366]                         quietly = TRUE)
[15:32:25.366]                       if (has_future) {
[15:32:25.366]                         ns <- base::getNamespace("future")
[15:32:25.366]                         version <- ns[[".package"]][["version"]]
[15:32:25.366]                         if (is.null(version)) 
[15:32:25.366]                           version <- utils::packageVersion("future")
[15:32:25.366]                       }
[15:32:25.366]                       else {
[15:32:25.366]                         version <- NULL
[15:32:25.366]                       }
[15:32:25.366]                       if (!has_future || version < "1.8.0") {
[15:32:25.366]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:25.366]                           "", base::R.version$version.string), 
[15:32:25.366]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:25.366]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:25.366]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:25.366]                             "release", "version")], collapse = " "), 
[15:32:25.366]                           hostname = base::Sys.info()[["nodename"]])
[15:32:25.366]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:25.366]                           info)
[15:32:25.366]                         info <- base::paste(info, collapse = "; ")
[15:32:25.366]                         if (!has_future) {
[15:32:25.366]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:25.366]                             info)
[15:32:25.366]                         }
[15:32:25.366]                         else {
[15:32:25.366]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:25.366]                             info, version)
[15:32:25.366]                         }
[15:32:25.366]                         base::stop(msg)
[15:32:25.366]                       }
[15:32:25.366]                     })
[15:32:25.366]                   }
[15:32:25.366]                   ...future.strategy.old <- future::plan("list")
[15:32:25.366]                   options(future.plan = NULL)
[15:32:25.366]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:25.366]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:25.366]                 }
[15:32:25.366]                 ...future.workdir <- getwd()
[15:32:25.366]             }
[15:32:25.366]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:25.366]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:25.366]         }
[15:32:25.366]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:25.366]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:25.366]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:25.366]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:25.366]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:25.366]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:25.366]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:25.366]             base::names(...future.oldOptions))
[15:32:25.366]     }
[15:32:25.366]     if (FALSE) {
[15:32:25.366]     }
[15:32:25.366]     else {
[15:32:25.366]         if (TRUE) {
[15:32:25.366]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:25.366]                 open = "w")
[15:32:25.366]         }
[15:32:25.366]         else {
[15:32:25.366]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:25.366]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:25.366]         }
[15:32:25.366]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:25.366]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:25.366]             base::sink(type = "output", split = FALSE)
[15:32:25.366]             base::close(...future.stdout)
[15:32:25.366]         }, add = TRUE)
[15:32:25.366]     }
[15:32:25.366]     ...future.frame <- base::sys.nframe()
[15:32:25.366]     ...future.conditions <- base::list()
[15:32:25.366]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:25.366]     if (FALSE) {
[15:32:25.366]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:25.366]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:25.366]     }
[15:32:25.366]     ...future.result <- base::tryCatch({
[15:32:25.366]         base::withCallingHandlers({
[15:32:25.366]             ...future.value <- base::withVisible(base::local({
[15:32:25.366]                 do.call(function(...) {
[15:32:25.366]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:25.366]                   if (!identical(...future.globals.maxSize.org, 
[15:32:25.366]                     ...future.globals.maxSize)) {
[15:32:25.366]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:25.366]                     on.exit(options(oopts), add = TRUE)
[15:32:25.366]                   }
[15:32:25.366]                   {
[15:32:25.366]                     lapply(seq_along(...future.elements_ii), 
[15:32:25.366]                       FUN = function(jj) {
[15:32:25.366]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:25.366]                         ...future.FUN(...future.X_jj, ...)
[15:32:25.366]                       })
[15:32:25.366]                   }
[15:32:25.366]                 }, args = future.call.arguments)
[15:32:25.366]             }))
[15:32:25.366]             future::FutureResult(value = ...future.value$value, 
[15:32:25.366]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:25.366]                   ...future.rng), globalenv = if (FALSE) 
[15:32:25.366]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:25.366]                     ...future.globalenv.names))
[15:32:25.366]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:25.366]         }, condition = base::local({
[15:32:25.366]             c <- base::c
[15:32:25.366]             inherits <- base::inherits
[15:32:25.366]             invokeRestart <- base::invokeRestart
[15:32:25.366]             length <- base::length
[15:32:25.366]             list <- base::list
[15:32:25.366]             seq.int <- base::seq.int
[15:32:25.366]             signalCondition <- base::signalCondition
[15:32:25.366]             sys.calls <- base::sys.calls
[15:32:25.366]             `[[` <- base::`[[`
[15:32:25.366]             `+` <- base::`+`
[15:32:25.366]             `<<-` <- base::`<<-`
[15:32:25.366]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:25.366]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:25.366]                   3L)]
[15:32:25.366]             }
[15:32:25.366]             function(cond) {
[15:32:25.366]                 is_error <- inherits(cond, "error")
[15:32:25.366]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:25.366]                   NULL)
[15:32:25.366]                 if (is_error) {
[15:32:25.366]                   sessionInformation <- function() {
[15:32:25.366]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:25.366]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:25.366]                       search = base::search(), system = base::Sys.info())
[15:32:25.366]                   }
[15:32:25.366]                   ...future.conditions[[length(...future.conditions) + 
[15:32:25.366]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:25.366]                     cond$call), session = sessionInformation(), 
[15:32:25.366]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:25.366]                   signalCondition(cond)
[15:32:25.366]                 }
[15:32:25.366]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:25.366]                 "immediateCondition"))) {
[15:32:25.366]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:25.366]                   ...future.conditions[[length(...future.conditions) + 
[15:32:25.366]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:25.366]                   if (TRUE && !signal) {
[15:32:25.366]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:25.366]                     {
[15:32:25.366]                       inherits <- base::inherits
[15:32:25.366]                       invokeRestart <- base::invokeRestart
[15:32:25.366]                       is.null <- base::is.null
[15:32:25.366]                       muffled <- FALSE
[15:32:25.366]                       if (inherits(cond, "message")) {
[15:32:25.366]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:25.366]                         if (muffled) 
[15:32:25.366]                           invokeRestart("muffleMessage")
[15:32:25.366]                       }
[15:32:25.366]                       else if (inherits(cond, "warning")) {
[15:32:25.366]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:25.366]                         if (muffled) 
[15:32:25.366]                           invokeRestart("muffleWarning")
[15:32:25.366]                       }
[15:32:25.366]                       else if (inherits(cond, "condition")) {
[15:32:25.366]                         if (!is.null(pattern)) {
[15:32:25.366]                           computeRestarts <- base::computeRestarts
[15:32:25.366]                           grepl <- base::grepl
[15:32:25.366]                           restarts <- computeRestarts(cond)
[15:32:25.366]                           for (restart in restarts) {
[15:32:25.366]                             name <- restart$name
[15:32:25.366]                             if (is.null(name)) 
[15:32:25.366]                               next
[15:32:25.366]                             if (!grepl(pattern, name)) 
[15:32:25.366]                               next
[15:32:25.366]                             invokeRestart(restart)
[15:32:25.366]                             muffled <- TRUE
[15:32:25.366]                             break
[15:32:25.366]                           }
[15:32:25.366]                         }
[15:32:25.366]                       }
[15:32:25.366]                       invisible(muffled)
[15:32:25.366]                     }
[15:32:25.366]                     muffleCondition(cond, pattern = "^muffle")
[15:32:25.366]                   }
[15:32:25.366]                 }
[15:32:25.366]                 else {
[15:32:25.366]                   if (TRUE) {
[15:32:25.366]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:25.366]                     {
[15:32:25.366]                       inherits <- base::inherits
[15:32:25.366]                       invokeRestart <- base::invokeRestart
[15:32:25.366]                       is.null <- base::is.null
[15:32:25.366]                       muffled <- FALSE
[15:32:25.366]                       if (inherits(cond, "message")) {
[15:32:25.366]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:25.366]                         if (muffled) 
[15:32:25.366]                           invokeRestart("muffleMessage")
[15:32:25.366]                       }
[15:32:25.366]                       else if (inherits(cond, "warning")) {
[15:32:25.366]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:25.366]                         if (muffled) 
[15:32:25.366]                           invokeRestart("muffleWarning")
[15:32:25.366]                       }
[15:32:25.366]                       else if (inherits(cond, "condition")) {
[15:32:25.366]                         if (!is.null(pattern)) {
[15:32:25.366]                           computeRestarts <- base::computeRestarts
[15:32:25.366]                           grepl <- base::grepl
[15:32:25.366]                           restarts <- computeRestarts(cond)
[15:32:25.366]                           for (restart in restarts) {
[15:32:25.366]                             name <- restart$name
[15:32:25.366]                             if (is.null(name)) 
[15:32:25.366]                               next
[15:32:25.366]                             if (!grepl(pattern, name)) 
[15:32:25.366]                               next
[15:32:25.366]                             invokeRestart(restart)
[15:32:25.366]                             muffled <- TRUE
[15:32:25.366]                             break
[15:32:25.366]                           }
[15:32:25.366]                         }
[15:32:25.366]                       }
[15:32:25.366]                       invisible(muffled)
[15:32:25.366]                     }
[15:32:25.366]                     muffleCondition(cond, pattern = "^muffle")
[15:32:25.366]                   }
[15:32:25.366]                 }
[15:32:25.366]             }
[15:32:25.366]         }))
[15:32:25.366]     }, error = function(ex) {
[15:32:25.366]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:25.366]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:25.366]                 ...future.rng), started = ...future.startTime, 
[15:32:25.366]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:25.366]             version = "1.8"), class = "FutureResult")
[15:32:25.366]     }, finally = {
[15:32:25.366]         if (!identical(...future.workdir, getwd())) 
[15:32:25.366]             setwd(...future.workdir)
[15:32:25.366]         {
[15:32:25.366]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:25.366]                 ...future.oldOptions$nwarnings <- NULL
[15:32:25.366]             }
[15:32:25.366]             base::options(...future.oldOptions)
[15:32:25.366]             if (.Platform$OS.type == "windows") {
[15:32:25.366]                 old_names <- names(...future.oldEnvVars)
[15:32:25.366]                 envs <- base::Sys.getenv()
[15:32:25.366]                 names <- names(envs)
[15:32:25.366]                 common <- intersect(names, old_names)
[15:32:25.366]                 added <- setdiff(names, old_names)
[15:32:25.366]                 removed <- setdiff(old_names, names)
[15:32:25.366]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:25.366]                   envs[common]]
[15:32:25.366]                 NAMES <- toupper(changed)
[15:32:25.366]                 args <- list()
[15:32:25.366]                 for (kk in seq_along(NAMES)) {
[15:32:25.366]                   name <- changed[[kk]]
[15:32:25.366]                   NAME <- NAMES[[kk]]
[15:32:25.366]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:25.366]                     next
[15:32:25.366]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:25.366]                 }
[15:32:25.366]                 NAMES <- toupper(added)
[15:32:25.366]                 for (kk in seq_along(NAMES)) {
[15:32:25.366]                   name <- added[[kk]]
[15:32:25.366]                   NAME <- NAMES[[kk]]
[15:32:25.366]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:25.366]                     next
[15:32:25.366]                   args[[name]] <- ""
[15:32:25.366]                 }
[15:32:25.366]                 NAMES <- toupper(removed)
[15:32:25.366]                 for (kk in seq_along(NAMES)) {
[15:32:25.366]                   name <- removed[[kk]]
[15:32:25.366]                   NAME <- NAMES[[kk]]
[15:32:25.366]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:25.366]                     next
[15:32:25.366]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:25.366]                 }
[15:32:25.366]                 if (length(args) > 0) 
[15:32:25.366]                   base::do.call(base::Sys.setenv, args = args)
[15:32:25.366]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:25.366]             }
[15:32:25.366]             else {
[15:32:25.366]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:25.366]             }
[15:32:25.366]             {
[15:32:25.366]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:25.366]                   0L) {
[15:32:25.366]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:25.366]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:25.366]                   base::options(opts)
[15:32:25.366]                 }
[15:32:25.366]                 {
[15:32:25.366]                   {
[15:32:25.366]                     NULL
[15:32:25.366]                     RNGkind("Mersenne-Twister")
[15:32:25.366]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:25.366]                       inherits = FALSE)
[15:32:25.366]                   }
[15:32:25.366]                   options(future.plan = NULL)
[15:32:25.366]                   if (is.na(NA_character_)) 
[15:32:25.366]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:25.366]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:25.366]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:25.366]                     .init = FALSE)
[15:32:25.366]                 }
[15:32:25.366]             }
[15:32:25.366]         }
[15:32:25.366]     })
[15:32:25.366]     if (TRUE) {
[15:32:25.366]         base::sink(type = "output", split = FALSE)
[15:32:25.366]         if (TRUE) {
[15:32:25.366]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:25.366]         }
[15:32:25.366]         else {
[15:32:25.366]             ...future.result["stdout"] <- base::list(NULL)
[15:32:25.366]         }
[15:32:25.366]         base::close(...future.stdout)
[15:32:25.366]         ...future.stdout <- NULL
[15:32:25.366]     }
[15:32:25.366]     ...future.result$conditions <- ...future.conditions
[15:32:25.366]     ...future.result$finished <- base::Sys.time()
[15:32:25.366]     ...future.result
[15:32:25.366] }
[15:32:25.371] assign_globals() ...
[15:32:25.371] List of 5
[15:32:25.371]  $ ...future.FUN            :function (x)  
[15:32:25.371]  $ future.call.arguments    : list()
[15:32:25.371]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:25.371]  $ ...future.elements_ii    :List of 4
[15:32:25.371]   ..$ A: num 50
[15:32:25.371]   ..$ B: num 60
[15:32:25.371]   ..$ C: num 70
[15:32:25.371]   ..$ D: num 80
[15:32:25.371]  $ ...future.seeds_ii       : NULL
[15:32:25.371]  $ ...future.globals.maxSize: NULL
[15:32:25.371]  - attr(*, "where")=List of 5
[15:32:25.371]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:25.371]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:25.371]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:25.371]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:25.371]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:25.371]  - attr(*, "resolved")= logi FALSE
[15:32:25.371]  - attr(*, "total_size")= num 848
[15:32:25.371]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:25.371]  - attr(*, "already-done")= logi TRUE
[15:32:25.389] - copied '...future.FUN' to environment
[15:32:25.389] - copied 'future.call.arguments' to environment
[15:32:25.389] - copied '...future.elements_ii' to environment
[15:32:25.389] - copied '...future.seeds_ii' to environment
[15:32:25.390] - copied '...future.globals.maxSize' to environment
[15:32:25.390] assign_globals() ... done
[15:32:25.391] plan(): Setting new future strategy stack:
[15:32:25.391] List of future strategies:
[15:32:25.391] 1. sequential:
[15:32:25.391]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:25.391]    - tweaked: FALSE
[15:32:25.391]    - call: NULL
[15:32:25.392] plan(): nbrOfWorkers() = 1
[15:32:25.395] plan(): Setting new future strategy stack:
[15:32:25.395] List of future strategies:
[15:32:25.395] 1. sequential:
[15:32:25.395]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:25.395]    - tweaked: FALSE
[15:32:25.395]    - call: plan(strategy)
[15:32:25.396] plan(): nbrOfWorkers() = 1
[15:32:25.396] SequentialFuture started (and completed)
[15:32:25.397] - Launch lazy future ... done
[15:32:25.397] run() for 'SequentialFuture' ... done
[15:32:25.397] Created future:
[15:32:25.398] SequentialFuture:
[15:32:25.398] Label: 'future_sapply-1'
[15:32:25.398] Expression:
[15:32:25.398] {
[15:32:25.398]     do.call(function(...) {
[15:32:25.398]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:25.398]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:25.398]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:25.398]             on.exit(options(oopts), add = TRUE)
[15:32:25.398]         }
[15:32:25.398]         {
[15:32:25.398]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:25.398]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:25.398]                 ...future.FUN(...future.X_jj, ...)
[15:32:25.398]             })
[15:32:25.398]         }
[15:32:25.398]     }, args = future.call.arguments)
[15:32:25.398] }
[15:32:25.398] Lazy evaluation: FALSE
[15:32:25.398] Asynchronous evaluation: FALSE
[15:32:25.398] Local evaluation: TRUE
[15:32:25.398] Environment: R_GlobalEnv
[15:32:25.398] Capture standard output: TRUE
[15:32:25.398] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:25.398] Globals: 5 objects totaling 1.05 KiB (function '...future.FUN' of 848 bytes, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 224 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:25.398] Packages: <none>
[15:32:25.398] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:25.398] Resolved: TRUE
[15:32:25.398] Value: 224 bytes of class 'list'
[15:32:25.398] Early signaling: FALSE
[15:32:25.398] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:25.398] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:25.400] Chunk #1 of 1 ... DONE
[15:32:25.400] Launching 1 futures (chunks) ... DONE
[15:32:25.401] Resolving 1 futures (chunks) ...
[15:32:25.401] resolve() on list ...
[15:32:25.401]  recursive: 0
[15:32:25.402]  length: 1
[15:32:25.402] 
[15:32:25.402] resolved() for 'SequentialFuture' ...
[15:32:25.402] - state: 'finished'
[15:32:25.403] - run: TRUE
[15:32:25.403] - result: 'FutureResult'
[15:32:25.403] resolved() for 'SequentialFuture' ... done
[15:32:25.404] Future #1
[15:32:25.404] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:25.404] - nx: 1
[15:32:25.405] - relay: TRUE
[15:32:25.405] - stdout: TRUE
[15:32:25.405] - signal: TRUE
[15:32:25.405] - resignal: FALSE
[15:32:25.406] - force: TRUE
[15:32:25.406] - relayed: [n=1] FALSE
[15:32:25.406] - queued futures: [n=1] FALSE
[15:32:25.407]  - until=1
[15:32:25.407]  - relaying element #1
[15:32:25.407] - relayed: [n=1] TRUE
[15:32:25.408] - queued futures: [n=1] TRUE
[15:32:25.408] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:25.408]  length: 0 (resolved future 1)
[15:32:25.408] Relaying remaining futures
[15:32:25.409] signalConditionsASAP(NULL, pos=0) ...
[15:32:25.409] - nx: 1
[15:32:25.409] - relay: TRUE
[15:32:25.409] - stdout: TRUE
[15:32:25.410] - signal: TRUE
[15:32:25.410] - resignal: FALSE
[15:32:25.410] - force: TRUE
[15:32:25.411] - relayed: [n=1] TRUE
[15:32:25.411] - queued futures: [n=1] TRUE
 - flush all
[15:32:25.411] - relayed: [n=1] TRUE
[15:32:25.412] - queued futures: [n=1] TRUE
[15:32:25.412] signalConditionsASAP(NULL, pos=0) ... done
[15:32:25.412] resolve() on list ... DONE
[15:32:25.413]  - Number of value chunks collected: 1
[15:32:25.413] Resolving 1 futures (chunks) ... DONE
[15:32:25.413] Reducing values from 1 chunks ...
[15:32:25.413]  - Number of values collected after concatenation: 4
[15:32:25.414]  - Number of values expected: 4
[15:32:25.414] Reducing values from 1 chunks ... DONE
[15:32:25.414] future_lapply() ... DONE
List of 2
 $ y0: Named num [1:4] 50 60 70 80
  ..- attr(*, "names")= chr [1:4] "A" "B" "C" "D"
 $ y1: Named num [1:4] 50 60 70 80
  ..- attr(*, "names")= chr [1:4] "A" "B" "C" "D"
[15:32:25.418] future_lapply() ...
[15:32:25.419] Number of chunks: 1
[15:32:25.419] getGlobalsAndPackagesXApply() ...
[15:32:25.420]  - future.globals: TRUE
[15:32:25.420] getGlobalsAndPackages() ...
[15:32:25.420] Searching for globals...
[15:32:25.422] - globals found: [2] 'FUN', 'UseMethod'
[15:32:25.423] Searching for globals ... DONE
[15:32:25.423] Resolving globals: FALSE
[15:32:25.424] The total size of the 1 globals is 1.22 KiB (1248 bytes)
[15:32:25.425] The total size of the 1 globals exported for future expression ('FUN()') is 1.22 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.22 KiB of class 'function')
[15:32:25.425] - globals: [1] 'FUN'
[15:32:25.425] 
[15:32:25.426] getGlobalsAndPackages() ... DONE
[15:32:25.426]  - globals found/used: [n=1] 'FUN'
[15:32:25.426]  - needed namespaces: [n=0] 
[15:32:25.426] Finding globals ... DONE
[15:32:25.427]  - use_args: TRUE
[15:32:25.427]  - Getting '...' globals ...
[15:32:25.428] resolve() on list ...
[15:32:25.428]  recursive: 0
[15:32:25.428]  length: 1
[15:32:25.428]  elements: '...'
[15:32:25.429]  length: 0 (resolved future 1)
[15:32:25.429] resolve() on list ... DONE
[15:32:25.429]    - '...' content: [n=0] 
[15:32:25.430] List of 1
[15:32:25.430]  $ ...: list()
[15:32:25.430]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:25.430]  - attr(*, "where")=List of 1
[15:32:25.430]   ..$ ...:<environment: 0x00000276e1c9c068> 
[15:32:25.430]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:25.430]  - attr(*, "resolved")= logi TRUE
[15:32:25.430]  - attr(*, "total_size")= num NA
[15:32:25.435]  - Getting '...' globals ... DONE
[15:32:25.435] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:25.436] List of 2
[15:32:25.436]  $ ...future.FUN:function (x, ...)  
[15:32:25.436]  $ ...          : list()
[15:32:25.436]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:25.436]  - attr(*, "where")=List of 2
[15:32:25.436]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:25.436]   ..$ ...          :<environment: 0x00000276e1c9c068> 
[15:32:25.436]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:25.436]  - attr(*, "resolved")= logi FALSE
[15:32:25.436]  - attr(*, "total_size")= num 1248
[15:32:25.441] Packages to be attached in all futures: [n=0] 
[15:32:25.442] getGlobalsAndPackagesXApply() ... DONE
[15:32:25.442] Number of futures (= number of chunks): 1
[15:32:25.442] Launching 1 futures (chunks) ...
[15:32:25.443] Chunk #1 of 1 ...
[15:32:25.443]  - Finding globals in 'X' for chunk #1 ...
[15:32:25.443] getGlobalsAndPackages() ...
[15:32:25.444] Searching for globals...
[15:32:25.444] 
[15:32:25.444] Searching for globals ... DONE
[15:32:25.445] - globals: [0] <none>
[15:32:25.445] getGlobalsAndPackages() ... DONE
[15:32:25.445]    + additional globals found: [n=0] 
[15:32:25.446]    + additional namespaces needed: [n=0] 
[15:32:25.446]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:25.446]  - seeds: <none>
[15:32:25.446]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:25.447] getGlobalsAndPackages() ...
[15:32:25.447] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:25.448] Resolving globals: FALSE
[15:32:25.448] Tweak future expression to call with '...' arguments ...
[15:32:25.448] {
[15:32:25.448]     do.call(function(...) {
[15:32:25.448]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:25.448]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:25.448]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:25.448]             on.exit(options(oopts), add = TRUE)
[15:32:25.448]         }
[15:32:25.448]         {
[15:32:25.448]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:25.448]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:25.448]                 ...future.FUN(...future.X_jj, ...)
[15:32:25.448]             })
[15:32:25.448]         }
[15:32:25.448]     }, args = future.call.arguments)
[15:32:25.448] }
[15:32:25.449] Tweak future expression to call with '...' arguments ... DONE
[15:32:25.450] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:25.450] 
[15:32:25.451] getGlobalsAndPackages() ... DONE
[15:32:25.451] run() for 'Future' ...
[15:32:25.452] - state: 'created'
[15:32:25.452] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:25.453] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:25.453] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:25.454]   - Field: 'label'
[15:32:25.454]   - Field: 'local'
[15:32:25.454]   - Field: 'owner'
[15:32:25.455]   - Field: 'envir'
[15:32:25.455]   - Field: 'packages'
[15:32:25.455]   - Field: 'gc'
[15:32:25.456]   - Field: 'conditions'
[15:32:25.456]   - Field: 'expr'
[15:32:25.456]   - Field: 'uuid'
[15:32:25.457]   - Field: 'seed'
[15:32:25.457]   - Field: 'version'
[15:32:25.457]   - Field: 'result'
[15:32:25.458]   - Field: 'asynchronous'
[15:32:25.458]   - Field: 'calls'
[15:32:25.458]   - Field: 'globals'
[15:32:25.459]   - Field: 'stdout'
[15:32:25.459]   - Field: 'earlySignal'
[15:32:25.459]   - Field: 'lazy'
[15:32:25.459]   - Field: 'state'
[15:32:25.460] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:25.460] - Launch lazy future ...
[15:32:25.461] Packages needed by the future expression (n = 0): <none>
[15:32:25.461] Packages needed by future strategies (n = 0): <none>
[15:32:25.462] {
[15:32:25.462]     {
[15:32:25.462]         {
[15:32:25.462]             ...future.startTime <- base::Sys.time()
[15:32:25.462]             {
[15:32:25.462]                 {
[15:32:25.462]                   {
[15:32:25.462]                     base::local({
[15:32:25.462]                       has_future <- base::requireNamespace("future", 
[15:32:25.462]                         quietly = TRUE)
[15:32:25.462]                       if (has_future) {
[15:32:25.462]                         ns <- base::getNamespace("future")
[15:32:25.462]                         version <- ns[[".package"]][["version"]]
[15:32:25.462]                         if (is.null(version)) 
[15:32:25.462]                           version <- utils::packageVersion("future")
[15:32:25.462]                       }
[15:32:25.462]                       else {
[15:32:25.462]                         version <- NULL
[15:32:25.462]                       }
[15:32:25.462]                       if (!has_future || version < "1.8.0") {
[15:32:25.462]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:25.462]                           "", base::R.version$version.string), 
[15:32:25.462]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:25.462]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:25.462]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:25.462]                             "release", "version")], collapse = " "), 
[15:32:25.462]                           hostname = base::Sys.info()[["nodename"]])
[15:32:25.462]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:25.462]                           info)
[15:32:25.462]                         info <- base::paste(info, collapse = "; ")
[15:32:25.462]                         if (!has_future) {
[15:32:25.462]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:25.462]                             info)
[15:32:25.462]                         }
[15:32:25.462]                         else {
[15:32:25.462]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:25.462]                             info, version)
[15:32:25.462]                         }
[15:32:25.462]                         base::stop(msg)
[15:32:25.462]                       }
[15:32:25.462]                     })
[15:32:25.462]                   }
[15:32:25.462]                   ...future.strategy.old <- future::plan("list")
[15:32:25.462]                   options(future.plan = NULL)
[15:32:25.462]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:25.462]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:25.462]                 }
[15:32:25.462]                 ...future.workdir <- getwd()
[15:32:25.462]             }
[15:32:25.462]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:25.462]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:25.462]         }
[15:32:25.462]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:25.462]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:25.462]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:25.462]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:25.462]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:25.462]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:25.462]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:25.462]             base::names(...future.oldOptions))
[15:32:25.462]     }
[15:32:25.462]     if (FALSE) {
[15:32:25.462]     }
[15:32:25.462]     else {
[15:32:25.462]         if (TRUE) {
[15:32:25.462]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:25.462]                 open = "w")
[15:32:25.462]         }
[15:32:25.462]         else {
[15:32:25.462]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:25.462]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:25.462]         }
[15:32:25.462]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:25.462]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:25.462]             base::sink(type = "output", split = FALSE)
[15:32:25.462]             base::close(...future.stdout)
[15:32:25.462]         }, add = TRUE)
[15:32:25.462]     }
[15:32:25.462]     ...future.frame <- base::sys.nframe()
[15:32:25.462]     ...future.conditions <- base::list()
[15:32:25.462]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:25.462]     if (FALSE) {
[15:32:25.462]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:25.462]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:25.462]     }
[15:32:25.462]     ...future.result <- base::tryCatch({
[15:32:25.462]         base::withCallingHandlers({
[15:32:25.462]             ...future.value <- base::withVisible(base::local({
[15:32:25.462]                 do.call(function(...) {
[15:32:25.462]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:25.462]                   if (!identical(...future.globals.maxSize.org, 
[15:32:25.462]                     ...future.globals.maxSize)) {
[15:32:25.462]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:25.462]                     on.exit(options(oopts), add = TRUE)
[15:32:25.462]                   }
[15:32:25.462]                   {
[15:32:25.462]                     lapply(seq_along(...future.elements_ii), 
[15:32:25.462]                       FUN = function(jj) {
[15:32:25.462]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:25.462]                         ...future.FUN(...future.X_jj, ...)
[15:32:25.462]                       })
[15:32:25.462]                   }
[15:32:25.462]                 }, args = future.call.arguments)
[15:32:25.462]             }))
[15:32:25.462]             future::FutureResult(value = ...future.value$value, 
[15:32:25.462]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:25.462]                   ...future.rng), globalenv = if (FALSE) 
[15:32:25.462]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:25.462]                     ...future.globalenv.names))
[15:32:25.462]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:25.462]         }, condition = base::local({
[15:32:25.462]             c <- base::c
[15:32:25.462]             inherits <- base::inherits
[15:32:25.462]             invokeRestart <- base::invokeRestart
[15:32:25.462]             length <- base::length
[15:32:25.462]             list <- base::list
[15:32:25.462]             seq.int <- base::seq.int
[15:32:25.462]             signalCondition <- base::signalCondition
[15:32:25.462]             sys.calls <- base::sys.calls
[15:32:25.462]             `[[` <- base::`[[`
[15:32:25.462]             `+` <- base::`+`
[15:32:25.462]             `<<-` <- base::`<<-`
[15:32:25.462]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:25.462]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:25.462]                   3L)]
[15:32:25.462]             }
[15:32:25.462]             function(cond) {
[15:32:25.462]                 is_error <- inherits(cond, "error")
[15:32:25.462]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:25.462]                   NULL)
[15:32:25.462]                 if (is_error) {
[15:32:25.462]                   sessionInformation <- function() {
[15:32:25.462]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:25.462]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:25.462]                       search = base::search(), system = base::Sys.info())
[15:32:25.462]                   }
[15:32:25.462]                   ...future.conditions[[length(...future.conditions) + 
[15:32:25.462]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:25.462]                     cond$call), session = sessionInformation(), 
[15:32:25.462]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:25.462]                   signalCondition(cond)
[15:32:25.462]                 }
[15:32:25.462]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:25.462]                 "immediateCondition"))) {
[15:32:25.462]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:25.462]                   ...future.conditions[[length(...future.conditions) + 
[15:32:25.462]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:25.462]                   if (TRUE && !signal) {
[15:32:25.462]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:25.462]                     {
[15:32:25.462]                       inherits <- base::inherits
[15:32:25.462]                       invokeRestart <- base::invokeRestart
[15:32:25.462]                       is.null <- base::is.null
[15:32:25.462]                       muffled <- FALSE
[15:32:25.462]                       if (inherits(cond, "message")) {
[15:32:25.462]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:25.462]                         if (muffled) 
[15:32:25.462]                           invokeRestart("muffleMessage")
[15:32:25.462]                       }
[15:32:25.462]                       else if (inherits(cond, "warning")) {
[15:32:25.462]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:25.462]                         if (muffled) 
[15:32:25.462]                           invokeRestart("muffleWarning")
[15:32:25.462]                       }
[15:32:25.462]                       else if (inherits(cond, "condition")) {
[15:32:25.462]                         if (!is.null(pattern)) {
[15:32:25.462]                           computeRestarts <- base::computeRestarts
[15:32:25.462]                           grepl <- base::grepl
[15:32:25.462]                           restarts <- computeRestarts(cond)
[15:32:25.462]                           for (restart in restarts) {
[15:32:25.462]                             name <- restart$name
[15:32:25.462]                             if (is.null(name)) 
[15:32:25.462]                               next
[15:32:25.462]                             if (!grepl(pattern, name)) 
[15:32:25.462]                               next
[15:32:25.462]                             invokeRestart(restart)
[15:32:25.462]                             muffled <- TRUE
[15:32:25.462]                             break
[15:32:25.462]                           }
[15:32:25.462]                         }
[15:32:25.462]                       }
[15:32:25.462]                       invisible(muffled)
[15:32:25.462]                     }
[15:32:25.462]                     muffleCondition(cond, pattern = "^muffle")
[15:32:25.462]                   }
[15:32:25.462]                 }
[15:32:25.462]                 else {
[15:32:25.462]                   if (TRUE) {
[15:32:25.462]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:25.462]                     {
[15:32:25.462]                       inherits <- base::inherits
[15:32:25.462]                       invokeRestart <- base::invokeRestart
[15:32:25.462]                       is.null <- base::is.null
[15:32:25.462]                       muffled <- FALSE
[15:32:25.462]                       if (inherits(cond, "message")) {
[15:32:25.462]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:25.462]                         if (muffled) 
[15:32:25.462]                           invokeRestart("muffleMessage")
[15:32:25.462]                       }
[15:32:25.462]                       else if (inherits(cond, "warning")) {
[15:32:25.462]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:25.462]                         if (muffled) 
[15:32:25.462]                           invokeRestart("muffleWarning")
[15:32:25.462]                       }
[15:32:25.462]                       else if (inherits(cond, "condition")) {
[15:32:25.462]                         if (!is.null(pattern)) {
[15:32:25.462]                           computeRestarts <- base::computeRestarts
[15:32:25.462]                           grepl <- base::grepl
[15:32:25.462]                           restarts <- computeRestarts(cond)
[15:32:25.462]                           for (restart in restarts) {
[15:32:25.462]                             name <- restart$name
[15:32:25.462]                             if (is.null(name)) 
[15:32:25.462]                               next
[15:32:25.462]                             if (!grepl(pattern, name)) 
[15:32:25.462]                               next
[15:32:25.462]                             invokeRestart(restart)
[15:32:25.462]                             muffled <- TRUE
[15:32:25.462]                             break
[15:32:25.462]                           }
[15:32:25.462]                         }
[15:32:25.462]                       }
[15:32:25.462]                       invisible(muffled)
[15:32:25.462]                     }
[15:32:25.462]                     muffleCondition(cond, pattern = "^muffle")
[15:32:25.462]                   }
[15:32:25.462]                 }
[15:32:25.462]             }
[15:32:25.462]         }))
[15:32:25.462]     }, error = function(ex) {
[15:32:25.462]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:25.462]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:25.462]                 ...future.rng), started = ...future.startTime, 
[15:32:25.462]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:25.462]             version = "1.8"), class = "FutureResult")
[15:32:25.462]     }, finally = {
[15:32:25.462]         if (!identical(...future.workdir, getwd())) 
[15:32:25.462]             setwd(...future.workdir)
[15:32:25.462]         {
[15:32:25.462]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:25.462]                 ...future.oldOptions$nwarnings <- NULL
[15:32:25.462]             }
[15:32:25.462]             base::options(...future.oldOptions)
[15:32:25.462]             if (.Platform$OS.type == "windows") {
[15:32:25.462]                 old_names <- names(...future.oldEnvVars)
[15:32:25.462]                 envs <- base::Sys.getenv()
[15:32:25.462]                 names <- names(envs)
[15:32:25.462]                 common <- intersect(names, old_names)
[15:32:25.462]                 added <- setdiff(names, old_names)
[15:32:25.462]                 removed <- setdiff(old_names, names)
[15:32:25.462]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:25.462]                   envs[common]]
[15:32:25.462]                 NAMES <- toupper(changed)
[15:32:25.462]                 args <- list()
[15:32:25.462]                 for (kk in seq_along(NAMES)) {
[15:32:25.462]                   name <- changed[[kk]]
[15:32:25.462]                   NAME <- NAMES[[kk]]
[15:32:25.462]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:25.462]                     next
[15:32:25.462]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:25.462]                 }
[15:32:25.462]                 NAMES <- toupper(added)
[15:32:25.462]                 for (kk in seq_along(NAMES)) {
[15:32:25.462]                   name <- added[[kk]]
[15:32:25.462]                   NAME <- NAMES[[kk]]
[15:32:25.462]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:25.462]                     next
[15:32:25.462]                   args[[name]] <- ""
[15:32:25.462]                 }
[15:32:25.462]                 NAMES <- toupper(removed)
[15:32:25.462]                 for (kk in seq_along(NAMES)) {
[15:32:25.462]                   name <- removed[[kk]]
[15:32:25.462]                   NAME <- NAMES[[kk]]
[15:32:25.462]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:25.462]                     next
[15:32:25.462]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:25.462]                 }
[15:32:25.462]                 if (length(args) > 0) 
[15:32:25.462]                   base::do.call(base::Sys.setenv, args = args)
[15:32:25.462]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:25.462]             }
[15:32:25.462]             else {
[15:32:25.462]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:25.462]             }
[15:32:25.462]             {
[15:32:25.462]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:25.462]                   0L) {
[15:32:25.462]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:25.462]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:25.462]                   base::options(opts)
[15:32:25.462]                 }
[15:32:25.462]                 {
[15:32:25.462]                   {
[15:32:25.462]                     NULL
[15:32:25.462]                     RNGkind("Mersenne-Twister")
[15:32:25.462]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:25.462]                       inherits = FALSE)
[15:32:25.462]                   }
[15:32:25.462]                   options(future.plan = NULL)
[15:32:25.462]                   if (is.na(NA_character_)) 
[15:32:25.462]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:25.462]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:25.462]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:25.462]                     .init = FALSE)
[15:32:25.462]                 }
[15:32:25.462]             }
[15:32:25.462]         }
[15:32:25.462]     })
[15:32:25.462]     if (TRUE) {
[15:32:25.462]         base::sink(type = "output", split = FALSE)
[15:32:25.462]         if (TRUE) {
[15:32:25.462]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:25.462]         }
[15:32:25.462]         else {
[15:32:25.462]             ...future.result["stdout"] <- base::list(NULL)
[15:32:25.462]         }
[15:32:25.462]         base::close(...future.stdout)
[15:32:25.462]         ...future.stdout <- NULL
[15:32:25.462]     }
[15:32:25.462]     ...future.result$conditions <- ...future.conditions
[15:32:25.462]     ...future.result$finished <- base::Sys.time()
[15:32:25.462]     ...future.result
[15:32:25.462] }
[15:32:25.470] assign_globals() ...
[15:32:25.470] List of 5
[15:32:25.470]  $ ...future.FUN            :function (x, ...)  
[15:32:25.470]  $ future.call.arguments    : list()
[15:32:25.470]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:25.470]  $ ...future.elements_ii    :List of 4
[15:32:25.470]   ..$ A: num 50
[15:32:25.470]   ..$ B: num 60
[15:32:25.470]   ..$ C: num 70
[15:32:25.470]   ..$ D: num 80
[15:32:25.470]  $ ...future.seeds_ii       : NULL
[15:32:25.470]  $ ...future.globals.maxSize: NULL
[15:32:25.470]  - attr(*, "where")=List of 5
[15:32:25.470]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:25.470]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:25.470]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:25.470]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:25.470]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:25.470]  - attr(*, "resolved")= logi FALSE
[15:32:25.470]  - attr(*, "total_size")= num 1248
[15:32:25.470]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:25.470]  - attr(*, "already-done")= logi TRUE
[15:32:25.484] - copied '...future.FUN' to environment
[15:32:25.484] - copied 'future.call.arguments' to environment
[15:32:25.484] - copied '...future.elements_ii' to environment
[15:32:25.485] - copied '...future.seeds_ii' to environment
[15:32:25.485] - copied '...future.globals.maxSize' to environment
[15:32:25.485] assign_globals() ... done
[15:32:25.486] plan(): Setting new future strategy stack:
[15:32:25.486] List of future strategies:
[15:32:25.486] 1. sequential:
[15:32:25.486]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:25.486]    - tweaked: FALSE
[15:32:25.486]    - call: NULL
[15:32:25.488] plan(): nbrOfWorkers() = 1
[15:32:25.490] plan(): Setting new future strategy stack:
[15:32:25.490] List of future strategies:
[15:32:25.490] 1. sequential:
[15:32:25.490]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:25.490]    - tweaked: FALSE
[15:32:25.490]    - call: plan(strategy)
[15:32:25.491] plan(): nbrOfWorkers() = 1
[15:32:25.492] SequentialFuture started (and completed)
[15:32:25.492] - Launch lazy future ... done
[15:32:25.493] run() for 'SequentialFuture' ... done
[15:32:25.493] Created future:
[15:32:25.493] SequentialFuture:
[15:32:25.493] Label: 'future_sapply-1'
[15:32:25.493] Expression:
[15:32:25.493] {
[15:32:25.493]     do.call(function(...) {
[15:32:25.493]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:25.493]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:25.493]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:25.493]             on.exit(options(oopts), add = TRUE)
[15:32:25.493]         }
[15:32:25.493]         {
[15:32:25.493]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:25.493]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:25.493]                 ...future.FUN(...future.X_jj, ...)
[15:32:25.493]             })
[15:32:25.493]         }
[15:32:25.493]     }, args = future.call.arguments)
[15:32:25.493] }
[15:32:25.493] Lazy evaluation: FALSE
[15:32:25.493] Asynchronous evaluation: FALSE
[15:32:25.493] Local evaluation: TRUE
[15:32:25.493] Environment: R_GlobalEnv
[15:32:25.493] Capture standard output: TRUE
[15:32:25.493] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:25.493] Globals: 5 objects totaling 1.44 KiB (function '...future.FUN' of 1.22 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 224 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:25.493] Packages: <none>
[15:32:25.493] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:25.493] Resolved: TRUE
[15:32:25.493] Value: 896 bytes of class 'list'
[15:32:25.493] Early signaling: FALSE
[15:32:25.493] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:25.493] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:25.496] Chunk #1 of 1 ... DONE
[15:32:25.497] Launching 1 futures (chunks) ... DONE
[15:32:25.497] Resolving 1 futures (chunks) ...
[15:32:25.497] resolve() on list ...
[15:32:25.498]  recursive: 0
[15:32:25.498]  length: 1
[15:32:25.498] 
[15:32:25.498] resolved() for 'SequentialFuture' ...
[15:32:25.499] - state: 'finished'
[15:32:25.499] - run: TRUE
[15:32:25.499] - result: 'FutureResult'
[15:32:25.500] resolved() for 'SequentialFuture' ... done
[15:32:25.500] Future #1
[15:32:25.500] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:25.501] - nx: 1
[15:32:25.501] - relay: TRUE
[15:32:25.501] - stdout: TRUE
[15:32:25.501] - signal: TRUE
[15:32:25.502] - resignal: FALSE
[15:32:25.502] - force: TRUE
[15:32:25.502] - relayed: [n=1] FALSE
[15:32:25.502] - queued futures: [n=1] FALSE
[15:32:25.503]  - until=1
[15:32:25.503]  - relaying element #1
[15:32:25.503] - relayed: [n=1] TRUE
[15:32:25.503] - queued futures: [n=1] TRUE
[15:32:25.504] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:25.504]  length: 0 (resolved future 1)
[15:32:25.504] Relaying remaining futures
[15:32:25.504] signalConditionsASAP(NULL, pos=0) ...
[15:32:25.505] - nx: 1
[15:32:25.505] - relay: TRUE
[15:32:25.505] - stdout: TRUE
[15:32:25.505] - signal: TRUE
[15:32:25.505] - resignal: FALSE
[15:32:25.506] - force: TRUE
[15:32:25.506] - relayed: [n=1] TRUE
[15:32:25.506] - queued futures: [n=1] TRUE
 - flush all
[15:32:25.507] - relayed: [n=1] TRUE
[15:32:25.507] - queued futures: [n=1] TRUE
[15:32:25.507] signalConditionsASAP(NULL, pos=0) ... done
[15:32:25.507] resolve() on list ... DONE
[15:32:25.508]  - Number of value chunks collected: 1
[15:32:25.508] Resolving 1 futures (chunks) ... DONE
[15:32:25.508] Reducing values from 1 chunks ...
[15:32:25.508]  - Number of values collected after concatenation: 4
[15:32:25.508]  - Number of values expected: 4
[15:32:25.509] Reducing values from 1 chunks ... DONE
[15:32:25.509] future_lapply() ... DONE
List of 2
 $ y0: Named num [1:4] 50 60 70 80
  ..- attr(*, "names")= chr [1:4] "A" "B" "C" "D"
 $ y1: Named num [1:4] 50 60 70 80
  ..- attr(*, "names")= chr [1:4] "A" "B" "C" "D"
[15:32:25.512] future_lapply() ...
[15:32:25.514] Number of chunks: 1
[15:32:25.514] getGlobalsAndPackagesXApply() ...
[15:32:25.514]  - future.globals: TRUE
[15:32:25.515] getGlobalsAndPackages() ...
[15:32:25.515] Searching for globals...
[15:32:25.518] - globals found: [5] 'FUN', '*', ':', 'outer', 'rep'
[15:32:25.518] Searching for globals ... DONE
[15:32:25.518] Resolving globals: FALSE
[15:32:25.519] The total size of the 1 globals is 4.62 KiB (4728 bytes)
[15:32:25.520] The total size of the 1 globals exported for future expression ('FUN()') is 4.62 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.62 KiB of class 'function')
[15:32:25.520] - globals: [1] 'FUN'
[15:32:25.520] 
[15:32:25.520] getGlobalsAndPackages() ... DONE
[15:32:25.521]  - globals found/used: [n=1] 'FUN'
[15:32:25.521]  - needed namespaces: [n=0] 
[15:32:25.521] Finding globals ... DONE
[15:32:25.521]  - use_args: TRUE
[15:32:25.522]  - Getting '...' globals ...
[15:32:25.522] resolve() on list ...
[15:32:25.522]  recursive: 0
[15:32:25.523]  length: 1
[15:32:25.523]  elements: '...'
[15:32:25.523]  length: 0 (resolved future 1)
[15:32:25.524] resolve() on list ... DONE
[15:32:25.524]    - '...' content: [n=0] 
[15:32:25.524] List of 1
[15:32:25.524]  $ ...: list()
[15:32:25.524]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:25.524]  - attr(*, "where")=List of 1
[15:32:25.524]   ..$ ...:<environment: 0x00000276e4f1dae0> 
[15:32:25.524]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:25.524]  - attr(*, "resolved")= logi TRUE
[15:32:25.524]  - attr(*, "total_size")= num NA
[15:32:25.528]  - Getting '...' globals ... DONE
[15:32:25.529] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:25.529] List of 2
[15:32:25.529]  $ ...future.FUN:function (x, y = 2 * 1:5)  
[15:32:25.529]  $ ...          : list()
[15:32:25.529]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:25.529]  - attr(*, "where")=List of 2
[15:32:25.529]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:25.529]   ..$ ...          :<environment: 0x00000276e4f1dae0> 
[15:32:25.529]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:25.529]  - attr(*, "resolved")= logi FALSE
[15:32:25.529]  - attr(*, "total_size")= num 4728
[15:32:25.534] Packages to be attached in all futures: [n=0] 
[15:32:25.534] getGlobalsAndPackagesXApply() ... DONE
[15:32:25.534] Number of futures (= number of chunks): 1
[15:32:25.535] Launching 1 futures (chunks) ...
[15:32:25.535] Chunk #1 of 1 ...
[15:32:25.535]  - Finding globals in 'X' for chunk #1 ...
[15:32:25.536] getGlobalsAndPackages() ...
[15:32:25.536] Searching for globals...
[15:32:25.536] 
[15:32:25.537] Searching for globals ... DONE
[15:32:25.537] - globals: [0] <none>
[15:32:25.537] getGlobalsAndPackages() ... DONE
[15:32:25.537]    + additional globals found: [n=0] 
[15:32:25.538]    + additional namespaces needed: [n=0] 
[15:32:25.538]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:25.538]  - seeds: <none>
[15:32:25.538]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:25.539] getGlobalsAndPackages() ...
[15:32:25.539] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:25.539] Resolving globals: FALSE
[15:32:25.539] Tweak future expression to call with '...' arguments ...
[15:32:25.540] {
[15:32:25.540]     do.call(function(...) {
[15:32:25.540]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:25.540]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:25.540]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:25.540]             on.exit(options(oopts), add = TRUE)
[15:32:25.540]         }
[15:32:25.540]         {
[15:32:25.540]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:25.540]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:25.540]                 ...future.FUN(...future.X_jj, ...)
[15:32:25.540]             })
[15:32:25.540]         }
[15:32:25.540]     }, args = future.call.arguments)
[15:32:25.540] }
[15:32:25.540] Tweak future expression to call with '...' arguments ... DONE
[15:32:25.541] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:25.541] 
[15:32:25.542] getGlobalsAndPackages() ... DONE
[15:32:25.542] run() for 'Future' ...
[15:32:25.543] - state: 'created'
[15:32:25.543] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:25.544] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:25.544] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:25.544]   - Field: 'label'
[15:32:25.544]   - Field: 'local'
[15:32:25.545]   - Field: 'owner'
[15:32:25.545]   - Field: 'envir'
[15:32:25.545]   - Field: 'packages'
[15:32:25.545]   - Field: 'gc'
[15:32:25.546]   - Field: 'conditions'
[15:32:25.546]   - Field: 'expr'
[15:32:25.546]   - Field: 'uuid'
[15:32:25.547]   - Field: 'seed'
[15:32:25.547]   - Field: 'version'
[15:32:25.547]   - Field: 'result'
[15:32:25.547]   - Field: 'asynchronous'
[15:32:25.548]   - Field: 'calls'
[15:32:25.548]   - Field: 'globals'
[15:32:25.548]   - Field: 'stdout'
[15:32:25.548]   - Field: 'earlySignal'
[15:32:25.549]   - Field: 'lazy'
[15:32:25.549]   - Field: 'state'
[15:32:25.549] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:25.549] - Launch lazy future ...
[15:32:25.550] Packages needed by the future expression (n = 0): <none>
[15:32:25.550] Packages needed by future strategies (n = 0): <none>
[15:32:25.551] {
[15:32:25.551]     {
[15:32:25.551]         {
[15:32:25.551]             ...future.startTime <- base::Sys.time()
[15:32:25.551]             {
[15:32:25.551]                 {
[15:32:25.551]                   {
[15:32:25.551]                     base::local({
[15:32:25.551]                       has_future <- base::requireNamespace("future", 
[15:32:25.551]                         quietly = TRUE)
[15:32:25.551]                       if (has_future) {
[15:32:25.551]                         ns <- base::getNamespace("future")
[15:32:25.551]                         version <- ns[[".package"]][["version"]]
[15:32:25.551]                         if (is.null(version)) 
[15:32:25.551]                           version <- utils::packageVersion("future")
[15:32:25.551]                       }
[15:32:25.551]                       else {
[15:32:25.551]                         version <- NULL
[15:32:25.551]                       }
[15:32:25.551]                       if (!has_future || version < "1.8.0") {
[15:32:25.551]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:25.551]                           "", base::R.version$version.string), 
[15:32:25.551]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:25.551]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:25.551]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:25.551]                             "release", "version")], collapse = " "), 
[15:32:25.551]                           hostname = base::Sys.info()[["nodename"]])
[15:32:25.551]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:25.551]                           info)
[15:32:25.551]                         info <- base::paste(info, collapse = "; ")
[15:32:25.551]                         if (!has_future) {
[15:32:25.551]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:25.551]                             info)
[15:32:25.551]                         }
[15:32:25.551]                         else {
[15:32:25.551]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:25.551]                             info, version)
[15:32:25.551]                         }
[15:32:25.551]                         base::stop(msg)
[15:32:25.551]                       }
[15:32:25.551]                     })
[15:32:25.551]                   }
[15:32:25.551]                   ...future.strategy.old <- future::plan("list")
[15:32:25.551]                   options(future.plan = NULL)
[15:32:25.551]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:25.551]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:25.551]                 }
[15:32:25.551]                 ...future.workdir <- getwd()
[15:32:25.551]             }
[15:32:25.551]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:25.551]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:25.551]         }
[15:32:25.551]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:25.551]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:25.551]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:25.551]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:25.551]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:25.551]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:25.551]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:25.551]             base::names(...future.oldOptions))
[15:32:25.551]     }
[15:32:25.551]     if (FALSE) {
[15:32:25.551]     }
[15:32:25.551]     else {
[15:32:25.551]         if (TRUE) {
[15:32:25.551]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:25.551]                 open = "w")
[15:32:25.551]         }
[15:32:25.551]         else {
[15:32:25.551]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:25.551]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:25.551]         }
[15:32:25.551]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:25.551]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:25.551]             base::sink(type = "output", split = FALSE)
[15:32:25.551]             base::close(...future.stdout)
[15:32:25.551]         }, add = TRUE)
[15:32:25.551]     }
[15:32:25.551]     ...future.frame <- base::sys.nframe()
[15:32:25.551]     ...future.conditions <- base::list()
[15:32:25.551]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:25.551]     if (FALSE) {
[15:32:25.551]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:25.551]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:25.551]     }
[15:32:25.551]     ...future.result <- base::tryCatch({
[15:32:25.551]         base::withCallingHandlers({
[15:32:25.551]             ...future.value <- base::withVisible(base::local({
[15:32:25.551]                 do.call(function(...) {
[15:32:25.551]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:25.551]                   if (!identical(...future.globals.maxSize.org, 
[15:32:25.551]                     ...future.globals.maxSize)) {
[15:32:25.551]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:25.551]                     on.exit(options(oopts), add = TRUE)
[15:32:25.551]                   }
[15:32:25.551]                   {
[15:32:25.551]                     lapply(seq_along(...future.elements_ii), 
[15:32:25.551]                       FUN = function(jj) {
[15:32:25.551]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:25.551]                         ...future.FUN(...future.X_jj, ...)
[15:32:25.551]                       })
[15:32:25.551]                   }
[15:32:25.551]                 }, args = future.call.arguments)
[15:32:25.551]             }))
[15:32:25.551]             future::FutureResult(value = ...future.value$value, 
[15:32:25.551]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:25.551]                   ...future.rng), globalenv = if (FALSE) 
[15:32:25.551]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:25.551]                     ...future.globalenv.names))
[15:32:25.551]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:25.551]         }, condition = base::local({
[15:32:25.551]             c <- base::c
[15:32:25.551]             inherits <- base::inherits
[15:32:25.551]             invokeRestart <- base::invokeRestart
[15:32:25.551]             length <- base::length
[15:32:25.551]             list <- base::list
[15:32:25.551]             seq.int <- base::seq.int
[15:32:25.551]             signalCondition <- base::signalCondition
[15:32:25.551]             sys.calls <- base::sys.calls
[15:32:25.551]             `[[` <- base::`[[`
[15:32:25.551]             `+` <- base::`+`
[15:32:25.551]             `<<-` <- base::`<<-`
[15:32:25.551]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:25.551]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:25.551]                   3L)]
[15:32:25.551]             }
[15:32:25.551]             function(cond) {
[15:32:25.551]                 is_error <- inherits(cond, "error")
[15:32:25.551]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:25.551]                   NULL)
[15:32:25.551]                 if (is_error) {
[15:32:25.551]                   sessionInformation <- function() {
[15:32:25.551]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:25.551]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:25.551]                       search = base::search(), system = base::Sys.info())
[15:32:25.551]                   }
[15:32:25.551]                   ...future.conditions[[length(...future.conditions) + 
[15:32:25.551]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:25.551]                     cond$call), session = sessionInformation(), 
[15:32:25.551]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:25.551]                   signalCondition(cond)
[15:32:25.551]                 }
[15:32:25.551]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:25.551]                 "immediateCondition"))) {
[15:32:25.551]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:25.551]                   ...future.conditions[[length(...future.conditions) + 
[15:32:25.551]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:25.551]                   if (TRUE && !signal) {
[15:32:25.551]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:25.551]                     {
[15:32:25.551]                       inherits <- base::inherits
[15:32:25.551]                       invokeRestart <- base::invokeRestart
[15:32:25.551]                       is.null <- base::is.null
[15:32:25.551]                       muffled <- FALSE
[15:32:25.551]                       if (inherits(cond, "message")) {
[15:32:25.551]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:25.551]                         if (muffled) 
[15:32:25.551]                           invokeRestart("muffleMessage")
[15:32:25.551]                       }
[15:32:25.551]                       else if (inherits(cond, "warning")) {
[15:32:25.551]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:25.551]                         if (muffled) 
[15:32:25.551]                           invokeRestart("muffleWarning")
[15:32:25.551]                       }
[15:32:25.551]                       else if (inherits(cond, "condition")) {
[15:32:25.551]                         if (!is.null(pattern)) {
[15:32:25.551]                           computeRestarts <- base::computeRestarts
[15:32:25.551]                           grepl <- base::grepl
[15:32:25.551]                           restarts <- computeRestarts(cond)
[15:32:25.551]                           for (restart in restarts) {
[15:32:25.551]                             name <- restart$name
[15:32:25.551]                             if (is.null(name)) 
[15:32:25.551]                               next
[15:32:25.551]                             if (!grepl(pattern, name)) 
[15:32:25.551]                               next
[15:32:25.551]                             invokeRestart(restart)
[15:32:25.551]                             muffled <- TRUE
[15:32:25.551]                             break
[15:32:25.551]                           }
[15:32:25.551]                         }
[15:32:25.551]                       }
[15:32:25.551]                       invisible(muffled)
[15:32:25.551]                     }
[15:32:25.551]                     muffleCondition(cond, pattern = "^muffle")
[15:32:25.551]                   }
[15:32:25.551]                 }
[15:32:25.551]                 else {
[15:32:25.551]                   if (TRUE) {
[15:32:25.551]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:25.551]                     {
[15:32:25.551]                       inherits <- base::inherits
[15:32:25.551]                       invokeRestart <- base::invokeRestart
[15:32:25.551]                       is.null <- base::is.null
[15:32:25.551]                       muffled <- FALSE
[15:32:25.551]                       if (inherits(cond, "message")) {
[15:32:25.551]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:25.551]                         if (muffled) 
[15:32:25.551]                           invokeRestart("muffleMessage")
[15:32:25.551]                       }
[15:32:25.551]                       else if (inherits(cond, "warning")) {
[15:32:25.551]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:25.551]                         if (muffled) 
[15:32:25.551]                           invokeRestart("muffleWarning")
[15:32:25.551]                       }
[15:32:25.551]                       else if (inherits(cond, "condition")) {
[15:32:25.551]                         if (!is.null(pattern)) {
[15:32:25.551]                           computeRestarts <- base::computeRestarts
[15:32:25.551]                           grepl <- base::grepl
[15:32:25.551]                           restarts <- computeRestarts(cond)
[15:32:25.551]                           for (restart in restarts) {
[15:32:25.551]                             name <- restart$name
[15:32:25.551]                             if (is.null(name)) 
[15:32:25.551]                               next
[15:32:25.551]                             if (!grepl(pattern, name)) 
[15:32:25.551]                               next
[15:32:25.551]                             invokeRestart(restart)
[15:32:25.551]                             muffled <- TRUE
[15:32:25.551]                             break
[15:32:25.551]                           }
[15:32:25.551]                         }
[15:32:25.551]                       }
[15:32:25.551]                       invisible(muffled)
[15:32:25.551]                     }
[15:32:25.551]                     muffleCondition(cond, pattern = "^muffle")
[15:32:25.551]                   }
[15:32:25.551]                 }
[15:32:25.551]             }
[15:32:25.551]         }))
[15:32:25.551]     }, error = function(ex) {
[15:32:25.551]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:25.551]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:25.551]                 ...future.rng), started = ...future.startTime, 
[15:32:25.551]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:25.551]             version = "1.8"), class = "FutureResult")
[15:32:25.551]     }, finally = {
[15:32:25.551]         if (!identical(...future.workdir, getwd())) 
[15:32:25.551]             setwd(...future.workdir)
[15:32:25.551]         {
[15:32:25.551]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:25.551]                 ...future.oldOptions$nwarnings <- NULL
[15:32:25.551]             }
[15:32:25.551]             base::options(...future.oldOptions)
[15:32:25.551]             if (.Platform$OS.type == "windows") {
[15:32:25.551]                 old_names <- names(...future.oldEnvVars)
[15:32:25.551]                 envs <- base::Sys.getenv()
[15:32:25.551]                 names <- names(envs)
[15:32:25.551]                 common <- intersect(names, old_names)
[15:32:25.551]                 added <- setdiff(names, old_names)
[15:32:25.551]                 removed <- setdiff(old_names, names)
[15:32:25.551]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:25.551]                   envs[common]]
[15:32:25.551]                 NAMES <- toupper(changed)
[15:32:25.551]                 args <- list()
[15:32:25.551]                 for (kk in seq_along(NAMES)) {
[15:32:25.551]                   name <- changed[[kk]]
[15:32:25.551]                   NAME <- NAMES[[kk]]
[15:32:25.551]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:25.551]                     next
[15:32:25.551]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:25.551]                 }
[15:32:25.551]                 NAMES <- toupper(added)
[15:32:25.551]                 for (kk in seq_along(NAMES)) {
[15:32:25.551]                   name <- added[[kk]]
[15:32:25.551]                   NAME <- NAMES[[kk]]
[15:32:25.551]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:25.551]                     next
[15:32:25.551]                   args[[name]] <- ""
[15:32:25.551]                 }
[15:32:25.551]                 NAMES <- toupper(removed)
[15:32:25.551]                 for (kk in seq_along(NAMES)) {
[15:32:25.551]                   name <- removed[[kk]]
[15:32:25.551]                   NAME <- NAMES[[kk]]
[15:32:25.551]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:25.551]                     next
[15:32:25.551]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:25.551]                 }
[15:32:25.551]                 if (length(args) > 0) 
[15:32:25.551]                   base::do.call(base::Sys.setenv, args = args)
[15:32:25.551]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:25.551]             }
[15:32:25.551]             else {
[15:32:25.551]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:25.551]             }
[15:32:25.551]             {
[15:32:25.551]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:25.551]                   0L) {
[15:32:25.551]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:25.551]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:25.551]                   base::options(opts)
[15:32:25.551]                 }
[15:32:25.551]                 {
[15:32:25.551]                   {
[15:32:25.551]                     NULL
[15:32:25.551]                     RNGkind("Mersenne-Twister")
[15:32:25.551]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:25.551]                       inherits = FALSE)
[15:32:25.551]                   }
[15:32:25.551]                   options(future.plan = NULL)
[15:32:25.551]                   if (is.na(NA_character_)) 
[15:32:25.551]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:25.551]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:25.551]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:25.551]                     .init = FALSE)
[15:32:25.551]                 }
[15:32:25.551]             }
[15:32:25.551]         }
[15:32:25.551]     })
[15:32:25.551]     if (TRUE) {
[15:32:25.551]         base::sink(type = "output", split = FALSE)
[15:32:25.551]         if (TRUE) {
[15:32:25.551]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:25.551]         }
[15:32:25.551]         else {
[15:32:25.551]             ...future.result["stdout"] <- base::list(NULL)
[15:32:25.551]         }
[15:32:25.551]         base::close(...future.stdout)
[15:32:25.551]         ...future.stdout <- NULL
[15:32:25.551]     }
[15:32:25.551]     ...future.result$conditions <- ...future.conditions
[15:32:25.551]     ...future.result$finished <- base::Sys.time()
[15:32:25.551]     ...future.result
[15:32:25.551] }
[15:32:25.558] assign_globals() ...
[15:32:25.558] List of 5
[15:32:25.558]  $ ...future.FUN            :function (x, y = 2 * 1:5)  
[15:32:25.558]  $ future.call.arguments    : list()
[15:32:25.558]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:25.558]  $ ...future.elements_ii    :List of 4
[15:32:25.558]   ..$ A: num 50
[15:32:25.558]   ..$ B: num 60
[15:32:25.558]   ..$ C: num 70
[15:32:25.558]   ..$ D: num 80
[15:32:25.558]  $ ...future.seeds_ii       : NULL
[15:32:25.558]  $ ...future.globals.maxSize: NULL
[15:32:25.558]  - attr(*, "where")=List of 5
[15:32:25.558]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:25.558]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:25.558]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:25.558]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:25.558]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:25.558]  - attr(*, "resolved")= logi FALSE
[15:32:25.558]  - attr(*, "total_size")= num 4728
[15:32:25.558]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:25.558]  - attr(*, "already-done")= logi TRUE
[15:32:25.574] - reassign environment for '...future.FUN'
[15:32:25.574] - copied '...future.FUN' to environment
[15:32:25.575] - copied 'future.call.arguments' to environment
[15:32:25.575] - copied '...future.elements_ii' to environment
[15:32:25.575] - copied '...future.seeds_ii' to environment
[15:32:25.575] - copied '...future.globals.maxSize' to environment
[15:32:25.576] assign_globals() ... done
[15:32:25.576] plan(): Setting new future strategy stack:
[15:32:25.577] List of future strategies:
[15:32:25.577] 1. sequential:
[15:32:25.577]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:25.577]    - tweaked: FALSE
[15:32:25.577]    - call: NULL
[15:32:25.577] plan(): nbrOfWorkers() = 1
[15:32:25.580] plan(): Setting new future strategy stack:
[15:32:25.580] List of future strategies:
[15:32:25.580] 1. sequential:
[15:32:25.580]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:25.580]    - tweaked: FALSE
[15:32:25.580]    - call: plan(strategy)
[15:32:25.581] plan(): nbrOfWorkers() = 1
[15:32:25.581] SequentialFuture started (and completed)
[15:32:25.581] - Launch lazy future ... done
[15:32:25.582] run() for 'SequentialFuture' ... done
[15:32:25.582] Created future:
[15:32:25.582] SequentialFuture:
[15:32:25.582] Label: 'future_sapply-1'
[15:32:25.582] Expression:
[15:32:25.582] {
[15:32:25.582]     do.call(function(...) {
[15:32:25.582]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:25.582]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:25.582]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:25.582]             on.exit(options(oopts), add = TRUE)
[15:32:25.582]         }
[15:32:25.582]         {
[15:32:25.582]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:25.582]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:25.582]                 ...future.FUN(...future.X_jj, ...)
[15:32:25.582]             })
[15:32:25.582]         }
[15:32:25.582]     }, args = future.call.arguments)
[15:32:25.582] }
[15:32:25.582] Lazy evaluation: FALSE
[15:32:25.582] Asynchronous evaluation: FALSE
[15:32:25.582] Local evaluation: TRUE
[15:32:25.582] Environment: R_GlobalEnv
[15:32:25.582] Capture standard output: TRUE
[15:32:25.582] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:25.582] Globals: 5 objects totaling 4.84 KiB (function '...future.FUN' of 4.62 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 224 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:25.582] Packages: <none>
[15:32:25.582] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:25.582] Resolved: TRUE
[15:32:25.582] Value: 1.34 KiB of class 'list'
[15:32:25.582] Early signaling: FALSE
[15:32:25.582] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:25.582] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:25.584] Chunk #1 of 1 ... DONE
[15:32:25.585] Launching 1 futures (chunks) ... DONE
[15:32:25.585] Resolving 1 futures (chunks) ...
[15:32:25.585] resolve() on list ...
[15:32:25.585]  recursive: 0
[15:32:25.586]  length: 1
[15:32:25.586] 
[15:32:25.586] resolved() for 'SequentialFuture' ...
[15:32:25.586] - state: 'finished'
[15:32:25.587] - run: TRUE
[15:32:25.587] - result: 'FutureResult'
[15:32:25.587] resolved() for 'SequentialFuture' ... done
[15:32:25.588] Future #1
[15:32:25.588] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:25.588] - nx: 1
[15:32:25.588] - relay: TRUE
[15:32:25.589] - stdout: TRUE
[15:32:25.589] - signal: TRUE
[15:32:25.589] - resignal: FALSE
[15:32:25.589] - force: TRUE
[15:32:25.590] - relayed: [n=1] FALSE
[15:32:25.590] - queued futures: [n=1] FALSE
[15:32:25.590]  - until=1
[15:32:25.590]  - relaying element #1
[15:32:25.591] - relayed: [n=1] TRUE
[15:32:25.591] - queued futures: [n=1] TRUE
[15:32:25.591] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:25.592]  length: 0 (resolved future 1)
[15:32:25.592] Relaying remaining futures
[15:32:25.592] signalConditionsASAP(NULL, pos=0) ...
[15:32:25.592] - nx: 1
[15:32:25.593] - relay: TRUE
[15:32:25.593] - stdout: TRUE
[15:32:25.593] - signal: TRUE
[15:32:25.593] - resignal: FALSE
[15:32:25.593] - force: TRUE
[15:32:25.594] - relayed: [n=1] TRUE
[15:32:25.594] - queued futures: [n=1] TRUE
 - flush all
[15:32:25.594] - relayed: [n=1] TRUE
[15:32:25.595] - queued futures: [n=1] TRUE
[15:32:25.595] signalConditionsASAP(NULL, pos=0) ... done
[15:32:25.595] resolve() on list ... DONE
[15:32:25.595]  - Number of value chunks collected: 1
[15:32:25.596] Resolving 1 futures (chunks) ... DONE
[15:32:25.596] Reducing values from 1 chunks ...
[15:32:25.596]  - Number of values collected after concatenation: 4
[15:32:25.596]  - Number of values expected: 4
[15:32:25.597] Reducing values from 1 chunks ... DONE
[15:32:25.597] future_lapply() ... DONE
List of 2
 $ y0: num [1:3, 1:5, 1:4] 100 100 100 200 200 200 300 300 300 400 ...
  ..- attr(*, "dimnames")=List of 3
  .. ..$ : NULL
  .. ..$ : NULL
  .. ..$ : chr [1:4] "A" "B" "C" "D"
 $ y1: num [1:3, 1:5, 1:4] 100 100 100 200 200 200 300 300 300 400 ...
  ..- attr(*, "dimnames")=List of 3
  .. ..$ : NULL
  .. ..$ : NULL
  .. ..$ : chr [1:4] "A" "B" "C" "D"
[15:32:25.604] future_lapply() ...
[15:32:25.605] Number of chunks: 1
[15:32:25.605] getGlobalsAndPackagesXApply() ...
[15:32:25.605]  - future.globals: TRUE
[15:32:25.605] getGlobalsAndPackages() ...
[15:32:25.606] Searching for globals...
[15:32:25.607] - globals found: [1] 'FUN'
[15:32:25.607] Searching for globals ... DONE
[15:32:25.608] Resolving globals: FALSE
[15:32:25.608] The total size of the 1 globals is 56 bytes (56 bytes)
[15:32:25.609] The total size of the 1 globals exported for future expression ('FUN()') is 56 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (56 bytes of class 'function')
[15:32:25.609] - globals: [1] 'FUN'
[15:32:25.610] 
[15:32:25.610] getGlobalsAndPackages() ... DONE
[15:32:25.610]  - globals found/used: [n=1] 'FUN'
[15:32:25.611]  - needed namespaces: [n=0] 
[15:32:25.611] Finding globals ... DONE
[15:32:25.611]  - use_args: TRUE
[15:32:25.611]  - Getting '...' globals ...
[15:32:25.612] resolve() on list ...
[15:32:25.612]  recursive: 0
[15:32:25.613]  length: 1
[15:32:25.613]  elements: '...'
[15:32:25.613]  length: 0 (resolved future 1)
[15:32:25.614] resolve() on list ... DONE
[15:32:25.614]    - '...' content: [n=0] 
[15:32:25.614] List of 1
[15:32:25.614]  $ ...: list()
[15:32:25.614]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:25.614]  - attr(*, "where")=List of 1
[15:32:25.614]   ..$ ...:<environment: 0x00000276e1abb290> 
[15:32:25.614]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:25.614]  - attr(*, "resolved")= logi TRUE
[15:32:25.614]  - attr(*, "total_size")= num NA
[15:32:25.619]  - Getting '...' globals ... DONE
[15:32:25.620] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:25.620] List of 2
[15:32:25.620]  $ ...future.FUN:function (x)  
[15:32:25.620]  $ ...          : list()
[15:32:25.620]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:25.620]  - attr(*, "where")=List of 2
[15:32:25.620]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:25.620]   ..$ ...          :<environment: 0x00000276e1abb290> 
[15:32:25.620]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:25.620]  - attr(*, "resolved")= logi FALSE
[15:32:25.620]  - attr(*, "total_size")= num 56
[15:32:25.626] Packages to be attached in all futures: [n=0] 
[15:32:25.626] getGlobalsAndPackagesXApply() ... DONE
[15:32:25.626] Number of futures (= number of chunks): 1
[15:32:25.627] Launching 1 futures (chunks) ...
[15:32:25.627] Chunk #1 of 1 ...
[15:32:25.627]  - Finding globals in 'X' for chunk #1 ...
[15:32:25.628] getGlobalsAndPackages() ...
[15:32:25.628] Searching for globals...
[15:32:25.629] 
[15:32:25.629] Searching for globals ... DONE
[15:32:25.629] - globals: [0] <none>
[15:32:25.629] getGlobalsAndPackages() ... DONE
[15:32:25.630]    + additional globals found: [n=0] 
[15:32:25.630]    + additional namespaces needed: [n=0] 
[15:32:25.630]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:25.630]  - seeds: <none>
[15:32:25.631]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:25.631] getGlobalsAndPackages() ...
[15:32:25.631] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:25.632] Resolving globals: FALSE
[15:32:25.632] Tweak future expression to call with '...' arguments ...
[15:32:25.632] {
[15:32:25.632]     do.call(function(...) {
[15:32:25.632]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:25.632]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:25.632]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:25.632]             on.exit(options(oopts), add = TRUE)
[15:32:25.632]         }
[15:32:25.632]         {
[15:32:25.632]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:25.632]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:25.632]                 ...future.FUN(...future.X_jj, ...)
[15:32:25.632]             })
[15:32:25.632]         }
[15:32:25.632]     }, args = future.call.arguments)
[15:32:25.632] }
[15:32:25.633] Tweak future expression to call with '...' arguments ... DONE
[15:32:25.634] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:25.634] 
[15:32:25.634] getGlobalsAndPackages() ... DONE
[15:32:25.635] run() for 'Future' ...
[15:32:25.635] - state: 'created'
[15:32:25.636] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:25.636] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:25.637] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:25.637]   - Field: 'label'
[15:32:25.637]   - Field: 'local'
[15:32:25.638]   - Field: 'owner'
[15:32:25.638]   - Field: 'envir'
[15:32:25.638]   - Field: 'packages'
[15:32:25.638]   - Field: 'gc'
[15:32:25.639]   - Field: 'conditions'
[15:32:25.639]   - Field: 'expr'
[15:32:25.639]   - Field: 'uuid'
[15:32:25.639]   - Field: 'seed'
[15:32:25.640]   - Field: 'version'
[15:32:25.640]   - Field: 'result'
[15:32:25.640]   - Field: 'asynchronous'
[15:32:25.641]   - Field: 'calls'
[15:32:25.641]   - Field: 'globals'
[15:32:25.641]   - Field: 'stdout'
[15:32:25.642]   - Field: 'earlySignal'
[15:32:25.642]   - Field: 'lazy'
[15:32:25.642]   - Field: 'state'
[15:32:25.643] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:25.643] - Launch lazy future ...
[15:32:25.643] Packages needed by the future expression (n = 0): <none>
[15:32:25.644] Packages needed by future strategies (n = 0): <none>
[15:32:25.645] {
[15:32:25.645]     {
[15:32:25.645]         {
[15:32:25.645]             ...future.startTime <- base::Sys.time()
[15:32:25.645]             {
[15:32:25.645]                 {
[15:32:25.645]                   {
[15:32:25.645]                     base::local({
[15:32:25.645]                       has_future <- base::requireNamespace("future", 
[15:32:25.645]                         quietly = TRUE)
[15:32:25.645]                       if (has_future) {
[15:32:25.645]                         ns <- base::getNamespace("future")
[15:32:25.645]                         version <- ns[[".package"]][["version"]]
[15:32:25.645]                         if (is.null(version)) 
[15:32:25.645]                           version <- utils::packageVersion("future")
[15:32:25.645]                       }
[15:32:25.645]                       else {
[15:32:25.645]                         version <- NULL
[15:32:25.645]                       }
[15:32:25.645]                       if (!has_future || version < "1.8.0") {
[15:32:25.645]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:25.645]                           "", base::R.version$version.string), 
[15:32:25.645]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:25.645]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:25.645]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:25.645]                             "release", "version")], collapse = " "), 
[15:32:25.645]                           hostname = base::Sys.info()[["nodename"]])
[15:32:25.645]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:25.645]                           info)
[15:32:25.645]                         info <- base::paste(info, collapse = "; ")
[15:32:25.645]                         if (!has_future) {
[15:32:25.645]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:25.645]                             info)
[15:32:25.645]                         }
[15:32:25.645]                         else {
[15:32:25.645]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:25.645]                             info, version)
[15:32:25.645]                         }
[15:32:25.645]                         base::stop(msg)
[15:32:25.645]                       }
[15:32:25.645]                     })
[15:32:25.645]                   }
[15:32:25.645]                   ...future.strategy.old <- future::plan("list")
[15:32:25.645]                   options(future.plan = NULL)
[15:32:25.645]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:25.645]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:25.645]                 }
[15:32:25.645]                 ...future.workdir <- getwd()
[15:32:25.645]             }
[15:32:25.645]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:25.645]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:25.645]         }
[15:32:25.645]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:25.645]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:25.645]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:25.645]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:25.645]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:25.645]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:25.645]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:25.645]             base::names(...future.oldOptions))
[15:32:25.645]     }
[15:32:25.645]     if (FALSE) {
[15:32:25.645]     }
[15:32:25.645]     else {
[15:32:25.645]         if (TRUE) {
[15:32:25.645]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:25.645]                 open = "w")
[15:32:25.645]         }
[15:32:25.645]         else {
[15:32:25.645]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:25.645]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:25.645]         }
[15:32:25.645]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:25.645]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:25.645]             base::sink(type = "output", split = FALSE)
[15:32:25.645]             base::close(...future.stdout)
[15:32:25.645]         }, add = TRUE)
[15:32:25.645]     }
[15:32:25.645]     ...future.frame <- base::sys.nframe()
[15:32:25.645]     ...future.conditions <- base::list()
[15:32:25.645]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:25.645]     if (FALSE) {
[15:32:25.645]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:25.645]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:25.645]     }
[15:32:25.645]     ...future.result <- base::tryCatch({
[15:32:25.645]         base::withCallingHandlers({
[15:32:25.645]             ...future.value <- base::withVisible(base::local({
[15:32:25.645]                 do.call(function(...) {
[15:32:25.645]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:25.645]                   if (!identical(...future.globals.maxSize.org, 
[15:32:25.645]                     ...future.globals.maxSize)) {
[15:32:25.645]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:25.645]                     on.exit(options(oopts), add = TRUE)
[15:32:25.645]                   }
[15:32:25.645]                   {
[15:32:25.645]                     lapply(seq_along(...future.elements_ii), 
[15:32:25.645]                       FUN = function(jj) {
[15:32:25.645]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:25.645]                         ...future.FUN(...future.X_jj, ...)
[15:32:25.645]                       })
[15:32:25.645]                   }
[15:32:25.645]                 }, args = future.call.arguments)
[15:32:25.645]             }))
[15:32:25.645]             future::FutureResult(value = ...future.value$value, 
[15:32:25.645]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:25.645]                   ...future.rng), globalenv = if (FALSE) 
[15:32:25.645]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:25.645]                     ...future.globalenv.names))
[15:32:25.645]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:25.645]         }, condition = base::local({
[15:32:25.645]             c <- base::c
[15:32:25.645]             inherits <- base::inherits
[15:32:25.645]             invokeRestart <- base::invokeRestart
[15:32:25.645]             length <- base::length
[15:32:25.645]             list <- base::list
[15:32:25.645]             seq.int <- base::seq.int
[15:32:25.645]             signalCondition <- base::signalCondition
[15:32:25.645]             sys.calls <- base::sys.calls
[15:32:25.645]             `[[` <- base::`[[`
[15:32:25.645]             `+` <- base::`+`
[15:32:25.645]             `<<-` <- base::`<<-`
[15:32:25.645]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:25.645]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:25.645]                   3L)]
[15:32:25.645]             }
[15:32:25.645]             function(cond) {
[15:32:25.645]                 is_error <- inherits(cond, "error")
[15:32:25.645]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:25.645]                   NULL)
[15:32:25.645]                 if (is_error) {
[15:32:25.645]                   sessionInformation <- function() {
[15:32:25.645]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:25.645]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:25.645]                       search = base::search(), system = base::Sys.info())
[15:32:25.645]                   }
[15:32:25.645]                   ...future.conditions[[length(...future.conditions) + 
[15:32:25.645]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:25.645]                     cond$call), session = sessionInformation(), 
[15:32:25.645]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:25.645]                   signalCondition(cond)
[15:32:25.645]                 }
[15:32:25.645]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:25.645]                 "immediateCondition"))) {
[15:32:25.645]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:25.645]                   ...future.conditions[[length(...future.conditions) + 
[15:32:25.645]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:25.645]                   if (TRUE && !signal) {
[15:32:25.645]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:25.645]                     {
[15:32:25.645]                       inherits <- base::inherits
[15:32:25.645]                       invokeRestart <- base::invokeRestart
[15:32:25.645]                       is.null <- base::is.null
[15:32:25.645]                       muffled <- FALSE
[15:32:25.645]                       if (inherits(cond, "message")) {
[15:32:25.645]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:25.645]                         if (muffled) 
[15:32:25.645]                           invokeRestart("muffleMessage")
[15:32:25.645]                       }
[15:32:25.645]                       else if (inherits(cond, "warning")) {
[15:32:25.645]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:25.645]                         if (muffled) 
[15:32:25.645]                           invokeRestart("muffleWarning")
[15:32:25.645]                       }
[15:32:25.645]                       else if (inherits(cond, "condition")) {
[15:32:25.645]                         if (!is.null(pattern)) {
[15:32:25.645]                           computeRestarts <- base::computeRestarts
[15:32:25.645]                           grepl <- base::grepl
[15:32:25.645]                           restarts <- computeRestarts(cond)
[15:32:25.645]                           for (restart in restarts) {
[15:32:25.645]                             name <- restart$name
[15:32:25.645]                             if (is.null(name)) 
[15:32:25.645]                               next
[15:32:25.645]                             if (!grepl(pattern, name)) 
[15:32:25.645]                               next
[15:32:25.645]                             invokeRestart(restart)
[15:32:25.645]                             muffled <- TRUE
[15:32:25.645]                             break
[15:32:25.645]                           }
[15:32:25.645]                         }
[15:32:25.645]                       }
[15:32:25.645]                       invisible(muffled)
[15:32:25.645]                     }
[15:32:25.645]                     muffleCondition(cond, pattern = "^muffle")
[15:32:25.645]                   }
[15:32:25.645]                 }
[15:32:25.645]                 else {
[15:32:25.645]                   if (TRUE) {
[15:32:25.645]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:25.645]                     {
[15:32:25.645]                       inherits <- base::inherits
[15:32:25.645]                       invokeRestart <- base::invokeRestart
[15:32:25.645]                       is.null <- base::is.null
[15:32:25.645]                       muffled <- FALSE
[15:32:25.645]                       if (inherits(cond, "message")) {
[15:32:25.645]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:25.645]                         if (muffled) 
[15:32:25.645]                           invokeRestart("muffleMessage")
[15:32:25.645]                       }
[15:32:25.645]                       else if (inherits(cond, "warning")) {
[15:32:25.645]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:25.645]                         if (muffled) 
[15:32:25.645]                           invokeRestart("muffleWarning")
[15:32:25.645]                       }
[15:32:25.645]                       else if (inherits(cond, "condition")) {
[15:32:25.645]                         if (!is.null(pattern)) {
[15:32:25.645]                           computeRestarts <- base::computeRestarts
[15:32:25.645]                           grepl <- base::grepl
[15:32:25.645]                           restarts <- computeRestarts(cond)
[15:32:25.645]                           for (restart in restarts) {
[15:32:25.645]                             name <- restart$name
[15:32:25.645]                             if (is.null(name)) 
[15:32:25.645]                               next
[15:32:25.645]                             if (!grepl(pattern, name)) 
[15:32:25.645]                               next
[15:32:25.645]                             invokeRestart(restart)
[15:32:25.645]                             muffled <- TRUE
[15:32:25.645]                             break
[15:32:25.645]                           }
[15:32:25.645]                         }
[15:32:25.645]                       }
[15:32:25.645]                       invisible(muffled)
[15:32:25.645]                     }
[15:32:25.645]                     muffleCondition(cond, pattern = "^muffle")
[15:32:25.645]                   }
[15:32:25.645]                 }
[15:32:25.645]             }
[15:32:25.645]         }))
[15:32:25.645]     }, error = function(ex) {
[15:32:25.645]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:25.645]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:25.645]                 ...future.rng), started = ...future.startTime, 
[15:32:25.645]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:25.645]             version = "1.8"), class = "FutureResult")
[15:32:25.645]     }, finally = {
[15:32:25.645]         if (!identical(...future.workdir, getwd())) 
[15:32:25.645]             setwd(...future.workdir)
[15:32:25.645]         {
[15:32:25.645]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:25.645]                 ...future.oldOptions$nwarnings <- NULL
[15:32:25.645]             }
[15:32:25.645]             base::options(...future.oldOptions)
[15:32:25.645]             if (.Platform$OS.type == "windows") {
[15:32:25.645]                 old_names <- names(...future.oldEnvVars)
[15:32:25.645]                 envs <- base::Sys.getenv()
[15:32:25.645]                 names <- names(envs)
[15:32:25.645]                 common <- intersect(names, old_names)
[15:32:25.645]                 added <- setdiff(names, old_names)
[15:32:25.645]                 removed <- setdiff(old_names, names)
[15:32:25.645]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:25.645]                   envs[common]]
[15:32:25.645]                 NAMES <- toupper(changed)
[15:32:25.645]                 args <- list()
[15:32:25.645]                 for (kk in seq_along(NAMES)) {
[15:32:25.645]                   name <- changed[[kk]]
[15:32:25.645]                   NAME <- NAMES[[kk]]
[15:32:25.645]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:25.645]                     next
[15:32:25.645]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:25.645]                 }
[15:32:25.645]                 NAMES <- toupper(added)
[15:32:25.645]                 for (kk in seq_along(NAMES)) {
[15:32:25.645]                   name <- added[[kk]]
[15:32:25.645]                   NAME <- NAMES[[kk]]
[15:32:25.645]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:25.645]                     next
[15:32:25.645]                   args[[name]] <- ""
[15:32:25.645]                 }
[15:32:25.645]                 NAMES <- toupper(removed)
[15:32:25.645]                 for (kk in seq_along(NAMES)) {
[15:32:25.645]                   name <- removed[[kk]]
[15:32:25.645]                   NAME <- NAMES[[kk]]
[15:32:25.645]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:25.645]                     next
[15:32:25.645]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:25.645]                 }
[15:32:25.645]                 if (length(args) > 0) 
[15:32:25.645]                   base::do.call(base::Sys.setenv, args = args)
[15:32:25.645]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:25.645]             }
[15:32:25.645]             else {
[15:32:25.645]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:25.645]             }
[15:32:25.645]             {
[15:32:25.645]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:25.645]                   0L) {
[15:32:25.645]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:25.645]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:25.645]                   base::options(opts)
[15:32:25.645]                 }
[15:32:25.645]                 {
[15:32:25.645]                   {
[15:32:25.645]                     NULL
[15:32:25.645]                     RNGkind("Mersenne-Twister")
[15:32:25.645]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:25.645]                       inherits = FALSE)
[15:32:25.645]                   }
[15:32:25.645]                   options(future.plan = NULL)
[15:32:25.645]                   if (is.na(NA_character_)) 
[15:32:25.645]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:25.645]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:25.645]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:25.645]                     .init = FALSE)
[15:32:25.645]                 }
[15:32:25.645]             }
[15:32:25.645]         }
[15:32:25.645]     })
[15:32:25.645]     if (TRUE) {
[15:32:25.645]         base::sink(type = "output", split = FALSE)
[15:32:25.645]         if (TRUE) {
[15:32:25.645]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:25.645]         }
[15:32:25.645]         else {
[15:32:25.645]             ...future.result["stdout"] <- base::list(NULL)
[15:32:25.645]         }
[15:32:25.645]         base::close(...future.stdout)
[15:32:25.645]         ...future.stdout <- NULL
[15:32:25.645]     }
[15:32:25.645]     ...future.result$conditions <- ...future.conditions
[15:32:25.645]     ...future.result$finished <- base::Sys.time()
[15:32:25.645]     ...future.result
[15:32:25.645] }
[15:32:25.652] assign_globals() ...
[15:32:25.652] List of 5
[15:32:25.652]  $ ...future.FUN            :function (x)  
[15:32:25.652]  $ future.call.arguments    : list()
[15:32:25.652]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:25.652]  $ ...future.elements_ii    :List of 3
[15:32:25.652]   ..$ : int 1
[15:32:25.652]   ..$ : int 2
[15:32:25.652]   ..$ : int 3
[15:32:25.652]  $ ...future.seeds_ii       : NULL
[15:32:25.652]  $ ...future.globals.maxSize: NULL
[15:32:25.652]  - attr(*, "where")=List of 5
[15:32:25.652]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:25.652]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:25.652]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:25.652]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:25.652]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:25.652]  - attr(*, "resolved")= logi FALSE
[15:32:25.652]  - attr(*, "total_size")= num 56
[15:32:25.652]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:25.652]  - attr(*, "already-done")= logi TRUE
[15:32:25.663] - copied '...future.FUN' to environment
[15:32:25.663] - copied 'future.call.arguments' to environment
[15:32:25.663] - copied '...future.elements_ii' to environment
[15:32:25.664] - copied '...future.seeds_ii' to environment
[15:32:25.664] - copied '...future.globals.maxSize' to environment
[15:32:25.664] assign_globals() ... done
[15:32:25.665] plan(): Setting new future strategy stack:
[15:32:25.665] List of future strategies:
[15:32:25.665] 1. sequential:
[15:32:25.665]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:25.665]    - tweaked: FALSE
[15:32:25.665]    - call: NULL
[15:32:25.666] plan(): nbrOfWorkers() = 1
[15:32:25.669] plan(): Setting new future strategy stack:
[15:32:25.669] List of future strategies:
[15:32:25.669] 1. sequential:
[15:32:25.669]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:25.669]    - tweaked: FALSE
[15:32:25.669]    - call: plan(strategy)
[15:32:25.670] plan(): nbrOfWorkers() = 1
[15:32:25.671] SequentialFuture started (and completed)
[15:32:25.671] - Launch lazy future ... done
[15:32:25.671] run() for 'SequentialFuture' ... done
[15:32:25.672] Created future:
[15:32:25.672] SequentialFuture:
[15:32:25.672] Label: 'future_sapply-1'
[15:32:25.672] Expression:
[15:32:25.672] {
[15:32:25.672]     do.call(function(...) {
[15:32:25.672]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:25.672]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:25.672]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:25.672]             on.exit(options(oopts), add = TRUE)
[15:32:25.672]         }
[15:32:25.672]         {
[15:32:25.672]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:25.672]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:25.672]                 ...future.FUN(...future.X_jj, ...)
[15:32:25.672]             })
[15:32:25.672]         }
[15:32:25.672]     }, args = future.call.arguments)
[15:32:25.672] }
[15:32:25.672] Lazy evaluation: FALSE
[15:32:25.672] Asynchronous evaluation: FALSE
[15:32:25.672] Local evaluation: TRUE
[15:32:25.672] Environment: R_GlobalEnv
[15:32:25.672] Capture standard output: TRUE
[15:32:25.672] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:25.672] Globals: 5 objects totaling 224 bytes (function '...future.FUN' of 56 bytes, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:25.672] Packages: <none>
[15:32:25.672] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:25.672] Resolved: TRUE
[15:32:25.672] Value: 168 bytes of class 'list'
[15:32:25.672] Early signaling: FALSE
[15:32:25.672] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:25.672] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:25.674] Chunk #1 of 1 ... DONE
[15:32:25.675] Launching 1 futures (chunks) ... DONE
[15:32:25.675] Resolving 1 futures (chunks) ...
[15:32:25.675] resolve() on list ...
[15:32:25.676]  recursive: 0
[15:32:25.676]  length: 1
[15:32:25.676] 
[15:32:25.677] resolved() for 'SequentialFuture' ...
[15:32:25.677] - state: 'finished'
[15:32:25.677] - run: TRUE
[15:32:25.678] - result: 'FutureResult'
[15:32:25.678] resolved() for 'SequentialFuture' ... done
[15:32:25.678] Future #1
[15:32:25.679] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:25.679] - nx: 1
[15:32:25.679] - relay: TRUE
[15:32:25.680] - stdout: TRUE
[15:32:25.680] - signal: TRUE
[15:32:25.680] - resignal: FALSE
[15:32:25.680] - force: TRUE
[15:32:25.681] - relayed: [n=1] FALSE
[15:32:25.681] - queued futures: [n=1] FALSE
[15:32:25.681]  - until=1
[15:32:25.682]  - relaying element #1
[15:32:25.682] - relayed: [n=1] TRUE
[15:32:25.682] - queued futures: [n=1] TRUE
[15:32:25.683] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:25.683]  length: 0 (resolved future 1)
[15:32:25.683] Relaying remaining futures
[15:32:25.684] signalConditionsASAP(NULL, pos=0) ...
[15:32:25.684] - nx: 1
[15:32:25.684] - relay: TRUE
[15:32:25.684] - stdout: TRUE
[15:32:25.685] - signal: TRUE
[15:32:25.685] - resignal: FALSE
[15:32:25.685] - force: TRUE
[15:32:25.685] - relayed: [n=1] TRUE
[15:32:25.686] - queued futures: [n=1] TRUE
 - flush all
[15:32:25.686] - relayed: [n=1] TRUE
[15:32:25.686] - queued futures: [n=1] TRUE
[15:32:25.687] signalConditionsASAP(NULL, pos=0) ... done
[15:32:25.687] resolve() on list ... DONE
[15:32:25.687]  - Number of value chunks collected: 1
[15:32:25.688] Resolving 1 futures (chunks) ... DONE
[15:32:25.688] Reducing values from 1 chunks ...
[15:32:25.688]  - Number of values collected after concatenation: 3
[15:32:25.688]  - Number of values expected: 3
[15:32:25.689] Reducing values from 1 chunks ... DONE
[15:32:25.689] future_lapply() ... DONE
[15:32:25.689] future_lapply() ...
[15:32:25.692] Number of chunks: 1
[15:32:25.692] getGlobalsAndPackagesXApply() ...
[15:32:25.692]  - future.globals: TRUE
[15:32:25.693] getGlobalsAndPackages() ...
[15:32:25.693] Searching for globals...
[15:32:25.698] - globals found: [4] 'FUN', 'compute', '...', '+'
[15:32:25.698] Searching for globals ... DONE
[15:32:25.698] Resolving globals: FALSE
[15:32:25.699] Tweak future expression to call with '...' arguments ...
[15:32:25.699] {
[15:32:25.699]     do.call(function(...) FUN(), args = future.call.arguments)
[15:32:25.699] }
[15:32:25.699] Tweak future expression to call with '...' arguments ... DONE
[15:32:25.701] The total size of the 3 globals is 3.92 KiB (4016 bytes)
[15:32:25.702] The total size of the 3 globals exported for future expression ('FUN()') is 3.92 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are three globals: 'FUN' (2.43 KiB of class 'function'), 'compute' (1.44 KiB of class 'function') and 'future.call.arguments' (56 bytes of class 'list')
[15:32:25.702] - globals: [3] 'FUN', 'compute', 'future.call.arguments'
[15:32:25.702] 
[15:32:25.703] getGlobalsAndPackages() ... DONE
[15:32:25.703]  - globals found/used: [n=3] 'FUN', 'compute', 'future.call.arguments'
[15:32:25.703]  - needed namespaces: [n=0] 
[15:32:25.704] Finding globals ... DONE
[15:32:25.704]  - use_args: TRUE
[15:32:25.704]  - Getting '...' globals ...
[15:32:25.705] resolve() on list ...
[15:32:25.705]  recursive: 0
[15:32:25.706]  length: 1
[15:32:25.706]  elements: '...'
[15:32:25.706]  length: 0 (resolved future 1)
[15:32:25.706] resolve() on list ... DONE
[15:32:25.707]    - '...' content: [n=0] 
[15:32:25.707] List of 1
[15:32:25.707]  $ ...: list()
[15:32:25.707]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:25.707]  - attr(*, "where")=List of 1
[15:32:25.707]   ..$ ...:<environment: 0x00000276e4e0b728> 
[15:32:25.707]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:25.707]  - attr(*, "resolved")= logi TRUE
[15:32:25.707]  - attr(*, "total_size")= num NA
[15:32:25.712]  - Getting '...' globals ... DONE
[15:32:25.712] Globals to be used in all futures (chunks): [n=4] '...future.FUN', 'compute', 'future.call.arguments', '...'
[15:32:25.713] List of 4
[15:32:25.713]  $ ...future.FUN        :function (x)  
[15:32:25.713]  $ compute              :function (a, x_vec)  
[15:32:25.713]  $ future.call.arguments:List of 1
[15:32:25.713]   ..$ : int 0
[15:32:25.713]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:25.713]  $ ...                  : list()
[15:32:25.713]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:25.713]  - attr(*, "where")=List of 4
[15:32:25.713]   ..$ ...future.FUN        :<environment: R_EmptyEnv> 
[15:32:25.713]   ..$ compute              :<environment: R_EmptyEnv> 
[15:32:25.713]   ..$ future.call.arguments:<environment: R_EmptyEnv> 
[15:32:25.713]   ..$ ...                  :<environment: 0x00000276e4e0b728> 
[15:32:25.713]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:25.713]  - attr(*, "resolved")= logi FALSE
[15:32:25.713]  - attr(*, "total_size")= num 4016
[15:32:25.721] Packages to be attached in all futures: [n=0] 
[15:32:25.722] getGlobalsAndPackagesXApply() ... DONE
[15:32:25.724] Number of futures (= number of chunks): 1
[15:32:25.725] Launching 1 futures (chunks) ...
[15:32:25.725] Chunk #1 of 1 ...
[15:32:25.725]  - Finding globals in 'X' for chunk #1 ...
[15:32:25.726] getGlobalsAndPackages() ...
[15:32:25.726] Searching for globals...
[15:32:25.727] 
[15:32:25.727] Searching for globals ... DONE
[15:32:25.728] - globals: [0] <none>
[15:32:25.728] getGlobalsAndPackages() ... DONE
[15:32:25.728]    + additional globals found: [n=0] 
[15:32:25.729]    + additional namespaces needed: [n=0] 
[15:32:25.729]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:25.730]  - seeds: <none>
[15:32:25.730]  - All globals exported: [n=7] '...future.FUN', 'compute', 'future.call.arguments', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:25.730] getGlobalsAndPackages() ...
[15:32:25.731] - globals passed as-is: [7] '...future.FUN', 'compute', 'future.call.arguments', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:25.731] Resolving globals: FALSE
[15:32:25.732] Tweak future expression to call with '...' arguments ...
[15:32:25.732] - Detected 2 'future.call.arguments' global entries:
[15:32:25.732] List of 2
[15:32:25.732]  $ future.call.arguments:List of 1
[15:32:25.732]   ..$ : int 0
[15:32:25.732]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:25.732]  $ future.call.arguments: list()
[15:32:25.732]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:25.732]  - attr(*, "where")=List of 2
[15:32:25.732]   ..$ future.call.arguments:<environment: R_EmptyEnv> 
[15:32:25.732]   ..$ future.call.arguments:<environment: 0x00000276e4e0b728> 
[15:32:25.732]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:25.732]  - attr(*, "resolved")= logi FALSE
[15:32:25.732]  - attr(*, "total_size")= num 4016
[15:32:25.742] future.call.arguments future.call.arguments 
[15:32:25.742]                     1                     0 
[15:32:25.743] - 'future.call.arguments' global entries:
[15:32:25.744] List of 2
[15:32:25.744]  $ future.call.arguments:List of 1
[15:32:25.744]   ..$ : int 0
[15:32:25.744]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:25.744]  $ ...future.elements_ii:List of 2
[15:32:25.744]   ..$ : int 1
[15:32:25.744]   ..$ : int 2
[15:32:25.744]  - attr(*, "where")=List of 2
[15:32:25.744]   ..$ future.call.arguments:<environment: R_EmptyEnv> 
[15:32:25.744]   ..$ ...future.elements_ii:<environment: R_EmptyEnv> 
[15:32:25.744]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:25.744]  - attr(*, "resolved")= logi FALSE
[15:32:25.744]  - attr(*, "total_size")= num 4016
[15:32:25.756] {
[15:32:25.756]     do.call(function(...) {
[15:32:25.756]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:25.756]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:25.756]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:25.756]             on.exit(options(oopts), add = TRUE)
[15:32:25.756]         }
[15:32:25.756]         {
[15:32:25.756]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:25.756]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:25.756]                 ...future.FUN(...future.X_jj)
[15:32:25.756]             })
[15:32:25.756]         }
[15:32:25.756]     }, args = future.call.arguments)
[15:32:25.756] }
[15:32:25.757] Tweak future expression to call with '...' arguments ... DONE
[15:32:25.758] - globals: [6] '...future.FUN', 'compute', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:25.758] 
[15:32:25.759] getGlobalsAndPackages() ... DONE
[15:32:25.759] run() for 'Future' ...
[15:32:25.760] - state: 'created'
[15:32:25.760] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:25.761] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:25.761] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:25.762]   - Field: 'label'
[15:32:25.762]   - Field: 'local'
[15:32:25.762]   - Field: 'owner'
[15:32:25.762]   - Field: 'envir'
[15:32:25.763]   - Field: 'packages'
[15:32:25.763]   - Field: 'gc'
[15:32:25.763]   - Field: 'conditions'
[15:32:25.764]   - Field: 'expr'
[15:32:25.764]   - Field: 'uuid'
[15:32:25.764]   - Field: 'seed'
[15:32:25.765]   - Field: 'version'
[15:32:25.765]   - Field: 'result'
[15:32:25.765]   - Field: 'asynchronous'
[15:32:25.766]   - Field: 'calls'
[15:32:25.766]   - Field: 'globals'
[15:32:25.766]   - Field: 'stdout'
[15:32:25.767]   - Field: 'earlySignal'
[15:32:25.767]   - Field: 'lazy'
[15:32:25.767]   - Field: 'state'
[15:32:25.768] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:25.768] - Launch lazy future ...
[15:32:25.768] Packages needed by the future expression (n = 0): <none>
[15:32:25.769] Packages needed by future strategies (n = 0): <none>
[15:32:25.770] {
[15:32:25.770]     {
[15:32:25.770]         {
[15:32:25.770]             ...future.startTime <- base::Sys.time()
[15:32:25.770]             {
[15:32:25.770]                 {
[15:32:25.770]                   {
[15:32:25.770]                     base::local({
[15:32:25.770]                       has_future <- base::requireNamespace("future", 
[15:32:25.770]                         quietly = TRUE)
[15:32:25.770]                       if (has_future) {
[15:32:25.770]                         ns <- base::getNamespace("future")
[15:32:25.770]                         version <- ns[[".package"]][["version"]]
[15:32:25.770]                         if (is.null(version)) 
[15:32:25.770]                           version <- utils::packageVersion("future")
[15:32:25.770]                       }
[15:32:25.770]                       else {
[15:32:25.770]                         version <- NULL
[15:32:25.770]                       }
[15:32:25.770]                       if (!has_future || version < "1.8.0") {
[15:32:25.770]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:25.770]                           "", base::R.version$version.string), 
[15:32:25.770]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:25.770]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:25.770]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:25.770]                             "release", "version")], collapse = " "), 
[15:32:25.770]                           hostname = base::Sys.info()[["nodename"]])
[15:32:25.770]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:25.770]                           info)
[15:32:25.770]                         info <- base::paste(info, collapse = "; ")
[15:32:25.770]                         if (!has_future) {
[15:32:25.770]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:25.770]                             info)
[15:32:25.770]                         }
[15:32:25.770]                         else {
[15:32:25.770]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:25.770]                             info, version)
[15:32:25.770]                         }
[15:32:25.770]                         base::stop(msg)
[15:32:25.770]                       }
[15:32:25.770]                     })
[15:32:25.770]                   }
[15:32:25.770]                   ...future.strategy.old <- future::plan("list")
[15:32:25.770]                   options(future.plan = NULL)
[15:32:25.770]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:25.770]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:25.770]                 }
[15:32:25.770]                 ...future.workdir <- getwd()
[15:32:25.770]             }
[15:32:25.770]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:25.770]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:25.770]         }
[15:32:25.770]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:25.770]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:25.770]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:25.770]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:25.770]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:25.770]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:25.770]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:25.770]             base::names(...future.oldOptions))
[15:32:25.770]     }
[15:32:25.770]     if (FALSE) {
[15:32:25.770]     }
[15:32:25.770]     else {
[15:32:25.770]         if (TRUE) {
[15:32:25.770]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:25.770]                 open = "w")
[15:32:25.770]         }
[15:32:25.770]         else {
[15:32:25.770]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:25.770]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:25.770]         }
[15:32:25.770]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:25.770]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:25.770]             base::sink(type = "output", split = FALSE)
[15:32:25.770]             base::close(...future.stdout)
[15:32:25.770]         }, add = TRUE)
[15:32:25.770]     }
[15:32:25.770]     ...future.frame <- base::sys.nframe()
[15:32:25.770]     ...future.conditions <- base::list()
[15:32:25.770]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:25.770]     if (FALSE) {
[15:32:25.770]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:25.770]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:25.770]     }
[15:32:25.770]     ...future.result <- base::tryCatch({
[15:32:25.770]         base::withCallingHandlers({
[15:32:25.770]             ...future.value <- base::withVisible(base::local({
[15:32:25.770]                 do.call(function(...) {
[15:32:25.770]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:25.770]                   if (!identical(...future.globals.maxSize.org, 
[15:32:25.770]                     ...future.globals.maxSize)) {
[15:32:25.770]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:25.770]                     on.exit(options(oopts), add = TRUE)
[15:32:25.770]                   }
[15:32:25.770]                   {
[15:32:25.770]                     lapply(seq_along(...future.elements_ii), 
[15:32:25.770]                       FUN = function(jj) {
[15:32:25.770]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:25.770]                         ...future.FUN(...future.X_jj)
[15:32:25.770]                       })
[15:32:25.770]                   }
[15:32:25.770]                 }, args = future.call.arguments)
[15:32:25.770]             }))
[15:32:25.770]             future::FutureResult(value = ...future.value$value, 
[15:32:25.770]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:25.770]                   ...future.rng), globalenv = if (FALSE) 
[15:32:25.770]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:25.770]                     ...future.globalenv.names))
[15:32:25.770]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:25.770]         }, condition = base::local({
[15:32:25.770]             c <- base::c
[15:32:25.770]             inherits <- base::inherits
[15:32:25.770]             invokeRestart <- base::invokeRestart
[15:32:25.770]             length <- base::length
[15:32:25.770]             list <- base::list
[15:32:25.770]             seq.int <- base::seq.int
[15:32:25.770]             signalCondition <- base::signalCondition
[15:32:25.770]             sys.calls <- base::sys.calls
[15:32:25.770]             `[[` <- base::`[[`
[15:32:25.770]             `+` <- base::`+`
[15:32:25.770]             `<<-` <- base::`<<-`
[15:32:25.770]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:25.770]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:25.770]                   3L)]
[15:32:25.770]             }
[15:32:25.770]             function(cond) {
[15:32:25.770]                 is_error <- inherits(cond, "error")
[15:32:25.770]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:25.770]                   NULL)
[15:32:25.770]                 if (is_error) {
[15:32:25.770]                   sessionInformation <- function() {
[15:32:25.770]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:25.770]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:25.770]                       search = base::search(), system = base::Sys.info())
[15:32:25.770]                   }
[15:32:25.770]                   ...future.conditions[[length(...future.conditions) + 
[15:32:25.770]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:25.770]                     cond$call), session = sessionInformation(), 
[15:32:25.770]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:25.770]                   signalCondition(cond)
[15:32:25.770]                 }
[15:32:25.770]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:25.770]                 "immediateCondition"))) {
[15:32:25.770]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:25.770]                   ...future.conditions[[length(...future.conditions) + 
[15:32:25.770]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:25.770]                   if (TRUE && !signal) {
[15:32:25.770]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:25.770]                     {
[15:32:25.770]                       inherits <- base::inherits
[15:32:25.770]                       invokeRestart <- base::invokeRestart
[15:32:25.770]                       is.null <- base::is.null
[15:32:25.770]                       muffled <- FALSE
[15:32:25.770]                       if (inherits(cond, "message")) {
[15:32:25.770]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:25.770]                         if (muffled) 
[15:32:25.770]                           invokeRestart("muffleMessage")
[15:32:25.770]                       }
[15:32:25.770]                       else if (inherits(cond, "warning")) {
[15:32:25.770]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:25.770]                         if (muffled) 
[15:32:25.770]                           invokeRestart("muffleWarning")
[15:32:25.770]                       }
[15:32:25.770]                       else if (inherits(cond, "condition")) {
[15:32:25.770]                         if (!is.null(pattern)) {
[15:32:25.770]                           computeRestarts <- base::computeRestarts
[15:32:25.770]                           grepl <- base::grepl
[15:32:25.770]                           restarts <- computeRestarts(cond)
[15:32:25.770]                           for (restart in restarts) {
[15:32:25.770]                             name <- restart$name
[15:32:25.770]                             if (is.null(name)) 
[15:32:25.770]                               next
[15:32:25.770]                             if (!grepl(pattern, name)) 
[15:32:25.770]                               next
[15:32:25.770]                             invokeRestart(restart)
[15:32:25.770]                             muffled <- TRUE
[15:32:25.770]                             break
[15:32:25.770]                           }
[15:32:25.770]                         }
[15:32:25.770]                       }
[15:32:25.770]                       invisible(muffled)
[15:32:25.770]                     }
[15:32:25.770]                     muffleCondition(cond, pattern = "^muffle")
[15:32:25.770]                   }
[15:32:25.770]                 }
[15:32:25.770]                 else {
[15:32:25.770]                   if (TRUE) {
[15:32:25.770]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:25.770]                     {
[15:32:25.770]                       inherits <- base::inherits
[15:32:25.770]                       invokeRestart <- base::invokeRestart
[15:32:25.770]                       is.null <- base::is.null
[15:32:25.770]                       muffled <- FALSE
[15:32:25.770]                       if (inherits(cond, "message")) {
[15:32:25.770]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:25.770]                         if (muffled) 
[15:32:25.770]                           invokeRestart("muffleMessage")
[15:32:25.770]                       }
[15:32:25.770]                       else if (inherits(cond, "warning")) {
[15:32:25.770]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:25.770]                         if (muffled) 
[15:32:25.770]                           invokeRestart("muffleWarning")
[15:32:25.770]                       }
[15:32:25.770]                       else if (inherits(cond, "condition")) {
[15:32:25.770]                         if (!is.null(pattern)) {
[15:32:25.770]                           computeRestarts <- base::computeRestarts
[15:32:25.770]                           grepl <- base::grepl
[15:32:25.770]                           restarts <- computeRestarts(cond)
[15:32:25.770]                           for (restart in restarts) {
[15:32:25.770]                             name <- restart$name
[15:32:25.770]                             if (is.null(name)) 
[15:32:25.770]                               next
[15:32:25.770]                             if (!grepl(pattern, name)) 
[15:32:25.770]                               next
[15:32:25.770]                             invokeRestart(restart)
[15:32:25.770]                             muffled <- TRUE
[15:32:25.770]                             break
[15:32:25.770]                           }
[15:32:25.770]                         }
[15:32:25.770]                       }
[15:32:25.770]                       invisible(muffled)
[15:32:25.770]                     }
[15:32:25.770]                     muffleCondition(cond, pattern = "^muffle")
[15:32:25.770]                   }
[15:32:25.770]                 }
[15:32:25.770]             }
[15:32:25.770]         }))
[15:32:25.770]     }, error = function(ex) {
[15:32:25.770]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:25.770]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:25.770]                 ...future.rng), started = ...future.startTime, 
[15:32:25.770]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:25.770]             version = "1.8"), class = "FutureResult")
[15:32:25.770]     }, finally = {
[15:32:25.770]         if (!identical(...future.workdir, getwd())) 
[15:32:25.770]             setwd(...future.workdir)
[15:32:25.770]         {
[15:32:25.770]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:25.770]                 ...future.oldOptions$nwarnings <- NULL
[15:32:25.770]             }
[15:32:25.770]             base::options(...future.oldOptions)
[15:32:25.770]             if (.Platform$OS.type == "windows") {
[15:32:25.770]                 old_names <- names(...future.oldEnvVars)
[15:32:25.770]                 envs <- base::Sys.getenv()
[15:32:25.770]                 names <- names(envs)
[15:32:25.770]                 common <- intersect(names, old_names)
[15:32:25.770]                 added <- setdiff(names, old_names)
[15:32:25.770]                 removed <- setdiff(old_names, names)
[15:32:25.770]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:25.770]                   envs[common]]
[15:32:25.770]                 NAMES <- toupper(changed)
[15:32:25.770]                 args <- list()
[15:32:25.770]                 for (kk in seq_along(NAMES)) {
[15:32:25.770]                   name <- changed[[kk]]
[15:32:25.770]                   NAME <- NAMES[[kk]]
[15:32:25.770]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:25.770]                     next
[15:32:25.770]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:25.770]                 }
[15:32:25.770]                 NAMES <- toupper(added)
[15:32:25.770]                 for (kk in seq_along(NAMES)) {
[15:32:25.770]                   name <- added[[kk]]
[15:32:25.770]                   NAME <- NAMES[[kk]]
[15:32:25.770]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:25.770]                     next
[15:32:25.770]                   args[[name]] <- ""
[15:32:25.770]                 }
[15:32:25.770]                 NAMES <- toupper(removed)
[15:32:25.770]                 for (kk in seq_along(NAMES)) {
[15:32:25.770]                   name <- removed[[kk]]
[15:32:25.770]                   NAME <- NAMES[[kk]]
[15:32:25.770]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:25.770]                     next
[15:32:25.770]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:25.770]                 }
[15:32:25.770]                 if (length(args) > 0) 
[15:32:25.770]                   base::do.call(base::Sys.setenv, args = args)
[15:32:25.770]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:25.770]             }
[15:32:25.770]             else {
[15:32:25.770]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:25.770]             }
[15:32:25.770]             {
[15:32:25.770]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:25.770]                   0L) {
[15:32:25.770]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:25.770]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:25.770]                   base::options(opts)
[15:32:25.770]                 }
[15:32:25.770]                 {
[15:32:25.770]                   {
[15:32:25.770]                     NULL
[15:32:25.770]                     RNGkind("Mersenne-Twister")
[15:32:25.770]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:25.770]                       inherits = FALSE)
[15:32:25.770]                   }
[15:32:25.770]                   options(future.plan = NULL)
[15:32:25.770]                   if (is.na(NA_character_)) 
[15:32:25.770]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:25.770]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:25.770]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:25.770]                     .init = FALSE)
[15:32:25.770]                 }
[15:32:25.770]             }
[15:32:25.770]         }
[15:32:25.770]     })
[15:32:25.770]     if (TRUE) {
[15:32:25.770]         base::sink(type = "output", split = FALSE)
[15:32:25.770]         if (TRUE) {
[15:32:25.770]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:25.770]         }
[15:32:25.770]         else {
[15:32:25.770]             ...future.result["stdout"] <- base::list(NULL)
[15:32:25.770]         }
[15:32:25.770]         base::close(...future.stdout)
[15:32:25.770]         ...future.stdout <- NULL
[15:32:25.770]     }
[15:32:25.770]     ...future.result$conditions <- ...future.conditions
[15:32:25.770]     ...future.result$finished <- base::Sys.time()
[15:32:25.770]     ...future.result
[15:32:25.770] }
[15:32:25.777] assign_globals() ...
[15:32:25.778] List of 6
[15:32:25.778]  $ ...future.FUN            :function (x)  
[15:32:25.778]  $ compute                  :function (a, x_vec)  
[15:32:25.778]  $ future.call.arguments    :List of 1
[15:32:25.778]   ..$ : int 0
[15:32:25.778]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:25.778]  $ ...future.elements_ii    :List of 2
[15:32:25.778]   ..$ : int 1
[15:32:25.778]   ..$ : int 2
[15:32:25.778]  $ ...future.seeds_ii       : NULL
[15:32:25.778]  $ ...future.globals.maxSize: NULL
[15:32:25.778]  - attr(*, "where")=List of 6
[15:32:25.778]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:25.778]   ..$ compute                  :<environment: R_EmptyEnv> 
[15:32:25.778]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:25.778]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:25.778]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:25.778]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:25.778]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:25.778]  - attr(*, "resolved")= logi FALSE
[15:32:25.778]  - attr(*, "total_size")= num 4016
[15:32:25.778]  - attr(*, "already-done")= logi TRUE
[15:32:25.790] - reassign environment for '...future.FUN'
[15:32:25.790] - copied '...future.FUN' to environment
[15:32:25.790] - reassign environment for 'compute'
[15:32:25.791] - copied 'compute' to environment
[15:32:25.791] - copied 'future.call.arguments' to environment
[15:32:25.791] - copied '...future.elements_ii' to environment
[15:32:25.792] - copied '...future.seeds_ii' to environment
[15:32:25.792] - copied '...future.globals.maxSize' to environment
[15:32:25.792] assign_globals() ... done
[15:32:25.793] plan(): Setting new future strategy stack:
[15:32:25.793] List of future strategies:
[15:32:25.793] 1. sequential:
[15:32:25.793]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:25.793]    - tweaked: FALSE
[15:32:25.793]    - call: NULL
[15:32:25.794] plan(): nbrOfWorkers() = 1
[15:32:25.797] plan(): Setting new future strategy stack:
[15:32:25.797] List of future strategies:
[15:32:25.797] 1. sequential:
[15:32:25.797]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:25.797]    - tweaked: FALSE
[15:32:25.797]    - call: plan(strategy)
[15:32:25.798] plan(): nbrOfWorkers() = 1
[15:32:25.798] SequentialFuture started (and completed)
[15:32:25.799] - Launch lazy future ... done
[15:32:25.799] run() for 'SequentialFuture' ... done
[15:32:25.799] Created future:
[15:32:25.799] SequentialFuture:
[15:32:25.799] Label: 'future_sapply-1'
[15:32:25.799] Expression:
[15:32:25.799] {
[15:32:25.799]     do.call(function(...) {
[15:32:25.799]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:25.799]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:25.799]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:25.799]             on.exit(options(oopts), add = TRUE)
[15:32:25.799]         }
[15:32:25.799]         {
[15:32:25.799]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:25.799]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:25.799]                 ...future.FUN(...future.X_jj)
[15:32:25.799]             })
[15:32:25.799]         }
[15:32:25.799]     }, args = future.call.arguments)
[15:32:25.799] }
[15:32:25.799] Lazy evaluation: FALSE
[15:32:25.799] Asynchronous evaluation: FALSE
[15:32:25.799] Local evaluation: TRUE
[15:32:25.799] Environment: 0x00000276e4e02260
[15:32:25.799] Capture standard output: TRUE
[15:32:25.799] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:25.799] Globals: 6 objects totaling 4.03 KiB (function '...future.FUN' of 2.43 KiB, function 'compute' of 1.44 KiB, DotDotDotList 'future.call.arguments' of 56 bytes, list '...future.elements_ii' of 112 bytes, NULL '...future.seeds_ii' of 0 bytes, ...)
[15:32:25.799] Packages: <none>
[15:32:25.799] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:25.799] Resolved: TRUE
[15:32:25.799] Value: 112 bytes of class 'list'
[15:32:25.799] Early signaling: FALSE
[15:32:25.799] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:25.799] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:25.801] Chunk #1 of 1 ... DONE
[15:32:25.801] Launching 1 futures (chunks) ... DONE
[15:32:25.802] Resolving 1 futures (chunks) ...
[15:32:25.802] resolve() on list ...
[15:32:25.802]  recursive: 0
[15:32:25.802]  length: 1
[15:32:25.802] 
[15:32:25.803] resolved() for 'SequentialFuture' ...
[15:32:25.803] - state: 'finished'
[15:32:25.803] - run: TRUE
[15:32:25.803] - result: 'FutureResult'
[15:32:25.803] resolved() for 'SequentialFuture' ... done
[15:32:25.803] Future #1
[15:32:25.804] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:25.804] - nx: 1
[15:32:25.804] - relay: TRUE
[15:32:25.804] - stdout: TRUE
[15:32:25.804] - signal: TRUE
[15:32:25.805] - resignal: FALSE
[15:32:25.805] - force: TRUE
[15:32:25.805] - relayed: [n=1] FALSE
[15:32:25.805] - queued futures: [n=1] FALSE
[15:32:25.805]  - until=1
[15:32:25.806]  - relaying element #1
[15:32:25.806] - relayed: [n=1] TRUE
[15:32:25.806] - queued futures: [n=1] TRUE
[15:32:25.806] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:25.806]  length: 0 (resolved future 1)
[15:32:25.807] Relaying remaining futures
[15:32:25.807] signalConditionsASAP(NULL, pos=0) ...
[15:32:25.807] - nx: 1
[15:32:25.807] - relay: TRUE
[15:32:25.807] - stdout: TRUE
[15:32:25.807] - signal: TRUE
[15:32:25.808] - resignal: FALSE
[15:32:25.808] - force: TRUE
[15:32:25.808] - relayed: [n=1] TRUE
[15:32:25.808] - queued futures: [n=1] TRUE
 - flush all
[15:32:25.808] - relayed: [n=1] TRUE
[15:32:25.809] - queued futures: [n=1] TRUE
[15:32:25.809] signalConditionsASAP(NULL, pos=0) ... done
[15:32:25.809] resolve() on list ... DONE
[15:32:25.809]  - Number of value chunks collected: 1
[15:32:25.809] Resolving 1 futures (chunks) ... DONE
[15:32:25.810] Reducing values from 1 chunks ...
[15:32:25.810]  - Number of values collected after concatenation: 2
[15:32:25.810]  - Number of values expected: 2
[15:32:25.810] Reducing values from 1 chunks ... DONE
[15:32:25.810] future_lapply() ... DONE
[1] 1 2
[15:32:25.811] plan(): Setting new future strategy stack:
[15:32:25.811] List of future strategies:
[15:32:25.811] 1. sequential:
[15:32:25.811]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:25.811]    - tweaked: FALSE
[15:32:25.811]    - call: plan(sequential)
[15:32:25.812] plan(): nbrOfWorkers() = 1
*** strategy = 'sequential' ... done
*** strategy = 'multisession' ...
[15:32:25.812] plan(): Setting new future strategy stack:
[15:32:25.813] List of future strategies:
[15:32:25.813] 1. multisession:
[15:32:25.813]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[15:32:25.813]    - tweaked: FALSE
[15:32:25.813]    - call: plan(strategy)
[15:32:25.813] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
[15:32:25.813] multisession:
[15:32:25.813] - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[15:32:25.813] - tweaked: FALSE
[15:32:25.813] - call: plan(strategy)
[15:32:25.819] getGlobalsAndPackages() ...
[15:32:25.819] Not searching for globals
[15:32:25.819] - globals: [0] <none>
[15:32:25.819] getGlobalsAndPackages() ... DONE
[15:32:25.820] [local output] makeClusterPSOCK() ...
[15:32:25.888] [local output] Workers: [n = 2] 'localhost', 'localhost'
[15:32:25.895] [local output] Base port: 36733
[15:32:25.895] [local output] Getting setup options for 2 cluster nodes ...
[15:32:25.895] [local output]  - Node 1 of 2 ...
[15:32:25.896] [local output] localMachine=TRUE => revtunnel=FALSE

[15:32:25.897] Testing if worker's PID can be inferred: '"D:/RCompile/recent/R/bin/x64/Rscript" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpINLIso/worker.rank=1.parallelly.parent=41016.a0381f9356f6.pid\")), silent = TRUE)" -e "file.exists(\"D:/temp/RtmpINLIso/worker.rank=1.parallelly.parent=41016.a0381f9356f6.pid\")"'
[15:32:26.344] - Possible to infer worker's PID: TRUE
[15:32:26.345] [local output] Rscript port: 36733

[15:32:26.346] [local output]  - Node 2 of 2 ...
[15:32:26.346] [local output] localMachine=TRUE => revtunnel=FALSE

[15:32:26.348] [local output] Rscript port: 36733

[15:32:26.349] [local output] Getting setup options for 2 cluster nodes ... done
[15:32:26.350] [local output]  - Parallel setup requested for some PSOCK nodes
[15:32:26.351] [local output] Setting up PSOCK nodes in parallel
[15:32:26.351] List of 36
[15:32:26.351]  $ worker          : chr "localhost"
[15:32:26.351]   ..- attr(*, "localhost")= logi TRUE
[15:32:26.351]  $ master          : chr "localhost"
[15:32:26.351]  $ port            : int 36733
[15:32:26.351]  $ connectTimeout  : num 120
[15:32:26.351]  $ timeout         : num 120
[15:32:26.351]  $ rscript         : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\""
[15:32:26.351]  $ homogeneous     : logi TRUE
[15:32:26.351]  $ rscript_args    : chr "--default-packages=datasets,utils,grDevices,graphics,stats,methods -e \"#label=future_sapply.R:41016:CRANWIN3:C"| __truncated__
[15:32:26.351]  $ rscript_envs    : NULL
[15:32:26.351]  $ rscript_libs    : chr [1:2] "D:/temp/RtmpIhDozX/RLIBS_2bbc83f2b47c7" "D:/RCompile/recent/R/library"
[15:32:26.351]  $ rscript_startup : NULL
[15:32:26.351]  $ rscript_sh      : chr "cmd"
[15:32:26.351]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[15:32:26.351]  $ methods         : logi TRUE
[15:32:26.351]  $ socketOptions   : chr "no-delay"
[15:32:26.351]  $ useXDR          : logi FALSE
[15:32:26.351]  $ outfile         : chr "/dev/null"
[15:32:26.351]  $ renice          : int NA
[15:32:26.351]  $ rshcmd          : NULL
[15:32:26.351]  $ user            : chr(0) 
[15:32:26.351]  $ revtunnel       : logi FALSE
[15:32:26.351]  $ rshlogfile      : NULL
[15:32:26.351]  $ rshopts         : chr(0) 
[15:32:26.351]  $ rank            : int 1
[15:32:26.351]  $ manual          : logi FALSE
[15:32:26.351]  $ dryrun          : logi FALSE
[15:32:26.351]  $ quiet           : logi FALSE
[15:32:26.351]  $ setup_strategy  : chr "parallel"
[15:32:26.351]  $ local_cmd       : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[15:32:26.351]  $ pidfile         : chr "D:/temp/RtmpINLIso/worker.rank=1.parallelly.parent=41016.a0381f9356f6.pid"
[15:32:26.351]  $ rshcmd_label    : NULL
[15:32:26.351]  $ rsh_call        : NULL
[15:32:26.351]  $ cmd             : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[15:32:26.351]  $ localMachine    : logi TRUE
[15:32:26.351]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[15:32:26.351]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[15:32:26.351]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[15:32:26.351]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[15:32:26.351]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[15:32:26.351]         "cmd", "sh"), default_packages = c("datasets", "utils", "grDevices", 
[15:32:26.351]         "graphics", "stats", if (methods) "methods"), methods = TRUE, socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[15:32:26.351]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[15:32:26.351]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[15:32:26.351]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[15:32:26.351]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[15:32:26.351]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[15:32:26.351]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[15:32:26.351]  $ arguments       :List of 28
[15:32:26.351]   ..$ worker          : chr "localhost"
[15:32:26.351]   ..$ master          : NULL
[15:32:26.351]   ..$ port            : int 36733
[15:32:26.351]   ..$ connectTimeout  : num 120
[15:32:26.351]   ..$ timeout         : num 120
[15:32:26.351]   ..$ rscript         : NULL
[15:32:26.351]   ..$ homogeneous     : NULL
[15:32:26.351]   ..$ rscript_args    : NULL
[15:32:26.351]   ..$ rscript_envs    : NULL
[15:32:26.351]   ..$ rscript_libs    : chr [1:2] "D:/temp/RtmpIhDozX/RLIBS_2bbc83f2b47c7" "D:/RCompile/recent/R/library"
[15:32:26.351]   ..$ rscript_startup : NULL
[15:32:26.351]   ..$ rscript_sh      : chr [1:3] "auto" "cmd" "sh"
[15:32:26.351]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[15:32:26.351]   ..$ methods         : logi TRUE
[15:32:26.351]   ..$ socketOptions   : chr "no-delay"
[15:32:26.351]   ..$ useXDR          : logi FALSE
[15:32:26.351]   ..$ outfile         : chr "/dev/null"
[15:32:26.351]   ..$ renice          : int NA
[15:32:26.351]   ..$ rshcmd          : NULL
[15:32:26.351]   ..$ user            : NULL
[15:32:26.351]   ..$ revtunnel       : logi NA
[15:32:26.351]   ..$ rshlogfile      : NULL
[15:32:26.351]   ..$ rshopts         : NULL
[15:32:26.351]   ..$ rank            : int 1
[15:32:26.351]   ..$ manual          : logi FALSE
[15:32:26.351]   ..$ dryrun          : logi FALSE
[15:32:26.351]   ..$ quiet           : logi FALSE
[15:32:26.351]   ..$ setup_strategy  : chr "parallel"
[15:32:26.351]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[15:32:26.389] [local output] System call to launch all workers:
[15:32:26.389] [local output] "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=future_sapply.R:41016:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpINLIso/worker.rank=1.parallelly.parent=41016.a0381f9356f6.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e ".libPaths(c(\"D:/temp/RtmpIhDozX/RLIBS_2bbc83f2b47c7\",\"D:/RCompile/recent/R/library\"))" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" MASTER=localhost PORT=36733 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[15:32:26.389] [local output] Starting PSOCK main server
[15:32:26.398] [local output] Workers launched
[15:32:26.398] [local output] Waiting for workers to connect back
[15:32:26.399]  - [local output] 0 workers out of 2 ready
[15:32:26.623]  - [local output] 0 workers out of 2 ready
[15:32:26.623]  - [local output] 1 workers out of 2 ready
[15:32:26.678]  - [local output] 1 workers out of 2 ready
[15:32:26.679]  - [local output] 2 workers out of 2 ready
[15:32:26.679] [local output] Launching of workers completed
[15:32:26.680] [local output] Collecting session information from workers
[15:32:26.681] [local output]  - Worker #1 of 2
[15:32:26.683] [local output]  - Worker #2 of 2
[15:32:26.683] [local output] makeClusterPSOCK() ... done
[15:32:26.700] Packages needed by the future expression (n = 0): <none>
[15:32:26.701] Packages needed by future strategies (n = 0): <none>
[15:32:26.702] {
[15:32:26.702]     {
[15:32:26.702]         {
[15:32:26.702]             ...future.startTime <- base::Sys.time()
[15:32:26.702]             {
[15:32:26.702]                 {
[15:32:26.702]                   {
[15:32:26.702]                     {
[15:32:26.702]                       base::local({
[15:32:26.702]                         has_future <- base::requireNamespace("future", 
[15:32:26.702]                           quietly = TRUE)
[15:32:26.702]                         if (has_future) {
[15:32:26.702]                           ns <- base::getNamespace("future")
[15:32:26.702]                           version <- ns[[".package"]][["version"]]
[15:32:26.702]                           if (is.null(version)) 
[15:32:26.702]                             version <- utils::packageVersion("future")
[15:32:26.702]                         }
[15:32:26.702]                         else {
[15:32:26.702]                           version <- NULL
[15:32:26.702]                         }
[15:32:26.702]                         if (!has_future || version < "1.8.0") {
[15:32:26.702]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:26.702]                             "", base::R.version$version.string), 
[15:32:26.702]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:26.702]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:26.702]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:26.702]                               "release", "version")], collapse = " "), 
[15:32:26.702]                             hostname = base::Sys.info()[["nodename"]])
[15:32:26.702]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:26.702]                             info)
[15:32:26.702]                           info <- base::paste(info, collapse = "; ")
[15:32:26.702]                           if (!has_future) {
[15:32:26.702]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:26.702]                               info)
[15:32:26.702]                           }
[15:32:26.702]                           else {
[15:32:26.702]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:26.702]                               info, version)
[15:32:26.702]                           }
[15:32:26.702]                           base::stop(msg)
[15:32:26.702]                         }
[15:32:26.702]                       })
[15:32:26.702]                     }
[15:32:26.702]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:26.702]                     base::options(mc.cores = 1L)
[15:32:26.702]                   }
[15:32:26.702]                   ...future.strategy.old <- future::plan("list")
[15:32:26.702]                   options(future.plan = NULL)
[15:32:26.702]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:26.702]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:26.702]                 }
[15:32:26.702]                 ...future.workdir <- getwd()
[15:32:26.702]             }
[15:32:26.702]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:26.702]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:26.702]         }
[15:32:26.702]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:26.702]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:26.702]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:26.702]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:26.702]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:26.702]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:26.702]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:26.702]             base::names(...future.oldOptions))
[15:32:26.702]     }
[15:32:26.702]     if (FALSE) {
[15:32:26.702]     }
[15:32:26.702]     else {
[15:32:26.702]         if (TRUE) {
[15:32:26.702]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:26.702]                 open = "w")
[15:32:26.702]         }
[15:32:26.702]         else {
[15:32:26.702]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:26.702]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:26.702]         }
[15:32:26.702]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:26.702]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:26.702]             base::sink(type = "output", split = FALSE)
[15:32:26.702]             base::close(...future.stdout)
[15:32:26.702]         }, add = TRUE)
[15:32:26.702]     }
[15:32:26.702]     ...future.frame <- base::sys.nframe()
[15:32:26.702]     ...future.conditions <- base::list()
[15:32:26.702]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:26.702]     if (FALSE) {
[15:32:26.702]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:26.702]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:26.702]     }
[15:32:26.702]     ...future.result <- base::tryCatch({
[15:32:26.702]         base::withCallingHandlers({
[15:32:26.702]             ...future.value <- base::withVisible(base::local({
[15:32:26.702]                 ...future.makeSendCondition <- base::local({
[15:32:26.702]                   sendCondition <- NULL
[15:32:26.702]                   function(frame = 1L) {
[15:32:26.702]                     if (is.function(sendCondition)) 
[15:32:26.702]                       return(sendCondition)
[15:32:26.702]                     ns <- getNamespace("parallel")
[15:32:26.702]                     if (exists("sendData", mode = "function", 
[15:32:26.702]                       envir = ns)) {
[15:32:26.702]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:26.702]                         envir = ns)
[15:32:26.702]                       envir <- sys.frame(frame)
[15:32:26.702]                       master <- NULL
[15:32:26.702]                       while (!identical(envir, .GlobalEnv) && 
[15:32:26.702]                         !identical(envir, emptyenv())) {
[15:32:26.702]                         if (exists("master", mode = "list", envir = envir, 
[15:32:26.702]                           inherits = FALSE)) {
[15:32:26.702]                           master <- get("master", mode = "list", 
[15:32:26.702]                             envir = envir, inherits = FALSE)
[15:32:26.702]                           if (inherits(master, c("SOCKnode", 
[15:32:26.702]                             "SOCK0node"))) {
[15:32:26.702]                             sendCondition <<- function(cond) {
[15:32:26.702]                               data <- list(type = "VALUE", value = cond, 
[15:32:26.702]                                 success = TRUE)
[15:32:26.702]                               parallel_sendData(master, data)
[15:32:26.702]                             }
[15:32:26.702]                             return(sendCondition)
[15:32:26.702]                           }
[15:32:26.702]                         }
[15:32:26.702]                         frame <- frame + 1L
[15:32:26.702]                         envir <- sys.frame(frame)
[15:32:26.702]                       }
[15:32:26.702]                     }
[15:32:26.702]                     sendCondition <<- function(cond) NULL
[15:32:26.702]                   }
[15:32:26.702]                 })
[15:32:26.702]                 withCallingHandlers({
[15:32:26.702]                   NA
[15:32:26.702]                 }, immediateCondition = function(cond) {
[15:32:26.702]                   sendCondition <- ...future.makeSendCondition()
[15:32:26.702]                   sendCondition(cond)
[15:32:26.702]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:26.702]                   {
[15:32:26.702]                     inherits <- base::inherits
[15:32:26.702]                     invokeRestart <- base::invokeRestart
[15:32:26.702]                     is.null <- base::is.null
[15:32:26.702]                     muffled <- FALSE
[15:32:26.702]                     if (inherits(cond, "message")) {
[15:32:26.702]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:26.702]                       if (muffled) 
[15:32:26.702]                         invokeRestart("muffleMessage")
[15:32:26.702]                     }
[15:32:26.702]                     else if (inherits(cond, "warning")) {
[15:32:26.702]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:26.702]                       if (muffled) 
[15:32:26.702]                         invokeRestart("muffleWarning")
[15:32:26.702]                     }
[15:32:26.702]                     else if (inherits(cond, "condition")) {
[15:32:26.702]                       if (!is.null(pattern)) {
[15:32:26.702]                         computeRestarts <- base::computeRestarts
[15:32:26.702]                         grepl <- base::grepl
[15:32:26.702]                         restarts <- computeRestarts(cond)
[15:32:26.702]                         for (restart in restarts) {
[15:32:26.702]                           name <- restart$name
[15:32:26.702]                           if (is.null(name)) 
[15:32:26.702]                             next
[15:32:26.702]                           if (!grepl(pattern, name)) 
[15:32:26.702]                             next
[15:32:26.702]                           invokeRestart(restart)
[15:32:26.702]                           muffled <- TRUE
[15:32:26.702]                           break
[15:32:26.702]                         }
[15:32:26.702]                       }
[15:32:26.702]                     }
[15:32:26.702]                     invisible(muffled)
[15:32:26.702]                   }
[15:32:26.702]                   muffleCondition(cond)
[15:32:26.702]                 })
[15:32:26.702]             }))
[15:32:26.702]             future::FutureResult(value = ...future.value$value, 
[15:32:26.702]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:26.702]                   ...future.rng), globalenv = if (FALSE) 
[15:32:26.702]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:26.702]                     ...future.globalenv.names))
[15:32:26.702]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:26.702]         }, condition = base::local({
[15:32:26.702]             c <- base::c
[15:32:26.702]             inherits <- base::inherits
[15:32:26.702]             invokeRestart <- base::invokeRestart
[15:32:26.702]             length <- base::length
[15:32:26.702]             list <- base::list
[15:32:26.702]             seq.int <- base::seq.int
[15:32:26.702]             signalCondition <- base::signalCondition
[15:32:26.702]             sys.calls <- base::sys.calls
[15:32:26.702]             `[[` <- base::`[[`
[15:32:26.702]             `+` <- base::`+`
[15:32:26.702]             `<<-` <- base::`<<-`
[15:32:26.702]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:26.702]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:26.702]                   3L)]
[15:32:26.702]             }
[15:32:26.702]             function(cond) {
[15:32:26.702]                 is_error <- inherits(cond, "error")
[15:32:26.702]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:26.702]                   NULL)
[15:32:26.702]                 if (is_error) {
[15:32:26.702]                   sessionInformation <- function() {
[15:32:26.702]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:26.702]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:26.702]                       search = base::search(), system = base::Sys.info())
[15:32:26.702]                   }
[15:32:26.702]                   ...future.conditions[[length(...future.conditions) + 
[15:32:26.702]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:26.702]                     cond$call), session = sessionInformation(), 
[15:32:26.702]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:26.702]                   signalCondition(cond)
[15:32:26.702]                 }
[15:32:26.702]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:26.702]                 "immediateCondition"))) {
[15:32:26.702]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:26.702]                   ...future.conditions[[length(...future.conditions) + 
[15:32:26.702]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:26.702]                   if (TRUE && !signal) {
[15:32:26.702]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:26.702]                     {
[15:32:26.702]                       inherits <- base::inherits
[15:32:26.702]                       invokeRestart <- base::invokeRestart
[15:32:26.702]                       is.null <- base::is.null
[15:32:26.702]                       muffled <- FALSE
[15:32:26.702]                       if (inherits(cond, "message")) {
[15:32:26.702]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:26.702]                         if (muffled) 
[15:32:26.702]                           invokeRestart("muffleMessage")
[15:32:26.702]                       }
[15:32:26.702]                       else if (inherits(cond, "warning")) {
[15:32:26.702]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:26.702]                         if (muffled) 
[15:32:26.702]                           invokeRestart("muffleWarning")
[15:32:26.702]                       }
[15:32:26.702]                       else if (inherits(cond, "condition")) {
[15:32:26.702]                         if (!is.null(pattern)) {
[15:32:26.702]                           computeRestarts <- base::computeRestarts
[15:32:26.702]                           grepl <- base::grepl
[15:32:26.702]                           restarts <- computeRestarts(cond)
[15:32:26.702]                           for (restart in restarts) {
[15:32:26.702]                             name <- restart$name
[15:32:26.702]                             if (is.null(name)) 
[15:32:26.702]                               next
[15:32:26.702]                             if (!grepl(pattern, name)) 
[15:32:26.702]                               next
[15:32:26.702]                             invokeRestart(restart)
[15:32:26.702]                             muffled <- TRUE
[15:32:26.702]                             break
[15:32:26.702]                           }
[15:32:26.702]                         }
[15:32:26.702]                       }
[15:32:26.702]                       invisible(muffled)
[15:32:26.702]                     }
[15:32:26.702]                     muffleCondition(cond, pattern = "^muffle")
[15:32:26.702]                   }
[15:32:26.702]                 }
[15:32:26.702]                 else {
[15:32:26.702]                   if (TRUE) {
[15:32:26.702]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:26.702]                     {
[15:32:26.702]                       inherits <- base::inherits
[15:32:26.702]                       invokeRestart <- base::invokeRestart
[15:32:26.702]                       is.null <- base::is.null
[15:32:26.702]                       muffled <- FALSE
[15:32:26.702]                       if (inherits(cond, "message")) {
[15:32:26.702]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:26.702]                         if (muffled) 
[15:32:26.702]                           invokeRestart("muffleMessage")
[15:32:26.702]                       }
[15:32:26.702]                       else if (inherits(cond, "warning")) {
[15:32:26.702]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:26.702]                         if (muffled) 
[15:32:26.702]                           invokeRestart("muffleWarning")
[15:32:26.702]                       }
[15:32:26.702]                       else if (inherits(cond, "condition")) {
[15:32:26.702]                         if (!is.null(pattern)) {
[15:32:26.702]                           computeRestarts <- base::computeRestarts
[15:32:26.702]                           grepl <- base::grepl
[15:32:26.702]                           restarts <- computeRestarts(cond)
[15:32:26.702]                           for (restart in restarts) {
[15:32:26.702]                             name <- restart$name
[15:32:26.702]                             if (is.null(name)) 
[15:32:26.702]                               next
[15:32:26.702]                             if (!grepl(pattern, name)) 
[15:32:26.702]                               next
[15:32:26.702]                             invokeRestart(restart)
[15:32:26.702]                             muffled <- TRUE
[15:32:26.702]                             break
[15:32:26.702]                           }
[15:32:26.702]                         }
[15:32:26.702]                       }
[15:32:26.702]                       invisible(muffled)
[15:32:26.702]                     }
[15:32:26.702]                     muffleCondition(cond, pattern = "^muffle")
[15:32:26.702]                   }
[15:32:26.702]                 }
[15:32:26.702]             }
[15:32:26.702]         }))
[15:32:26.702]     }, error = function(ex) {
[15:32:26.702]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:26.702]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:26.702]                 ...future.rng), started = ...future.startTime, 
[15:32:26.702]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:26.702]             version = "1.8"), class = "FutureResult")
[15:32:26.702]     }, finally = {
[15:32:26.702]         if (!identical(...future.workdir, getwd())) 
[15:32:26.702]             setwd(...future.workdir)
[15:32:26.702]         {
[15:32:26.702]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:26.702]                 ...future.oldOptions$nwarnings <- NULL
[15:32:26.702]             }
[15:32:26.702]             base::options(...future.oldOptions)
[15:32:26.702]             if (.Platform$OS.type == "windows") {
[15:32:26.702]                 old_names <- names(...future.oldEnvVars)
[15:32:26.702]                 envs <- base::Sys.getenv()
[15:32:26.702]                 names <- names(envs)
[15:32:26.702]                 common <- intersect(names, old_names)
[15:32:26.702]                 added <- setdiff(names, old_names)
[15:32:26.702]                 removed <- setdiff(old_names, names)
[15:32:26.702]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:26.702]                   envs[common]]
[15:32:26.702]                 NAMES <- toupper(changed)
[15:32:26.702]                 args <- list()
[15:32:26.702]                 for (kk in seq_along(NAMES)) {
[15:32:26.702]                   name <- changed[[kk]]
[15:32:26.702]                   NAME <- NAMES[[kk]]
[15:32:26.702]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:26.702]                     next
[15:32:26.702]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:26.702]                 }
[15:32:26.702]                 NAMES <- toupper(added)
[15:32:26.702]                 for (kk in seq_along(NAMES)) {
[15:32:26.702]                   name <- added[[kk]]
[15:32:26.702]                   NAME <- NAMES[[kk]]
[15:32:26.702]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:26.702]                     next
[15:32:26.702]                   args[[name]] <- ""
[15:32:26.702]                 }
[15:32:26.702]                 NAMES <- toupper(removed)
[15:32:26.702]                 for (kk in seq_along(NAMES)) {
[15:32:26.702]                   name <- removed[[kk]]
[15:32:26.702]                   NAME <- NAMES[[kk]]
[15:32:26.702]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:26.702]                     next
[15:32:26.702]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:26.702]                 }
[15:32:26.702]                 if (length(args) > 0) 
[15:32:26.702]                   base::do.call(base::Sys.setenv, args = args)
[15:32:26.702]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:26.702]             }
[15:32:26.702]             else {
[15:32:26.702]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:26.702]             }
[15:32:26.702]             {
[15:32:26.702]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:26.702]                   0L) {
[15:32:26.702]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:26.702]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:26.702]                   base::options(opts)
[15:32:26.702]                 }
[15:32:26.702]                 {
[15:32:26.702]                   {
[15:32:26.702]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:26.702]                     NULL
[15:32:26.702]                   }
[15:32:26.702]                   options(future.plan = NULL)
[15:32:26.702]                   if (is.na(NA_character_)) 
[15:32:26.702]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:26.702]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:26.702]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:26.702]                     .init = FALSE)
[15:32:26.702]                 }
[15:32:26.702]             }
[15:32:26.702]         }
[15:32:26.702]     })
[15:32:26.702]     if (TRUE) {
[15:32:26.702]         base::sink(type = "output", split = FALSE)
[15:32:26.702]         if (TRUE) {
[15:32:26.702]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:26.702]         }
[15:32:26.702]         else {
[15:32:26.702]             ...future.result["stdout"] <- base::list(NULL)
[15:32:26.702]         }
[15:32:26.702]         base::close(...future.stdout)
[15:32:26.702]         ...future.stdout <- NULL
[15:32:26.702]     }
[15:32:26.702]     ...future.result$conditions <- ...future.conditions
[15:32:26.702]     ...future.result$finished <- base::Sys.time()
[15:32:26.702]     ...future.result
[15:32:26.702] }
[15:32:26.851] MultisessionFuture started
[15:32:26.851] result() for ClusterFuture ...
[15:32:26.852] receiveMessageFromWorker() for ClusterFuture ...
[15:32:26.852] - Validating connection of MultisessionFuture
[15:32:26.912] - received message: FutureResult
[15:32:26.913] - Received FutureResult
[15:32:26.918] - Erased future from FutureRegistry
[15:32:26.919] result() for ClusterFuture ...
[15:32:26.919] - result already collected: FutureResult
[15:32:26.919] result() for ClusterFuture ... done
[15:32:26.920] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:26.920] result() for ClusterFuture ... done
[15:32:26.920] result() for ClusterFuture ...
[15:32:26.921] - result already collected: FutureResult
[15:32:26.921] result() for ClusterFuture ... done
[15:32:26.921] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
[15:32:26.926] plan(): nbrOfWorkers() = 2
[15:32:26.926] future_lapply() ...
[15:32:26.931] Number of chunks: 2
[15:32:26.931] getGlobalsAndPackagesXApply() ...
[15:32:26.931]  - future.globals: TRUE
[15:32:26.932] getGlobalsAndPackages() ...
[15:32:26.932] Searching for globals...
[15:32:26.933] - globals found: [1] 'FUN'
[15:32:26.934] Searching for globals ... DONE
[15:32:26.934] Resolving globals: FALSE
[15:32:26.935] The total size of the 1 globals is 848 bytes (848 bytes)
[15:32:26.935] The total size of the 1 globals exported for future expression ('FUN()') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:32:26.936] - globals: [1] 'FUN'
[15:32:26.936] 
[15:32:26.936] getGlobalsAndPackages() ... DONE
[15:32:26.937]  - globals found/used: [n=1] 'FUN'
[15:32:26.937]  - needed namespaces: [n=0] 
[15:32:26.937] Finding globals ... DONE
[15:32:26.937]  - use_args: TRUE
[15:32:26.938]  - Getting '...' globals ...
[15:32:26.938] resolve() on list ...
[15:32:26.939]  recursive: 0
[15:32:26.939]  length: 1
[15:32:26.939]  elements: '...'
[15:32:26.940]  length: 0 (resolved future 1)
[15:32:26.940] resolve() on list ... DONE
[15:32:26.940]    - '...' content: [n=0] 
[15:32:26.940] List of 1
[15:32:26.940]  $ ...: list()
[15:32:26.940]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:26.940]  - attr(*, "where")=List of 1
[15:32:26.940]   ..$ ...:<environment: 0x00000276e56193c0> 
[15:32:26.940]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:26.940]  - attr(*, "resolved")= logi TRUE
[15:32:26.940]  - attr(*, "total_size")= num NA
[15:32:26.945]  - Getting '...' globals ... DONE
[15:32:26.946] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:26.946] List of 2
[15:32:26.946]  $ ...future.FUN:function (x)  
[15:32:26.946]  $ ...          : list()
[15:32:26.946]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:26.946]  - attr(*, "where")=List of 2
[15:32:26.946]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:26.946]   ..$ ...          :<environment: 0x00000276e56193c0> 
[15:32:26.946]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:26.946]  - attr(*, "resolved")= logi FALSE
[15:32:26.946]  - attr(*, "total_size")= num 848
[15:32:26.952] Packages to be attached in all futures: [n=0] 
[15:32:26.952] getGlobalsAndPackagesXApply() ... DONE
[15:32:26.953] Number of futures (= number of chunks): 2
[15:32:26.953] Launching 2 futures (chunks) ...
[15:32:26.953] Chunk #1 of 2 ...
[15:32:26.954]  - Finding globals in 'X' for chunk #1 ...
[15:32:26.954] getGlobalsAndPackages() ...
[15:32:26.954] Searching for globals...
[15:32:26.955] 
[15:32:26.955] Searching for globals ... DONE
[15:32:26.956] - globals: [0] <none>
[15:32:26.956] getGlobalsAndPackages() ... DONE
[15:32:26.956]    + additional globals found: [n=0] 
[15:32:26.956]    + additional namespaces needed: [n=0] 
[15:32:26.957]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:26.957]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:26.957]  - seeds: <none>
[15:32:26.958]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:26.958] getGlobalsAndPackages() ...
[15:32:26.958] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:26.959] Resolving globals: FALSE
[15:32:26.959] Tweak future expression to call with '...' arguments ...
[15:32:26.959] {
[15:32:26.959]     do.call(function(...) {
[15:32:26.959]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:26.959]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:26.959]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:26.959]             on.exit(options(oopts), add = TRUE)
[15:32:26.959]         }
[15:32:26.959]         {
[15:32:26.959]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:26.959]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:26.959]                 ...future.FUN(...future.X_jj, ...)
[15:32:26.959]             })
[15:32:26.959]         }
[15:32:26.959]     }, args = future.call.arguments)
[15:32:26.959] }
[15:32:26.960] Tweak future expression to call with '...' arguments ... DONE
[15:32:26.961] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:26.962] 
[15:32:26.962] getGlobalsAndPackages() ... DONE
[15:32:26.962] run() for 'Future' ...
[15:32:26.963] - state: 'created'
[15:32:26.963] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:26.981] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:26.982] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:26.982]   - Field: 'node'
[15:32:26.983]   - Field: 'label'
[15:32:26.983]   - Field: 'local'
[15:32:26.983]   - Field: 'owner'
[15:32:26.983]   - Field: 'envir'
[15:32:26.984]   - Field: 'workers'
[15:32:26.984]   - Field: 'packages'
[15:32:26.984]   - Field: 'gc'
[15:32:26.985]   - Field: 'conditions'
[15:32:26.985]   - Field: 'persistent'
[15:32:26.985]   - Field: 'expr'
[15:32:26.986]   - Field: 'uuid'
[15:32:26.986]   - Field: 'seed'
[15:32:26.986]   - Field: 'version'
[15:32:26.987]   - Field: 'result'
[15:32:26.987]   - Field: 'asynchronous'
[15:32:26.987]   - Field: 'calls'
[15:32:26.988]   - Field: 'globals'
[15:32:26.988]   - Field: 'stdout'
[15:32:26.988]   - Field: 'earlySignal'
[15:32:26.989]   - Field: 'lazy'
[15:32:26.989]   - Field: 'state'
[15:32:26.989] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:26.990] - Launch lazy future ...
[15:32:26.990] Packages needed by the future expression (n = 0): <none>
[15:32:26.991] Packages needed by future strategies (n = 0): <none>
[15:32:26.992] {
[15:32:26.992]     {
[15:32:26.992]         {
[15:32:26.992]             ...future.startTime <- base::Sys.time()
[15:32:26.992]             {
[15:32:26.992]                 {
[15:32:26.992]                   {
[15:32:26.992]                     {
[15:32:26.992]                       base::local({
[15:32:26.992]                         has_future <- base::requireNamespace("future", 
[15:32:26.992]                           quietly = TRUE)
[15:32:26.992]                         if (has_future) {
[15:32:26.992]                           ns <- base::getNamespace("future")
[15:32:26.992]                           version <- ns[[".package"]][["version"]]
[15:32:26.992]                           if (is.null(version)) 
[15:32:26.992]                             version <- utils::packageVersion("future")
[15:32:26.992]                         }
[15:32:26.992]                         else {
[15:32:26.992]                           version <- NULL
[15:32:26.992]                         }
[15:32:26.992]                         if (!has_future || version < "1.8.0") {
[15:32:26.992]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:26.992]                             "", base::R.version$version.string), 
[15:32:26.992]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:26.992]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:26.992]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:26.992]                               "release", "version")], collapse = " "), 
[15:32:26.992]                             hostname = base::Sys.info()[["nodename"]])
[15:32:26.992]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:26.992]                             info)
[15:32:26.992]                           info <- base::paste(info, collapse = "; ")
[15:32:26.992]                           if (!has_future) {
[15:32:26.992]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:26.992]                               info)
[15:32:26.992]                           }
[15:32:26.992]                           else {
[15:32:26.992]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:26.992]                               info, version)
[15:32:26.992]                           }
[15:32:26.992]                           base::stop(msg)
[15:32:26.992]                         }
[15:32:26.992]                       })
[15:32:26.992]                     }
[15:32:26.992]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:26.992]                     base::options(mc.cores = 1L)
[15:32:26.992]                   }
[15:32:26.992]                   ...future.strategy.old <- future::plan("list")
[15:32:26.992]                   options(future.plan = NULL)
[15:32:26.992]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:26.992]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:26.992]                 }
[15:32:26.992]                 ...future.workdir <- getwd()
[15:32:26.992]             }
[15:32:26.992]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:26.992]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:26.992]         }
[15:32:26.992]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:26.992]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:26.992]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:26.992]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:26.992]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:26.992]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:26.992]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:26.992]             base::names(...future.oldOptions))
[15:32:26.992]     }
[15:32:26.992]     if (FALSE) {
[15:32:26.992]     }
[15:32:26.992]     else {
[15:32:26.992]         if (TRUE) {
[15:32:26.992]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:26.992]                 open = "w")
[15:32:26.992]         }
[15:32:26.992]         else {
[15:32:26.992]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:26.992]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:26.992]         }
[15:32:26.992]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:26.992]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:26.992]             base::sink(type = "output", split = FALSE)
[15:32:26.992]             base::close(...future.stdout)
[15:32:26.992]         }, add = TRUE)
[15:32:26.992]     }
[15:32:26.992]     ...future.frame <- base::sys.nframe()
[15:32:26.992]     ...future.conditions <- base::list()
[15:32:26.992]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:26.992]     if (FALSE) {
[15:32:26.992]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:26.992]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:26.992]     }
[15:32:26.992]     ...future.result <- base::tryCatch({
[15:32:26.992]         base::withCallingHandlers({
[15:32:26.992]             ...future.value <- base::withVisible(base::local({
[15:32:26.992]                 ...future.makeSendCondition <- base::local({
[15:32:26.992]                   sendCondition <- NULL
[15:32:26.992]                   function(frame = 1L) {
[15:32:26.992]                     if (is.function(sendCondition)) 
[15:32:26.992]                       return(sendCondition)
[15:32:26.992]                     ns <- getNamespace("parallel")
[15:32:26.992]                     if (exists("sendData", mode = "function", 
[15:32:26.992]                       envir = ns)) {
[15:32:26.992]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:26.992]                         envir = ns)
[15:32:26.992]                       envir <- sys.frame(frame)
[15:32:26.992]                       master <- NULL
[15:32:26.992]                       while (!identical(envir, .GlobalEnv) && 
[15:32:26.992]                         !identical(envir, emptyenv())) {
[15:32:26.992]                         if (exists("master", mode = "list", envir = envir, 
[15:32:26.992]                           inherits = FALSE)) {
[15:32:26.992]                           master <- get("master", mode = "list", 
[15:32:26.992]                             envir = envir, inherits = FALSE)
[15:32:26.992]                           if (inherits(master, c("SOCKnode", 
[15:32:26.992]                             "SOCK0node"))) {
[15:32:26.992]                             sendCondition <<- function(cond) {
[15:32:26.992]                               data <- list(type = "VALUE", value = cond, 
[15:32:26.992]                                 success = TRUE)
[15:32:26.992]                               parallel_sendData(master, data)
[15:32:26.992]                             }
[15:32:26.992]                             return(sendCondition)
[15:32:26.992]                           }
[15:32:26.992]                         }
[15:32:26.992]                         frame <- frame + 1L
[15:32:26.992]                         envir <- sys.frame(frame)
[15:32:26.992]                       }
[15:32:26.992]                     }
[15:32:26.992]                     sendCondition <<- function(cond) NULL
[15:32:26.992]                   }
[15:32:26.992]                 })
[15:32:26.992]                 withCallingHandlers({
[15:32:26.992]                   {
[15:32:26.992]                     do.call(function(...) {
[15:32:26.992]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:26.992]                       if (!identical(...future.globals.maxSize.org, 
[15:32:26.992]                         ...future.globals.maxSize)) {
[15:32:26.992]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:26.992]                         on.exit(options(oopts), add = TRUE)
[15:32:26.992]                       }
[15:32:26.992]                       {
[15:32:26.992]                         lapply(seq_along(...future.elements_ii), 
[15:32:26.992]                           FUN = function(jj) {
[15:32:26.992]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:26.992]                             ...future.FUN(...future.X_jj, ...)
[15:32:26.992]                           })
[15:32:26.992]                       }
[15:32:26.992]                     }, args = future.call.arguments)
[15:32:26.992]                   }
[15:32:26.992]                 }, immediateCondition = function(cond) {
[15:32:26.992]                   sendCondition <- ...future.makeSendCondition()
[15:32:26.992]                   sendCondition(cond)
[15:32:26.992]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:26.992]                   {
[15:32:26.992]                     inherits <- base::inherits
[15:32:26.992]                     invokeRestart <- base::invokeRestart
[15:32:26.992]                     is.null <- base::is.null
[15:32:26.992]                     muffled <- FALSE
[15:32:26.992]                     if (inherits(cond, "message")) {
[15:32:26.992]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:26.992]                       if (muffled) 
[15:32:26.992]                         invokeRestart("muffleMessage")
[15:32:26.992]                     }
[15:32:26.992]                     else if (inherits(cond, "warning")) {
[15:32:26.992]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:26.992]                       if (muffled) 
[15:32:26.992]                         invokeRestart("muffleWarning")
[15:32:26.992]                     }
[15:32:26.992]                     else if (inherits(cond, "condition")) {
[15:32:26.992]                       if (!is.null(pattern)) {
[15:32:26.992]                         computeRestarts <- base::computeRestarts
[15:32:26.992]                         grepl <- base::grepl
[15:32:26.992]                         restarts <- computeRestarts(cond)
[15:32:26.992]                         for (restart in restarts) {
[15:32:26.992]                           name <- restart$name
[15:32:26.992]                           if (is.null(name)) 
[15:32:26.992]                             next
[15:32:26.992]                           if (!grepl(pattern, name)) 
[15:32:26.992]                             next
[15:32:26.992]                           invokeRestart(restart)
[15:32:26.992]                           muffled <- TRUE
[15:32:26.992]                           break
[15:32:26.992]                         }
[15:32:26.992]                       }
[15:32:26.992]                     }
[15:32:26.992]                     invisible(muffled)
[15:32:26.992]                   }
[15:32:26.992]                   muffleCondition(cond)
[15:32:26.992]                 })
[15:32:26.992]             }))
[15:32:26.992]             future::FutureResult(value = ...future.value$value, 
[15:32:26.992]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:26.992]                   ...future.rng), globalenv = if (FALSE) 
[15:32:26.992]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:26.992]                     ...future.globalenv.names))
[15:32:26.992]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:26.992]         }, condition = base::local({
[15:32:26.992]             c <- base::c
[15:32:26.992]             inherits <- base::inherits
[15:32:26.992]             invokeRestart <- base::invokeRestart
[15:32:26.992]             length <- base::length
[15:32:26.992]             list <- base::list
[15:32:26.992]             seq.int <- base::seq.int
[15:32:26.992]             signalCondition <- base::signalCondition
[15:32:26.992]             sys.calls <- base::sys.calls
[15:32:26.992]             `[[` <- base::`[[`
[15:32:26.992]             `+` <- base::`+`
[15:32:26.992]             `<<-` <- base::`<<-`
[15:32:26.992]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:26.992]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:26.992]                   3L)]
[15:32:26.992]             }
[15:32:26.992]             function(cond) {
[15:32:26.992]                 is_error <- inherits(cond, "error")
[15:32:26.992]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:26.992]                   NULL)
[15:32:26.992]                 if (is_error) {
[15:32:26.992]                   sessionInformation <- function() {
[15:32:26.992]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:26.992]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:26.992]                       search = base::search(), system = base::Sys.info())
[15:32:26.992]                   }
[15:32:26.992]                   ...future.conditions[[length(...future.conditions) + 
[15:32:26.992]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:26.992]                     cond$call), session = sessionInformation(), 
[15:32:26.992]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:26.992]                   signalCondition(cond)
[15:32:26.992]                 }
[15:32:26.992]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:26.992]                 "immediateCondition"))) {
[15:32:26.992]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:26.992]                   ...future.conditions[[length(...future.conditions) + 
[15:32:26.992]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:26.992]                   if (TRUE && !signal) {
[15:32:26.992]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:26.992]                     {
[15:32:26.992]                       inherits <- base::inherits
[15:32:26.992]                       invokeRestart <- base::invokeRestart
[15:32:26.992]                       is.null <- base::is.null
[15:32:26.992]                       muffled <- FALSE
[15:32:26.992]                       if (inherits(cond, "message")) {
[15:32:26.992]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:26.992]                         if (muffled) 
[15:32:26.992]                           invokeRestart("muffleMessage")
[15:32:26.992]                       }
[15:32:26.992]                       else if (inherits(cond, "warning")) {
[15:32:26.992]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:26.992]                         if (muffled) 
[15:32:26.992]                           invokeRestart("muffleWarning")
[15:32:26.992]                       }
[15:32:26.992]                       else if (inherits(cond, "condition")) {
[15:32:26.992]                         if (!is.null(pattern)) {
[15:32:26.992]                           computeRestarts <- base::computeRestarts
[15:32:26.992]                           grepl <- base::grepl
[15:32:26.992]                           restarts <- computeRestarts(cond)
[15:32:26.992]                           for (restart in restarts) {
[15:32:26.992]                             name <- restart$name
[15:32:26.992]                             if (is.null(name)) 
[15:32:26.992]                               next
[15:32:26.992]                             if (!grepl(pattern, name)) 
[15:32:26.992]                               next
[15:32:26.992]                             invokeRestart(restart)
[15:32:26.992]                             muffled <- TRUE
[15:32:26.992]                             break
[15:32:26.992]                           }
[15:32:26.992]                         }
[15:32:26.992]                       }
[15:32:26.992]                       invisible(muffled)
[15:32:26.992]                     }
[15:32:26.992]                     muffleCondition(cond, pattern = "^muffle")
[15:32:26.992]                   }
[15:32:26.992]                 }
[15:32:26.992]                 else {
[15:32:26.992]                   if (TRUE) {
[15:32:26.992]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:26.992]                     {
[15:32:26.992]                       inherits <- base::inherits
[15:32:26.992]                       invokeRestart <- base::invokeRestart
[15:32:26.992]                       is.null <- base::is.null
[15:32:26.992]                       muffled <- FALSE
[15:32:26.992]                       if (inherits(cond, "message")) {
[15:32:26.992]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:26.992]                         if (muffled) 
[15:32:26.992]                           invokeRestart("muffleMessage")
[15:32:26.992]                       }
[15:32:26.992]                       else if (inherits(cond, "warning")) {
[15:32:26.992]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:26.992]                         if (muffled) 
[15:32:26.992]                           invokeRestart("muffleWarning")
[15:32:26.992]                       }
[15:32:26.992]                       else if (inherits(cond, "condition")) {
[15:32:26.992]                         if (!is.null(pattern)) {
[15:32:26.992]                           computeRestarts <- base::computeRestarts
[15:32:26.992]                           grepl <- base::grepl
[15:32:26.992]                           restarts <- computeRestarts(cond)
[15:32:26.992]                           for (restart in restarts) {
[15:32:26.992]                             name <- restart$name
[15:32:26.992]                             if (is.null(name)) 
[15:32:26.992]                               next
[15:32:26.992]                             if (!grepl(pattern, name)) 
[15:32:26.992]                               next
[15:32:26.992]                             invokeRestart(restart)
[15:32:26.992]                             muffled <- TRUE
[15:32:26.992]                             break
[15:32:26.992]                           }
[15:32:26.992]                         }
[15:32:26.992]                       }
[15:32:26.992]                       invisible(muffled)
[15:32:26.992]                     }
[15:32:26.992]                     muffleCondition(cond, pattern = "^muffle")
[15:32:26.992]                   }
[15:32:26.992]                 }
[15:32:26.992]             }
[15:32:26.992]         }))
[15:32:26.992]     }, error = function(ex) {
[15:32:26.992]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:26.992]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:26.992]                 ...future.rng), started = ...future.startTime, 
[15:32:26.992]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:26.992]             version = "1.8"), class = "FutureResult")
[15:32:26.992]     }, finally = {
[15:32:26.992]         if (!identical(...future.workdir, getwd())) 
[15:32:26.992]             setwd(...future.workdir)
[15:32:26.992]         {
[15:32:26.992]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:26.992]                 ...future.oldOptions$nwarnings <- NULL
[15:32:26.992]             }
[15:32:26.992]             base::options(...future.oldOptions)
[15:32:26.992]             if (.Platform$OS.type == "windows") {
[15:32:26.992]                 old_names <- names(...future.oldEnvVars)
[15:32:26.992]                 envs <- base::Sys.getenv()
[15:32:26.992]                 names <- names(envs)
[15:32:26.992]                 common <- intersect(names, old_names)
[15:32:26.992]                 added <- setdiff(names, old_names)
[15:32:26.992]                 removed <- setdiff(old_names, names)
[15:32:26.992]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:26.992]                   envs[common]]
[15:32:26.992]                 NAMES <- toupper(changed)
[15:32:26.992]                 args <- list()
[15:32:26.992]                 for (kk in seq_along(NAMES)) {
[15:32:26.992]                   name <- changed[[kk]]
[15:32:26.992]                   NAME <- NAMES[[kk]]
[15:32:26.992]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:26.992]                     next
[15:32:26.992]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:26.992]                 }
[15:32:26.992]                 NAMES <- toupper(added)
[15:32:26.992]                 for (kk in seq_along(NAMES)) {
[15:32:26.992]                   name <- added[[kk]]
[15:32:26.992]                   NAME <- NAMES[[kk]]
[15:32:26.992]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:26.992]                     next
[15:32:26.992]                   args[[name]] <- ""
[15:32:26.992]                 }
[15:32:26.992]                 NAMES <- toupper(removed)
[15:32:26.992]                 for (kk in seq_along(NAMES)) {
[15:32:26.992]                   name <- removed[[kk]]
[15:32:26.992]                   NAME <- NAMES[[kk]]
[15:32:26.992]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:26.992]                     next
[15:32:26.992]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:26.992]                 }
[15:32:26.992]                 if (length(args) > 0) 
[15:32:26.992]                   base::do.call(base::Sys.setenv, args = args)
[15:32:26.992]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:26.992]             }
[15:32:26.992]             else {
[15:32:26.992]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:26.992]             }
[15:32:26.992]             {
[15:32:26.992]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:26.992]                   0L) {
[15:32:26.992]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:26.992]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:26.992]                   base::options(opts)
[15:32:26.992]                 }
[15:32:26.992]                 {
[15:32:26.992]                   {
[15:32:26.992]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:26.992]                     NULL
[15:32:26.992]                   }
[15:32:26.992]                   options(future.plan = NULL)
[15:32:26.992]                   if (is.na(NA_character_)) 
[15:32:26.992]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:26.992]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:26.992]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:26.992]                     .init = FALSE)
[15:32:26.992]                 }
[15:32:26.992]             }
[15:32:26.992]         }
[15:32:26.992]     })
[15:32:26.992]     if (TRUE) {
[15:32:26.992]         base::sink(type = "output", split = FALSE)
[15:32:26.992]         if (TRUE) {
[15:32:26.992]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:26.992]         }
[15:32:26.992]         else {
[15:32:26.992]             ...future.result["stdout"] <- base::list(NULL)
[15:32:26.992]         }
[15:32:26.992]         base::close(...future.stdout)
[15:32:26.992]         ...future.stdout <- NULL
[15:32:26.992]     }
[15:32:26.992]     ...future.result$conditions <- ...future.conditions
[15:32:26.992]     ...future.result$finished <- base::Sys.time()
[15:32:26.992]     ...future.result
[15:32:26.992] }
[15:32:27.001] Exporting 5 global objects (848 bytes) to cluster node #1 ...
[15:32:27.002] Exporting '...future.FUN' (848 bytes) to cluster node #1 ...
[15:32:27.003] Exporting '...future.FUN' (848 bytes) to cluster node #1 ... DONE
[15:32:27.004] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:27.005] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:27.006] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ...
[15:32:27.006] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ... DONE
[15:32:27.007] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:27.007] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:27.008] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:27.009] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:27.009] Exporting 5 global objects (848 bytes) to cluster node #1 ... DONE
[15:32:27.010] MultisessionFuture started
[15:32:27.011] - Launch lazy future ... done
[15:32:27.011] run() for 'MultisessionFuture' ... done
[15:32:27.011] Created future:
[15:32:27.040] receiveMessageFromWorker() for ClusterFuture ...
[15:32:27.040] - Validating connection of MultisessionFuture
[15:32:27.041] - received message: FutureResult
[15:32:27.041] - Received FutureResult
[15:32:27.042] - Erased future from FutureRegistry
[15:32:27.042] result() for ClusterFuture ...
[15:32:27.042] - result already collected: FutureResult
[15:32:27.042] result() for ClusterFuture ... done
[15:32:27.043] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:27.012] MultisessionFuture:
[15:32:27.012] Label: 'future_sapply-1'
[15:32:27.012] Expression:
[15:32:27.012] {
[15:32:27.012]     do.call(function(...) {
[15:32:27.012]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:27.012]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:27.012]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:27.012]             on.exit(options(oopts), add = TRUE)
[15:32:27.012]         }
[15:32:27.012]         {
[15:32:27.012]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:27.012]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:27.012]                 ...future.FUN(...future.X_jj, ...)
[15:32:27.012]             })
[15:32:27.012]         }
[15:32:27.012]     }, args = future.call.arguments)
[15:32:27.012] }
[15:32:27.012] Lazy evaluation: FALSE
[15:32:27.012] Asynchronous evaluation: TRUE
[15:32:27.012] Local evaluation: TRUE
[15:32:27.012] Environment: R_GlobalEnv
[15:32:27.012] Capture standard output: TRUE
[15:32:27.012] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:27.012] Globals: 5 objects totaling 904 bytes (function '...future.FUN' of 848 bytes, 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)
[15:32:27.012] Packages: <none>
[15:32:27.012] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:27.012] Resolved: TRUE
[15:32:27.012] Value: <not collected>
[15:32:27.012] Conditions captured: <none>
[15:32:27.012] Early signaling: FALSE
[15:32:27.012] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:27.012] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:27.044] Chunk #1 of 2 ... DONE
[15:32:27.044] Chunk #2 of 2 ...
[15:32:27.044]  - Finding globals in 'X' for chunk #2 ...
[15:32:27.044] getGlobalsAndPackages() ...
[15:32:27.045] Searching for globals...
[15:32:27.045] 
[15:32:27.046] Searching for globals ... DONE
[15:32:27.046] - globals: [0] <none>
[15:32:27.046] getGlobalsAndPackages() ... DONE
[15:32:27.047]    + additional globals found: [n=0] 
[15:32:27.047]    + additional namespaces needed: [n=0] 
[15:32:27.047]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:27.047]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:27.048]  - seeds: <none>
[15:32:27.048]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:27.048] getGlobalsAndPackages() ...
[15:32:27.049] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:27.049] Resolving globals: FALSE
[15:32:27.049] Tweak future expression to call with '...' arguments ...
[15:32:27.050] {
[15:32:27.050]     do.call(function(...) {
[15:32:27.050]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:27.050]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:27.050]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:27.050]             on.exit(options(oopts), add = TRUE)
[15:32:27.050]         }
[15:32:27.050]         {
[15:32:27.050]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:27.050]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:27.050]                 ...future.FUN(...future.X_jj, ...)
[15:32:27.050]             })
[15:32:27.050]         }
[15:32:27.050]     }, args = future.call.arguments)
[15:32:27.050] }
[15:32:27.051] Tweak future expression to call with '...' arguments ... DONE
[15:32:27.052] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:27.052] 
[15:32:27.052] getGlobalsAndPackages() ... DONE
[15:32:27.057] run() for 'Future' ...
[15:32:27.057] - state: 'created'
[15:32:27.058] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:27.078] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:27.078] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:27.082]   - Field: 'node'
[15:32:27.082]   - Field: 'label'
[15:32:27.083]   - Field: 'local'
[15:32:27.083]   - Field: 'owner'
[15:32:27.083]   - Field: 'envir'
[15:32:27.084]   - Field: 'workers'
[15:32:27.084]   - Field: 'packages'
[15:32:27.084]   - Field: 'gc'
[15:32:27.085]   - Field: 'conditions'
[15:32:27.085]   - Field: 'persistent'
[15:32:27.085]   - Field: 'expr'
[15:32:27.085]   - Field: 'uuid'
[15:32:27.086]   - Field: 'seed'
[15:32:27.086]   - Field: 'version'
[15:32:27.086]   - Field: 'result'
[15:32:27.087]   - Field: 'asynchronous'
[15:32:27.087]   - Field: 'calls'
[15:32:27.087]   - Field: 'globals'
[15:32:27.088]   - Field: 'stdout'
[15:32:27.088]   - Field: 'earlySignal'
[15:32:27.088]   - Field: 'lazy'
[15:32:27.089]   - Field: 'state'
[15:32:27.089] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:27.089] - Launch lazy future ...
[15:32:27.090] Packages needed by the future expression (n = 0): <none>
[15:32:27.090] Packages needed by future strategies (n = 0): <none>
[15:32:27.091] {
[15:32:27.091]     {
[15:32:27.091]         {
[15:32:27.091]             ...future.startTime <- base::Sys.time()
[15:32:27.091]             {
[15:32:27.091]                 {
[15:32:27.091]                   {
[15:32:27.091]                     {
[15:32:27.091]                       base::local({
[15:32:27.091]                         has_future <- base::requireNamespace("future", 
[15:32:27.091]                           quietly = TRUE)
[15:32:27.091]                         if (has_future) {
[15:32:27.091]                           ns <- base::getNamespace("future")
[15:32:27.091]                           version <- ns[[".package"]][["version"]]
[15:32:27.091]                           if (is.null(version)) 
[15:32:27.091]                             version <- utils::packageVersion("future")
[15:32:27.091]                         }
[15:32:27.091]                         else {
[15:32:27.091]                           version <- NULL
[15:32:27.091]                         }
[15:32:27.091]                         if (!has_future || version < "1.8.0") {
[15:32:27.091]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:27.091]                             "", base::R.version$version.string), 
[15:32:27.091]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:27.091]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:27.091]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:27.091]                               "release", "version")], collapse = " "), 
[15:32:27.091]                             hostname = base::Sys.info()[["nodename"]])
[15:32:27.091]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:27.091]                             info)
[15:32:27.091]                           info <- base::paste(info, collapse = "; ")
[15:32:27.091]                           if (!has_future) {
[15:32:27.091]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:27.091]                               info)
[15:32:27.091]                           }
[15:32:27.091]                           else {
[15:32:27.091]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:27.091]                               info, version)
[15:32:27.091]                           }
[15:32:27.091]                           base::stop(msg)
[15:32:27.091]                         }
[15:32:27.091]                       })
[15:32:27.091]                     }
[15:32:27.091]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:27.091]                     base::options(mc.cores = 1L)
[15:32:27.091]                   }
[15:32:27.091]                   ...future.strategy.old <- future::plan("list")
[15:32:27.091]                   options(future.plan = NULL)
[15:32:27.091]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:27.091]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:27.091]                 }
[15:32:27.091]                 ...future.workdir <- getwd()
[15:32:27.091]             }
[15:32:27.091]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:27.091]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:27.091]         }
[15:32:27.091]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:27.091]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:27.091]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:27.091]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:27.091]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:27.091]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:27.091]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:27.091]             base::names(...future.oldOptions))
[15:32:27.091]     }
[15:32:27.091]     if (FALSE) {
[15:32:27.091]     }
[15:32:27.091]     else {
[15:32:27.091]         if (TRUE) {
[15:32:27.091]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:27.091]                 open = "w")
[15:32:27.091]         }
[15:32:27.091]         else {
[15:32:27.091]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:27.091]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:27.091]         }
[15:32:27.091]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:27.091]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:27.091]             base::sink(type = "output", split = FALSE)
[15:32:27.091]             base::close(...future.stdout)
[15:32:27.091]         }, add = TRUE)
[15:32:27.091]     }
[15:32:27.091]     ...future.frame <- base::sys.nframe()
[15:32:27.091]     ...future.conditions <- base::list()
[15:32:27.091]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:27.091]     if (FALSE) {
[15:32:27.091]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:27.091]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:27.091]     }
[15:32:27.091]     ...future.result <- base::tryCatch({
[15:32:27.091]         base::withCallingHandlers({
[15:32:27.091]             ...future.value <- base::withVisible(base::local({
[15:32:27.091]                 ...future.makeSendCondition <- base::local({
[15:32:27.091]                   sendCondition <- NULL
[15:32:27.091]                   function(frame = 1L) {
[15:32:27.091]                     if (is.function(sendCondition)) 
[15:32:27.091]                       return(sendCondition)
[15:32:27.091]                     ns <- getNamespace("parallel")
[15:32:27.091]                     if (exists("sendData", mode = "function", 
[15:32:27.091]                       envir = ns)) {
[15:32:27.091]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:27.091]                         envir = ns)
[15:32:27.091]                       envir <- sys.frame(frame)
[15:32:27.091]                       master <- NULL
[15:32:27.091]                       while (!identical(envir, .GlobalEnv) && 
[15:32:27.091]                         !identical(envir, emptyenv())) {
[15:32:27.091]                         if (exists("master", mode = "list", envir = envir, 
[15:32:27.091]                           inherits = FALSE)) {
[15:32:27.091]                           master <- get("master", mode = "list", 
[15:32:27.091]                             envir = envir, inherits = FALSE)
[15:32:27.091]                           if (inherits(master, c("SOCKnode", 
[15:32:27.091]                             "SOCK0node"))) {
[15:32:27.091]                             sendCondition <<- function(cond) {
[15:32:27.091]                               data <- list(type = "VALUE", value = cond, 
[15:32:27.091]                                 success = TRUE)
[15:32:27.091]                               parallel_sendData(master, data)
[15:32:27.091]                             }
[15:32:27.091]                             return(sendCondition)
[15:32:27.091]                           }
[15:32:27.091]                         }
[15:32:27.091]                         frame <- frame + 1L
[15:32:27.091]                         envir <- sys.frame(frame)
[15:32:27.091]                       }
[15:32:27.091]                     }
[15:32:27.091]                     sendCondition <<- function(cond) NULL
[15:32:27.091]                   }
[15:32:27.091]                 })
[15:32:27.091]                 withCallingHandlers({
[15:32:27.091]                   {
[15:32:27.091]                     do.call(function(...) {
[15:32:27.091]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:27.091]                       if (!identical(...future.globals.maxSize.org, 
[15:32:27.091]                         ...future.globals.maxSize)) {
[15:32:27.091]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:27.091]                         on.exit(options(oopts), add = TRUE)
[15:32:27.091]                       }
[15:32:27.091]                       {
[15:32:27.091]                         lapply(seq_along(...future.elements_ii), 
[15:32:27.091]                           FUN = function(jj) {
[15:32:27.091]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:27.091]                             ...future.FUN(...future.X_jj, ...)
[15:32:27.091]                           })
[15:32:27.091]                       }
[15:32:27.091]                     }, args = future.call.arguments)
[15:32:27.091]                   }
[15:32:27.091]                 }, immediateCondition = function(cond) {
[15:32:27.091]                   sendCondition <- ...future.makeSendCondition()
[15:32:27.091]                   sendCondition(cond)
[15:32:27.091]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:27.091]                   {
[15:32:27.091]                     inherits <- base::inherits
[15:32:27.091]                     invokeRestart <- base::invokeRestart
[15:32:27.091]                     is.null <- base::is.null
[15:32:27.091]                     muffled <- FALSE
[15:32:27.091]                     if (inherits(cond, "message")) {
[15:32:27.091]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:27.091]                       if (muffled) 
[15:32:27.091]                         invokeRestart("muffleMessage")
[15:32:27.091]                     }
[15:32:27.091]                     else if (inherits(cond, "warning")) {
[15:32:27.091]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:27.091]                       if (muffled) 
[15:32:27.091]                         invokeRestart("muffleWarning")
[15:32:27.091]                     }
[15:32:27.091]                     else if (inherits(cond, "condition")) {
[15:32:27.091]                       if (!is.null(pattern)) {
[15:32:27.091]                         computeRestarts <- base::computeRestarts
[15:32:27.091]                         grepl <- base::grepl
[15:32:27.091]                         restarts <- computeRestarts(cond)
[15:32:27.091]                         for (restart in restarts) {
[15:32:27.091]                           name <- restart$name
[15:32:27.091]                           if (is.null(name)) 
[15:32:27.091]                             next
[15:32:27.091]                           if (!grepl(pattern, name)) 
[15:32:27.091]                             next
[15:32:27.091]                           invokeRestart(restart)
[15:32:27.091]                           muffled <- TRUE
[15:32:27.091]                           break
[15:32:27.091]                         }
[15:32:27.091]                       }
[15:32:27.091]                     }
[15:32:27.091]                     invisible(muffled)
[15:32:27.091]                   }
[15:32:27.091]                   muffleCondition(cond)
[15:32:27.091]                 })
[15:32:27.091]             }))
[15:32:27.091]             future::FutureResult(value = ...future.value$value, 
[15:32:27.091]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:27.091]                   ...future.rng), globalenv = if (FALSE) 
[15:32:27.091]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:27.091]                     ...future.globalenv.names))
[15:32:27.091]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:27.091]         }, condition = base::local({
[15:32:27.091]             c <- base::c
[15:32:27.091]             inherits <- base::inherits
[15:32:27.091]             invokeRestart <- base::invokeRestart
[15:32:27.091]             length <- base::length
[15:32:27.091]             list <- base::list
[15:32:27.091]             seq.int <- base::seq.int
[15:32:27.091]             signalCondition <- base::signalCondition
[15:32:27.091]             sys.calls <- base::sys.calls
[15:32:27.091]             `[[` <- base::`[[`
[15:32:27.091]             `+` <- base::`+`
[15:32:27.091]             `<<-` <- base::`<<-`
[15:32:27.091]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:27.091]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:27.091]                   3L)]
[15:32:27.091]             }
[15:32:27.091]             function(cond) {
[15:32:27.091]                 is_error <- inherits(cond, "error")
[15:32:27.091]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:27.091]                   NULL)
[15:32:27.091]                 if (is_error) {
[15:32:27.091]                   sessionInformation <- function() {
[15:32:27.091]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:27.091]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:27.091]                       search = base::search(), system = base::Sys.info())
[15:32:27.091]                   }
[15:32:27.091]                   ...future.conditions[[length(...future.conditions) + 
[15:32:27.091]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:27.091]                     cond$call), session = sessionInformation(), 
[15:32:27.091]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:27.091]                   signalCondition(cond)
[15:32:27.091]                 }
[15:32:27.091]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:27.091]                 "immediateCondition"))) {
[15:32:27.091]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:27.091]                   ...future.conditions[[length(...future.conditions) + 
[15:32:27.091]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:27.091]                   if (TRUE && !signal) {
[15:32:27.091]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:27.091]                     {
[15:32:27.091]                       inherits <- base::inherits
[15:32:27.091]                       invokeRestart <- base::invokeRestart
[15:32:27.091]                       is.null <- base::is.null
[15:32:27.091]                       muffled <- FALSE
[15:32:27.091]                       if (inherits(cond, "message")) {
[15:32:27.091]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:27.091]                         if (muffled) 
[15:32:27.091]                           invokeRestart("muffleMessage")
[15:32:27.091]                       }
[15:32:27.091]                       else if (inherits(cond, "warning")) {
[15:32:27.091]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:27.091]                         if (muffled) 
[15:32:27.091]                           invokeRestart("muffleWarning")
[15:32:27.091]                       }
[15:32:27.091]                       else if (inherits(cond, "condition")) {
[15:32:27.091]                         if (!is.null(pattern)) {
[15:32:27.091]                           computeRestarts <- base::computeRestarts
[15:32:27.091]                           grepl <- base::grepl
[15:32:27.091]                           restarts <- computeRestarts(cond)
[15:32:27.091]                           for (restart in restarts) {
[15:32:27.091]                             name <- restart$name
[15:32:27.091]                             if (is.null(name)) 
[15:32:27.091]                               next
[15:32:27.091]                             if (!grepl(pattern, name)) 
[15:32:27.091]                               next
[15:32:27.091]                             invokeRestart(restart)
[15:32:27.091]                             muffled <- TRUE
[15:32:27.091]                             break
[15:32:27.091]                           }
[15:32:27.091]                         }
[15:32:27.091]                       }
[15:32:27.091]                       invisible(muffled)
[15:32:27.091]                     }
[15:32:27.091]                     muffleCondition(cond, pattern = "^muffle")
[15:32:27.091]                   }
[15:32:27.091]                 }
[15:32:27.091]                 else {
[15:32:27.091]                   if (TRUE) {
[15:32:27.091]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:27.091]                     {
[15:32:27.091]                       inherits <- base::inherits
[15:32:27.091]                       invokeRestart <- base::invokeRestart
[15:32:27.091]                       is.null <- base::is.null
[15:32:27.091]                       muffled <- FALSE
[15:32:27.091]                       if (inherits(cond, "message")) {
[15:32:27.091]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:27.091]                         if (muffled) 
[15:32:27.091]                           invokeRestart("muffleMessage")
[15:32:27.091]                       }
[15:32:27.091]                       else if (inherits(cond, "warning")) {
[15:32:27.091]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:27.091]                         if (muffled) 
[15:32:27.091]                           invokeRestart("muffleWarning")
[15:32:27.091]                       }
[15:32:27.091]                       else if (inherits(cond, "condition")) {
[15:32:27.091]                         if (!is.null(pattern)) {
[15:32:27.091]                           computeRestarts <- base::computeRestarts
[15:32:27.091]                           grepl <- base::grepl
[15:32:27.091]                           restarts <- computeRestarts(cond)
[15:32:27.091]                           for (restart in restarts) {
[15:32:27.091]                             name <- restart$name
[15:32:27.091]                             if (is.null(name)) 
[15:32:27.091]                               next
[15:32:27.091]                             if (!grepl(pattern, name)) 
[15:32:27.091]                               next
[15:32:27.091]                             invokeRestart(restart)
[15:32:27.091]                             muffled <- TRUE
[15:32:27.091]                             break
[15:32:27.091]                           }
[15:32:27.091]                         }
[15:32:27.091]                       }
[15:32:27.091]                       invisible(muffled)
[15:32:27.091]                     }
[15:32:27.091]                     muffleCondition(cond, pattern = "^muffle")
[15:32:27.091]                   }
[15:32:27.091]                 }
[15:32:27.091]             }
[15:32:27.091]         }))
[15:32:27.091]     }, error = function(ex) {
[15:32:27.091]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:27.091]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:27.091]                 ...future.rng), started = ...future.startTime, 
[15:32:27.091]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:27.091]             version = "1.8"), class = "FutureResult")
[15:32:27.091]     }, finally = {
[15:32:27.091]         if (!identical(...future.workdir, getwd())) 
[15:32:27.091]             setwd(...future.workdir)
[15:32:27.091]         {
[15:32:27.091]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:27.091]                 ...future.oldOptions$nwarnings <- NULL
[15:32:27.091]             }
[15:32:27.091]             base::options(...future.oldOptions)
[15:32:27.091]             if (.Platform$OS.type == "windows") {
[15:32:27.091]                 old_names <- names(...future.oldEnvVars)
[15:32:27.091]                 envs <- base::Sys.getenv()
[15:32:27.091]                 names <- names(envs)
[15:32:27.091]                 common <- intersect(names, old_names)
[15:32:27.091]                 added <- setdiff(names, old_names)
[15:32:27.091]                 removed <- setdiff(old_names, names)
[15:32:27.091]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:27.091]                   envs[common]]
[15:32:27.091]                 NAMES <- toupper(changed)
[15:32:27.091]                 args <- list()
[15:32:27.091]                 for (kk in seq_along(NAMES)) {
[15:32:27.091]                   name <- changed[[kk]]
[15:32:27.091]                   NAME <- NAMES[[kk]]
[15:32:27.091]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:27.091]                     next
[15:32:27.091]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:27.091]                 }
[15:32:27.091]                 NAMES <- toupper(added)
[15:32:27.091]                 for (kk in seq_along(NAMES)) {
[15:32:27.091]                   name <- added[[kk]]
[15:32:27.091]                   NAME <- NAMES[[kk]]
[15:32:27.091]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:27.091]                     next
[15:32:27.091]                   args[[name]] <- ""
[15:32:27.091]                 }
[15:32:27.091]                 NAMES <- toupper(removed)
[15:32:27.091]                 for (kk in seq_along(NAMES)) {
[15:32:27.091]                   name <- removed[[kk]]
[15:32:27.091]                   NAME <- NAMES[[kk]]
[15:32:27.091]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:27.091]                     next
[15:32:27.091]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:27.091]                 }
[15:32:27.091]                 if (length(args) > 0) 
[15:32:27.091]                   base::do.call(base::Sys.setenv, args = args)
[15:32:27.091]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:27.091]             }
[15:32:27.091]             else {
[15:32:27.091]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:27.091]             }
[15:32:27.091]             {
[15:32:27.091]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:27.091]                   0L) {
[15:32:27.091]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:27.091]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:27.091]                   base::options(opts)
[15:32:27.091]                 }
[15:32:27.091]                 {
[15:32:27.091]                   {
[15:32:27.091]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:27.091]                     NULL
[15:32:27.091]                   }
[15:32:27.091]                   options(future.plan = NULL)
[15:32:27.091]                   if (is.na(NA_character_)) 
[15:32:27.091]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:27.091]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:27.091]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:27.091]                     .init = FALSE)
[15:32:27.091]                 }
[15:32:27.091]             }
[15:32:27.091]         }
[15:32:27.091]     })
[15:32:27.091]     if (TRUE) {
[15:32:27.091]         base::sink(type = "output", split = FALSE)
[15:32:27.091]         if (TRUE) {
[15:32:27.091]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:27.091]         }
[15:32:27.091]         else {
[15:32:27.091]             ...future.result["stdout"] <- base::list(NULL)
[15:32:27.091]         }
[15:32:27.091]         base::close(...future.stdout)
[15:32:27.091]         ...future.stdout <- NULL
[15:32:27.091]     }
[15:32:27.091]     ...future.result$conditions <- ...future.conditions
[15:32:27.091]     ...future.result$finished <- base::Sys.time()
[15:32:27.091]     ...future.result
[15:32:27.091] }
[15:32:27.101] Exporting 5 global objects (848 bytes) to cluster node #1 ...
[15:32:27.101] Exporting '...future.FUN' (848 bytes) to cluster node #1 ...
[15:32:27.102] Exporting '...future.FUN' (848 bytes) to cluster node #1 ... DONE
[15:32:27.103] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:27.103] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:27.103] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:27.104] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:27.104] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:27.106] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:27.106] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:27.107] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:27.108] Exporting 5 global objects (848 bytes) to cluster node #1 ... DONE
[15:32:27.110] MultisessionFuture started
[15:32:27.110] - Launch lazy future ... done
[15:32:27.111] run() for 'MultisessionFuture' ... done
[15:32:27.111] Created future:
[15:32:27.133] receiveMessageFromWorker() for ClusterFuture ...
[15:32:27.133] - Validating connection of MultisessionFuture
[15:32:27.134] - received message: FutureResult
[15:32:27.134] - Received FutureResult
[15:32:27.134] - Erased future from FutureRegistry
[15:32:27.135] result() for ClusterFuture ...
[15:32:27.135] - result already collected: FutureResult
[15:32:27.135] result() for ClusterFuture ... done
[15:32:27.136] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:27.112] MultisessionFuture:
[15:32:27.112] Label: 'future_sapply-2'
[15:32:27.112] Expression:
[15:32:27.112] {
[15:32:27.112]     do.call(function(...) {
[15:32:27.112]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:27.112]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:27.112]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:27.112]             on.exit(options(oopts), add = TRUE)
[15:32:27.112]         }
[15:32:27.112]         {
[15:32:27.112]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:27.112]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:27.112]                 ...future.FUN(...future.X_jj, ...)
[15:32:27.112]             })
[15:32:27.112]         }
[15:32:27.112]     }, args = future.call.arguments)
[15:32:27.112] }
[15:32:27.112] Lazy evaluation: FALSE
[15:32:27.112] Asynchronous evaluation: TRUE
[15:32:27.112] Local evaluation: TRUE
[15:32:27.112] Environment: R_GlobalEnv
[15:32:27.112] Capture standard output: TRUE
[15:32:27.112] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:27.112] Globals: 5 objects totaling 960 bytes (function '...future.FUN' of 848 bytes, 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)
[15:32:27.112] Packages: <none>
[15:32:27.112] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:27.112] Resolved: TRUE
[15:32:27.112] Value: <not collected>
[15:32:27.112] Conditions captured: <none>
[15:32:27.112] Early signaling: FALSE
[15:32:27.112] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:27.112] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:27.136] Chunk #2 of 2 ... DONE
[15:32:27.137] Launching 2 futures (chunks) ... DONE
[15:32:27.137] Resolving 2 futures (chunks) ...
[15:32:27.137] resolve() on list ...
[15:32:27.138]  recursive: 0
[15:32:27.138]  length: 2
[15:32:27.138] 
[15:32:27.138] Future #1
[15:32:27.139] result() for ClusterFuture ...
[15:32:27.139] - result already collected: FutureResult
[15:32:27.139] result() for ClusterFuture ... done
[15:32:27.140] result() for ClusterFuture ...
[15:32:27.140] - result already collected: FutureResult
[15:32:27.140] result() for ClusterFuture ... done
[15:32:27.140] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:27.141] - nx: 2
[15:32:27.141] - relay: TRUE
[15:32:27.141] - stdout: TRUE
[15:32:27.141] - signal: TRUE
[15:32:27.142] - resignal: FALSE
[15:32:27.142] - force: TRUE
[15:32:27.142] - relayed: [n=2] FALSE, FALSE
[15:32:27.142] - queued futures: [n=2] FALSE, FALSE
[15:32:27.143]  - until=1
[15:32:27.143]  - relaying element #1
[15:32:27.143] result() for ClusterFuture ...
[15:32:27.144] - result already collected: FutureResult
[15:32:27.144] result() for ClusterFuture ... done
[15:32:27.144] result() for ClusterFuture ...
[15:32:27.144] - result already collected: FutureResult
[15:32:27.145] result() for ClusterFuture ... done
[15:32:27.145] result() for ClusterFuture ...
[15:32:27.145] - result already collected: FutureResult
[15:32:27.146] result() for ClusterFuture ... done
[15:32:27.146] result() for ClusterFuture ...
[15:32:27.146] - result already collected: FutureResult
[15:32:27.146] result() for ClusterFuture ... done
[15:32:27.147] - relayed: [n=2] TRUE, FALSE
[15:32:27.147] - queued futures: [n=2] TRUE, FALSE
[15:32:27.147] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:27.147]  length: 1 (resolved future 1)
[15:32:27.148] Future #2
[15:32:27.148] result() for ClusterFuture ...
[15:32:27.148] - result already collected: FutureResult
[15:32:27.149] result() for ClusterFuture ... done
[15:32:27.149] result() for ClusterFuture ...
[15:32:27.149] - result already collected: FutureResult
[15:32:27.149] result() for ClusterFuture ... done
[15:32:27.150] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:27.150] - nx: 2
[15:32:27.150] - relay: TRUE
[15:32:27.151] - stdout: TRUE
[15:32:27.151] - signal: TRUE
[15:32:27.151] - resignal: FALSE
[15:32:27.151] - force: TRUE
[15:32:27.152] - relayed: [n=2] TRUE, FALSE
[15:32:27.152] - queued futures: [n=2] TRUE, FALSE
[15:32:27.152]  - until=2
[15:32:27.152]  - relaying element #2
[15:32:27.153] result() for ClusterFuture ...
[15:32:27.153] - result already collected: FutureResult
[15:32:27.153] result() for ClusterFuture ... done
[15:32:27.154] result() for ClusterFuture ...
[15:32:27.154] - result already collected: FutureResult
[15:32:27.154] result() for ClusterFuture ... done
[15:32:27.154] result() for ClusterFuture ...
[15:32:27.155] - result already collected: FutureResult
[15:32:27.155] result() for ClusterFuture ... done
[15:32:27.155] result() for ClusterFuture ...
[15:32:27.156] - result already collected: FutureResult
[15:32:27.156] result() for ClusterFuture ... done
[15:32:27.156] - relayed: [n=2] TRUE, TRUE
[15:32:27.156] - queued futures: [n=2] TRUE, TRUE
[15:32:27.157] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:27.157]  length: 0 (resolved future 2)
[15:32:27.157] Relaying remaining futures
[15:32:27.158] signalConditionsASAP(NULL, pos=0) ...
[15:32:27.158] - nx: 2
[15:32:27.158] - relay: TRUE
[15:32:27.158] - stdout: TRUE
[15:32:27.159] - signal: TRUE
[15:32:27.159] - resignal: FALSE
[15:32:27.159] - force: TRUE
[15:32:27.159] - relayed: [n=2] TRUE, TRUE
[15:32:27.160] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:27.160] - relayed: [n=2] TRUE, TRUE
[15:32:27.160] - queued futures: [n=2] TRUE, TRUE
[15:32:27.161] signalConditionsASAP(NULL, pos=0) ... done
[15:32:27.161] resolve() on list ... DONE
[15:32:27.161] result() for ClusterFuture ...
[15:32:27.161] - result already collected: FutureResult
[15:32:27.162] result() for ClusterFuture ... done
[15:32:27.162] result() for ClusterFuture ...
[15:32:27.162] - result already collected: FutureResult
[15:32:27.162] result() for ClusterFuture ... done
[15:32:27.163] result() for ClusterFuture ...
[15:32:27.163] - result already collected: FutureResult
[15:32:27.163] result() for ClusterFuture ... done
[15:32:27.164] result() for ClusterFuture ...
[15:32:27.164] - result already collected: FutureResult
[15:32:27.164] result() for ClusterFuture ... done
[15:32:27.165]  - Number of value chunks collected: 2
[15:32:27.165] Resolving 2 futures (chunks) ... DONE
[15:32:27.165] Reducing values from 2 chunks ...
[15:32:27.165]  - Number of values collected after concatenation: 3
[15:32:27.166]  - Number of values expected: 3
[15:32:27.166] Reducing values from 2 chunks ... DONE
[15:32:27.166] future_lapply() ... DONE
List of 2
 $ y0:List of 3
  ..$ a: num 1
  ..$ b: num 2
  ..$ c: num 3
 $ y1:List of 3
  ..$ a: num 1
  ..$ b: num 2
  ..$ c: num 3
List of 2
 $ y0:List of 3
  ..$ a: num 1
  ..$ b: num 2
  ..$ c: num 3
 $ y2:List of 3
  ..$ a: num 1
  ..$ b: num 2
  ..$ c: num 3
[15:32:27.177] future_lapply() ...
[15:32:27.182] Number of chunks: 2
[15:32:27.182] getGlobalsAndPackagesXApply() ...
[15:32:27.182]  - future.globals: TRUE
[15:32:27.182] getGlobalsAndPackages() ...
[15:32:27.183] Searching for globals...
[15:32:27.185] - globals found: [2] 'FUN', 'UseMethod'
[15:32:27.185] Searching for globals ... DONE
[15:32:27.185] Resolving globals: FALSE
[15:32:27.186] The total size of the 1 globals is 1.22 KiB (1248 bytes)
[15:32:27.187] The total size of the 1 globals exported for future expression ('FUN()') is 1.22 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.22 KiB of class 'function')
[15:32:27.187] - globals: [1] 'FUN'
[15:32:27.187] 
[15:32:27.188] getGlobalsAndPackages() ... DONE
[15:32:27.188]  - globals found/used: [n=1] 'FUN'
[15:32:27.188]  - needed namespaces: [n=0] 
[15:32:27.188] Finding globals ... DONE
[15:32:27.189]  - use_args: TRUE
[15:32:27.189]  - Getting '...' globals ...
[15:32:27.190] resolve() on list ...
[15:32:27.190]  recursive: 0
[15:32:27.190]  length: 1
[15:32:27.190]  elements: '...'
[15:32:27.191]  length: 0 (resolved future 1)
[15:32:27.191] resolve() on list ... DONE
[15:32:27.191]    - '...' content: [n=0] 
[15:32:27.192] List of 1
[15:32:27.192]  $ ...: list()
[15:32:27.192]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:27.192]  - attr(*, "where")=List of 1
[15:32:27.192]   ..$ ...:<environment: 0x00000276dee36068> 
[15:32:27.192]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:27.192]  - attr(*, "resolved")= logi TRUE
[15:32:27.192]  - attr(*, "total_size")= num NA
[15:32:27.196]  - Getting '...' globals ... DONE
[15:32:27.197] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:27.197] List of 2
[15:32:27.197]  $ ...future.FUN:function (x, ...)  
[15:32:27.197]  $ ...          : list()
[15:32:27.197]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:27.197]  - attr(*, "where")=List of 2
[15:32:27.197]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:27.197]   ..$ ...          :<environment: 0x00000276dee36068> 
[15:32:27.197]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:27.197]  - attr(*, "resolved")= logi FALSE
[15:32:27.197]  - attr(*, "total_size")= num 1248
[15:32:27.202] Packages to be attached in all futures: [n=0] 
[15:32:27.203] getGlobalsAndPackagesXApply() ... DONE
[15:32:27.203] Number of futures (= number of chunks): 2
[15:32:27.204] Launching 2 futures (chunks) ...
[15:32:27.204] Chunk #1 of 2 ...
[15:32:27.204]  - Finding globals in 'X' for chunk #1 ...
[15:32:27.204] getGlobalsAndPackages() ...
[15:32:27.205] Searching for globals...
[15:32:27.205] 
[15:32:27.206] Searching for globals ... DONE
[15:32:27.206] - globals: [0] <none>
[15:32:27.206] getGlobalsAndPackages() ... DONE
[15:32:27.206]    + additional globals found: [n=0] 
[15:32:27.207]    + additional namespaces needed: [n=0] 
[15:32:27.207]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:27.207]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:27.207]  - seeds: <none>
[15:32:27.208]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:27.208] getGlobalsAndPackages() ...
[15:32:27.208] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:27.209] Resolving globals: FALSE
[15:32:27.209] Tweak future expression to call with '...' arguments ...
[15:32:27.209] {
[15:32:27.209]     do.call(function(...) {
[15:32:27.209]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:27.209]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:27.209]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:27.209]             on.exit(options(oopts), add = TRUE)
[15:32:27.209]         }
[15:32:27.209]         {
[15:32:27.209]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:27.209]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:27.209]                 ...future.FUN(...future.X_jj, ...)
[15:32:27.209]             })
[15:32:27.209]         }
[15:32:27.209]     }, args = future.call.arguments)
[15:32:27.209] }
[15:32:27.210] Tweak future expression to call with '...' arguments ... DONE
[15:32:27.211] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:27.211] 
[15:32:27.211] getGlobalsAndPackages() ... DONE
[15:32:27.212] run() for 'Future' ...
[15:32:27.212] - state: 'created'
[15:32:27.213] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:27.231] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:27.231] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:27.231]   - Field: 'node'
[15:32:27.232]   - Field: 'label'
[15:32:27.232]   - Field: 'local'
[15:32:27.232]   - Field: 'owner'
[15:32:27.232]   - Field: 'envir'
[15:32:27.233]   - Field: 'workers'
[15:32:27.233]   - Field: 'packages'
[15:32:27.233]   - Field: 'gc'
[15:32:27.234]   - Field: 'conditions'
[15:32:27.234]   - Field: 'persistent'
[15:32:27.234]   - Field: 'expr'
[15:32:27.234]   - Field: 'uuid'
[15:32:27.235]   - Field: 'seed'
[15:32:27.235]   - Field: 'version'
[15:32:27.235]   - Field: 'result'
[15:32:27.236]   - Field: 'asynchronous'
[15:32:27.236]   - Field: 'calls'
[15:32:27.236]   - Field: 'globals'
[15:32:27.236]   - Field: 'stdout'
[15:32:27.237]   - Field: 'earlySignal'
[15:32:27.237]   - Field: 'lazy'
[15:32:27.237]   - Field: 'state'
[15:32:27.237] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:27.238] - Launch lazy future ...
[15:32:27.238] Packages needed by the future expression (n = 0): <none>
[15:32:27.239] Packages needed by future strategies (n = 0): <none>
[15:32:27.240] {
[15:32:27.240]     {
[15:32:27.240]         {
[15:32:27.240]             ...future.startTime <- base::Sys.time()
[15:32:27.240]             {
[15:32:27.240]                 {
[15:32:27.240]                   {
[15:32:27.240]                     {
[15:32:27.240]                       base::local({
[15:32:27.240]                         has_future <- base::requireNamespace("future", 
[15:32:27.240]                           quietly = TRUE)
[15:32:27.240]                         if (has_future) {
[15:32:27.240]                           ns <- base::getNamespace("future")
[15:32:27.240]                           version <- ns[[".package"]][["version"]]
[15:32:27.240]                           if (is.null(version)) 
[15:32:27.240]                             version <- utils::packageVersion("future")
[15:32:27.240]                         }
[15:32:27.240]                         else {
[15:32:27.240]                           version <- NULL
[15:32:27.240]                         }
[15:32:27.240]                         if (!has_future || version < "1.8.0") {
[15:32:27.240]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:27.240]                             "", base::R.version$version.string), 
[15:32:27.240]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:27.240]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:27.240]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:27.240]                               "release", "version")], collapse = " "), 
[15:32:27.240]                             hostname = base::Sys.info()[["nodename"]])
[15:32:27.240]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:27.240]                             info)
[15:32:27.240]                           info <- base::paste(info, collapse = "; ")
[15:32:27.240]                           if (!has_future) {
[15:32:27.240]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:27.240]                               info)
[15:32:27.240]                           }
[15:32:27.240]                           else {
[15:32:27.240]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:27.240]                               info, version)
[15:32:27.240]                           }
[15:32:27.240]                           base::stop(msg)
[15:32:27.240]                         }
[15:32:27.240]                       })
[15:32:27.240]                     }
[15:32:27.240]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:27.240]                     base::options(mc.cores = 1L)
[15:32:27.240]                   }
[15:32:27.240]                   ...future.strategy.old <- future::plan("list")
[15:32:27.240]                   options(future.plan = NULL)
[15:32:27.240]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:27.240]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:27.240]                 }
[15:32:27.240]                 ...future.workdir <- getwd()
[15:32:27.240]             }
[15:32:27.240]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:27.240]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:27.240]         }
[15:32:27.240]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:27.240]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:27.240]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:27.240]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:27.240]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:27.240]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:27.240]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:27.240]             base::names(...future.oldOptions))
[15:32:27.240]     }
[15:32:27.240]     if (FALSE) {
[15:32:27.240]     }
[15:32:27.240]     else {
[15:32:27.240]         if (TRUE) {
[15:32:27.240]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:27.240]                 open = "w")
[15:32:27.240]         }
[15:32:27.240]         else {
[15:32:27.240]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:27.240]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:27.240]         }
[15:32:27.240]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:27.240]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:27.240]             base::sink(type = "output", split = FALSE)
[15:32:27.240]             base::close(...future.stdout)
[15:32:27.240]         }, add = TRUE)
[15:32:27.240]     }
[15:32:27.240]     ...future.frame <- base::sys.nframe()
[15:32:27.240]     ...future.conditions <- base::list()
[15:32:27.240]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:27.240]     if (FALSE) {
[15:32:27.240]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:27.240]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:27.240]     }
[15:32:27.240]     ...future.result <- base::tryCatch({
[15:32:27.240]         base::withCallingHandlers({
[15:32:27.240]             ...future.value <- base::withVisible(base::local({
[15:32:27.240]                 ...future.makeSendCondition <- base::local({
[15:32:27.240]                   sendCondition <- NULL
[15:32:27.240]                   function(frame = 1L) {
[15:32:27.240]                     if (is.function(sendCondition)) 
[15:32:27.240]                       return(sendCondition)
[15:32:27.240]                     ns <- getNamespace("parallel")
[15:32:27.240]                     if (exists("sendData", mode = "function", 
[15:32:27.240]                       envir = ns)) {
[15:32:27.240]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:27.240]                         envir = ns)
[15:32:27.240]                       envir <- sys.frame(frame)
[15:32:27.240]                       master <- NULL
[15:32:27.240]                       while (!identical(envir, .GlobalEnv) && 
[15:32:27.240]                         !identical(envir, emptyenv())) {
[15:32:27.240]                         if (exists("master", mode = "list", envir = envir, 
[15:32:27.240]                           inherits = FALSE)) {
[15:32:27.240]                           master <- get("master", mode = "list", 
[15:32:27.240]                             envir = envir, inherits = FALSE)
[15:32:27.240]                           if (inherits(master, c("SOCKnode", 
[15:32:27.240]                             "SOCK0node"))) {
[15:32:27.240]                             sendCondition <<- function(cond) {
[15:32:27.240]                               data <- list(type = "VALUE", value = cond, 
[15:32:27.240]                                 success = TRUE)
[15:32:27.240]                               parallel_sendData(master, data)
[15:32:27.240]                             }
[15:32:27.240]                             return(sendCondition)
[15:32:27.240]                           }
[15:32:27.240]                         }
[15:32:27.240]                         frame <- frame + 1L
[15:32:27.240]                         envir <- sys.frame(frame)
[15:32:27.240]                       }
[15:32:27.240]                     }
[15:32:27.240]                     sendCondition <<- function(cond) NULL
[15:32:27.240]                   }
[15:32:27.240]                 })
[15:32:27.240]                 withCallingHandlers({
[15:32:27.240]                   {
[15:32:27.240]                     do.call(function(...) {
[15:32:27.240]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:27.240]                       if (!identical(...future.globals.maxSize.org, 
[15:32:27.240]                         ...future.globals.maxSize)) {
[15:32:27.240]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:27.240]                         on.exit(options(oopts), add = TRUE)
[15:32:27.240]                       }
[15:32:27.240]                       {
[15:32:27.240]                         lapply(seq_along(...future.elements_ii), 
[15:32:27.240]                           FUN = function(jj) {
[15:32:27.240]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:27.240]                             ...future.FUN(...future.X_jj, ...)
[15:32:27.240]                           })
[15:32:27.240]                       }
[15:32:27.240]                     }, args = future.call.arguments)
[15:32:27.240]                   }
[15:32:27.240]                 }, immediateCondition = function(cond) {
[15:32:27.240]                   sendCondition <- ...future.makeSendCondition()
[15:32:27.240]                   sendCondition(cond)
[15:32:27.240]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:27.240]                   {
[15:32:27.240]                     inherits <- base::inherits
[15:32:27.240]                     invokeRestart <- base::invokeRestart
[15:32:27.240]                     is.null <- base::is.null
[15:32:27.240]                     muffled <- FALSE
[15:32:27.240]                     if (inherits(cond, "message")) {
[15:32:27.240]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:27.240]                       if (muffled) 
[15:32:27.240]                         invokeRestart("muffleMessage")
[15:32:27.240]                     }
[15:32:27.240]                     else if (inherits(cond, "warning")) {
[15:32:27.240]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:27.240]                       if (muffled) 
[15:32:27.240]                         invokeRestart("muffleWarning")
[15:32:27.240]                     }
[15:32:27.240]                     else if (inherits(cond, "condition")) {
[15:32:27.240]                       if (!is.null(pattern)) {
[15:32:27.240]                         computeRestarts <- base::computeRestarts
[15:32:27.240]                         grepl <- base::grepl
[15:32:27.240]                         restarts <- computeRestarts(cond)
[15:32:27.240]                         for (restart in restarts) {
[15:32:27.240]                           name <- restart$name
[15:32:27.240]                           if (is.null(name)) 
[15:32:27.240]                             next
[15:32:27.240]                           if (!grepl(pattern, name)) 
[15:32:27.240]                             next
[15:32:27.240]                           invokeRestart(restart)
[15:32:27.240]                           muffled <- TRUE
[15:32:27.240]                           break
[15:32:27.240]                         }
[15:32:27.240]                       }
[15:32:27.240]                     }
[15:32:27.240]                     invisible(muffled)
[15:32:27.240]                   }
[15:32:27.240]                   muffleCondition(cond)
[15:32:27.240]                 })
[15:32:27.240]             }))
[15:32:27.240]             future::FutureResult(value = ...future.value$value, 
[15:32:27.240]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:27.240]                   ...future.rng), globalenv = if (FALSE) 
[15:32:27.240]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:27.240]                     ...future.globalenv.names))
[15:32:27.240]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:27.240]         }, condition = base::local({
[15:32:27.240]             c <- base::c
[15:32:27.240]             inherits <- base::inherits
[15:32:27.240]             invokeRestart <- base::invokeRestart
[15:32:27.240]             length <- base::length
[15:32:27.240]             list <- base::list
[15:32:27.240]             seq.int <- base::seq.int
[15:32:27.240]             signalCondition <- base::signalCondition
[15:32:27.240]             sys.calls <- base::sys.calls
[15:32:27.240]             `[[` <- base::`[[`
[15:32:27.240]             `+` <- base::`+`
[15:32:27.240]             `<<-` <- base::`<<-`
[15:32:27.240]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:27.240]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:27.240]                   3L)]
[15:32:27.240]             }
[15:32:27.240]             function(cond) {
[15:32:27.240]                 is_error <- inherits(cond, "error")
[15:32:27.240]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:27.240]                   NULL)
[15:32:27.240]                 if (is_error) {
[15:32:27.240]                   sessionInformation <- function() {
[15:32:27.240]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:27.240]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:27.240]                       search = base::search(), system = base::Sys.info())
[15:32:27.240]                   }
[15:32:27.240]                   ...future.conditions[[length(...future.conditions) + 
[15:32:27.240]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:27.240]                     cond$call), session = sessionInformation(), 
[15:32:27.240]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:27.240]                   signalCondition(cond)
[15:32:27.240]                 }
[15:32:27.240]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:27.240]                 "immediateCondition"))) {
[15:32:27.240]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:27.240]                   ...future.conditions[[length(...future.conditions) + 
[15:32:27.240]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:27.240]                   if (TRUE && !signal) {
[15:32:27.240]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:27.240]                     {
[15:32:27.240]                       inherits <- base::inherits
[15:32:27.240]                       invokeRestart <- base::invokeRestart
[15:32:27.240]                       is.null <- base::is.null
[15:32:27.240]                       muffled <- FALSE
[15:32:27.240]                       if (inherits(cond, "message")) {
[15:32:27.240]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:27.240]                         if (muffled) 
[15:32:27.240]                           invokeRestart("muffleMessage")
[15:32:27.240]                       }
[15:32:27.240]                       else if (inherits(cond, "warning")) {
[15:32:27.240]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:27.240]                         if (muffled) 
[15:32:27.240]                           invokeRestart("muffleWarning")
[15:32:27.240]                       }
[15:32:27.240]                       else if (inherits(cond, "condition")) {
[15:32:27.240]                         if (!is.null(pattern)) {
[15:32:27.240]                           computeRestarts <- base::computeRestarts
[15:32:27.240]                           grepl <- base::grepl
[15:32:27.240]                           restarts <- computeRestarts(cond)
[15:32:27.240]                           for (restart in restarts) {
[15:32:27.240]                             name <- restart$name
[15:32:27.240]                             if (is.null(name)) 
[15:32:27.240]                               next
[15:32:27.240]                             if (!grepl(pattern, name)) 
[15:32:27.240]                               next
[15:32:27.240]                             invokeRestart(restart)
[15:32:27.240]                             muffled <- TRUE
[15:32:27.240]                             break
[15:32:27.240]                           }
[15:32:27.240]                         }
[15:32:27.240]                       }
[15:32:27.240]                       invisible(muffled)
[15:32:27.240]                     }
[15:32:27.240]                     muffleCondition(cond, pattern = "^muffle")
[15:32:27.240]                   }
[15:32:27.240]                 }
[15:32:27.240]                 else {
[15:32:27.240]                   if (TRUE) {
[15:32:27.240]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:27.240]                     {
[15:32:27.240]                       inherits <- base::inherits
[15:32:27.240]                       invokeRestart <- base::invokeRestart
[15:32:27.240]                       is.null <- base::is.null
[15:32:27.240]                       muffled <- FALSE
[15:32:27.240]                       if (inherits(cond, "message")) {
[15:32:27.240]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:27.240]                         if (muffled) 
[15:32:27.240]                           invokeRestart("muffleMessage")
[15:32:27.240]                       }
[15:32:27.240]                       else if (inherits(cond, "warning")) {
[15:32:27.240]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:27.240]                         if (muffled) 
[15:32:27.240]                           invokeRestart("muffleWarning")
[15:32:27.240]                       }
[15:32:27.240]                       else if (inherits(cond, "condition")) {
[15:32:27.240]                         if (!is.null(pattern)) {
[15:32:27.240]                           computeRestarts <- base::computeRestarts
[15:32:27.240]                           grepl <- base::grepl
[15:32:27.240]                           restarts <- computeRestarts(cond)
[15:32:27.240]                           for (restart in restarts) {
[15:32:27.240]                             name <- restart$name
[15:32:27.240]                             if (is.null(name)) 
[15:32:27.240]                               next
[15:32:27.240]                             if (!grepl(pattern, name)) 
[15:32:27.240]                               next
[15:32:27.240]                             invokeRestart(restart)
[15:32:27.240]                             muffled <- TRUE
[15:32:27.240]                             break
[15:32:27.240]                           }
[15:32:27.240]                         }
[15:32:27.240]                       }
[15:32:27.240]                       invisible(muffled)
[15:32:27.240]                     }
[15:32:27.240]                     muffleCondition(cond, pattern = "^muffle")
[15:32:27.240]                   }
[15:32:27.240]                 }
[15:32:27.240]             }
[15:32:27.240]         }))
[15:32:27.240]     }, error = function(ex) {
[15:32:27.240]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:27.240]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:27.240]                 ...future.rng), started = ...future.startTime, 
[15:32:27.240]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:27.240]             version = "1.8"), class = "FutureResult")
[15:32:27.240]     }, finally = {
[15:32:27.240]         if (!identical(...future.workdir, getwd())) 
[15:32:27.240]             setwd(...future.workdir)
[15:32:27.240]         {
[15:32:27.240]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:27.240]                 ...future.oldOptions$nwarnings <- NULL
[15:32:27.240]             }
[15:32:27.240]             base::options(...future.oldOptions)
[15:32:27.240]             if (.Platform$OS.type == "windows") {
[15:32:27.240]                 old_names <- names(...future.oldEnvVars)
[15:32:27.240]                 envs <- base::Sys.getenv()
[15:32:27.240]                 names <- names(envs)
[15:32:27.240]                 common <- intersect(names, old_names)
[15:32:27.240]                 added <- setdiff(names, old_names)
[15:32:27.240]                 removed <- setdiff(old_names, names)
[15:32:27.240]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:27.240]                   envs[common]]
[15:32:27.240]                 NAMES <- toupper(changed)
[15:32:27.240]                 args <- list()
[15:32:27.240]                 for (kk in seq_along(NAMES)) {
[15:32:27.240]                   name <- changed[[kk]]
[15:32:27.240]                   NAME <- NAMES[[kk]]
[15:32:27.240]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:27.240]                     next
[15:32:27.240]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:27.240]                 }
[15:32:27.240]                 NAMES <- toupper(added)
[15:32:27.240]                 for (kk in seq_along(NAMES)) {
[15:32:27.240]                   name <- added[[kk]]
[15:32:27.240]                   NAME <- NAMES[[kk]]
[15:32:27.240]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:27.240]                     next
[15:32:27.240]                   args[[name]] <- ""
[15:32:27.240]                 }
[15:32:27.240]                 NAMES <- toupper(removed)
[15:32:27.240]                 for (kk in seq_along(NAMES)) {
[15:32:27.240]                   name <- removed[[kk]]
[15:32:27.240]                   NAME <- NAMES[[kk]]
[15:32:27.240]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:27.240]                     next
[15:32:27.240]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:27.240]                 }
[15:32:27.240]                 if (length(args) > 0) 
[15:32:27.240]                   base::do.call(base::Sys.setenv, args = args)
[15:32:27.240]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:27.240]             }
[15:32:27.240]             else {
[15:32:27.240]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:27.240]             }
[15:32:27.240]             {
[15:32:27.240]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:27.240]                   0L) {
[15:32:27.240]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:27.240]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:27.240]                   base::options(opts)
[15:32:27.240]                 }
[15:32:27.240]                 {
[15:32:27.240]                   {
[15:32:27.240]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:27.240]                     NULL
[15:32:27.240]                   }
[15:32:27.240]                   options(future.plan = NULL)
[15:32:27.240]                   if (is.na(NA_character_)) 
[15:32:27.240]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:27.240]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:27.240]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:27.240]                     .init = FALSE)
[15:32:27.240]                 }
[15:32:27.240]             }
[15:32:27.240]         }
[15:32:27.240]     })
[15:32:27.240]     if (TRUE) {
[15:32:27.240]         base::sink(type = "output", split = FALSE)
[15:32:27.240]         if (TRUE) {
[15:32:27.240]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:27.240]         }
[15:32:27.240]         else {
[15:32:27.240]             ...future.result["stdout"] <- base::list(NULL)
[15:32:27.240]         }
[15:32:27.240]         base::close(...future.stdout)
[15:32:27.240]         ...future.stdout <- NULL
[15:32:27.240]     }
[15:32:27.240]     ...future.result$conditions <- ...future.conditions
[15:32:27.240]     ...future.result$finished <- base::Sys.time()
[15:32:27.240]     ...future.result
[15:32:27.240] }
[15:32:27.248] Exporting 5 global objects (1.22 KiB) to cluster node #1 ...
[15:32:27.249] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ...
[15:32:27.250] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ... DONE
[15:32:27.250] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:27.251] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:27.251] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ...
[15:32:27.252] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ... DONE
[15:32:27.252] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:27.253] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:27.253] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:27.254] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:27.254] Exporting 5 global objects (1.22 KiB) to cluster node #1 ... DONE
[15:32:27.255] MultisessionFuture started
[15:32:27.255] - Launch lazy future ... done
[15:32:27.256] run() for 'MultisessionFuture' ... done
[15:32:27.256] Created future:
[15:32:27.283] receiveMessageFromWorker() for ClusterFuture ...
[15:32:27.283] - Validating connection of MultisessionFuture
[15:32:27.284] - received message: FutureResult
[15:32:27.284] - Received FutureResult
[15:32:27.284] - Erased future from FutureRegistry
[15:32:27.284] result() for ClusterFuture ...
[15:32:27.284] - result already collected: FutureResult
[15:32:27.285] result() for ClusterFuture ... done
[15:32:27.285] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:27.256] MultisessionFuture:
[15:32:27.256] Label: 'future_sapply-1'
[15:32:27.256] Expression:
[15:32:27.256] {
[15:32:27.256]     do.call(function(...) {
[15:32:27.256]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:27.256]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:27.256]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:27.256]             on.exit(options(oopts), add = TRUE)
[15:32:27.256]         }
[15:32:27.256]         {
[15:32:27.256]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:27.256]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:27.256]                 ...future.FUN(...future.X_jj, ...)
[15:32:27.256]             })
[15:32:27.256]         }
[15:32:27.256]     }, args = future.call.arguments)
[15:32:27.256] }
[15:32:27.256] Lazy evaluation: FALSE
[15:32:27.256] Asynchronous evaluation: TRUE
[15:32:27.256] Local evaluation: TRUE
[15:32:27.256] Environment: R_GlobalEnv
[15:32:27.256] Capture standard output: TRUE
[15:32:27.256] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:27.256] Globals: 5 objects totaling 1.27 KiB (function '...future.FUN' of 1.22 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)
[15:32:27.256] Packages: <none>
[15:32:27.256] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:27.256] Resolved: TRUE
[15:32:27.256] Value: <not collected>
[15:32:27.256] Conditions captured: <none>
[15:32:27.256] Early signaling: FALSE
[15:32:27.256] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:27.256] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:27.285] Chunk #1 of 2 ... DONE
[15:32:27.285] Chunk #2 of 2 ...
[15:32:27.286]  - Finding globals in 'X' for chunk #2 ...
[15:32:27.286] getGlobalsAndPackages() ...
[15:32:27.286] Searching for globals...
[15:32:27.286] 
[15:32:27.287] Searching for globals ... DONE
[15:32:27.287] - globals: [0] <none>
[15:32:27.287] getGlobalsAndPackages() ... DONE
[15:32:27.287]    + additional globals found: [n=0] 
[15:32:27.287]    + additional namespaces needed: [n=0] 
[15:32:27.287]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:27.288]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:27.288]  - seeds: <none>
[15:32:27.288]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:27.288] getGlobalsAndPackages() ...
[15:32:27.288] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:27.288] Resolving globals: FALSE
[15:32:27.289] Tweak future expression to call with '...' arguments ...
[15:32:27.289] {
[15:32:27.289]     do.call(function(...) {
[15:32:27.289]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:27.289]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:27.289]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:27.289]             on.exit(options(oopts), add = TRUE)
[15:32:27.289]         }
[15:32:27.289]         {
[15:32:27.289]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:27.289]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:27.289]                 ...future.FUN(...future.X_jj, ...)
[15:32:27.289]             })
[15:32:27.289]         }
[15:32:27.289]     }, args = future.call.arguments)
[15:32:27.289] }
[15:32:27.289] Tweak future expression to call with '...' arguments ... DONE
[15:32:27.290] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:27.290] 
[15:32:27.290] getGlobalsAndPackages() ... DONE
[15:32:27.291] run() for 'Future' ...
[15:32:27.291] - state: 'created'
[15:32:27.291] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:27.311] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:27.311] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:27.312]   - Field: 'node'
[15:32:27.313]   - Field: 'label'
[15:32:27.313]   - Field: 'local'
[15:32:27.313]   - Field: 'owner'
[15:32:27.313]   - Field: 'envir'
[15:32:27.314]   - Field: 'workers'
[15:32:27.314]   - Field: 'packages'
[15:32:27.315]   - Field: 'gc'
[15:32:27.315]   - Field: 'conditions'
[15:32:27.315]   - Field: 'persistent'
[15:32:27.316]   - Field: 'expr'
[15:32:27.316]   - Field: 'uuid'
[15:32:27.316]   - Field: 'seed'
[15:32:27.317]   - Field: 'version'
[15:32:27.317]   - Field: 'result'
[15:32:27.318]   - Field: 'asynchronous'
[15:32:27.318]   - Field: 'calls'
[15:32:27.318]   - Field: 'globals'
[15:32:27.319]   - Field: 'stdout'
[15:32:27.319]   - Field: 'earlySignal'
[15:32:27.319]   - Field: 'lazy'
[15:32:27.320]   - Field: 'state'
[15:32:27.320] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:27.320] - Launch lazy future ...
[15:32:27.321] Packages needed by the future expression (n = 0): <none>
[15:32:27.321] Packages needed by future strategies (n = 0): <none>
[15:32:27.322] {
[15:32:27.322]     {
[15:32:27.322]         {
[15:32:27.322]             ...future.startTime <- base::Sys.time()
[15:32:27.322]             {
[15:32:27.322]                 {
[15:32:27.322]                   {
[15:32:27.322]                     {
[15:32:27.322]                       base::local({
[15:32:27.322]                         has_future <- base::requireNamespace("future", 
[15:32:27.322]                           quietly = TRUE)
[15:32:27.322]                         if (has_future) {
[15:32:27.322]                           ns <- base::getNamespace("future")
[15:32:27.322]                           version <- ns[[".package"]][["version"]]
[15:32:27.322]                           if (is.null(version)) 
[15:32:27.322]                             version <- utils::packageVersion("future")
[15:32:27.322]                         }
[15:32:27.322]                         else {
[15:32:27.322]                           version <- NULL
[15:32:27.322]                         }
[15:32:27.322]                         if (!has_future || version < "1.8.0") {
[15:32:27.322]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:27.322]                             "", base::R.version$version.string), 
[15:32:27.322]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:27.322]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:27.322]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:27.322]                               "release", "version")], collapse = " "), 
[15:32:27.322]                             hostname = base::Sys.info()[["nodename"]])
[15:32:27.322]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:27.322]                             info)
[15:32:27.322]                           info <- base::paste(info, collapse = "; ")
[15:32:27.322]                           if (!has_future) {
[15:32:27.322]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:27.322]                               info)
[15:32:27.322]                           }
[15:32:27.322]                           else {
[15:32:27.322]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:27.322]                               info, version)
[15:32:27.322]                           }
[15:32:27.322]                           base::stop(msg)
[15:32:27.322]                         }
[15:32:27.322]                       })
[15:32:27.322]                     }
[15:32:27.322]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:27.322]                     base::options(mc.cores = 1L)
[15:32:27.322]                   }
[15:32:27.322]                   ...future.strategy.old <- future::plan("list")
[15:32:27.322]                   options(future.plan = NULL)
[15:32:27.322]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:27.322]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:27.322]                 }
[15:32:27.322]                 ...future.workdir <- getwd()
[15:32:27.322]             }
[15:32:27.322]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:27.322]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:27.322]         }
[15:32:27.322]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:27.322]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:27.322]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:27.322]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:27.322]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:27.322]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:27.322]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:27.322]             base::names(...future.oldOptions))
[15:32:27.322]     }
[15:32:27.322]     if (FALSE) {
[15:32:27.322]     }
[15:32:27.322]     else {
[15:32:27.322]         if (TRUE) {
[15:32:27.322]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:27.322]                 open = "w")
[15:32:27.322]         }
[15:32:27.322]         else {
[15:32:27.322]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:27.322]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:27.322]         }
[15:32:27.322]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:27.322]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:27.322]             base::sink(type = "output", split = FALSE)
[15:32:27.322]             base::close(...future.stdout)
[15:32:27.322]         }, add = TRUE)
[15:32:27.322]     }
[15:32:27.322]     ...future.frame <- base::sys.nframe()
[15:32:27.322]     ...future.conditions <- base::list()
[15:32:27.322]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:27.322]     if (FALSE) {
[15:32:27.322]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:27.322]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:27.322]     }
[15:32:27.322]     ...future.result <- base::tryCatch({
[15:32:27.322]         base::withCallingHandlers({
[15:32:27.322]             ...future.value <- base::withVisible(base::local({
[15:32:27.322]                 ...future.makeSendCondition <- base::local({
[15:32:27.322]                   sendCondition <- NULL
[15:32:27.322]                   function(frame = 1L) {
[15:32:27.322]                     if (is.function(sendCondition)) 
[15:32:27.322]                       return(sendCondition)
[15:32:27.322]                     ns <- getNamespace("parallel")
[15:32:27.322]                     if (exists("sendData", mode = "function", 
[15:32:27.322]                       envir = ns)) {
[15:32:27.322]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:27.322]                         envir = ns)
[15:32:27.322]                       envir <- sys.frame(frame)
[15:32:27.322]                       master <- NULL
[15:32:27.322]                       while (!identical(envir, .GlobalEnv) && 
[15:32:27.322]                         !identical(envir, emptyenv())) {
[15:32:27.322]                         if (exists("master", mode = "list", envir = envir, 
[15:32:27.322]                           inherits = FALSE)) {
[15:32:27.322]                           master <- get("master", mode = "list", 
[15:32:27.322]                             envir = envir, inherits = FALSE)
[15:32:27.322]                           if (inherits(master, c("SOCKnode", 
[15:32:27.322]                             "SOCK0node"))) {
[15:32:27.322]                             sendCondition <<- function(cond) {
[15:32:27.322]                               data <- list(type = "VALUE", value = cond, 
[15:32:27.322]                                 success = TRUE)
[15:32:27.322]                               parallel_sendData(master, data)
[15:32:27.322]                             }
[15:32:27.322]                             return(sendCondition)
[15:32:27.322]                           }
[15:32:27.322]                         }
[15:32:27.322]                         frame <- frame + 1L
[15:32:27.322]                         envir <- sys.frame(frame)
[15:32:27.322]                       }
[15:32:27.322]                     }
[15:32:27.322]                     sendCondition <<- function(cond) NULL
[15:32:27.322]                   }
[15:32:27.322]                 })
[15:32:27.322]                 withCallingHandlers({
[15:32:27.322]                   {
[15:32:27.322]                     do.call(function(...) {
[15:32:27.322]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:27.322]                       if (!identical(...future.globals.maxSize.org, 
[15:32:27.322]                         ...future.globals.maxSize)) {
[15:32:27.322]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:27.322]                         on.exit(options(oopts), add = TRUE)
[15:32:27.322]                       }
[15:32:27.322]                       {
[15:32:27.322]                         lapply(seq_along(...future.elements_ii), 
[15:32:27.322]                           FUN = function(jj) {
[15:32:27.322]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:27.322]                             ...future.FUN(...future.X_jj, ...)
[15:32:27.322]                           })
[15:32:27.322]                       }
[15:32:27.322]                     }, args = future.call.arguments)
[15:32:27.322]                   }
[15:32:27.322]                 }, immediateCondition = function(cond) {
[15:32:27.322]                   sendCondition <- ...future.makeSendCondition()
[15:32:27.322]                   sendCondition(cond)
[15:32:27.322]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:27.322]                   {
[15:32:27.322]                     inherits <- base::inherits
[15:32:27.322]                     invokeRestart <- base::invokeRestart
[15:32:27.322]                     is.null <- base::is.null
[15:32:27.322]                     muffled <- FALSE
[15:32:27.322]                     if (inherits(cond, "message")) {
[15:32:27.322]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:27.322]                       if (muffled) 
[15:32:27.322]                         invokeRestart("muffleMessage")
[15:32:27.322]                     }
[15:32:27.322]                     else if (inherits(cond, "warning")) {
[15:32:27.322]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:27.322]                       if (muffled) 
[15:32:27.322]                         invokeRestart("muffleWarning")
[15:32:27.322]                     }
[15:32:27.322]                     else if (inherits(cond, "condition")) {
[15:32:27.322]                       if (!is.null(pattern)) {
[15:32:27.322]                         computeRestarts <- base::computeRestarts
[15:32:27.322]                         grepl <- base::grepl
[15:32:27.322]                         restarts <- computeRestarts(cond)
[15:32:27.322]                         for (restart in restarts) {
[15:32:27.322]                           name <- restart$name
[15:32:27.322]                           if (is.null(name)) 
[15:32:27.322]                             next
[15:32:27.322]                           if (!grepl(pattern, name)) 
[15:32:27.322]                             next
[15:32:27.322]                           invokeRestart(restart)
[15:32:27.322]                           muffled <- TRUE
[15:32:27.322]                           break
[15:32:27.322]                         }
[15:32:27.322]                       }
[15:32:27.322]                     }
[15:32:27.322]                     invisible(muffled)
[15:32:27.322]                   }
[15:32:27.322]                   muffleCondition(cond)
[15:32:27.322]                 })
[15:32:27.322]             }))
[15:32:27.322]             future::FutureResult(value = ...future.value$value, 
[15:32:27.322]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:27.322]                   ...future.rng), globalenv = if (FALSE) 
[15:32:27.322]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:27.322]                     ...future.globalenv.names))
[15:32:27.322]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:27.322]         }, condition = base::local({
[15:32:27.322]             c <- base::c
[15:32:27.322]             inherits <- base::inherits
[15:32:27.322]             invokeRestart <- base::invokeRestart
[15:32:27.322]             length <- base::length
[15:32:27.322]             list <- base::list
[15:32:27.322]             seq.int <- base::seq.int
[15:32:27.322]             signalCondition <- base::signalCondition
[15:32:27.322]             sys.calls <- base::sys.calls
[15:32:27.322]             `[[` <- base::`[[`
[15:32:27.322]             `+` <- base::`+`
[15:32:27.322]             `<<-` <- base::`<<-`
[15:32:27.322]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:27.322]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:27.322]                   3L)]
[15:32:27.322]             }
[15:32:27.322]             function(cond) {
[15:32:27.322]                 is_error <- inherits(cond, "error")
[15:32:27.322]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:27.322]                   NULL)
[15:32:27.322]                 if (is_error) {
[15:32:27.322]                   sessionInformation <- function() {
[15:32:27.322]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:27.322]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:27.322]                       search = base::search(), system = base::Sys.info())
[15:32:27.322]                   }
[15:32:27.322]                   ...future.conditions[[length(...future.conditions) + 
[15:32:27.322]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:27.322]                     cond$call), session = sessionInformation(), 
[15:32:27.322]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:27.322]                   signalCondition(cond)
[15:32:27.322]                 }
[15:32:27.322]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:27.322]                 "immediateCondition"))) {
[15:32:27.322]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:27.322]                   ...future.conditions[[length(...future.conditions) + 
[15:32:27.322]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:27.322]                   if (TRUE && !signal) {
[15:32:27.322]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:27.322]                     {
[15:32:27.322]                       inherits <- base::inherits
[15:32:27.322]                       invokeRestart <- base::invokeRestart
[15:32:27.322]                       is.null <- base::is.null
[15:32:27.322]                       muffled <- FALSE
[15:32:27.322]                       if (inherits(cond, "message")) {
[15:32:27.322]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:27.322]                         if (muffled) 
[15:32:27.322]                           invokeRestart("muffleMessage")
[15:32:27.322]                       }
[15:32:27.322]                       else if (inherits(cond, "warning")) {
[15:32:27.322]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:27.322]                         if (muffled) 
[15:32:27.322]                           invokeRestart("muffleWarning")
[15:32:27.322]                       }
[15:32:27.322]                       else if (inherits(cond, "condition")) {
[15:32:27.322]                         if (!is.null(pattern)) {
[15:32:27.322]                           computeRestarts <- base::computeRestarts
[15:32:27.322]                           grepl <- base::grepl
[15:32:27.322]                           restarts <- computeRestarts(cond)
[15:32:27.322]                           for (restart in restarts) {
[15:32:27.322]                             name <- restart$name
[15:32:27.322]                             if (is.null(name)) 
[15:32:27.322]                               next
[15:32:27.322]                             if (!grepl(pattern, name)) 
[15:32:27.322]                               next
[15:32:27.322]                             invokeRestart(restart)
[15:32:27.322]                             muffled <- TRUE
[15:32:27.322]                             break
[15:32:27.322]                           }
[15:32:27.322]                         }
[15:32:27.322]                       }
[15:32:27.322]                       invisible(muffled)
[15:32:27.322]                     }
[15:32:27.322]                     muffleCondition(cond, pattern = "^muffle")
[15:32:27.322]                   }
[15:32:27.322]                 }
[15:32:27.322]                 else {
[15:32:27.322]                   if (TRUE) {
[15:32:27.322]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:27.322]                     {
[15:32:27.322]                       inherits <- base::inherits
[15:32:27.322]                       invokeRestart <- base::invokeRestart
[15:32:27.322]                       is.null <- base::is.null
[15:32:27.322]                       muffled <- FALSE
[15:32:27.322]                       if (inherits(cond, "message")) {
[15:32:27.322]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:27.322]                         if (muffled) 
[15:32:27.322]                           invokeRestart("muffleMessage")
[15:32:27.322]                       }
[15:32:27.322]                       else if (inherits(cond, "warning")) {
[15:32:27.322]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:27.322]                         if (muffled) 
[15:32:27.322]                           invokeRestart("muffleWarning")
[15:32:27.322]                       }
[15:32:27.322]                       else if (inherits(cond, "condition")) {
[15:32:27.322]                         if (!is.null(pattern)) {
[15:32:27.322]                           computeRestarts <- base::computeRestarts
[15:32:27.322]                           grepl <- base::grepl
[15:32:27.322]                           restarts <- computeRestarts(cond)
[15:32:27.322]                           for (restart in restarts) {
[15:32:27.322]                             name <- restart$name
[15:32:27.322]                             if (is.null(name)) 
[15:32:27.322]                               next
[15:32:27.322]                             if (!grepl(pattern, name)) 
[15:32:27.322]                               next
[15:32:27.322]                             invokeRestart(restart)
[15:32:27.322]                             muffled <- TRUE
[15:32:27.322]                             break
[15:32:27.322]                           }
[15:32:27.322]                         }
[15:32:27.322]                       }
[15:32:27.322]                       invisible(muffled)
[15:32:27.322]                     }
[15:32:27.322]                     muffleCondition(cond, pattern = "^muffle")
[15:32:27.322]                   }
[15:32:27.322]                 }
[15:32:27.322]             }
[15:32:27.322]         }))
[15:32:27.322]     }, error = function(ex) {
[15:32:27.322]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:27.322]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:27.322]                 ...future.rng), started = ...future.startTime, 
[15:32:27.322]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:27.322]             version = "1.8"), class = "FutureResult")
[15:32:27.322]     }, finally = {
[15:32:27.322]         if (!identical(...future.workdir, getwd())) 
[15:32:27.322]             setwd(...future.workdir)
[15:32:27.322]         {
[15:32:27.322]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:27.322]                 ...future.oldOptions$nwarnings <- NULL
[15:32:27.322]             }
[15:32:27.322]             base::options(...future.oldOptions)
[15:32:27.322]             if (.Platform$OS.type == "windows") {
[15:32:27.322]                 old_names <- names(...future.oldEnvVars)
[15:32:27.322]                 envs <- base::Sys.getenv()
[15:32:27.322]                 names <- names(envs)
[15:32:27.322]                 common <- intersect(names, old_names)
[15:32:27.322]                 added <- setdiff(names, old_names)
[15:32:27.322]                 removed <- setdiff(old_names, names)
[15:32:27.322]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:27.322]                   envs[common]]
[15:32:27.322]                 NAMES <- toupper(changed)
[15:32:27.322]                 args <- list()
[15:32:27.322]                 for (kk in seq_along(NAMES)) {
[15:32:27.322]                   name <- changed[[kk]]
[15:32:27.322]                   NAME <- NAMES[[kk]]
[15:32:27.322]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:27.322]                     next
[15:32:27.322]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:27.322]                 }
[15:32:27.322]                 NAMES <- toupper(added)
[15:32:27.322]                 for (kk in seq_along(NAMES)) {
[15:32:27.322]                   name <- added[[kk]]
[15:32:27.322]                   NAME <- NAMES[[kk]]
[15:32:27.322]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:27.322]                     next
[15:32:27.322]                   args[[name]] <- ""
[15:32:27.322]                 }
[15:32:27.322]                 NAMES <- toupper(removed)
[15:32:27.322]                 for (kk in seq_along(NAMES)) {
[15:32:27.322]                   name <- removed[[kk]]
[15:32:27.322]                   NAME <- NAMES[[kk]]
[15:32:27.322]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:27.322]                     next
[15:32:27.322]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:27.322]                 }
[15:32:27.322]                 if (length(args) > 0) 
[15:32:27.322]                   base::do.call(base::Sys.setenv, args = args)
[15:32:27.322]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:27.322]             }
[15:32:27.322]             else {
[15:32:27.322]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:27.322]             }
[15:32:27.322]             {
[15:32:27.322]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:27.322]                   0L) {
[15:32:27.322]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:27.322]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:27.322]                   base::options(opts)
[15:32:27.322]                 }
[15:32:27.322]                 {
[15:32:27.322]                   {
[15:32:27.322]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:27.322]                     NULL
[15:32:27.322]                   }
[15:32:27.322]                   options(future.plan = NULL)
[15:32:27.322]                   if (is.na(NA_character_)) 
[15:32:27.322]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:27.322]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:27.322]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:27.322]                     .init = FALSE)
[15:32:27.322]                 }
[15:32:27.322]             }
[15:32:27.322]         }
[15:32:27.322]     })
[15:32:27.322]     if (TRUE) {
[15:32:27.322]         base::sink(type = "output", split = FALSE)
[15:32:27.322]         if (TRUE) {
[15:32:27.322]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:27.322]         }
[15:32:27.322]         else {
[15:32:27.322]             ...future.result["stdout"] <- base::list(NULL)
[15:32:27.322]         }
[15:32:27.322]         base::close(...future.stdout)
[15:32:27.322]         ...future.stdout <- NULL
[15:32:27.322]     }
[15:32:27.322]     ...future.result$conditions <- ...future.conditions
[15:32:27.322]     ...future.result$finished <- base::Sys.time()
[15:32:27.322]     ...future.result
[15:32:27.322] }
[15:32:27.333] Exporting 5 global objects (1.22 KiB) to cluster node #1 ...
[15:32:27.334] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ...
[15:32:27.335] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ... DONE
[15:32:27.335] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:27.336] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:27.337] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:27.337] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:27.338] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:27.339] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:27.340] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:27.341] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:27.341] Exporting 5 global objects (1.22 KiB) to cluster node #1 ... DONE
[15:32:27.342] MultisessionFuture started
[15:32:27.343] - Launch lazy future ... done
[15:32:27.343] run() for 'MultisessionFuture' ... done
[15:32:27.344] Created future:
[15:32:27.369] receiveMessageFromWorker() for ClusterFuture ...
[15:32:27.370] - Validating connection of MultisessionFuture
[15:32:27.370] - received message: FutureResult
[15:32:27.371] - Received FutureResult
[15:32:27.371] - Erased future from FutureRegistry
[15:32:27.372] result() for ClusterFuture ...
[15:32:27.372] - result already collected: FutureResult
[15:32:27.372] result() for ClusterFuture ... done
[15:32:27.372] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:27.344] MultisessionFuture:
[15:32:27.344] Label: 'future_sapply-2'
[15:32:27.344] Expression:
[15:32:27.344] {
[15:32:27.344]     do.call(function(...) {
[15:32:27.344]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:27.344]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:27.344]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:27.344]             on.exit(options(oopts), add = TRUE)
[15:32:27.344]         }
[15:32:27.344]         {
[15:32:27.344]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:27.344]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:27.344]                 ...future.FUN(...future.X_jj, ...)
[15:32:27.344]             })
[15:32:27.344]         }
[15:32:27.344]     }, args = future.call.arguments)
[15:32:27.344] }
[15:32:27.344] Lazy evaluation: FALSE
[15:32:27.344] Asynchronous evaluation: TRUE
[15:32:27.344] Local evaluation: TRUE
[15:32:27.344] Environment: R_GlobalEnv
[15:32:27.344] Capture standard output: TRUE
[15:32:27.344] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:27.344] Globals: 5 objects totaling 1.33 KiB (function '...future.FUN' of 1.22 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)
[15:32:27.344] Packages: <none>
[15:32:27.344] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:27.344] Resolved: TRUE
[15:32:27.344] Value: <not collected>
[15:32:27.344] Conditions captured: <none>
[15:32:27.344] Early signaling: FALSE
[15:32:27.344] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:27.344] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:27.373] Chunk #2 of 2 ... DONE
[15:32:27.374] Launching 2 futures (chunks) ... DONE
[15:32:27.374] Resolving 2 futures (chunks) ...
[15:32:27.374] resolve() on list ...
[15:32:27.375]  recursive: 0
[15:32:27.375]  length: 2
[15:32:27.375] 
[15:32:27.376] Future #1
[15:32:27.376] result() for ClusterFuture ...
[15:32:27.376] - result already collected: FutureResult
[15:32:27.377] result() for ClusterFuture ... done
[15:32:27.377] result() for ClusterFuture ...
[15:32:27.377] - result already collected: FutureResult
[15:32:27.377] result() for ClusterFuture ... done
[15:32:27.378] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:27.378] - nx: 2
[15:32:27.378] - relay: TRUE
[15:32:27.378] - stdout: TRUE
[15:32:27.378] - signal: TRUE
[15:32:27.379] - resignal: FALSE
[15:32:27.379] - force: TRUE
[15:32:27.379] - relayed: [n=2] FALSE, FALSE
[15:32:27.379] - queued futures: [n=2] FALSE, FALSE
[15:32:27.380]  - until=1
[15:32:27.380]  - relaying element #1
[15:32:27.380] result() for ClusterFuture ...
[15:32:27.380] - result already collected: FutureResult
[15:32:27.380] result() for ClusterFuture ... done
[15:32:27.381] result() for ClusterFuture ...
[15:32:27.381] - result already collected: FutureResult
[15:32:27.381] result() for ClusterFuture ... done
[15:32:27.382] result() for ClusterFuture ...
[15:32:27.382] - result already collected: FutureResult
[15:32:27.387] result() for ClusterFuture ... done
[15:32:27.387] result() for ClusterFuture ...
[15:32:27.387] - result already collected: FutureResult
[15:32:27.388] result() for ClusterFuture ... done
[15:32:27.388] - relayed: [n=2] TRUE, FALSE
[15:32:27.388] - queued futures: [n=2] TRUE, FALSE
[15:32:27.389] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:27.389]  length: 1 (resolved future 1)
[15:32:27.389] Future #2
[15:32:27.389] result() for ClusterFuture ...
[15:32:27.390] - result already collected: FutureResult
[15:32:27.390] result() for ClusterFuture ... done
[15:32:27.390] result() for ClusterFuture ...
[15:32:27.390] - result already collected: FutureResult
[15:32:27.391] result() for ClusterFuture ... done
[15:32:27.391] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:27.391] - nx: 2
[15:32:27.392] - relay: TRUE
[15:32:27.392] - stdout: TRUE
[15:32:27.392] - signal: TRUE
[15:32:27.392] - resignal: FALSE
[15:32:27.393] - force: TRUE
[15:32:27.393] - relayed: [n=2] TRUE, FALSE
[15:32:27.393] - queued futures: [n=2] TRUE, FALSE
[15:32:27.393]  - until=2
[15:32:27.394]  - relaying element #2
[15:32:27.394] result() for ClusterFuture ...
[15:32:27.394] - result already collected: FutureResult
[15:32:27.394] result() for ClusterFuture ... done
[15:32:27.394] result() for ClusterFuture ...
[15:32:27.395] - result already collected: FutureResult
[15:32:27.395] result() for ClusterFuture ... done
[15:32:27.395] result() for ClusterFuture ...
[15:32:27.395] - result already collected: FutureResult
[15:32:27.395] result() for ClusterFuture ... done
[15:32:27.396] result() for ClusterFuture ...
[15:32:27.396] - result already collected: FutureResult
[15:32:27.396] result() for ClusterFuture ... done
[15:32:27.396] - relayed: [n=2] TRUE, TRUE
[15:32:27.396] - queued futures: [n=2] TRUE, TRUE
[15:32:27.396] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:27.397]  length: 0 (resolved future 2)
[15:32:27.397] Relaying remaining futures
[15:32:27.397] signalConditionsASAP(NULL, pos=0) ...
[15:32:27.397] - nx: 2
[15:32:27.397] - relay: TRUE
[15:32:27.397] - stdout: TRUE
[15:32:27.397] - signal: TRUE
[15:32:27.398] - resignal: FALSE
[15:32:27.398] - force: TRUE
[15:32:27.398] - relayed: [n=2] TRUE, TRUE
[15:32:27.398] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:27.398] - relayed: [n=2] TRUE, TRUE
[15:32:27.398] - queued futures: [n=2] TRUE, TRUE
[15:32:27.399] signalConditionsASAP(NULL, pos=0) ... done
[15:32:27.399] resolve() on list ... DONE
[15:32:27.399] result() for ClusterFuture ...
[15:32:27.399] - result already collected: FutureResult
[15:32:27.399] result() for ClusterFuture ... done
[15:32:27.399] result() for ClusterFuture ...
[15:32:27.400] - result already collected: FutureResult
[15:32:27.400] result() for ClusterFuture ... done
[15:32:27.400] result() for ClusterFuture ...
[15:32:27.400] - result already collected: FutureResult
[15:32:27.400] result() for ClusterFuture ... done
[15:32:27.400] result() for ClusterFuture ...
[15:32:27.401] - result already collected: FutureResult
[15:32:27.401] result() for ClusterFuture ... done
[15:32:27.401]  - Number of value chunks collected: 2
[15:32:27.401] Resolving 2 futures (chunks) ... DONE
[15:32:27.402] Reducing values from 2 chunks ...
[15:32:27.402]  - Number of values collected after concatenation: 3
[15:32:27.402]  - Number of values expected: 3
[15:32:27.402] Reducing values from 2 chunks ... DONE
[15:32:27.403] future_lapply() ... DONE
List of 2
 $ y0:List of 3
  ..$ a: num [1, 1] 1
  ..$ b: num [1, 1] 2
  ..$ c: num [1, 1] 3
 $ y1:List of 3
  ..$ a: num [1, 1] 1
  ..$ b: num [1, 1] 2
  ..$ c: num [1, 1] 3
List of 2
 $ y0:List of 3
  ..$ a: num [1, 1] 1
  ..$ b: num [1, 1] 2
  ..$ c: num [1, 1] 3
 $ y2:List of 3
  ..$ a: num [1, 1] 1
  ..$ b: num [1, 1] 2
  ..$ c: num [1, 1] 3
[15:32:27.413] future_lapply() ...
[15:32:27.418] Number of chunks: 2
[15:32:27.419] getGlobalsAndPackagesXApply() ...
[15:32:27.419]  - future.globals: TRUE
[15:32:27.419] getGlobalsAndPackages() ...
[15:32:27.419] Searching for globals...
[15:32:27.422] - globals found: [5] 'FUN', '*', ':', 'outer', 'rep'
[15:32:27.423] Searching for globals ... DONE
[15:32:27.423] Resolving globals: FALSE
[15:32:27.424] The total size of the 1 globals is 4.62 KiB (4728 bytes)
[15:32:27.425] The total size of the 1 globals exported for future expression ('FUN()') is 4.62 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.62 KiB of class 'function')
[15:32:27.425] - globals: [1] 'FUN'
[15:32:27.425] 
[15:32:27.426] getGlobalsAndPackages() ... DONE
[15:32:27.426]  - globals found/used: [n=1] 'FUN'
[15:32:27.426]  - needed namespaces: [n=0] 
[15:32:27.426] Finding globals ... DONE
[15:32:27.427]  - use_args: TRUE
[15:32:27.427]  - Getting '...' globals ...
[15:32:27.428] resolve() on list ...
[15:32:27.428]  recursive: 0
[15:32:27.428]  length: 1
[15:32:27.428]  elements: '...'
[15:32:27.429]  length: 0 (resolved future 1)
[15:32:27.429] resolve() on list ... DONE
[15:32:27.429]    - '...' content: [n=0] 
[15:32:27.430] List of 1
[15:32:27.430]  $ ...: list()
[15:32:27.430]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:27.430]  - attr(*, "where")=List of 1
[15:32:27.430]   ..$ ...:<environment: 0x00000276e1e15a70> 
[15:32:27.430]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:27.430]  - attr(*, "resolved")= logi TRUE
[15:32:27.430]  - attr(*, "total_size")= num NA
[15:32:27.435]  - Getting '...' globals ... DONE
[15:32:27.435] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:27.435] List of 2
[15:32:27.435]  $ ...future.FUN:function (x, y = 2 * 1:5)  
[15:32:27.435]  $ ...          : list()
[15:32:27.435]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:27.435]  - attr(*, "where")=List of 2
[15:32:27.435]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:27.435]   ..$ ...          :<environment: 0x00000276e1e15a70> 
[15:32:27.435]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:27.435]  - attr(*, "resolved")= logi FALSE
[15:32:27.435]  - attr(*, "total_size")= num 4728
[15:32:27.440] Packages to be attached in all futures: [n=0] 
[15:32:27.440] getGlobalsAndPackagesXApply() ... DONE
[15:32:27.440] Number of futures (= number of chunks): 2
[15:32:27.440] Launching 2 futures (chunks) ...
[15:32:27.441] Chunk #1 of 2 ...
[15:32:27.441]  - Finding globals in 'X' for chunk #1 ...
[15:32:27.441] getGlobalsAndPackages() ...
[15:32:27.441] Searching for globals...
[15:32:27.441] 
[15:32:27.442] Searching for globals ... DONE
[15:32:27.442] - globals: [0] <none>
[15:32:27.442] getGlobalsAndPackages() ... DONE
[15:32:27.442]    + additional globals found: [n=0] 
[15:32:27.442]    + additional namespaces needed: [n=0] 
[15:32:27.442]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:27.443]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:27.443]  - seeds: <none>
[15:32:27.443]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:27.443] getGlobalsAndPackages() ...
[15:32:27.443] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:27.444] Resolving globals: FALSE
[15:32:27.444] Tweak future expression to call with '...' arguments ...
[15:32:27.444] {
[15:32:27.444]     do.call(function(...) {
[15:32:27.444]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:27.444]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:27.444]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:27.444]             on.exit(options(oopts), add = TRUE)
[15:32:27.444]         }
[15:32:27.444]         {
[15:32:27.444]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:27.444]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:27.444]                 ...future.FUN(...future.X_jj, ...)
[15:32:27.444]             })
[15:32:27.444]         }
[15:32:27.444]     }, args = future.call.arguments)
[15:32:27.444] }
[15:32:27.444] Tweak future expression to call with '...' arguments ... DONE
[15:32:27.445] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:27.445] 
[15:32:27.445] getGlobalsAndPackages() ... DONE
[15:32:27.446] run() for 'Future' ...
[15:32:27.446] - state: 'created'
[15:32:27.446] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:27.462] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:27.463] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:27.463]   - Field: 'node'
[15:32:27.463]   - Field: 'label'
[15:32:27.464]   - Field: 'local'
[15:32:27.464]   - Field: 'owner'
[15:32:27.464]   - Field: 'envir'
[15:32:27.465]   - Field: 'workers'
[15:32:27.465]   - Field: 'packages'
[15:32:27.465]   - Field: 'gc'
[15:32:27.465]   - Field: 'conditions'
[15:32:27.466]   - Field: 'persistent'
[15:32:27.466]   - Field: 'expr'
[15:32:27.466]   - Field: 'uuid'
[15:32:27.467]   - Field: 'seed'
[15:32:27.467]   - Field: 'version'
[15:32:27.467]   - Field: 'result'
[15:32:27.467]   - Field: 'asynchronous'
[15:32:27.468]   - Field: 'calls'
[15:32:27.468]   - Field: 'globals'
[15:32:27.468]   - Field: 'stdout'
[15:32:27.469]   - Field: 'earlySignal'
[15:32:27.469]   - Field: 'lazy'
[15:32:27.469]   - Field: 'state'
[15:32:27.470] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:27.470] - Launch lazy future ...
[15:32:27.471] Packages needed by the future expression (n = 0): <none>
[15:32:27.471] Packages needed by future strategies (n = 0): <none>
[15:32:27.471] {
[15:32:27.471]     {
[15:32:27.471]         {
[15:32:27.471]             ...future.startTime <- base::Sys.time()
[15:32:27.471]             {
[15:32:27.471]                 {
[15:32:27.471]                   {
[15:32:27.471]                     {
[15:32:27.471]                       base::local({
[15:32:27.471]                         has_future <- base::requireNamespace("future", 
[15:32:27.471]                           quietly = TRUE)
[15:32:27.471]                         if (has_future) {
[15:32:27.471]                           ns <- base::getNamespace("future")
[15:32:27.471]                           version <- ns[[".package"]][["version"]]
[15:32:27.471]                           if (is.null(version)) 
[15:32:27.471]                             version <- utils::packageVersion("future")
[15:32:27.471]                         }
[15:32:27.471]                         else {
[15:32:27.471]                           version <- NULL
[15:32:27.471]                         }
[15:32:27.471]                         if (!has_future || version < "1.8.0") {
[15:32:27.471]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:27.471]                             "", base::R.version$version.string), 
[15:32:27.471]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:27.471]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:27.471]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:27.471]                               "release", "version")], collapse = " "), 
[15:32:27.471]                             hostname = base::Sys.info()[["nodename"]])
[15:32:27.471]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:27.471]                             info)
[15:32:27.471]                           info <- base::paste(info, collapse = "; ")
[15:32:27.471]                           if (!has_future) {
[15:32:27.471]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:27.471]                               info)
[15:32:27.471]                           }
[15:32:27.471]                           else {
[15:32:27.471]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:27.471]                               info, version)
[15:32:27.471]                           }
[15:32:27.471]                           base::stop(msg)
[15:32:27.471]                         }
[15:32:27.471]                       })
[15:32:27.471]                     }
[15:32:27.471]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:27.471]                     base::options(mc.cores = 1L)
[15:32:27.471]                   }
[15:32:27.471]                   ...future.strategy.old <- future::plan("list")
[15:32:27.471]                   options(future.plan = NULL)
[15:32:27.471]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:27.471]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:27.471]                 }
[15:32:27.471]                 ...future.workdir <- getwd()
[15:32:27.471]             }
[15:32:27.471]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:27.471]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:27.471]         }
[15:32:27.471]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:27.471]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:27.471]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:27.471]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:27.471]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:27.471]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:27.471]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:27.471]             base::names(...future.oldOptions))
[15:32:27.471]     }
[15:32:27.471]     if (FALSE) {
[15:32:27.471]     }
[15:32:27.471]     else {
[15:32:27.471]         if (TRUE) {
[15:32:27.471]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:27.471]                 open = "w")
[15:32:27.471]         }
[15:32:27.471]         else {
[15:32:27.471]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:27.471]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:27.471]         }
[15:32:27.471]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:27.471]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:27.471]             base::sink(type = "output", split = FALSE)
[15:32:27.471]             base::close(...future.stdout)
[15:32:27.471]         }, add = TRUE)
[15:32:27.471]     }
[15:32:27.471]     ...future.frame <- base::sys.nframe()
[15:32:27.471]     ...future.conditions <- base::list()
[15:32:27.471]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:27.471]     if (FALSE) {
[15:32:27.471]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:27.471]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:27.471]     }
[15:32:27.471]     ...future.result <- base::tryCatch({
[15:32:27.471]         base::withCallingHandlers({
[15:32:27.471]             ...future.value <- base::withVisible(base::local({
[15:32:27.471]                 ...future.makeSendCondition <- base::local({
[15:32:27.471]                   sendCondition <- NULL
[15:32:27.471]                   function(frame = 1L) {
[15:32:27.471]                     if (is.function(sendCondition)) 
[15:32:27.471]                       return(sendCondition)
[15:32:27.471]                     ns <- getNamespace("parallel")
[15:32:27.471]                     if (exists("sendData", mode = "function", 
[15:32:27.471]                       envir = ns)) {
[15:32:27.471]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:27.471]                         envir = ns)
[15:32:27.471]                       envir <- sys.frame(frame)
[15:32:27.471]                       master <- NULL
[15:32:27.471]                       while (!identical(envir, .GlobalEnv) && 
[15:32:27.471]                         !identical(envir, emptyenv())) {
[15:32:27.471]                         if (exists("master", mode = "list", envir = envir, 
[15:32:27.471]                           inherits = FALSE)) {
[15:32:27.471]                           master <- get("master", mode = "list", 
[15:32:27.471]                             envir = envir, inherits = FALSE)
[15:32:27.471]                           if (inherits(master, c("SOCKnode", 
[15:32:27.471]                             "SOCK0node"))) {
[15:32:27.471]                             sendCondition <<- function(cond) {
[15:32:27.471]                               data <- list(type = "VALUE", value = cond, 
[15:32:27.471]                                 success = TRUE)
[15:32:27.471]                               parallel_sendData(master, data)
[15:32:27.471]                             }
[15:32:27.471]                             return(sendCondition)
[15:32:27.471]                           }
[15:32:27.471]                         }
[15:32:27.471]                         frame <- frame + 1L
[15:32:27.471]                         envir <- sys.frame(frame)
[15:32:27.471]                       }
[15:32:27.471]                     }
[15:32:27.471]                     sendCondition <<- function(cond) NULL
[15:32:27.471]                   }
[15:32:27.471]                 })
[15:32:27.471]                 withCallingHandlers({
[15:32:27.471]                   {
[15:32:27.471]                     do.call(function(...) {
[15:32:27.471]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:27.471]                       if (!identical(...future.globals.maxSize.org, 
[15:32:27.471]                         ...future.globals.maxSize)) {
[15:32:27.471]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:27.471]                         on.exit(options(oopts), add = TRUE)
[15:32:27.471]                       }
[15:32:27.471]                       {
[15:32:27.471]                         lapply(seq_along(...future.elements_ii), 
[15:32:27.471]                           FUN = function(jj) {
[15:32:27.471]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:27.471]                             ...future.FUN(...future.X_jj, ...)
[15:32:27.471]                           })
[15:32:27.471]                       }
[15:32:27.471]                     }, args = future.call.arguments)
[15:32:27.471]                   }
[15:32:27.471]                 }, immediateCondition = function(cond) {
[15:32:27.471]                   sendCondition <- ...future.makeSendCondition()
[15:32:27.471]                   sendCondition(cond)
[15:32:27.471]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:27.471]                   {
[15:32:27.471]                     inherits <- base::inherits
[15:32:27.471]                     invokeRestart <- base::invokeRestart
[15:32:27.471]                     is.null <- base::is.null
[15:32:27.471]                     muffled <- FALSE
[15:32:27.471]                     if (inherits(cond, "message")) {
[15:32:27.471]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:27.471]                       if (muffled) 
[15:32:27.471]                         invokeRestart("muffleMessage")
[15:32:27.471]                     }
[15:32:27.471]                     else if (inherits(cond, "warning")) {
[15:32:27.471]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:27.471]                       if (muffled) 
[15:32:27.471]                         invokeRestart("muffleWarning")
[15:32:27.471]                     }
[15:32:27.471]                     else if (inherits(cond, "condition")) {
[15:32:27.471]                       if (!is.null(pattern)) {
[15:32:27.471]                         computeRestarts <- base::computeRestarts
[15:32:27.471]                         grepl <- base::grepl
[15:32:27.471]                         restarts <- computeRestarts(cond)
[15:32:27.471]                         for (restart in restarts) {
[15:32:27.471]                           name <- restart$name
[15:32:27.471]                           if (is.null(name)) 
[15:32:27.471]                             next
[15:32:27.471]                           if (!grepl(pattern, name)) 
[15:32:27.471]                             next
[15:32:27.471]                           invokeRestart(restart)
[15:32:27.471]                           muffled <- TRUE
[15:32:27.471]                           break
[15:32:27.471]                         }
[15:32:27.471]                       }
[15:32:27.471]                     }
[15:32:27.471]                     invisible(muffled)
[15:32:27.471]                   }
[15:32:27.471]                   muffleCondition(cond)
[15:32:27.471]                 })
[15:32:27.471]             }))
[15:32:27.471]             future::FutureResult(value = ...future.value$value, 
[15:32:27.471]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:27.471]                   ...future.rng), globalenv = if (FALSE) 
[15:32:27.471]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:27.471]                     ...future.globalenv.names))
[15:32:27.471]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:27.471]         }, condition = base::local({
[15:32:27.471]             c <- base::c
[15:32:27.471]             inherits <- base::inherits
[15:32:27.471]             invokeRestart <- base::invokeRestart
[15:32:27.471]             length <- base::length
[15:32:27.471]             list <- base::list
[15:32:27.471]             seq.int <- base::seq.int
[15:32:27.471]             signalCondition <- base::signalCondition
[15:32:27.471]             sys.calls <- base::sys.calls
[15:32:27.471]             `[[` <- base::`[[`
[15:32:27.471]             `+` <- base::`+`
[15:32:27.471]             `<<-` <- base::`<<-`
[15:32:27.471]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:27.471]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:27.471]                   3L)]
[15:32:27.471]             }
[15:32:27.471]             function(cond) {
[15:32:27.471]                 is_error <- inherits(cond, "error")
[15:32:27.471]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:27.471]                   NULL)
[15:32:27.471]                 if (is_error) {
[15:32:27.471]                   sessionInformation <- function() {
[15:32:27.471]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:27.471]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:27.471]                       search = base::search(), system = base::Sys.info())
[15:32:27.471]                   }
[15:32:27.471]                   ...future.conditions[[length(...future.conditions) + 
[15:32:27.471]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:27.471]                     cond$call), session = sessionInformation(), 
[15:32:27.471]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:27.471]                   signalCondition(cond)
[15:32:27.471]                 }
[15:32:27.471]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:27.471]                 "immediateCondition"))) {
[15:32:27.471]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:27.471]                   ...future.conditions[[length(...future.conditions) + 
[15:32:27.471]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:27.471]                   if (TRUE && !signal) {
[15:32:27.471]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:27.471]                     {
[15:32:27.471]                       inherits <- base::inherits
[15:32:27.471]                       invokeRestart <- base::invokeRestart
[15:32:27.471]                       is.null <- base::is.null
[15:32:27.471]                       muffled <- FALSE
[15:32:27.471]                       if (inherits(cond, "message")) {
[15:32:27.471]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:27.471]                         if (muffled) 
[15:32:27.471]                           invokeRestart("muffleMessage")
[15:32:27.471]                       }
[15:32:27.471]                       else if (inherits(cond, "warning")) {
[15:32:27.471]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:27.471]                         if (muffled) 
[15:32:27.471]                           invokeRestart("muffleWarning")
[15:32:27.471]                       }
[15:32:27.471]                       else if (inherits(cond, "condition")) {
[15:32:27.471]                         if (!is.null(pattern)) {
[15:32:27.471]                           computeRestarts <- base::computeRestarts
[15:32:27.471]                           grepl <- base::grepl
[15:32:27.471]                           restarts <- computeRestarts(cond)
[15:32:27.471]                           for (restart in restarts) {
[15:32:27.471]                             name <- restart$name
[15:32:27.471]                             if (is.null(name)) 
[15:32:27.471]                               next
[15:32:27.471]                             if (!grepl(pattern, name)) 
[15:32:27.471]                               next
[15:32:27.471]                             invokeRestart(restart)
[15:32:27.471]                             muffled <- TRUE
[15:32:27.471]                             break
[15:32:27.471]                           }
[15:32:27.471]                         }
[15:32:27.471]                       }
[15:32:27.471]                       invisible(muffled)
[15:32:27.471]                     }
[15:32:27.471]                     muffleCondition(cond, pattern = "^muffle")
[15:32:27.471]                   }
[15:32:27.471]                 }
[15:32:27.471]                 else {
[15:32:27.471]                   if (TRUE) {
[15:32:27.471]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:27.471]                     {
[15:32:27.471]                       inherits <- base::inherits
[15:32:27.471]                       invokeRestart <- base::invokeRestart
[15:32:27.471]                       is.null <- base::is.null
[15:32:27.471]                       muffled <- FALSE
[15:32:27.471]                       if (inherits(cond, "message")) {
[15:32:27.471]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:27.471]                         if (muffled) 
[15:32:27.471]                           invokeRestart("muffleMessage")
[15:32:27.471]                       }
[15:32:27.471]                       else if (inherits(cond, "warning")) {
[15:32:27.471]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:27.471]                         if (muffled) 
[15:32:27.471]                           invokeRestart("muffleWarning")
[15:32:27.471]                       }
[15:32:27.471]                       else if (inherits(cond, "condition")) {
[15:32:27.471]                         if (!is.null(pattern)) {
[15:32:27.471]                           computeRestarts <- base::computeRestarts
[15:32:27.471]                           grepl <- base::grepl
[15:32:27.471]                           restarts <- computeRestarts(cond)
[15:32:27.471]                           for (restart in restarts) {
[15:32:27.471]                             name <- restart$name
[15:32:27.471]                             if (is.null(name)) 
[15:32:27.471]                               next
[15:32:27.471]                             if (!grepl(pattern, name)) 
[15:32:27.471]                               next
[15:32:27.471]                             invokeRestart(restart)
[15:32:27.471]                             muffled <- TRUE
[15:32:27.471]                             break
[15:32:27.471]                           }
[15:32:27.471]                         }
[15:32:27.471]                       }
[15:32:27.471]                       invisible(muffled)
[15:32:27.471]                     }
[15:32:27.471]                     muffleCondition(cond, pattern = "^muffle")
[15:32:27.471]                   }
[15:32:27.471]                 }
[15:32:27.471]             }
[15:32:27.471]         }))
[15:32:27.471]     }, error = function(ex) {
[15:32:27.471]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:27.471]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:27.471]                 ...future.rng), started = ...future.startTime, 
[15:32:27.471]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:27.471]             version = "1.8"), class = "FutureResult")
[15:32:27.471]     }, finally = {
[15:32:27.471]         if (!identical(...future.workdir, getwd())) 
[15:32:27.471]             setwd(...future.workdir)
[15:32:27.471]         {
[15:32:27.471]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:27.471]                 ...future.oldOptions$nwarnings <- NULL
[15:32:27.471]             }
[15:32:27.471]             base::options(...future.oldOptions)
[15:32:27.471]             if (.Platform$OS.type == "windows") {
[15:32:27.471]                 old_names <- names(...future.oldEnvVars)
[15:32:27.471]                 envs <- base::Sys.getenv()
[15:32:27.471]                 names <- names(envs)
[15:32:27.471]                 common <- intersect(names, old_names)
[15:32:27.471]                 added <- setdiff(names, old_names)
[15:32:27.471]                 removed <- setdiff(old_names, names)
[15:32:27.471]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:27.471]                   envs[common]]
[15:32:27.471]                 NAMES <- toupper(changed)
[15:32:27.471]                 args <- list()
[15:32:27.471]                 for (kk in seq_along(NAMES)) {
[15:32:27.471]                   name <- changed[[kk]]
[15:32:27.471]                   NAME <- NAMES[[kk]]
[15:32:27.471]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:27.471]                     next
[15:32:27.471]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:27.471]                 }
[15:32:27.471]                 NAMES <- toupper(added)
[15:32:27.471]                 for (kk in seq_along(NAMES)) {
[15:32:27.471]                   name <- added[[kk]]
[15:32:27.471]                   NAME <- NAMES[[kk]]
[15:32:27.471]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:27.471]                     next
[15:32:27.471]                   args[[name]] <- ""
[15:32:27.471]                 }
[15:32:27.471]                 NAMES <- toupper(removed)
[15:32:27.471]                 for (kk in seq_along(NAMES)) {
[15:32:27.471]                   name <- removed[[kk]]
[15:32:27.471]                   NAME <- NAMES[[kk]]
[15:32:27.471]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:27.471]                     next
[15:32:27.471]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:27.471]                 }
[15:32:27.471]                 if (length(args) > 0) 
[15:32:27.471]                   base::do.call(base::Sys.setenv, args = args)
[15:32:27.471]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:27.471]             }
[15:32:27.471]             else {
[15:32:27.471]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:27.471]             }
[15:32:27.471]             {
[15:32:27.471]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:27.471]                   0L) {
[15:32:27.471]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:27.471]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:27.471]                   base::options(opts)
[15:32:27.471]                 }
[15:32:27.471]                 {
[15:32:27.471]                   {
[15:32:27.471]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:27.471]                     NULL
[15:32:27.471]                   }
[15:32:27.471]                   options(future.plan = NULL)
[15:32:27.471]                   if (is.na(NA_character_)) 
[15:32:27.471]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:27.471]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:27.471]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:27.471]                     .init = FALSE)
[15:32:27.471]                 }
[15:32:27.471]             }
[15:32:27.471]         }
[15:32:27.471]     })
[15:32:27.471]     if (TRUE) {
[15:32:27.471]         base::sink(type = "output", split = FALSE)
[15:32:27.471]         if (TRUE) {
[15:32:27.471]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:27.471]         }
[15:32:27.471]         else {
[15:32:27.471]             ...future.result["stdout"] <- base::list(NULL)
[15:32:27.471]         }
[15:32:27.471]         base::close(...future.stdout)
[15:32:27.471]         ...future.stdout <- NULL
[15:32:27.471]     }
[15:32:27.471]     ...future.result$conditions <- ...future.conditions
[15:32:27.471]     ...future.result$finished <- base::Sys.time()
[15:32:27.471]     ...future.result
[15:32:27.471] }
[15:32:27.477] Exporting 5 global objects (4.62 KiB) to cluster node #1 ...
[15:32:27.478] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ...
[15:32:27.478] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ... DONE
[15:32:27.479] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:27.480] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:27.480] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ...
[15:32:27.481] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ... DONE
[15:32:27.481] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:27.482] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:27.482] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:27.483] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:27.483] Exporting 5 global objects (4.62 KiB) to cluster node #1 ... DONE
[15:32:27.484] MultisessionFuture started
[15:32:27.485] - Launch lazy future ... done
[15:32:27.485] run() for 'MultisessionFuture' ... done
[15:32:27.485] Created future:
[15:32:27.517] receiveMessageFromWorker() for ClusterFuture ...
[15:32:27.517] - Validating connection of MultisessionFuture
[15:32:27.518] - received message: FutureResult
[15:32:27.518] - Received FutureResult
[15:32:27.519] - Erased future from FutureRegistry
[15:32:27.519] result() for ClusterFuture ...
[15:32:27.520] - result already collected: FutureResult
[15:32:27.520] result() for ClusterFuture ... done
[15:32:27.520] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:27.486] MultisessionFuture:
[15:32:27.486] Label: 'future_sapply-1'
[15:32:27.486] Expression:
[15:32:27.486] {
[15:32:27.486]     do.call(function(...) {
[15:32:27.486]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:27.486]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:27.486]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:27.486]             on.exit(options(oopts), add = TRUE)
[15:32:27.486]         }
[15:32:27.486]         {
[15:32:27.486]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:27.486]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:27.486]                 ...future.FUN(...future.X_jj, ...)
[15:32:27.486]             })
[15:32:27.486]         }
[15:32:27.486]     }, args = future.call.arguments)
[15:32:27.486] }
[15:32:27.486] Lazy evaluation: FALSE
[15:32:27.486] Asynchronous evaluation: TRUE
[15:32:27.486] Local evaluation: TRUE
[15:32:27.486] Environment: R_GlobalEnv
[15:32:27.486] Capture standard output: TRUE
[15:32:27.486] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:27.486] Globals: 5 objects totaling 4.67 KiB (function '...future.FUN' of 4.62 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)
[15:32:27.486] Packages: <none>
[15:32:27.486] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:27.486] Resolved: TRUE
[15:32:27.486] Value: <not collected>
[15:32:27.486] Conditions captured: <none>
[15:32:27.486] Early signaling: FALSE
[15:32:27.486] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:27.486] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:27.521] Chunk #1 of 2 ... DONE
[15:32:27.521] Chunk #2 of 2 ...
[15:32:27.522]  - Finding globals in 'X' for chunk #2 ...
[15:32:27.522] getGlobalsAndPackages() ...
[15:32:27.522] Searching for globals...
[15:32:27.523] 
[15:32:27.523] Searching for globals ... DONE
[15:32:27.524] - globals: [0] <none>
[15:32:27.524] getGlobalsAndPackages() ... DONE
[15:32:27.524]    + additional globals found: [n=0] 
[15:32:27.525]    + additional namespaces needed: [n=0] 
[15:32:27.525]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:27.525]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:27.526]  - seeds: <none>
[15:32:27.526]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:27.526] getGlobalsAndPackages() ...
[15:32:27.527] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:27.527] Resolving globals: FALSE
[15:32:27.527] Tweak future expression to call with '...' arguments ...
[15:32:27.528] {
[15:32:27.528]     do.call(function(...) {
[15:32:27.528]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:27.528]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:27.528]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:27.528]             on.exit(options(oopts), add = TRUE)
[15:32:27.528]         }
[15:32:27.528]         {
[15:32:27.528]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:27.528]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:27.528]                 ...future.FUN(...future.X_jj, ...)
[15:32:27.528]             })
[15:32:27.528]         }
[15:32:27.528]     }, args = future.call.arguments)
[15:32:27.528] }
[15:32:27.529] Tweak future expression to call with '...' arguments ... DONE
[15:32:27.530] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:27.530] 
[15:32:27.530] getGlobalsAndPackages() ... DONE
[15:32:27.531] run() for 'Future' ...
[15:32:27.531] - state: 'created'
[15:32:27.532] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:27.554] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:27.554] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:27.555]   - Field: 'node'
[15:32:27.555]   - Field: 'label'
[15:32:27.555]   - Field: 'local'
[15:32:27.556]   - Field: 'owner'
[15:32:27.556]   - Field: 'envir'
[15:32:27.556]   - Field: 'workers'
[15:32:27.557]   - Field: 'packages'
[15:32:27.557]   - Field: 'gc'
[15:32:27.558]   - Field: 'conditions'
[15:32:27.558]   - Field: 'persistent'
[15:32:27.558]   - Field: 'expr'
[15:32:27.559]   - Field: 'uuid'
[15:32:27.559]   - Field: 'seed'
[15:32:27.559]   - Field: 'version'
[15:32:27.560]   - Field: 'result'
[15:32:27.560]   - Field: 'asynchronous'
[15:32:27.560]   - Field: 'calls'
[15:32:27.561]   - Field: 'globals'
[15:32:27.561]   - Field: 'stdout'
[15:32:27.561]   - Field: 'earlySignal'
[15:32:27.562]   - Field: 'lazy'
[15:32:27.562]   - Field: 'state'
[15:32:27.562] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:27.563] - Launch lazy future ...
[15:32:27.564] Packages needed by the future expression (n = 0): <none>
[15:32:27.564] Packages needed by future strategies (n = 0): <none>
[15:32:27.565] {
[15:32:27.565]     {
[15:32:27.565]         {
[15:32:27.565]             ...future.startTime <- base::Sys.time()
[15:32:27.565]             {
[15:32:27.565]                 {
[15:32:27.565]                   {
[15:32:27.565]                     {
[15:32:27.565]                       base::local({
[15:32:27.565]                         has_future <- base::requireNamespace("future", 
[15:32:27.565]                           quietly = TRUE)
[15:32:27.565]                         if (has_future) {
[15:32:27.565]                           ns <- base::getNamespace("future")
[15:32:27.565]                           version <- ns[[".package"]][["version"]]
[15:32:27.565]                           if (is.null(version)) 
[15:32:27.565]                             version <- utils::packageVersion("future")
[15:32:27.565]                         }
[15:32:27.565]                         else {
[15:32:27.565]                           version <- NULL
[15:32:27.565]                         }
[15:32:27.565]                         if (!has_future || version < "1.8.0") {
[15:32:27.565]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:27.565]                             "", base::R.version$version.string), 
[15:32:27.565]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:27.565]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:27.565]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:27.565]                               "release", "version")], collapse = " "), 
[15:32:27.565]                             hostname = base::Sys.info()[["nodename"]])
[15:32:27.565]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:27.565]                             info)
[15:32:27.565]                           info <- base::paste(info, collapse = "; ")
[15:32:27.565]                           if (!has_future) {
[15:32:27.565]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:27.565]                               info)
[15:32:27.565]                           }
[15:32:27.565]                           else {
[15:32:27.565]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:27.565]                               info, version)
[15:32:27.565]                           }
[15:32:27.565]                           base::stop(msg)
[15:32:27.565]                         }
[15:32:27.565]                       })
[15:32:27.565]                     }
[15:32:27.565]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:27.565]                     base::options(mc.cores = 1L)
[15:32:27.565]                   }
[15:32:27.565]                   ...future.strategy.old <- future::plan("list")
[15:32:27.565]                   options(future.plan = NULL)
[15:32:27.565]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:27.565]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:27.565]                 }
[15:32:27.565]                 ...future.workdir <- getwd()
[15:32:27.565]             }
[15:32:27.565]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:27.565]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:27.565]         }
[15:32:27.565]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:27.565]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:27.565]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:27.565]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:27.565]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:27.565]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:27.565]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:27.565]             base::names(...future.oldOptions))
[15:32:27.565]     }
[15:32:27.565]     if (FALSE) {
[15:32:27.565]     }
[15:32:27.565]     else {
[15:32:27.565]         if (TRUE) {
[15:32:27.565]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:27.565]                 open = "w")
[15:32:27.565]         }
[15:32:27.565]         else {
[15:32:27.565]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:27.565]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:27.565]         }
[15:32:27.565]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:27.565]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:27.565]             base::sink(type = "output", split = FALSE)
[15:32:27.565]             base::close(...future.stdout)
[15:32:27.565]         }, add = TRUE)
[15:32:27.565]     }
[15:32:27.565]     ...future.frame <- base::sys.nframe()
[15:32:27.565]     ...future.conditions <- base::list()
[15:32:27.565]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:27.565]     if (FALSE) {
[15:32:27.565]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:27.565]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:27.565]     }
[15:32:27.565]     ...future.result <- base::tryCatch({
[15:32:27.565]         base::withCallingHandlers({
[15:32:27.565]             ...future.value <- base::withVisible(base::local({
[15:32:27.565]                 ...future.makeSendCondition <- base::local({
[15:32:27.565]                   sendCondition <- NULL
[15:32:27.565]                   function(frame = 1L) {
[15:32:27.565]                     if (is.function(sendCondition)) 
[15:32:27.565]                       return(sendCondition)
[15:32:27.565]                     ns <- getNamespace("parallel")
[15:32:27.565]                     if (exists("sendData", mode = "function", 
[15:32:27.565]                       envir = ns)) {
[15:32:27.565]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:27.565]                         envir = ns)
[15:32:27.565]                       envir <- sys.frame(frame)
[15:32:27.565]                       master <- NULL
[15:32:27.565]                       while (!identical(envir, .GlobalEnv) && 
[15:32:27.565]                         !identical(envir, emptyenv())) {
[15:32:27.565]                         if (exists("master", mode = "list", envir = envir, 
[15:32:27.565]                           inherits = FALSE)) {
[15:32:27.565]                           master <- get("master", mode = "list", 
[15:32:27.565]                             envir = envir, inherits = FALSE)
[15:32:27.565]                           if (inherits(master, c("SOCKnode", 
[15:32:27.565]                             "SOCK0node"))) {
[15:32:27.565]                             sendCondition <<- function(cond) {
[15:32:27.565]                               data <- list(type = "VALUE", value = cond, 
[15:32:27.565]                                 success = TRUE)
[15:32:27.565]                               parallel_sendData(master, data)
[15:32:27.565]                             }
[15:32:27.565]                             return(sendCondition)
[15:32:27.565]                           }
[15:32:27.565]                         }
[15:32:27.565]                         frame <- frame + 1L
[15:32:27.565]                         envir <- sys.frame(frame)
[15:32:27.565]                       }
[15:32:27.565]                     }
[15:32:27.565]                     sendCondition <<- function(cond) NULL
[15:32:27.565]                   }
[15:32:27.565]                 })
[15:32:27.565]                 withCallingHandlers({
[15:32:27.565]                   {
[15:32:27.565]                     do.call(function(...) {
[15:32:27.565]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:27.565]                       if (!identical(...future.globals.maxSize.org, 
[15:32:27.565]                         ...future.globals.maxSize)) {
[15:32:27.565]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:27.565]                         on.exit(options(oopts), add = TRUE)
[15:32:27.565]                       }
[15:32:27.565]                       {
[15:32:27.565]                         lapply(seq_along(...future.elements_ii), 
[15:32:27.565]                           FUN = function(jj) {
[15:32:27.565]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:27.565]                             ...future.FUN(...future.X_jj, ...)
[15:32:27.565]                           })
[15:32:27.565]                       }
[15:32:27.565]                     }, args = future.call.arguments)
[15:32:27.565]                   }
[15:32:27.565]                 }, immediateCondition = function(cond) {
[15:32:27.565]                   sendCondition <- ...future.makeSendCondition()
[15:32:27.565]                   sendCondition(cond)
[15:32:27.565]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:27.565]                   {
[15:32:27.565]                     inherits <- base::inherits
[15:32:27.565]                     invokeRestart <- base::invokeRestart
[15:32:27.565]                     is.null <- base::is.null
[15:32:27.565]                     muffled <- FALSE
[15:32:27.565]                     if (inherits(cond, "message")) {
[15:32:27.565]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:27.565]                       if (muffled) 
[15:32:27.565]                         invokeRestart("muffleMessage")
[15:32:27.565]                     }
[15:32:27.565]                     else if (inherits(cond, "warning")) {
[15:32:27.565]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:27.565]                       if (muffled) 
[15:32:27.565]                         invokeRestart("muffleWarning")
[15:32:27.565]                     }
[15:32:27.565]                     else if (inherits(cond, "condition")) {
[15:32:27.565]                       if (!is.null(pattern)) {
[15:32:27.565]                         computeRestarts <- base::computeRestarts
[15:32:27.565]                         grepl <- base::grepl
[15:32:27.565]                         restarts <- computeRestarts(cond)
[15:32:27.565]                         for (restart in restarts) {
[15:32:27.565]                           name <- restart$name
[15:32:27.565]                           if (is.null(name)) 
[15:32:27.565]                             next
[15:32:27.565]                           if (!grepl(pattern, name)) 
[15:32:27.565]                             next
[15:32:27.565]                           invokeRestart(restart)
[15:32:27.565]                           muffled <- TRUE
[15:32:27.565]                           break
[15:32:27.565]                         }
[15:32:27.565]                       }
[15:32:27.565]                     }
[15:32:27.565]                     invisible(muffled)
[15:32:27.565]                   }
[15:32:27.565]                   muffleCondition(cond)
[15:32:27.565]                 })
[15:32:27.565]             }))
[15:32:27.565]             future::FutureResult(value = ...future.value$value, 
[15:32:27.565]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:27.565]                   ...future.rng), globalenv = if (FALSE) 
[15:32:27.565]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:27.565]                     ...future.globalenv.names))
[15:32:27.565]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:27.565]         }, condition = base::local({
[15:32:27.565]             c <- base::c
[15:32:27.565]             inherits <- base::inherits
[15:32:27.565]             invokeRestart <- base::invokeRestart
[15:32:27.565]             length <- base::length
[15:32:27.565]             list <- base::list
[15:32:27.565]             seq.int <- base::seq.int
[15:32:27.565]             signalCondition <- base::signalCondition
[15:32:27.565]             sys.calls <- base::sys.calls
[15:32:27.565]             `[[` <- base::`[[`
[15:32:27.565]             `+` <- base::`+`
[15:32:27.565]             `<<-` <- base::`<<-`
[15:32:27.565]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:27.565]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:27.565]                   3L)]
[15:32:27.565]             }
[15:32:27.565]             function(cond) {
[15:32:27.565]                 is_error <- inherits(cond, "error")
[15:32:27.565]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:27.565]                   NULL)
[15:32:27.565]                 if (is_error) {
[15:32:27.565]                   sessionInformation <- function() {
[15:32:27.565]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:27.565]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:27.565]                       search = base::search(), system = base::Sys.info())
[15:32:27.565]                   }
[15:32:27.565]                   ...future.conditions[[length(...future.conditions) + 
[15:32:27.565]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:27.565]                     cond$call), session = sessionInformation(), 
[15:32:27.565]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:27.565]                   signalCondition(cond)
[15:32:27.565]                 }
[15:32:27.565]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:27.565]                 "immediateCondition"))) {
[15:32:27.565]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:27.565]                   ...future.conditions[[length(...future.conditions) + 
[15:32:27.565]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:27.565]                   if (TRUE && !signal) {
[15:32:27.565]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:27.565]                     {
[15:32:27.565]                       inherits <- base::inherits
[15:32:27.565]                       invokeRestart <- base::invokeRestart
[15:32:27.565]                       is.null <- base::is.null
[15:32:27.565]                       muffled <- FALSE
[15:32:27.565]                       if (inherits(cond, "message")) {
[15:32:27.565]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:27.565]                         if (muffled) 
[15:32:27.565]                           invokeRestart("muffleMessage")
[15:32:27.565]                       }
[15:32:27.565]                       else if (inherits(cond, "warning")) {
[15:32:27.565]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:27.565]                         if (muffled) 
[15:32:27.565]                           invokeRestart("muffleWarning")
[15:32:27.565]                       }
[15:32:27.565]                       else if (inherits(cond, "condition")) {
[15:32:27.565]                         if (!is.null(pattern)) {
[15:32:27.565]                           computeRestarts <- base::computeRestarts
[15:32:27.565]                           grepl <- base::grepl
[15:32:27.565]                           restarts <- computeRestarts(cond)
[15:32:27.565]                           for (restart in restarts) {
[15:32:27.565]                             name <- restart$name
[15:32:27.565]                             if (is.null(name)) 
[15:32:27.565]                               next
[15:32:27.565]                             if (!grepl(pattern, name)) 
[15:32:27.565]                               next
[15:32:27.565]                             invokeRestart(restart)
[15:32:27.565]                             muffled <- TRUE
[15:32:27.565]                             break
[15:32:27.565]                           }
[15:32:27.565]                         }
[15:32:27.565]                       }
[15:32:27.565]                       invisible(muffled)
[15:32:27.565]                     }
[15:32:27.565]                     muffleCondition(cond, pattern = "^muffle")
[15:32:27.565]                   }
[15:32:27.565]                 }
[15:32:27.565]                 else {
[15:32:27.565]                   if (TRUE) {
[15:32:27.565]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:27.565]                     {
[15:32:27.565]                       inherits <- base::inherits
[15:32:27.565]                       invokeRestart <- base::invokeRestart
[15:32:27.565]                       is.null <- base::is.null
[15:32:27.565]                       muffled <- FALSE
[15:32:27.565]                       if (inherits(cond, "message")) {
[15:32:27.565]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:27.565]                         if (muffled) 
[15:32:27.565]                           invokeRestart("muffleMessage")
[15:32:27.565]                       }
[15:32:27.565]                       else if (inherits(cond, "warning")) {
[15:32:27.565]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:27.565]                         if (muffled) 
[15:32:27.565]                           invokeRestart("muffleWarning")
[15:32:27.565]                       }
[15:32:27.565]                       else if (inherits(cond, "condition")) {
[15:32:27.565]                         if (!is.null(pattern)) {
[15:32:27.565]                           computeRestarts <- base::computeRestarts
[15:32:27.565]                           grepl <- base::grepl
[15:32:27.565]                           restarts <- computeRestarts(cond)
[15:32:27.565]                           for (restart in restarts) {
[15:32:27.565]                             name <- restart$name
[15:32:27.565]                             if (is.null(name)) 
[15:32:27.565]                               next
[15:32:27.565]                             if (!grepl(pattern, name)) 
[15:32:27.565]                               next
[15:32:27.565]                             invokeRestart(restart)
[15:32:27.565]                             muffled <- TRUE
[15:32:27.565]                             break
[15:32:27.565]                           }
[15:32:27.565]                         }
[15:32:27.565]                       }
[15:32:27.565]                       invisible(muffled)
[15:32:27.565]                     }
[15:32:27.565]                     muffleCondition(cond, pattern = "^muffle")
[15:32:27.565]                   }
[15:32:27.565]                 }
[15:32:27.565]             }
[15:32:27.565]         }))
[15:32:27.565]     }, error = function(ex) {
[15:32:27.565]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:27.565]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:27.565]                 ...future.rng), started = ...future.startTime, 
[15:32:27.565]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:27.565]             version = "1.8"), class = "FutureResult")
[15:32:27.565]     }, finally = {
[15:32:27.565]         if (!identical(...future.workdir, getwd())) 
[15:32:27.565]             setwd(...future.workdir)
[15:32:27.565]         {
[15:32:27.565]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:27.565]                 ...future.oldOptions$nwarnings <- NULL
[15:32:27.565]             }
[15:32:27.565]             base::options(...future.oldOptions)
[15:32:27.565]             if (.Platform$OS.type == "windows") {
[15:32:27.565]                 old_names <- names(...future.oldEnvVars)
[15:32:27.565]                 envs <- base::Sys.getenv()
[15:32:27.565]                 names <- names(envs)
[15:32:27.565]                 common <- intersect(names, old_names)
[15:32:27.565]                 added <- setdiff(names, old_names)
[15:32:27.565]                 removed <- setdiff(old_names, names)
[15:32:27.565]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:27.565]                   envs[common]]
[15:32:27.565]                 NAMES <- toupper(changed)
[15:32:27.565]                 args <- list()
[15:32:27.565]                 for (kk in seq_along(NAMES)) {
[15:32:27.565]                   name <- changed[[kk]]
[15:32:27.565]                   NAME <- NAMES[[kk]]
[15:32:27.565]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:27.565]                     next
[15:32:27.565]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:27.565]                 }
[15:32:27.565]                 NAMES <- toupper(added)
[15:32:27.565]                 for (kk in seq_along(NAMES)) {
[15:32:27.565]                   name <- added[[kk]]
[15:32:27.565]                   NAME <- NAMES[[kk]]
[15:32:27.565]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:27.565]                     next
[15:32:27.565]                   args[[name]] <- ""
[15:32:27.565]                 }
[15:32:27.565]                 NAMES <- toupper(removed)
[15:32:27.565]                 for (kk in seq_along(NAMES)) {
[15:32:27.565]                   name <- removed[[kk]]
[15:32:27.565]                   NAME <- NAMES[[kk]]
[15:32:27.565]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:27.565]                     next
[15:32:27.565]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:27.565]                 }
[15:32:27.565]                 if (length(args) > 0) 
[15:32:27.565]                   base::do.call(base::Sys.setenv, args = args)
[15:32:27.565]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:27.565]             }
[15:32:27.565]             else {
[15:32:27.565]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:27.565]             }
[15:32:27.565]             {
[15:32:27.565]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:27.565]                   0L) {
[15:32:27.565]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:27.565]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:27.565]                   base::options(opts)
[15:32:27.565]                 }
[15:32:27.565]                 {
[15:32:27.565]                   {
[15:32:27.565]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:27.565]                     NULL
[15:32:27.565]                   }
[15:32:27.565]                   options(future.plan = NULL)
[15:32:27.565]                   if (is.na(NA_character_)) 
[15:32:27.565]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:27.565]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:27.565]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:27.565]                     .init = FALSE)
[15:32:27.565]                 }
[15:32:27.565]             }
[15:32:27.565]         }
[15:32:27.565]     })
[15:32:27.565]     if (TRUE) {
[15:32:27.565]         base::sink(type = "output", split = FALSE)
[15:32:27.565]         if (TRUE) {
[15:32:27.565]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:27.565]         }
[15:32:27.565]         else {
[15:32:27.565]             ...future.result["stdout"] <- base::list(NULL)
[15:32:27.565]         }
[15:32:27.565]         base::close(...future.stdout)
[15:32:27.565]         ...future.stdout <- NULL
[15:32:27.565]     }
[15:32:27.565]     ...future.result$conditions <- ...future.conditions
[15:32:27.565]     ...future.result$finished <- base::Sys.time()
[15:32:27.565]     ...future.result
[15:32:27.565] }
[15:32:27.576] Exporting 5 global objects (4.62 KiB) to cluster node #1 ...
[15:32:27.577] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ...
[15:32:27.578] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ... DONE
[15:32:27.578] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:27.579] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:27.579] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:27.580] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:27.581] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:27.581] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:27.582] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:27.582] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:27.583] Exporting 5 global objects (4.62 KiB) to cluster node #1 ... DONE
[15:32:27.584] MultisessionFuture started
[15:32:27.584] - Launch lazy future ... done
[15:32:27.585] run() for 'MultisessionFuture' ... done
[15:32:27.585] Created future:
[15:32:27.617] receiveMessageFromWorker() for ClusterFuture ...
[15:32:27.617] - Validating connection of MultisessionFuture
[15:32:27.618] - received message: FutureResult
[15:32:27.618] - Received FutureResult
[15:32:27.618] - Erased future from FutureRegistry
[15:32:27.619] result() for ClusterFuture ...
[15:32:27.619] - result already collected: FutureResult
[15:32:27.619] result() for ClusterFuture ... done
[15:32:27.620] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:27.586] MultisessionFuture:
[15:32:27.586] Label: 'future_sapply-2'
[15:32:27.586] Expression:
[15:32:27.586] {
[15:32:27.586]     do.call(function(...) {
[15:32:27.586]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:27.586]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:27.586]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:27.586]             on.exit(options(oopts), add = TRUE)
[15:32:27.586]         }
[15:32:27.586]         {
[15:32:27.586]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:27.586]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:27.586]                 ...future.FUN(...future.X_jj, ...)
[15:32:27.586]             })
[15:32:27.586]         }
[15:32:27.586]     }, args = future.call.arguments)
[15:32:27.586] }
[15:32:27.586] Lazy evaluation: FALSE
[15:32:27.586] Asynchronous evaluation: TRUE
[15:32:27.586] Local evaluation: TRUE
[15:32:27.586] Environment: R_GlobalEnv
[15:32:27.586] Capture standard output: TRUE
[15:32:27.586] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:27.586] Globals: 5 objects totaling 4.73 KiB (function '...future.FUN' of 4.62 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)
[15:32:27.586] Packages: <none>
[15:32:27.586] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:27.586] Resolved: TRUE
[15:32:27.586] Value: <not collected>
[15:32:27.586] Conditions captured: <none>
[15:32:27.586] Early signaling: FALSE
[15:32:27.586] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:27.586] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:27.621] Chunk #2 of 2 ... DONE
[15:32:27.621] Launching 2 futures (chunks) ... DONE
[15:32:27.621] Resolving 2 futures (chunks) ...
[15:32:27.622] resolve() on list ...
[15:32:27.622]  recursive: 0
[15:32:27.622]  length: 2
[15:32:27.623] 
[15:32:27.623] Future #1
[15:32:27.624] result() for ClusterFuture ...
[15:32:27.624] - result already collected: FutureResult
[15:32:27.624] result() for ClusterFuture ... done
[15:32:27.625] result() for ClusterFuture ...
[15:32:27.625] - result already collected: FutureResult
[15:32:27.625] result() for ClusterFuture ... done
[15:32:27.626] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:27.626] - nx: 2
[15:32:27.626] - relay: TRUE
[15:32:27.627] - stdout: TRUE
[15:32:27.627] - signal: TRUE
[15:32:27.627] - resignal: FALSE
[15:32:27.627] - force: TRUE
[15:32:27.628] - relayed: [n=2] FALSE, FALSE
[15:32:27.628] - queued futures: [n=2] FALSE, FALSE
[15:32:27.628]  - until=1
[15:32:27.629]  - relaying element #1
[15:32:27.629] result() for ClusterFuture ...
[15:32:27.629] - result already collected: FutureResult
[15:32:27.630] result() for ClusterFuture ... done
[15:32:27.630] result() for ClusterFuture ...
[15:32:27.630] - result already collected: FutureResult
[15:32:27.631] result() for ClusterFuture ... done
[15:32:27.631] result() for ClusterFuture ...
[15:32:27.632] - result already collected: FutureResult
[15:32:27.632] result() for ClusterFuture ... done
[15:32:27.632] result() for ClusterFuture ...
[15:32:27.632] - result already collected: FutureResult
[15:32:27.633] result() for ClusterFuture ... done
[15:32:27.633] - relayed: [n=2] TRUE, FALSE
[15:32:27.633] - queued futures: [n=2] TRUE, FALSE
[15:32:27.634] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:27.634]  length: 1 (resolved future 1)
[15:32:27.635] Future #2
[15:32:27.635] result() for ClusterFuture ...
[15:32:27.635] - result already collected: FutureResult
[15:32:27.636] result() for ClusterFuture ... done
[15:32:27.636] result() for ClusterFuture ...
[15:32:27.636] - result already collected: FutureResult
[15:32:27.637] result() for ClusterFuture ... done
[15:32:27.637] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:27.637] - nx: 2
[15:32:27.638] - relay: TRUE
[15:32:27.638] - stdout: TRUE
[15:32:27.638] - signal: TRUE
[15:32:27.639] - resignal: FALSE
[15:32:27.639] - force: TRUE
[15:32:27.639] - relayed: [n=2] TRUE, FALSE
[15:32:27.640] - queued futures: [n=2] TRUE, FALSE
[15:32:27.640]  - until=2
[15:32:27.640]  - relaying element #2
[15:32:27.641] result() for ClusterFuture ...
[15:32:27.641] - result already collected: FutureResult
[15:32:27.641] result() for ClusterFuture ... done
[15:32:27.642] result() for ClusterFuture ...
[15:32:27.642] - result already collected: FutureResult
[15:32:27.643] result() for ClusterFuture ... done
[15:32:27.643] result() for ClusterFuture ...
[15:32:27.643] - result already collected: FutureResult
[15:32:27.644] result() for ClusterFuture ... done
[15:32:27.644] result() for ClusterFuture ...
[15:32:27.644] - result already collected: FutureResult
[15:32:27.645] result() for ClusterFuture ... done
[15:32:27.645] - relayed: [n=2] TRUE, TRUE
[15:32:27.645] - queued futures: [n=2] TRUE, TRUE
[15:32:27.646] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:27.646]  length: 0 (resolved future 2)
[15:32:27.646] Relaying remaining futures
[15:32:27.647] signalConditionsASAP(NULL, pos=0) ...
[15:32:27.647] - nx: 2
[15:32:27.647] - relay: TRUE
[15:32:27.648] - stdout: TRUE
[15:32:27.648] - signal: TRUE
[15:32:27.648] - resignal: FALSE
[15:32:27.649] - force: TRUE
[15:32:27.649] - relayed: [n=2] TRUE, TRUE
[15:32:27.649] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:27.650] - relayed: [n=2] TRUE, TRUE
[15:32:27.650] - queued futures: [n=2] TRUE, TRUE
[15:32:27.651] signalConditionsASAP(NULL, pos=0) ... done
[15:32:27.651] resolve() on list ... DONE
[15:32:27.651] result() for ClusterFuture ...
[15:32:27.652] - result already collected: FutureResult
[15:32:27.652] result() for ClusterFuture ... done
[15:32:27.652] result() for ClusterFuture ...
[15:32:27.653] - result already collected: FutureResult
[15:32:27.653] result() for ClusterFuture ... done
[15:32:27.653] result() for ClusterFuture ...
[15:32:27.654] - result already collected: FutureResult
[15:32:27.654] result() for ClusterFuture ... done
[15:32:27.654] result() for ClusterFuture ...
[15:32:27.655] - result already collected: FutureResult
[15:32:27.655] result() for ClusterFuture ... done
[15:32:27.655]  - Number of value chunks collected: 2
[15:32:27.656] Resolving 2 futures (chunks) ... DONE
[15:32:27.656] Reducing values from 2 chunks ...
[15:32:27.656]  - Number of values collected after concatenation: 3
[15:32:27.656]  - Number of values expected: 3
[15:32:27.656] Reducing values from 2 chunks ... DONE
[15:32:27.657] future_lapply() ... DONE
List of 2
 $ y0:List of 3
  ..$ a: num [1:3, 1:5] 2 2 2 4 4 4 6 6 6 8 ...
  ..$ b: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
  ..$ c: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
 $ y1:List of 3
  ..$ a: num [1:3, 1:5] 2 2 2 4 4 4 6 6 6 8 ...
  ..$ b: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
  ..$ c: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
List of 2
 $ y0:List of 3
  ..$ a: num [1:3, 1:5] 2 2 2 4 4 4 6 6 6 8 ...
  ..$ b: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
  ..$ c: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
 $ y2:List of 3
  ..$ a: num [1:3, 1:5] 2 2 2 4 4 4 6 6 6 8 ...
  ..$ b: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
  ..$ c: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
[15:32:27.670] future_lapply() ...
[15:32:27.674] Number of chunks: 2
[15:32:27.674] getGlobalsAndPackagesXApply() ...
[15:32:27.674]  - future.globals: TRUE
[15:32:27.675] getGlobalsAndPackages() ...
[15:32:27.675] Searching for globals...
[15:32:27.676] - globals found: [1] 'FUN'
[15:32:27.677] Searching for globals ... DONE
[15:32:27.677] Resolving globals: FALSE
[15:32:27.677] The total size of the 1 globals is 848 bytes (848 bytes)
[15:32:27.678] The total size of the 1 globals exported for future expression ('FUN()') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:32:27.678] - globals: [1] 'FUN'
[15:32:27.678] 
[15:32:27.679] getGlobalsAndPackages() ... DONE
[15:32:27.679]  - globals found/used: [n=1] 'FUN'
[15:32:27.679]  - needed namespaces: [n=0] 
[15:32:27.679] Finding globals ... DONE
[15:32:27.679]  - use_args: TRUE
[15:32:27.680]  - Getting '...' globals ...
[15:32:27.680] resolve() on list ...
[15:32:27.680]  recursive: 0
[15:32:27.680]  length: 1
[15:32:27.681]  elements: '...'
[15:32:27.681]  length: 0 (resolved future 1)
[15:32:27.681] resolve() on list ... DONE
[15:32:27.681]    - '...' content: [n=0] 
[15:32:27.682] List of 1
[15:32:27.682]  $ ...: list()
[15:32:27.682]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:27.682]  - attr(*, "where")=List of 1
[15:32:27.682]   ..$ ...:<environment: 0x00000276e2a6cae0> 
[15:32:27.682]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:27.682]  - attr(*, "resolved")= logi TRUE
[15:32:27.682]  - attr(*, "total_size")= num NA
[15:32:27.687]  - Getting '...' globals ... DONE
[15:32:27.687] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:27.688] List of 2
[15:32:27.688]  $ ...future.FUN:function (x)  
[15:32:27.688]  $ ...          : list()
[15:32:27.688]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:27.688]  - attr(*, "where")=List of 2
[15:32:27.688]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:27.688]   ..$ ...          :<environment: 0x00000276e2a6cae0> 
[15:32:27.688]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:27.688]  - attr(*, "resolved")= logi FALSE
[15:32:27.688]  - attr(*, "total_size")= num 848
[15:32:27.692] Packages to be attached in all futures: [n=0] 
[15:32:27.692] getGlobalsAndPackagesXApply() ... DONE
[15:32:27.692] Number of futures (= number of chunks): 2
[15:32:27.692] Launching 2 futures (chunks) ...
[15:32:27.693] Chunk #1 of 2 ...
[15:32:27.693]  - Finding globals in 'X' for chunk #1 ...
[15:32:27.693] getGlobalsAndPackages() ...
[15:32:27.693] Searching for globals...
[15:32:27.694] 
[15:32:27.694] Searching for globals ... DONE
[15:32:27.694] - globals: [0] <none>
[15:32:27.694] getGlobalsAndPackages() ... DONE
[15:32:27.695]    + additional globals found: [n=0] 
[15:32:27.695]    + additional namespaces needed: [n=0] 
[15:32:27.695]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:27.695]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:27.695]  - seeds: <none>
[15:32:27.696]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:27.696] getGlobalsAndPackages() ...
[15:32:27.696] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:27.696] Resolving globals: FALSE
[15:32:27.696] Tweak future expression to call with '...' arguments ...
[15:32:27.697] {
[15:32:27.697]     do.call(function(...) {
[15:32:27.697]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:27.697]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:27.697]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:27.697]             on.exit(options(oopts), add = TRUE)
[15:32:27.697]         }
[15:32:27.697]         {
[15:32:27.697]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:27.697]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:27.697]                 ...future.FUN(...future.X_jj, ...)
[15:32:27.697]             })
[15:32:27.697]         }
[15:32:27.697]     }, args = future.call.arguments)
[15:32:27.697] }
[15:32:27.697] Tweak future expression to call with '...' arguments ... DONE
[15:32:27.698] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:27.698] 
[15:32:27.698] getGlobalsAndPackages() ... DONE
[15:32:27.699] run() for 'Future' ...
[15:32:27.699] - state: 'created'
[15:32:27.699] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:27.722] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:27.723] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:27.723]   - Field: 'node'
[15:32:27.723]   - Field: 'label'
[15:32:27.723]   - Field: 'local'
[15:32:27.724]   - Field: 'owner'
[15:32:27.724]   - Field: 'envir'
[15:32:27.724]   - Field: 'workers'
[15:32:27.724]   - Field: 'packages'
[15:32:27.725]   - Field: 'gc'
[15:32:27.725]   - Field: 'conditions'
[15:32:27.725]   - Field: 'persistent'
[15:32:27.725]   - Field: 'expr'
[15:32:27.725]   - Field: 'uuid'
[15:32:27.726]   - Field: 'seed'
[15:32:27.726]   - Field: 'version'
[15:32:27.726]   - Field: 'result'
[15:32:27.726]   - Field: 'asynchronous'
[15:32:27.727]   - Field: 'calls'
[15:32:27.727]   - Field: 'globals'
[15:32:27.727]   - Field: 'stdout'
[15:32:27.727]   - Field: 'earlySignal'
[15:32:27.728]   - Field: 'lazy'
[15:32:27.728]   - Field: 'state'
[15:32:27.728] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:27.729] - Launch lazy future ...
[15:32:27.729] Packages needed by the future expression (n = 0): <none>
[15:32:27.730] Packages needed by future strategies (n = 0): <none>
[15:32:27.731] {
[15:32:27.731]     {
[15:32:27.731]         {
[15:32:27.731]             ...future.startTime <- base::Sys.time()
[15:32:27.731]             {
[15:32:27.731]                 {
[15:32:27.731]                   {
[15:32:27.731]                     {
[15:32:27.731]                       base::local({
[15:32:27.731]                         has_future <- base::requireNamespace("future", 
[15:32:27.731]                           quietly = TRUE)
[15:32:27.731]                         if (has_future) {
[15:32:27.731]                           ns <- base::getNamespace("future")
[15:32:27.731]                           version <- ns[[".package"]][["version"]]
[15:32:27.731]                           if (is.null(version)) 
[15:32:27.731]                             version <- utils::packageVersion("future")
[15:32:27.731]                         }
[15:32:27.731]                         else {
[15:32:27.731]                           version <- NULL
[15:32:27.731]                         }
[15:32:27.731]                         if (!has_future || version < "1.8.0") {
[15:32:27.731]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:27.731]                             "", base::R.version$version.string), 
[15:32:27.731]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:27.731]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:27.731]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:27.731]                               "release", "version")], collapse = " "), 
[15:32:27.731]                             hostname = base::Sys.info()[["nodename"]])
[15:32:27.731]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:27.731]                             info)
[15:32:27.731]                           info <- base::paste(info, collapse = "; ")
[15:32:27.731]                           if (!has_future) {
[15:32:27.731]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:27.731]                               info)
[15:32:27.731]                           }
[15:32:27.731]                           else {
[15:32:27.731]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:27.731]                               info, version)
[15:32:27.731]                           }
[15:32:27.731]                           base::stop(msg)
[15:32:27.731]                         }
[15:32:27.731]                       })
[15:32:27.731]                     }
[15:32:27.731]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:27.731]                     base::options(mc.cores = 1L)
[15:32:27.731]                   }
[15:32:27.731]                   ...future.strategy.old <- future::plan("list")
[15:32:27.731]                   options(future.plan = NULL)
[15:32:27.731]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:27.731]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:27.731]                 }
[15:32:27.731]                 ...future.workdir <- getwd()
[15:32:27.731]             }
[15:32:27.731]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:27.731]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:27.731]         }
[15:32:27.731]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:27.731]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:27.731]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:27.731]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:27.731]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:27.731]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:27.731]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:27.731]             base::names(...future.oldOptions))
[15:32:27.731]     }
[15:32:27.731]     if (FALSE) {
[15:32:27.731]     }
[15:32:27.731]     else {
[15:32:27.731]         if (TRUE) {
[15:32:27.731]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:27.731]                 open = "w")
[15:32:27.731]         }
[15:32:27.731]         else {
[15:32:27.731]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:27.731]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:27.731]         }
[15:32:27.731]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:27.731]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:27.731]             base::sink(type = "output", split = FALSE)
[15:32:27.731]             base::close(...future.stdout)
[15:32:27.731]         }, add = TRUE)
[15:32:27.731]     }
[15:32:27.731]     ...future.frame <- base::sys.nframe()
[15:32:27.731]     ...future.conditions <- base::list()
[15:32:27.731]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:27.731]     if (FALSE) {
[15:32:27.731]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:27.731]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:27.731]     }
[15:32:27.731]     ...future.result <- base::tryCatch({
[15:32:27.731]         base::withCallingHandlers({
[15:32:27.731]             ...future.value <- base::withVisible(base::local({
[15:32:27.731]                 ...future.makeSendCondition <- base::local({
[15:32:27.731]                   sendCondition <- NULL
[15:32:27.731]                   function(frame = 1L) {
[15:32:27.731]                     if (is.function(sendCondition)) 
[15:32:27.731]                       return(sendCondition)
[15:32:27.731]                     ns <- getNamespace("parallel")
[15:32:27.731]                     if (exists("sendData", mode = "function", 
[15:32:27.731]                       envir = ns)) {
[15:32:27.731]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:27.731]                         envir = ns)
[15:32:27.731]                       envir <- sys.frame(frame)
[15:32:27.731]                       master <- NULL
[15:32:27.731]                       while (!identical(envir, .GlobalEnv) && 
[15:32:27.731]                         !identical(envir, emptyenv())) {
[15:32:27.731]                         if (exists("master", mode = "list", envir = envir, 
[15:32:27.731]                           inherits = FALSE)) {
[15:32:27.731]                           master <- get("master", mode = "list", 
[15:32:27.731]                             envir = envir, inherits = FALSE)
[15:32:27.731]                           if (inherits(master, c("SOCKnode", 
[15:32:27.731]                             "SOCK0node"))) {
[15:32:27.731]                             sendCondition <<- function(cond) {
[15:32:27.731]                               data <- list(type = "VALUE", value = cond, 
[15:32:27.731]                                 success = TRUE)
[15:32:27.731]                               parallel_sendData(master, data)
[15:32:27.731]                             }
[15:32:27.731]                             return(sendCondition)
[15:32:27.731]                           }
[15:32:27.731]                         }
[15:32:27.731]                         frame <- frame + 1L
[15:32:27.731]                         envir <- sys.frame(frame)
[15:32:27.731]                       }
[15:32:27.731]                     }
[15:32:27.731]                     sendCondition <<- function(cond) NULL
[15:32:27.731]                   }
[15:32:27.731]                 })
[15:32:27.731]                 withCallingHandlers({
[15:32:27.731]                   {
[15:32:27.731]                     do.call(function(...) {
[15:32:27.731]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:27.731]                       if (!identical(...future.globals.maxSize.org, 
[15:32:27.731]                         ...future.globals.maxSize)) {
[15:32:27.731]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:27.731]                         on.exit(options(oopts), add = TRUE)
[15:32:27.731]                       }
[15:32:27.731]                       {
[15:32:27.731]                         lapply(seq_along(...future.elements_ii), 
[15:32:27.731]                           FUN = function(jj) {
[15:32:27.731]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:27.731]                             ...future.FUN(...future.X_jj, ...)
[15:32:27.731]                           })
[15:32:27.731]                       }
[15:32:27.731]                     }, args = future.call.arguments)
[15:32:27.731]                   }
[15:32:27.731]                 }, immediateCondition = function(cond) {
[15:32:27.731]                   sendCondition <- ...future.makeSendCondition()
[15:32:27.731]                   sendCondition(cond)
[15:32:27.731]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:27.731]                   {
[15:32:27.731]                     inherits <- base::inherits
[15:32:27.731]                     invokeRestart <- base::invokeRestart
[15:32:27.731]                     is.null <- base::is.null
[15:32:27.731]                     muffled <- FALSE
[15:32:27.731]                     if (inherits(cond, "message")) {
[15:32:27.731]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:27.731]                       if (muffled) 
[15:32:27.731]                         invokeRestart("muffleMessage")
[15:32:27.731]                     }
[15:32:27.731]                     else if (inherits(cond, "warning")) {
[15:32:27.731]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:27.731]                       if (muffled) 
[15:32:27.731]                         invokeRestart("muffleWarning")
[15:32:27.731]                     }
[15:32:27.731]                     else if (inherits(cond, "condition")) {
[15:32:27.731]                       if (!is.null(pattern)) {
[15:32:27.731]                         computeRestarts <- base::computeRestarts
[15:32:27.731]                         grepl <- base::grepl
[15:32:27.731]                         restarts <- computeRestarts(cond)
[15:32:27.731]                         for (restart in restarts) {
[15:32:27.731]                           name <- restart$name
[15:32:27.731]                           if (is.null(name)) 
[15:32:27.731]                             next
[15:32:27.731]                           if (!grepl(pattern, name)) 
[15:32:27.731]                             next
[15:32:27.731]                           invokeRestart(restart)
[15:32:27.731]                           muffled <- TRUE
[15:32:27.731]                           break
[15:32:27.731]                         }
[15:32:27.731]                       }
[15:32:27.731]                     }
[15:32:27.731]                     invisible(muffled)
[15:32:27.731]                   }
[15:32:27.731]                   muffleCondition(cond)
[15:32:27.731]                 })
[15:32:27.731]             }))
[15:32:27.731]             future::FutureResult(value = ...future.value$value, 
[15:32:27.731]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:27.731]                   ...future.rng), globalenv = if (FALSE) 
[15:32:27.731]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:27.731]                     ...future.globalenv.names))
[15:32:27.731]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:27.731]         }, condition = base::local({
[15:32:27.731]             c <- base::c
[15:32:27.731]             inherits <- base::inherits
[15:32:27.731]             invokeRestart <- base::invokeRestart
[15:32:27.731]             length <- base::length
[15:32:27.731]             list <- base::list
[15:32:27.731]             seq.int <- base::seq.int
[15:32:27.731]             signalCondition <- base::signalCondition
[15:32:27.731]             sys.calls <- base::sys.calls
[15:32:27.731]             `[[` <- base::`[[`
[15:32:27.731]             `+` <- base::`+`
[15:32:27.731]             `<<-` <- base::`<<-`
[15:32:27.731]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:27.731]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:27.731]                   3L)]
[15:32:27.731]             }
[15:32:27.731]             function(cond) {
[15:32:27.731]                 is_error <- inherits(cond, "error")
[15:32:27.731]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:27.731]                   NULL)
[15:32:27.731]                 if (is_error) {
[15:32:27.731]                   sessionInformation <- function() {
[15:32:27.731]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:27.731]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:27.731]                       search = base::search(), system = base::Sys.info())
[15:32:27.731]                   }
[15:32:27.731]                   ...future.conditions[[length(...future.conditions) + 
[15:32:27.731]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:27.731]                     cond$call), session = sessionInformation(), 
[15:32:27.731]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:27.731]                   signalCondition(cond)
[15:32:27.731]                 }
[15:32:27.731]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:27.731]                 "immediateCondition"))) {
[15:32:27.731]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:27.731]                   ...future.conditions[[length(...future.conditions) + 
[15:32:27.731]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:27.731]                   if (TRUE && !signal) {
[15:32:27.731]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:27.731]                     {
[15:32:27.731]                       inherits <- base::inherits
[15:32:27.731]                       invokeRestart <- base::invokeRestart
[15:32:27.731]                       is.null <- base::is.null
[15:32:27.731]                       muffled <- FALSE
[15:32:27.731]                       if (inherits(cond, "message")) {
[15:32:27.731]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:27.731]                         if (muffled) 
[15:32:27.731]                           invokeRestart("muffleMessage")
[15:32:27.731]                       }
[15:32:27.731]                       else if (inherits(cond, "warning")) {
[15:32:27.731]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:27.731]                         if (muffled) 
[15:32:27.731]                           invokeRestart("muffleWarning")
[15:32:27.731]                       }
[15:32:27.731]                       else if (inherits(cond, "condition")) {
[15:32:27.731]                         if (!is.null(pattern)) {
[15:32:27.731]                           computeRestarts <- base::computeRestarts
[15:32:27.731]                           grepl <- base::grepl
[15:32:27.731]                           restarts <- computeRestarts(cond)
[15:32:27.731]                           for (restart in restarts) {
[15:32:27.731]                             name <- restart$name
[15:32:27.731]                             if (is.null(name)) 
[15:32:27.731]                               next
[15:32:27.731]                             if (!grepl(pattern, name)) 
[15:32:27.731]                               next
[15:32:27.731]                             invokeRestart(restart)
[15:32:27.731]                             muffled <- TRUE
[15:32:27.731]                             break
[15:32:27.731]                           }
[15:32:27.731]                         }
[15:32:27.731]                       }
[15:32:27.731]                       invisible(muffled)
[15:32:27.731]                     }
[15:32:27.731]                     muffleCondition(cond, pattern = "^muffle")
[15:32:27.731]                   }
[15:32:27.731]                 }
[15:32:27.731]                 else {
[15:32:27.731]                   if (TRUE) {
[15:32:27.731]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:27.731]                     {
[15:32:27.731]                       inherits <- base::inherits
[15:32:27.731]                       invokeRestart <- base::invokeRestart
[15:32:27.731]                       is.null <- base::is.null
[15:32:27.731]                       muffled <- FALSE
[15:32:27.731]                       if (inherits(cond, "message")) {
[15:32:27.731]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:27.731]                         if (muffled) 
[15:32:27.731]                           invokeRestart("muffleMessage")
[15:32:27.731]                       }
[15:32:27.731]                       else if (inherits(cond, "warning")) {
[15:32:27.731]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:27.731]                         if (muffled) 
[15:32:27.731]                           invokeRestart("muffleWarning")
[15:32:27.731]                       }
[15:32:27.731]                       else if (inherits(cond, "condition")) {
[15:32:27.731]                         if (!is.null(pattern)) {
[15:32:27.731]                           computeRestarts <- base::computeRestarts
[15:32:27.731]                           grepl <- base::grepl
[15:32:27.731]                           restarts <- computeRestarts(cond)
[15:32:27.731]                           for (restart in restarts) {
[15:32:27.731]                             name <- restart$name
[15:32:27.731]                             if (is.null(name)) 
[15:32:27.731]                               next
[15:32:27.731]                             if (!grepl(pattern, name)) 
[15:32:27.731]                               next
[15:32:27.731]                             invokeRestart(restart)
[15:32:27.731]                             muffled <- TRUE
[15:32:27.731]                             break
[15:32:27.731]                           }
[15:32:27.731]                         }
[15:32:27.731]                       }
[15:32:27.731]                       invisible(muffled)
[15:32:27.731]                     }
[15:32:27.731]                     muffleCondition(cond, pattern = "^muffle")
[15:32:27.731]                   }
[15:32:27.731]                 }
[15:32:27.731]             }
[15:32:27.731]         }))
[15:32:27.731]     }, error = function(ex) {
[15:32:27.731]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:27.731]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:27.731]                 ...future.rng), started = ...future.startTime, 
[15:32:27.731]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:27.731]             version = "1.8"), class = "FutureResult")
[15:32:27.731]     }, finally = {
[15:32:27.731]         if (!identical(...future.workdir, getwd())) 
[15:32:27.731]             setwd(...future.workdir)
[15:32:27.731]         {
[15:32:27.731]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:27.731]                 ...future.oldOptions$nwarnings <- NULL
[15:32:27.731]             }
[15:32:27.731]             base::options(...future.oldOptions)
[15:32:27.731]             if (.Platform$OS.type == "windows") {
[15:32:27.731]                 old_names <- names(...future.oldEnvVars)
[15:32:27.731]                 envs <- base::Sys.getenv()
[15:32:27.731]                 names <- names(envs)
[15:32:27.731]                 common <- intersect(names, old_names)
[15:32:27.731]                 added <- setdiff(names, old_names)
[15:32:27.731]                 removed <- setdiff(old_names, names)
[15:32:27.731]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:27.731]                   envs[common]]
[15:32:27.731]                 NAMES <- toupper(changed)
[15:32:27.731]                 args <- list()
[15:32:27.731]                 for (kk in seq_along(NAMES)) {
[15:32:27.731]                   name <- changed[[kk]]
[15:32:27.731]                   NAME <- NAMES[[kk]]
[15:32:27.731]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:27.731]                     next
[15:32:27.731]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:27.731]                 }
[15:32:27.731]                 NAMES <- toupper(added)
[15:32:27.731]                 for (kk in seq_along(NAMES)) {
[15:32:27.731]                   name <- added[[kk]]
[15:32:27.731]                   NAME <- NAMES[[kk]]
[15:32:27.731]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:27.731]                     next
[15:32:27.731]                   args[[name]] <- ""
[15:32:27.731]                 }
[15:32:27.731]                 NAMES <- toupper(removed)
[15:32:27.731]                 for (kk in seq_along(NAMES)) {
[15:32:27.731]                   name <- removed[[kk]]
[15:32:27.731]                   NAME <- NAMES[[kk]]
[15:32:27.731]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:27.731]                     next
[15:32:27.731]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:27.731]                 }
[15:32:27.731]                 if (length(args) > 0) 
[15:32:27.731]                   base::do.call(base::Sys.setenv, args = args)
[15:32:27.731]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:27.731]             }
[15:32:27.731]             else {
[15:32:27.731]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:27.731]             }
[15:32:27.731]             {
[15:32:27.731]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:27.731]                   0L) {
[15:32:27.731]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:27.731]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:27.731]                   base::options(opts)
[15:32:27.731]                 }
[15:32:27.731]                 {
[15:32:27.731]                   {
[15:32:27.731]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:27.731]                     NULL
[15:32:27.731]                   }
[15:32:27.731]                   options(future.plan = NULL)
[15:32:27.731]                   if (is.na(NA_character_)) 
[15:32:27.731]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:27.731]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:27.731]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:27.731]                     .init = FALSE)
[15:32:27.731]                 }
[15:32:27.731]             }
[15:32:27.731]         }
[15:32:27.731]     })
[15:32:27.731]     if (TRUE) {
[15:32:27.731]         base::sink(type = "output", split = FALSE)
[15:32:27.731]         if (TRUE) {
[15:32:27.731]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:27.731]         }
[15:32:27.731]         else {
[15:32:27.731]             ...future.result["stdout"] <- base::list(NULL)
[15:32:27.731]         }
[15:32:27.731]         base::close(...future.stdout)
[15:32:27.731]         ...future.stdout <- NULL
[15:32:27.731]     }
[15:32:27.731]     ...future.result$conditions <- ...future.conditions
[15:32:27.731]     ...future.result$finished <- base::Sys.time()
[15:32:27.731]     ...future.result
[15:32:27.731] }
[15:32:27.745] Exporting 5 global objects (848 bytes) to cluster node #1 ...
[15:32:27.745] Exporting '...future.FUN' (848 bytes) to cluster node #1 ...
[15:32:27.746] Exporting '...future.FUN' (848 bytes) to cluster node #1 ... DONE
[15:32:27.747] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:27.748] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:27.748] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ...
[15:32:27.749] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ... DONE
[15:32:27.749] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:27.750] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:27.750] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:27.751] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:27.751] Exporting 5 global objects (848 bytes) to cluster node #1 ... DONE
[15:32:27.752] MultisessionFuture started
[15:32:27.753] - Launch lazy future ... done
[15:32:27.753] run() for 'MultisessionFuture' ... done
[15:32:27.753] Created future:
[15:32:27.773] receiveMessageFromWorker() for ClusterFuture ...
[15:32:27.773] - Validating connection of MultisessionFuture
[15:32:27.774] - received message: FutureResult
[15:32:27.774] - Received FutureResult
[15:32:27.774] - Erased future from FutureRegistry
[15:32:27.775] result() for ClusterFuture ...
[15:32:27.775] - result already collected: FutureResult
[15:32:27.775] result() for ClusterFuture ... done
[15:32:27.775] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:27.754] MultisessionFuture:
[15:32:27.754] Label: 'future_sapply-1'
[15:32:27.754] Expression:
[15:32:27.754] {
[15:32:27.754]     do.call(function(...) {
[15:32:27.754]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:27.754]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:27.754]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:27.754]             on.exit(options(oopts), add = TRUE)
[15:32:27.754]         }
[15:32:27.754]         {
[15:32:27.754]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:27.754]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:27.754]                 ...future.FUN(...future.X_jj, ...)
[15:32:27.754]             })
[15:32:27.754]         }
[15:32:27.754]     }, args = future.call.arguments)
[15:32:27.754] }
[15:32:27.754] Lazy evaluation: FALSE
[15:32:27.754] Asynchronous evaluation: TRUE
[15:32:27.754] Local evaluation: TRUE
[15:32:27.754] Environment: R_GlobalEnv
[15:32:27.754] Capture standard output: TRUE
[15:32:27.754] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:27.754] Globals: 5 objects totaling 904 bytes (function '...future.FUN' of 848 bytes, 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)
[15:32:27.754] Packages: <none>
[15:32:27.754] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:27.754] Resolved: TRUE
[15:32:27.754] Value: <not collected>
[15:32:27.754] Conditions captured: <none>
[15:32:27.754] Early signaling: FALSE
[15:32:27.754] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:27.754] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:27.776] Chunk #1 of 2 ... DONE
[15:32:27.776] Chunk #2 of 2 ...
[15:32:27.777]  - Finding globals in 'X' for chunk #2 ...
[15:32:27.777] getGlobalsAndPackages() ...
[15:32:27.777] Searching for globals...
[15:32:27.778] 
[15:32:27.778] Searching for globals ... DONE
[15:32:27.778] - globals: [0] <none>
[15:32:27.779] getGlobalsAndPackages() ... DONE
[15:32:27.779]    + additional globals found: [n=0] 
[15:32:27.779]    + additional namespaces needed: [n=0] 
[15:32:27.779]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:27.780]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:27.780]  - seeds: <none>
[15:32:27.780]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:27.781] getGlobalsAndPackages() ...
[15:32:27.781] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:27.781] Resolving globals: FALSE
[15:32:27.782] Tweak future expression to call with '...' arguments ...
[15:32:27.782] {
[15:32:27.782]     do.call(function(...) {
[15:32:27.782]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:27.782]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:27.782]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:27.782]             on.exit(options(oopts), add = TRUE)
[15:32:27.782]         }
[15:32:27.782]         {
[15:32:27.782]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:27.782]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:27.782]                 ...future.FUN(...future.X_jj, ...)
[15:32:27.782]             })
[15:32:27.782]         }
[15:32:27.782]     }, args = future.call.arguments)
[15:32:27.782] }
[15:32:27.783] Tweak future expression to call with '...' arguments ... DONE
[15:32:27.783] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:27.784] 
[15:32:27.784] getGlobalsAndPackages() ... DONE
[15:32:27.785] run() for 'Future' ...
[15:32:27.785] - state: 'created'
[15:32:27.785] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:27.804] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:27.804] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:27.805]   - Field: 'node'
[15:32:27.805]   - Field: 'label'
[15:32:27.805]   - Field: 'local'
[15:32:27.805]   - Field: 'owner'
[15:32:27.806]   - Field: 'envir'
[15:32:27.806]   - Field: 'workers'
[15:32:27.806]   - Field: 'packages'
[15:32:27.807]   - Field: 'gc'
[15:32:27.807]   - Field: 'conditions'
[15:32:27.807]   - Field: 'persistent'
[15:32:27.807]   - Field: 'expr'
[15:32:27.808]   - Field: 'uuid'
[15:32:27.808]   - Field: 'seed'
[15:32:27.808]   - Field: 'version'
[15:32:27.809]   - Field: 'result'
[15:32:27.809]   - Field: 'asynchronous'
[15:32:27.809]   - Field: 'calls'
[15:32:27.809]   - Field: 'globals'
[15:32:27.810]   - Field: 'stdout'
[15:32:27.810]   - Field: 'earlySignal'
[15:32:27.810]   - Field: 'lazy'
[15:32:27.811]   - Field: 'state'
[15:32:27.811] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:27.811] - Launch lazy future ...
[15:32:27.812] Packages needed by the future expression (n = 0): <none>
[15:32:27.812] Packages needed by future strategies (n = 0): <none>
[15:32:27.813] {
[15:32:27.813]     {
[15:32:27.813]         {
[15:32:27.813]             ...future.startTime <- base::Sys.time()
[15:32:27.813]             {
[15:32:27.813]                 {
[15:32:27.813]                   {
[15:32:27.813]                     {
[15:32:27.813]                       base::local({
[15:32:27.813]                         has_future <- base::requireNamespace("future", 
[15:32:27.813]                           quietly = TRUE)
[15:32:27.813]                         if (has_future) {
[15:32:27.813]                           ns <- base::getNamespace("future")
[15:32:27.813]                           version <- ns[[".package"]][["version"]]
[15:32:27.813]                           if (is.null(version)) 
[15:32:27.813]                             version <- utils::packageVersion("future")
[15:32:27.813]                         }
[15:32:27.813]                         else {
[15:32:27.813]                           version <- NULL
[15:32:27.813]                         }
[15:32:27.813]                         if (!has_future || version < "1.8.0") {
[15:32:27.813]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:27.813]                             "", base::R.version$version.string), 
[15:32:27.813]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:27.813]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:27.813]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:27.813]                               "release", "version")], collapse = " "), 
[15:32:27.813]                             hostname = base::Sys.info()[["nodename"]])
[15:32:27.813]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:27.813]                             info)
[15:32:27.813]                           info <- base::paste(info, collapse = "; ")
[15:32:27.813]                           if (!has_future) {
[15:32:27.813]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:27.813]                               info)
[15:32:27.813]                           }
[15:32:27.813]                           else {
[15:32:27.813]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:27.813]                               info, version)
[15:32:27.813]                           }
[15:32:27.813]                           base::stop(msg)
[15:32:27.813]                         }
[15:32:27.813]                       })
[15:32:27.813]                     }
[15:32:27.813]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:27.813]                     base::options(mc.cores = 1L)
[15:32:27.813]                   }
[15:32:27.813]                   ...future.strategy.old <- future::plan("list")
[15:32:27.813]                   options(future.plan = NULL)
[15:32:27.813]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:27.813]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:27.813]                 }
[15:32:27.813]                 ...future.workdir <- getwd()
[15:32:27.813]             }
[15:32:27.813]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:27.813]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:27.813]         }
[15:32:27.813]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:27.813]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:27.813]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:27.813]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:27.813]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:27.813]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:27.813]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:27.813]             base::names(...future.oldOptions))
[15:32:27.813]     }
[15:32:27.813]     if (FALSE) {
[15:32:27.813]     }
[15:32:27.813]     else {
[15:32:27.813]         if (TRUE) {
[15:32:27.813]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:27.813]                 open = "w")
[15:32:27.813]         }
[15:32:27.813]         else {
[15:32:27.813]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:27.813]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:27.813]         }
[15:32:27.813]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:27.813]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:27.813]             base::sink(type = "output", split = FALSE)
[15:32:27.813]             base::close(...future.stdout)
[15:32:27.813]         }, add = TRUE)
[15:32:27.813]     }
[15:32:27.813]     ...future.frame <- base::sys.nframe()
[15:32:27.813]     ...future.conditions <- base::list()
[15:32:27.813]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:27.813]     if (FALSE) {
[15:32:27.813]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:27.813]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:27.813]     }
[15:32:27.813]     ...future.result <- base::tryCatch({
[15:32:27.813]         base::withCallingHandlers({
[15:32:27.813]             ...future.value <- base::withVisible(base::local({
[15:32:27.813]                 ...future.makeSendCondition <- base::local({
[15:32:27.813]                   sendCondition <- NULL
[15:32:27.813]                   function(frame = 1L) {
[15:32:27.813]                     if (is.function(sendCondition)) 
[15:32:27.813]                       return(sendCondition)
[15:32:27.813]                     ns <- getNamespace("parallel")
[15:32:27.813]                     if (exists("sendData", mode = "function", 
[15:32:27.813]                       envir = ns)) {
[15:32:27.813]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:27.813]                         envir = ns)
[15:32:27.813]                       envir <- sys.frame(frame)
[15:32:27.813]                       master <- NULL
[15:32:27.813]                       while (!identical(envir, .GlobalEnv) && 
[15:32:27.813]                         !identical(envir, emptyenv())) {
[15:32:27.813]                         if (exists("master", mode = "list", envir = envir, 
[15:32:27.813]                           inherits = FALSE)) {
[15:32:27.813]                           master <- get("master", mode = "list", 
[15:32:27.813]                             envir = envir, inherits = FALSE)
[15:32:27.813]                           if (inherits(master, c("SOCKnode", 
[15:32:27.813]                             "SOCK0node"))) {
[15:32:27.813]                             sendCondition <<- function(cond) {
[15:32:27.813]                               data <- list(type = "VALUE", value = cond, 
[15:32:27.813]                                 success = TRUE)
[15:32:27.813]                               parallel_sendData(master, data)
[15:32:27.813]                             }
[15:32:27.813]                             return(sendCondition)
[15:32:27.813]                           }
[15:32:27.813]                         }
[15:32:27.813]                         frame <- frame + 1L
[15:32:27.813]                         envir <- sys.frame(frame)
[15:32:27.813]                       }
[15:32:27.813]                     }
[15:32:27.813]                     sendCondition <<- function(cond) NULL
[15:32:27.813]                   }
[15:32:27.813]                 })
[15:32:27.813]                 withCallingHandlers({
[15:32:27.813]                   {
[15:32:27.813]                     do.call(function(...) {
[15:32:27.813]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:27.813]                       if (!identical(...future.globals.maxSize.org, 
[15:32:27.813]                         ...future.globals.maxSize)) {
[15:32:27.813]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:27.813]                         on.exit(options(oopts), add = TRUE)
[15:32:27.813]                       }
[15:32:27.813]                       {
[15:32:27.813]                         lapply(seq_along(...future.elements_ii), 
[15:32:27.813]                           FUN = function(jj) {
[15:32:27.813]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:27.813]                             ...future.FUN(...future.X_jj, ...)
[15:32:27.813]                           })
[15:32:27.813]                       }
[15:32:27.813]                     }, args = future.call.arguments)
[15:32:27.813]                   }
[15:32:27.813]                 }, immediateCondition = function(cond) {
[15:32:27.813]                   sendCondition <- ...future.makeSendCondition()
[15:32:27.813]                   sendCondition(cond)
[15:32:27.813]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:27.813]                   {
[15:32:27.813]                     inherits <- base::inherits
[15:32:27.813]                     invokeRestart <- base::invokeRestart
[15:32:27.813]                     is.null <- base::is.null
[15:32:27.813]                     muffled <- FALSE
[15:32:27.813]                     if (inherits(cond, "message")) {
[15:32:27.813]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:27.813]                       if (muffled) 
[15:32:27.813]                         invokeRestart("muffleMessage")
[15:32:27.813]                     }
[15:32:27.813]                     else if (inherits(cond, "warning")) {
[15:32:27.813]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:27.813]                       if (muffled) 
[15:32:27.813]                         invokeRestart("muffleWarning")
[15:32:27.813]                     }
[15:32:27.813]                     else if (inherits(cond, "condition")) {
[15:32:27.813]                       if (!is.null(pattern)) {
[15:32:27.813]                         computeRestarts <- base::computeRestarts
[15:32:27.813]                         grepl <- base::grepl
[15:32:27.813]                         restarts <- computeRestarts(cond)
[15:32:27.813]                         for (restart in restarts) {
[15:32:27.813]                           name <- restart$name
[15:32:27.813]                           if (is.null(name)) 
[15:32:27.813]                             next
[15:32:27.813]                           if (!grepl(pattern, name)) 
[15:32:27.813]                             next
[15:32:27.813]                           invokeRestart(restart)
[15:32:27.813]                           muffled <- TRUE
[15:32:27.813]                           break
[15:32:27.813]                         }
[15:32:27.813]                       }
[15:32:27.813]                     }
[15:32:27.813]                     invisible(muffled)
[15:32:27.813]                   }
[15:32:27.813]                   muffleCondition(cond)
[15:32:27.813]                 })
[15:32:27.813]             }))
[15:32:27.813]             future::FutureResult(value = ...future.value$value, 
[15:32:27.813]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:27.813]                   ...future.rng), globalenv = if (FALSE) 
[15:32:27.813]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:27.813]                     ...future.globalenv.names))
[15:32:27.813]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:27.813]         }, condition = base::local({
[15:32:27.813]             c <- base::c
[15:32:27.813]             inherits <- base::inherits
[15:32:27.813]             invokeRestart <- base::invokeRestart
[15:32:27.813]             length <- base::length
[15:32:27.813]             list <- base::list
[15:32:27.813]             seq.int <- base::seq.int
[15:32:27.813]             signalCondition <- base::signalCondition
[15:32:27.813]             sys.calls <- base::sys.calls
[15:32:27.813]             `[[` <- base::`[[`
[15:32:27.813]             `+` <- base::`+`
[15:32:27.813]             `<<-` <- base::`<<-`
[15:32:27.813]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:27.813]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:27.813]                   3L)]
[15:32:27.813]             }
[15:32:27.813]             function(cond) {
[15:32:27.813]                 is_error <- inherits(cond, "error")
[15:32:27.813]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:27.813]                   NULL)
[15:32:27.813]                 if (is_error) {
[15:32:27.813]                   sessionInformation <- function() {
[15:32:27.813]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:27.813]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:27.813]                       search = base::search(), system = base::Sys.info())
[15:32:27.813]                   }
[15:32:27.813]                   ...future.conditions[[length(...future.conditions) + 
[15:32:27.813]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:27.813]                     cond$call), session = sessionInformation(), 
[15:32:27.813]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:27.813]                   signalCondition(cond)
[15:32:27.813]                 }
[15:32:27.813]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:27.813]                 "immediateCondition"))) {
[15:32:27.813]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:27.813]                   ...future.conditions[[length(...future.conditions) + 
[15:32:27.813]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:27.813]                   if (TRUE && !signal) {
[15:32:27.813]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:27.813]                     {
[15:32:27.813]                       inherits <- base::inherits
[15:32:27.813]                       invokeRestart <- base::invokeRestart
[15:32:27.813]                       is.null <- base::is.null
[15:32:27.813]                       muffled <- FALSE
[15:32:27.813]                       if (inherits(cond, "message")) {
[15:32:27.813]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:27.813]                         if (muffled) 
[15:32:27.813]                           invokeRestart("muffleMessage")
[15:32:27.813]                       }
[15:32:27.813]                       else if (inherits(cond, "warning")) {
[15:32:27.813]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:27.813]                         if (muffled) 
[15:32:27.813]                           invokeRestart("muffleWarning")
[15:32:27.813]                       }
[15:32:27.813]                       else if (inherits(cond, "condition")) {
[15:32:27.813]                         if (!is.null(pattern)) {
[15:32:27.813]                           computeRestarts <- base::computeRestarts
[15:32:27.813]                           grepl <- base::grepl
[15:32:27.813]                           restarts <- computeRestarts(cond)
[15:32:27.813]                           for (restart in restarts) {
[15:32:27.813]                             name <- restart$name
[15:32:27.813]                             if (is.null(name)) 
[15:32:27.813]                               next
[15:32:27.813]                             if (!grepl(pattern, name)) 
[15:32:27.813]                               next
[15:32:27.813]                             invokeRestart(restart)
[15:32:27.813]                             muffled <- TRUE
[15:32:27.813]                             break
[15:32:27.813]                           }
[15:32:27.813]                         }
[15:32:27.813]                       }
[15:32:27.813]                       invisible(muffled)
[15:32:27.813]                     }
[15:32:27.813]                     muffleCondition(cond, pattern = "^muffle")
[15:32:27.813]                   }
[15:32:27.813]                 }
[15:32:27.813]                 else {
[15:32:27.813]                   if (TRUE) {
[15:32:27.813]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:27.813]                     {
[15:32:27.813]                       inherits <- base::inherits
[15:32:27.813]                       invokeRestart <- base::invokeRestart
[15:32:27.813]                       is.null <- base::is.null
[15:32:27.813]                       muffled <- FALSE
[15:32:27.813]                       if (inherits(cond, "message")) {
[15:32:27.813]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:27.813]                         if (muffled) 
[15:32:27.813]                           invokeRestart("muffleMessage")
[15:32:27.813]                       }
[15:32:27.813]                       else if (inherits(cond, "warning")) {
[15:32:27.813]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:27.813]                         if (muffled) 
[15:32:27.813]                           invokeRestart("muffleWarning")
[15:32:27.813]                       }
[15:32:27.813]                       else if (inherits(cond, "condition")) {
[15:32:27.813]                         if (!is.null(pattern)) {
[15:32:27.813]                           computeRestarts <- base::computeRestarts
[15:32:27.813]                           grepl <- base::grepl
[15:32:27.813]                           restarts <- computeRestarts(cond)
[15:32:27.813]                           for (restart in restarts) {
[15:32:27.813]                             name <- restart$name
[15:32:27.813]                             if (is.null(name)) 
[15:32:27.813]                               next
[15:32:27.813]                             if (!grepl(pattern, name)) 
[15:32:27.813]                               next
[15:32:27.813]                             invokeRestart(restart)
[15:32:27.813]                             muffled <- TRUE
[15:32:27.813]                             break
[15:32:27.813]                           }
[15:32:27.813]                         }
[15:32:27.813]                       }
[15:32:27.813]                       invisible(muffled)
[15:32:27.813]                     }
[15:32:27.813]                     muffleCondition(cond, pattern = "^muffle")
[15:32:27.813]                   }
[15:32:27.813]                 }
[15:32:27.813]             }
[15:32:27.813]         }))
[15:32:27.813]     }, error = function(ex) {
[15:32:27.813]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:27.813]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:27.813]                 ...future.rng), started = ...future.startTime, 
[15:32:27.813]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:27.813]             version = "1.8"), class = "FutureResult")
[15:32:27.813]     }, finally = {
[15:32:27.813]         if (!identical(...future.workdir, getwd())) 
[15:32:27.813]             setwd(...future.workdir)
[15:32:27.813]         {
[15:32:27.813]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:27.813]                 ...future.oldOptions$nwarnings <- NULL
[15:32:27.813]             }
[15:32:27.813]             base::options(...future.oldOptions)
[15:32:27.813]             if (.Platform$OS.type == "windows") {
[15:32:27.813]                 old_names <- names(...future.oldEnvVars)
[15:32:27.813]                 envs <- base::Sys.getenv()
[15:32:27.813]                 names <- names(envs)
[15:32:27.813]                 common <- intersect(names, old_names)
[15:32:27.813]                 added <- setdiff(names, old_names)
[15:32:27.813]                 removed <- setdiff(old_names, names)
[15:32:27.813]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:27.813]                   envs[common]]
[15:32:27.813]                 NAMES <- toupper(changed)
[15:32:27.813]                 args <- list()
[15:32:27.813]                 for (kk in seq_along(NAMES)) {
[15:32:27.813]                   name <- changed[[kk]]
[15:32:27.813]                   NAME <- NAMES[[kk]]
[15:32:27.813]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:27.813]                     next
[15:32:27.813]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:27.813]                 }
[15:32:27.813]                 NAMES <- toupper(added)
[15:32:27.813]                 for (kk in seq_along(NAMES)) {
[15:32:27.813]                   name <- added[[kk]]
[15:32:27.813]                   NAME <- NAMES[[kk]]
[15:32:27.813]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:27.813]                     next
[15:32:27.813]                   args[[name]] <- ""
[15:32:27.813]                 }
[15:32:27.813]                 NAMES <- toupper(removed)
[15:32:27.813]                 for (kk in seq_along(NAMES)) {
[15:32:27.813]                   name <- removed[[kk]]
[15:32:27.813]                   NAME <- NAMES[[kk]]
[15:32:27.813]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:27.813]                     next
[15:32:27.813]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:27.813]                 }
[15:32:27.813]                 if (length(args) > 0) 
[15:32:27.813]                   base::do.call(base::Sys.setenv, args = args)
[15:32:27.813]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:27.813]             }
[15:32:27.813]             else {
[15:32:27.813]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:27.813]             }
[15:32:27.813]             {
[15:32:27.813]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:27.813]                   0L) {
[15:32:27.813]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:27.813]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:27.813]                   base::options(opts)
[15:32:27.813]                 }
[15:32:27.813]                 {
[15:32:27.813]                   {
[15:32:27.813]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:27.813]                     NULL
[15:32:27.813]                   }
[15:32:27.813]                   options(future.plan = NULL)
[15:32:27.813]                   if (is.na(NA_character_)) 
[15:32:27.813]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:27.813]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:27.813]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:27.813]                     .init = FALSE)
[15:32:27.813]                 }
[15:32:27.813]             }
[15:32:27.813]         }
[15:32:27.813]     })
[15:32:27.813]     if (TRUE) {
[15:32:27.813]         base::sink(type = "output", split = FALSE)
[15:32:27.813]         if (TRUE) {
[15:32:27.813]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:27.813]         }
[15:32:27.813]         else {
[15:32:27.813]             ...future.result["stdout"] <- base::list(NULL)
[15:32:27.813]         }
[15:32:27.813]         base::close(...future.stdout)
[15:32:27.813]         ...future.stdout <- NULL
[15:32:27.813]     }
[15:32:27.813]     ...future.result$conditions <- ...future.conditions
[15:32:27.813]     ...future.result$finished <- base::Sys.time()
[15:32:27.813]     ...future.result
[15:32:27.813] }
[15:32:27.823] Exporting 5 global objects (848 bytes) to cluster node #1 ...
[15:32:27.823] Exporting '...future.FUN' (848 bytes) to cluster node #1 ...
[15:32:27.824] Exporting '...future.FUN' (848 bytes) to cluster node #1 ... DONE
[15:32:27.824] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:27.825] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:27.825] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:27.826] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:27.826] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:27.827] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:27.827] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:27.828] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:27.828] Exporting 5 global objects (848 bytes) to cluster node #1 ... DONE
[15:32:27.829] MultisessionFuture started
[15:32:27.829] - Launch lazy future ... done
[15:32:27.830] run() for 'MultisessionFuture' ... done
[15:32:27.830] Created future:
[15:32:27.852] receiveMessageFromWorker() for ClusterFuture ...
[15:32:27.852] - Validating connection of MultisessionFuture
[15:32:27.853] - received message: FutureResult
[15:32:27.853] - Received FutureResult
[15:32:27.854] - Erased future from FutureRegistry
[15:32:27.854] result() for ClusterFuture ...
[15:32:27.854] - result already collected: FutureResult
[15:32:27.854] result() for ClusterFuture ... done
[15:32:27.855] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:27.830] MultisessionFuture:
[15:32:27.830] Label: 'future_sapply-2'
[15:32:27.830] Expression:
[15:32:27.830] {
[15:32:27.830]     do.call(function(...) {
[15:32:27.830]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:27.830]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:27.830]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:27.830]             on.exit(options(oopts), add = TRUE)
[15:32:27.830]         }
[15:32:27.830]         {
[15:32:27.830]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:27.830]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:27.830]                 ...future.FUN(...future.X_jj, ...)
[15:32:27.830]             })
[15:32:27.830]         }
[15:32:27.830]     }, args = future.call.arguments)
[15:32:27.830] }
[15:32:27.830] Lazy evaluation: FALSE
[15:32:27.830] Asynchronous evaluation: TRUE
[15:32:27.830] Local evaluation: TRUE
[15:32:27.830] Environment: R_GlobalEnv
[15:32:27.830] Capture standard output: TRUE
[15:32:27.830] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:27.830] Globals: 5 objects totaling 960 bytes (function '...future.FUN' of 848 bytes, 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)
[15:32:27.830] Packages: <none>
[15:32:27.830] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:27.830] Resolved: TRUE
[15:32:27.830] Value: <not collected>
[15:32:27.830] Conditions captured: <none>
[15:32:27.830] Early signaling: FALSE
[15:32:27.830] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:27.830] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:27.856] Chunk #2 of 2 ... DONE
[15:32:27.856] Launching 2 futures (chunks) ... DONE
[15:32:27.856] Resolving 2 futures (chunks) ...
[15:32:27.856] resolve() on list ...
[15:32:27.857]  recursive: 0
[15:32:27.857]  length: 2
[15:32:27.857] 
[15:32:27.858] Future #1
[15:32:27.858] result() for ClusterFuture ...
[15:32:27.858] - result already collected: FutureResult
[15:32:27.858] result() for ClusterFuture ... done
[15:32:27.859] result() for ClusterFuture ...
[15:32:27.859] - result already collected: FutureResult
[15:32:27.859] result() for ClusterFuture ... done
[15:32:27.859] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:27.860] - nx: 2
[15:32:27.860] - relay: TRUE
[15:32:27.860] - stdout: TRUE
[15:32:27.860] - signal: TRUE
[15:32:27.861] - resignal: FALSE
[15:32:27.861] - force: TRUE
[15:32:27.861] - relayed: [n=2] FALSE, FALSE
[15:32:27.862] - queued futures: [n=2] FALSE, FALSE
[15:32:27.862]  - until=1
[15:32:27.862]  - relaying element #1
[15:32:27.862] result() for ClusterFuture ...
[15:32:27.863] - result already collected: FutureResult
[15:32:27.863] result() for ClusterFuture ... done
[15:32:27.863] result() for ClusterFuture ...
[15:32:27.863] - result already collected: FutureResult
[15:32:27.864] result() for ClusterFuture ... done
[15:32:27.864] result() for ClusterFuture ...
[15:32:27.864] - result already collected: FutureResult
[15:32:27.865] result() for ClusterFuture ... done
[15:32:27.865] result() for ClusterFuture ...
[15:32:27.865] - result already collected: FutureResult
[15:32:27.865] result() for ClusterFuture ... done
[15:32:27.866] - relayed: [n=2] TRUE, FALSE
[15:32:27.866] - queued futures: [n=2] TRUE, FALSE
[15:32:27.866] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:27.867]  length: 1 (resolved future 1)
[15:32:27.867] Future #2
[15:32:27.867] result() for ClusterFuture ...
[15:32:27.867] - result already collected: FutureResult
[15:32:27.868] result() for ClusterFuture ... done
[15:32:27.868] result() for ClusterFuture ...
[15:32:27.868] - result already collected: FutureResult
[15:32:27.868] result() for ClusterFuture ... done
[15:32:27.869] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:27.869] - nx: 2
[15:32:27.869] - relay: TRUE
[15:32:27.870] - stdout: TRUE
[15:32:27.870] - signal: TRUE
[15:32:27.870] - resignal: FALSE
[15:32:27.870] - force: TRUE
[15:32:27.871] - relayed: [n=2] TRUE, FALSE
[15:32:27.871] - queued futures: [n=2] TRUE, FALSE
[15:32:27.871]  - until=2
[15:32:27.871]  - relaying element #2
[15:32:27.872] result() for ClusterFuture ...
[15:32:27.872] - result already collected: FutureResult
[15:32:27.872] result() for ClusterFuture ... done
[15:32:27.873] result() for ClusterFuture ...
[15:32:27.873] - result already collected: FutureResult
[15:32:27.873] result() for ClusterFuture ... done
[15:32:27.873] result() for ClusterFuture ...
[15:32:27.874] - result already collected: FutureResult
[15:32:27.874] result() for ClusterFuture ... done
[15:32:27.874] result() for ClusterFuture ...
[15:32:27.874] - result already collected: FutureResult
[15:32:27.875] result() for ClusterFuture ... done
[15:32:27.875] - relayed: [n=2] TRUE, TRUE
[15:32:27.875] - queued futures: [n=2] TRUE, TRUE
[15:32:27.876] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:27.876]  length: 0 (resolved future 2)
[15:32:27.876] Relaying remaining futures
[15:32:27.876] signalConditionsASAP(NULL, pos=0) ...
[15:32:27.877] - nx: 2
[15:32:27.877] - relay: TRUE
[15:32:27.877] - stdout: TRUE
[15:32:27.877] - signal: TRUE
[15:32:27.878] - resignal: FALSE
[15:32:27.878] - force: TRUE
[15:32:27.878] - relayed: [n=2] TRUE, TRUE
[15:32:27.878] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:27.879] - relayed: [n=2] TRUE, TRUE
[15:32:27.879] - queued futures: [n=2] TRUE, TRUE
[15:32:27.879] signalConditionsASAP(NULL, pos=0) ... done
[15:32:27.880] resolve() on list ... DONE
[15:32:27.880] result() for ClusterFuture ...
[15:32:27.880] - result already collected: FutureResult
[15:32:27.881] result() for ClusterFuture ... done
[15:32:27.881] result() for ClusterFuture ...
[15:32:27.881] - result already collected: FutureResult
[15:32:27.881] result() for ClusterFuture ... done
[15:32:27.882] result() for ClusterFuture ...
[15:32:27.882] - result already collected: FutureResult
[15:32:27.882] result() for ClusterFuture ... done
[15:32:27.882] result() for ClusterFuture ...
[15:32:27.883] - result already collected: FutureResult
[15:32:27.883] result() for ClusterFuture ... done
[15:32:27.883]  - Number of value chunks collected: 2
[15:32:27.884] Resolving 2 futures (chunks) ... DONE
[15:32:27.884] Reducing values from 2 chunks ...
[15:32:27.884]  - Number of values collected after concatenation: 3
[15:32:27.884]  - Number of values expected: 3
[15:32:27.885] Reducing values from 2 chunks ... DONE
[15:32:27.885] future_lapply() ... DONE
List of 2
 $ y0: Named num [1:3] 1 2 3
  ..- attr(*, "names")= chr [1:3] "a" "b" "c"
 $ y1: Named num [1:3] 1 2 3
  ..- attr(*, "names")= chr [1:3] "a" "b" "c"
[15:32:27.889] future_lapply() ...
[15:32:27.894] Number of chunks: 2
[15:32:27.894] getGlobalsAndPackagesXApply() ...
[15:32:27.895]  - future.globals: TRUE
[15:32:27.895] getGlobalsAndPackages() ...
[15:32:27.895] Searching for globals...
[15:32:27.898] - globals found: [2] 'FUN', 'UseMethod'
[15:32:27.898] Searching for globals ... DONE
[15:32:27.898] Resolving globals: FALSE
[15:32:27.899] The total size of the 1 globals is 1.22 KiB (1248 bytes)
[15:32:27.900] The total size of the 1 globals exported for future expression ('FUN()') is 1.22 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.22 KiB of class 'function')
[15:32:27.900] - globals: [1] 'FUN'
[15:32:27.900] 
[15:32:27.901] getGlobalsAndPackages() ... DONE
[15:32:27.901]  - globals found/used: [n=1] 'FUN'
[15:32:27.901]  - needed namespaces: [n=0] 
[15:32:27.902] Finding globals ... DONE
[15:32:27.902]  - use_args: TRUE
[15:32:27.902]  - Getting '...' globals ...
[15:32:27.903] resolve() on list ...
[15:32:27.903]  recursive: 0
[15:32:27.903]  length: 1
[15:32:27.904]  elements: '...'
[15:32:27.904]  length: 0 (resolved future 1)
[15:32:27.904] resolve() on list ... DONE
[15:32:27.905]    - '...' content: [n=0] 
[15:32:27.905] List of 1
[15:32:27.905]  $ ...: list()
[15:32:27.905]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:27.905]  - attr(*, "where")=List of 1
[15:32:27.905]   ..$ ...:<environment: 0x00000276e4745b90> 
[15:32:27.905]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:27.905]  - attr(*, "resolved")= logi TRUE
[15:32:27.905]  - attr(*, "total_size")= num NA
[15:32:27.910]  - Getting '...' globals ... DONE
[15:32:27.911] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:27.911] List of 2
[15:32:27.911]  $ ...future.FUN:function (x, ...)  
[15:32:27.911]  $ ...          : list()
[15:32:27.911]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:27.911]  - attr(*, "where")=List of 2
[15:32:27.911]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:27.911]   ..$ ...          :<environment: 0x00000276e4745b90> 
[15:32:27.911]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:27.911]  - attr(*, "resolved")= logi FALSE
[15:32:27.911]  - attr(*, "total_size")= num 1248
[15:32:27.921] Packages to be attached in all futures: [n=0] 
[15:32:27.921] getGlobalsAndPackagesXApply() ... DONE
[15:32:27.921] Number of futures (= number of chunks): 2
[15:32:27.922] Launching 2 futures (chunks) ...
[15:32:27.922] Chunk #1 of 2 ...
[15:32:27.922]  - Finding globals in 'X' for chunk #1 ...
[15:32:27.923] getGlobalsAndPackages() ...
[15:32:27.923] Searching for globals...
[15:32:27.923] 
[15:32:27.924] Searching for globals ... DONE
[15:32:27.924] - globals: [0] <none>
[15:32:27.924] getGlobalsAndPackages() ... DONE
[15:32:27.924]    + additional globals found: [n=0] 
[15:32:27.925]    + additional namespaces needed: [n=0] 
[15:32:27.925]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:27.925]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:27.926]  - seeds: <none>
[15:32:27.926]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:27.926] getGlobalsAndPackages() ...
[15:32:27.926] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:27.927] Resolving globals: FALSE
[15:32:27.927] Tweak future expression to call with '...' arguments ...
[15:32:27.927] {
[15:32:27.927]     do.call(function(...) {
[15:32:27.927]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:27.927]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:27.927]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:27.927]             on.exit(options(oopts), add = TRUE)
[15:32:27.927]         }
[15:32:27.927]         {
[15:32:27.927]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:27.927]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:27.927]                 ...future.FUN(...future.X_jj, ...)
[15:32:27.927]             })
[15:32:27.927]         }
[15:32:27.927]     }, args = future.call.arguments)
[15:32:27.927] }
[15:32:27.928] Tweak future expression to call with '...' arguments ... DONE
[15:32:27.929] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:27.929] 
[15:32:27.929] getGlobalsAndPackages() ... DONE
[15:32:27.930] run() for 'Future' ...
[15:32:27.930] - state: 'created'
[15:32:27.931] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:27.951] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:27.951] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:27.952]   - Field: 'node'
[15:32:27.952]   - Field: 'label'
[15:32:27.952]   - Field: 'local'
[15:32:27.952]   - Field: 'owner'
[15:32:27.953]   - Field: 'envir'
[15:32:27.953]   - Field: 'workers'
[15:32:27.953]   - Field: 'packages'
[15:32:27.954]   - Field: 'gc'
[15:32:27.954]   - Field: 'conditions'
[15:32:27.954]   - Field: 'persistent'
[15:32:27.955]   - Field: 'expr'
[15:32:27.955]   - Field: 'uuid'
[15:32:27.955]   - Field: 'seed'
[15:32:27.956]   - Field: 'version'
[15:32:27.956]   - Field: 'result'
[15:32:27.957]   - Field: 'asynchronous'
[15:32:27.957]   - Field: 'calls'
[15:32:27.957]   - Field: 'globals'
[15:32:27.958]   - Field: 'stdout'
[15:32:27.958]   - Field: 'earlySignal'
[15:32:27.958]   - Field: 'lazy'
[15:32:27.959]   - Field: 'state'
[15:32:27.959] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:27.959] - Launch lazy future ...
[15:32:27.960] Packages needed by the future expression (n = 0): <none>
[15:32:27.961] Packages needed by future strategies (n = 0): <none>
[15:32:27.962] {
[15:32:27.962]     {
[15:32:27.962]         {
[15:32:27.962]             ...future.startTime <- base::Sys.time()
[15:32:27.962]             {
[15:32:27.962]                 {
[15:32:27.962]                   {
[15:32:27.962]                     {
[15:32:27.962]                       base::local({
[15:32:27.962]                         has_future <- base::requireNamespace("future", 
[15:32:27.962]                           quietly = TRUE)
[15:32:27.962]                         if (has_future) {
[15:32:27.962]                           ns <- base::getNamespace("future")
[15:32:27.962]                           version <- ns[[".package"]][["version"]]
[15:32:27.962]                           if (is.null(version)) 
[15:32:27.962]                             version <- utils::packageVersion("future")
[15:32:27.962]                         }
[15:32:27.962]                         else {
[15:32:27.962]                           version <- NULL
[15:32:27.962]                         }
[15:32:27.962]                         if (!has_future || version < "1.8.0") {
[15:32:27.962]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:27.962]                             "", base::R.version$version.string), 
[15:32:27.962]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:27.962]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:27.962]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:27.962]                               "release", "version")], collapse = " "), 
[15:32:27.962]                             hostname = base::Sys.info()[["nodename"]])
[15:32:27.962]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:27.962]                             info)
[15:32:27.962]                           info <- base::paste(info, collapse = "; ")
[15:32:27.962]                           if (!has_future) {
[15:32:27.962]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:27.962]                               info)
[15:32:27.962]                           }
[15:32:27.962]                           else {
[15:32:27.962]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:27.962]                               info, version)
[15:32:27.962]                           }
[15:32:27.962]                           base::stop(msg)
[15:32:27.962]                         }
[15:32:27.962]                       })
[15:32:27.962]                     }
[15:32:27.962]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:27.962]                     base::options(mc.cores = 1L)
[15:32:27.962]                   }
[15:32:27.962]                   ...future.strategy.old <- future::plan("list")
[15:32:27.962]                   options(future.plan = NULL)
[15:32:27.962]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:27.962]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:27.962]                 }
[15:32:27.962]                 ...future.workdir <- getwd()
[15:32:27.962]             }
[15:32:27.962]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:27.962]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:27.962]         }
[15:32:27.962]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:27.962]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:27.962]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:27.962]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:27.962]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:27.962]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:27.962]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:27.962]             base::names(...future.oldOptions))
[15:32:27.962]     }
[15:32:27.962]     if (FALSE) {
[15:32:27.962]     }
[15:32:27.962]     else {
[15:32:27.962]         if (TRUE) {
[15:32:27.962]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:27.962]                 open = "w")
[15:32:27.962]         }
[15:32:27.962]         else {
[15:32:27.962]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:27.962]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:27.962]         }
[15:32:27.962]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:27.962]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:27.962]             base::sink(type = "output", split = FALSE)
[15:32:27.962]             base::close(...future.stdout)
[15:32:27.962]         }, add = TRUE)
[15:32:27.962]     }
[15:32:27.962]     ...future.frame <- base::sys.nframe()
[15:32:27.962]     ...future.conditions <- base::list()
[15:32:27.962]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:27.962]     if (FALSE) {
[15:32:27.962]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:27.962]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:27.962]     }
[15:32:27.962]     ...future.result <- base::tryCatch({
[15:32:27.962]         base::withCallingHandlers({
[15:32:27.962]             ...future.value <- base::withVisible(base::local({
[15:32:27.962]                 ...future.makeSendCondition <- base::local({
[15:32:27.962]                   sendCondition <- NULL
[15:32:27.962]                   function(frame = 1L) {
[15:32:27.962]                     if (is.function(sendCondition)) 
[15:32:27.962]                       return(sendCondition)
[15:32:27.962]                     ns <- getNamespace("parallel")
[15:32:27.962]                     if (exists("sendData", mode = "function", 
[15:32:27.962]                       envir = ns)) {
[15:32:27.962]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:27.962]                         envir = ns)
[15:32:27.962]                       envir <- sys.frame(frame)
[15:32:27.962]                       master <- NULL
[15:32:27.962]                       while (!identical(envir, .GlobalEnv) && 
[15:32:27.962]                         !identical(envir, emptyenv())) {
[15:32:27.962]                         if (exists("master", mode = "list", envir = envir, 
[15:32:27.962]                           inherits = FALSE)) {
[15:32:27.962]                           master <- get("master", mode = "list", 
[15:32:27.962]                             envir = envir, inherits = FALSE)
[15:32:27.962]                           if (inherits(master, c("SOCKnode", 
[15:32:27.962]                             "SOCK0node"))) {
[15:32:27.962]                             sendCondition <<- function(cond) {
[15:32:27.962]                               data <- list(type = "VALUE", value = cond, 
[15:32:27.962]                                 success = TRUE)
[15:32:27.962]                               parallel_sendData(master, data)
[15:32:27.962]                             }
[15:32:27.962]                             return(sendCondition)
[15:32:27.962]                           }
[15:32:27.962]                         }
[15:32:27.962]                         frame <- frame + 1L
[15:32:27.962]                         envir <- sys.frame(frame)
[15:32:27.962]                       }
[15:32:27.962]                     }
[15:32:27.962]                     sendCondition <<- function(cond) NULL
[15:32:27.962]                   }
[15:32:27.962]                 })
[15:32:27.962]                 withCallingHandlers({
[15:32:27.962]                   {
[15:32:27.962]                     do.call(function(...) {
[15:32:27.962]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:27.962]                       if (!identical(...future.globals.maxSize.org, 
[15:32:27.962]                         ...future.globals.maxSize)) {
[15:32:27.962]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:27.962]                         on.exit(options(oopts), add = TRUE)
[15:32:27.962]                       }
[15:32:27.962]                       {
[15:32:27.962]                         lapply(seq_along(...future.elements_ii), 
[15:32:27.962]                           FUN = function(jj) {
[15:32:27.962]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:27.962]                             ...future.FUN(...future.X_jj, ...)
[15:32:27.962]                           })
[15:32:27.962]                       }
[15:32:27.962]                     }, args = future.call.arguments)
[15:32:27.962]                   }
[15:32:27.962]                 }, immediateCondition = function(cond) {
[15:32:27.962]                   sendCondition <- ...future.makeSendCondition()
[15:32:27.962]                   sendCondition(cond)
[15:32:27.962]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:27.962]                   {
[15:32:27.962]                     inherits <- base::inherits
[15:32:27.962]                     invokeRestart <- base::invokeRestart
[15:32:27.962]                     is.null <- base::is.null
[15:32:27.962]                     muffled <- FALSE
[15:32:27.962]                     if (inherits(cond, "message")) {
[15:32:27.962]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:27.962]                       if (muffled) 
[15:32:27.962]                         invokeRestart("muffleMessage")
[15:32:27.962]                     }
[15:32:27.962]                     else if (inherits(cond, "warning")) {
[15:32:27.962]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:27.962]                       if (muffled) 
[15:32:27.962]                         invokeRestart("muffleWarning")
[15:32:27.962]                     }
[15:32:27.962]                     else if (inherits(cond, "condition")) {
[15:32:27.962]                       if (!is.null(pattern)) {
[15:32:27.962]                         computeRestarts <- base::computeRestarts
[15:32:27.962]                         grepl <- base::grepl
[15:32:27.962]                         restarts <- computeRestarts(cond)
[15:32:27.962]                         for (restart in restarts) {
[15:32:27.962]                           name <- restart$name
[15:32:27.962]                           if (is.null(name)) 
[15:32:27.962]                             next
[15:32:27.962]                           if (!grepl(pattern, name)) 
[15:32:27.962]                             next
[15:32:27.962]                           invokeRestart(restart)
[15:32:27.962]                           muffled <- TRUE
[15:32:27.962]                           break
[15:32:27.962]                         }
[15:32:27.962]                       }
[15:32:27.962]                     }
[15:32:27.962]                     invisible(muffled)
[15:32:27.962]                   }
[15:32:27.962]                   muffleCondition(cond)
[15:32:27.962]                 })
[15:32:27.962]             }))
[15:32:27.962]             future::FutureResult(value = ...future.value$value, 
[15:32:27.962]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:27.962]                   ...future.rng), globalenv = if (FALSE) 
[15:32:27.962]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:27.962]                     ...future.globalenv.names))
[15:32:27.962]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:27.962]         }, condition = base::local({
[15:32:27.962]             c <- base::c
[15:32:27.962]             inherits <- base::inherits
[15:32:27.962]             invokeRestart <- base::invokeRestart
[15:32:27.962]             length <- base::length
[15:32:27.962]             list <- base::list
[15:32:27.962]             seq.int <- base::seq.int
[15:32:27.962]             signalCondition <- base::signalCondition
[15:32:27.962]             sys.calls <- base::sys.calls
[15:32:27.962]             `[[` <- base::`[[`
[15:32:27.962]             `+` <- base::`+`
[15:32:27.962]             `<<-` <- base::`<<-`
[15:32:27.962]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:27.962]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:27.962]                   3L)]
[15:32:27.962]             }
[15:32:27.962]             function(cond) {
[15:32:27.962]                 is_error <- inherits(cond, "error")
[15:32:27.962]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:27.962]                   NULL)
[15:32:27.962]                 if (is_error) {
[15:32:27.962]                   sessionInformation <- function() {
[15:32:27.962]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:27.962]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:27.962]                       search = base::search(), system = base::Sys.info())
[15:32:27.962]                   }
[15:32:27.962]                   ...future.conditions[[length(...future.conditions) + 
[15:32:27.962]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:27.962]                     cond$call), session = sessionInformation(), 
[15:32:27.962]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:27.962]                   signalCondition(cond)
[15:32:27.962]                 }
[15:32:27.962]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:27.962]                 "immediateCondition"))) {
[15:32:27.962]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:27.962]                   ...future.conditions[[length(...future.conditions) + 
[15:32:27.962]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:27.962]                   if (TRUE && !signal) {
[15:32:27.962]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:27.962]                     {
[15:32:27.962]                       inherits <- base::inherits
[15:32:27.962]                       invokeRestart <- base::invokeRestart
[15:32:27.962]                       is.null <- base::is.null
[15:32:27.962]                       muffled <- FALSE
[15:32:27.962]                       if (inherits(cond, "message")) {
[15:32:27.962]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:27.962]                         if (muffled) 
[15:32:27.962]                           invokeRestart("muffleMessage")
[15:32:27.962]                       }
[15:32:27.962]                       else if (inherits(cond, "warning")) {
[15:32:27.962]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:27.962]                         if (muffled) 
[15:32:27.962]                           invokeRestart("muffleWarning")
[15:32:27.962]                       }
[15:32:27.962]                       else if (inherits(cond, "condition")) {
[15:32:27.962]                         if (!is.null(pattern)) {
[15:32:27.962]                           computeRestarts <- base::computeRestarts
[15:32:27.962]                           grepl <- base::grepl
[15:32:27.962]                           restarts <- computeRestarts(cond)
[15:32:27.962]                           for (restart in restarts) {
[15:32:27.962]                             name <- restart$name
[15:32:27.962]                             if (is.null(name)) 
[15:32:27.962]                               next
[15:32:27.962]                             if (!grepl(pattern, name)) 
[15:32:27.962]                               next
[15:32:27.962]                             invokeRestart(restart)
[15:32:27.962]                             muffled <- TRUE
[15:32:27.962]                             break
[15:32:27.962]                           }
[15:32:27.962]                         }
[15:32:27.962]                       }
[15:32:27.962]                       invisible(muffled)
[15:32:27.962]                     }
[15:32:27.962]                     muffleCondition(cond, pattern = "^muffle")
[15:32:27.962]                   }
[15:32:27.962]                 }
[15:32:27.962]                 else {
[15:32:27.962]                   if (TRUE) {
[15:32:27.962]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:27.962]                     {
[15:32:27.962]                       inherits <- base::inherits
[15:32:27.962]                       invokeRestart <- base::invokeRestart
[15:32:27.962]                       is.null <- base::is.null
[15:32:27.962]                       muffled <- FALSE
[15:32:27.962]                       if (inherits(cond, "message")) {
[15:32:27.962]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:27.962]                         if (muffled) 
[15:32:27.962]                           invokeRestart("muffleMessage")
[15:32:27.962]                       }
[15:32:27.962]                       else if (inherits(cond, "warning")) {
[15:32:27.962]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:27.962]                         if (muffled) 
[15:32:27.962]                           invokeRestart("muffleWarning")
[15:32:27.962]                       }
[15:32:27.962]                       else if (inherits(cond, "condition")) {
[15:32:27.962]                         if (!is.null(pattern)) {
[15:32:27.962]                           computeRestarts <- base::computeRestarts
[15:32:27.962]                           grepl <- base::grepl
[15:32:27.962]                           restarts <- computeRestarts(cond)
[15:32:27.962]                           for (restart in restarts) {
[15:32:27.962]                             name <- restart$name
[15:32:27.962]                             if (is.null(name)) 
[15:32:27.962]                               next
[15:32:27.962]                             if (!grepl(pattern, name)) 
[15:32:27.962]                               next
[15:32:27.962]                             invokeRestart(restart)
[15:32:27.962]                             muffled <- TRUE
[15:32:27.962]                             break
[15:32:27.962]                           }
[15:32:27.962]                         }
[15:32:27.962]                       }
[15:32:27.962]                       invisible(muffled)
[15:32:27.962]                     }
[15:32:27.962]                     muffleCondition(cond, pattern = "^muffle")
[15:32:27.962]                   }
[15:32:27.962]                 }
[15:32:27.962]             }
[15:32:27.962]         }))
[15:32:27.962]     }, error = function(ex) {
[15:32:27.962]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:27.962]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:27.962]                 ...future.rng), started = ...future.startTime, 
[15:32:27.962]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:27.962]             version = "1.8"), class = "FutureResult")
[15:32:27.962]     }, finally = {
[15:32:27.962]         if (!identical(...future.workdir, getwd())) 
[15:32:27.962]             setwd(...future.workdir)
[15:32:27.962]         {
[15:32:27.962]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:27.962]                 ...future.oldOptions$nwarnings <- NULL
[15:32:27.962]             }
[15:32:27.962]             base::options(...future.oldOptions)
[15:32:27.962]             if (.Platform$OS.type == "windows") {
[15:32:27.962]                 old_names <- names(...future.oldEnvVars)
[15:32:27.962]                 envs <- base::Sys.getenv()
[15:32:27.962]                 names <- names(envs)
[15:32:27.962]                 common <- intersect(names, old_names)
[15:32:27.962]                 added <- setdiff(names, old_names)
[15:32:27.962]                 removed <- setdiff(old_names, names)
[15:32:27.962]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:27.962]                   envs[common]]
[15:32:27.962]                 NAMES <- toupper(changed)
[15:32:27.962]                 args <- list()
[15:32:27.962]                 for (kk in seq_along(NAMES)) {
[15:32:27.962]                   name <- changed[[kk]]
[15:32:27.962]                   NAME <- NAMES[[kk]]
[15:32:27.962]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:27.962]                     next
[15:32:27.962]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:27.962]                 }
[15:32:27.962]                 NAMES <- toupper(added)
[15:32:27.962]                 for (kk in seq_along(NAMES)) {
[15:32:27.962]                   name <- added[[kk]]
[15:32:27.962]                   NAME <- NAMES[[kk]]
[15:32:27.962]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:27.962]                     next
[15:32:27.962]                   args[[name]] <- ""
[15:32:27.962]                 }
[15:32:27.962]                 NAMES <- toupper(removed)
[15:32:27.962]                 for (kk in seq_along(NAMES)) {
[15:32:27.962]                   name <- removed[[kk]]
[15:32:27.962]                   NAME <- NAMES[[kk]]
[15:32:27.962]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:27.962]                     next
[15:32:27.962]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:27.962]                 }
[15:32:27.962]                 if (length(args) > 0) 
[15:32:27.962]                   base::do.call(base::Sys.setenv, args = args)
[15:32:27.962]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:27.962]             }
[15:32:27.962]             else {
[15:32:27.962]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:27.962]             }
[15:32:27.962]             {
[15:32:27.962]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:27.962]                   0L) {
[15:32:27.962]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:27.962]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:27.962]                   base::options(opts)
[15:32:27.962]                 }
[15:32:27.962]                 {
[15:32:27.962]                   {
[15:32:27.962]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:27.962]                     NULL
[15:32:27.962]                   }
[15:32:27.962]                   options(future.plan = NULL)
[15:32:27.962]                   if (is.na(NA_character_)) 
[15:32:27.962]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:27.962]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:27.962]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:27.962]                     .init = FALSE)
[15:32:27.962]                 }
[15:32:27.962]             }
[15:32:27.962]         }
[15:32:27.962]     })
[15:32:27.962]     if (TRUE) {
[15:32:27.962]         base::sink(type = "output", split = FALSE)
[15:32:27.962]         if (TRUE) {
[15:32:27.962]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:27.962]         }
[15:32:27.962]         else {
[15:32:27.962]             ...future.result["stdout"] <- base::list(NULL)
[15:32:27.962]         }
[15:32:27.962]         base::close(...future.stdout)
[15:32:27.962]         ...future.stdout <- NULL
[15:32:27.962]     }
[15:32:27.962]     ...future.result$conditions <- ...future.conditions
[15:32:27.962]     ...future.result$finished <- base::Sys.time()
[15:32:27.962]     ...future.result
[15:32:27.962] }
[15:32:27.971] Exporting 5 global objects (1.22 KiB) to cluster node #1 ...
[15:32:27.972] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ...
[15:32:27.973] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ... DONE
[15:32:27.973] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:27.974] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:27.974] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ...
[15:32:27.975] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ... DONE
[15:32:27.975] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:27.976] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:27.977] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:27.977] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:27.977] Exporting 5 global objects (1.22 KiB) to cluster node #1 ... DONE
[15:32:27.978] MultisessionFuture started
[15:32:27.979] - Launch lazy future ... done
[15:32:27.979] run() for 'MultisessionFuture' ... done
[15:32:27.979] Created future:
[15:32:28.007] receiveMessageFromWorker() for ClusterFuture ...
[15:32:28.008] - Validating connection of MultisessionFuture
[15:32:28.008] - received message: FutureResult
[15:32:28.009] - Received FutureResult
[15:32:28.009] - Erased future from FutureRegistry
[15:32:28.009] result() for ClusterFuture ...
[15:32:28.009] - result already collected: FutureResult
[15:32:28.010] result() for ClusterFuture ... done
[15:32:28.010] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:27.980] MultisessionFuture:
[15:32:27.980] Label: 'future_sapply-1'
[15:32:27.980] Expression:
[15:32:27.980] {
[15:32:27.980]     do.call(function(...) {
[15:32:27.980]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:27.980]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:27.980]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:27.980]             on.exit(options(oopts), add = TRUE)
[15:32:27.980]         }
[15:32:27.980]         {
[15:32:27.980]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:27.980]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:27.980]                 ...future.FUN(...future.X_jj, ...)
[15:32:27.980]             })
[15:32:27.980]         }
[15:32:27.980]     }, args = future.call.arguments)
[15:32:27.980] }
[15:32:27.980] Lazy evaluation: FALSE
[15:32:27.980] Asynchronous evaluation: TRUE
[15:32:27.980] Local evaluation: TRUE
[15:32:27.980] Environment: R_GlobalEnv
[15:32:27.980] Capture standard output: TRUE
[15:32:27.980] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:27.980] Globals: 5 objects totaling 1.27 KiB (function '...future.FUN' of 1.22 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)
[15:32:27.980] Packages: <none>
[15:32:27.980] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:27.980] Resolved: TRUE
[15:32:27.980] Value: <not collected>
[15:32:27.980] Conditions captured: <none>
[15:32:27.980] Early signaling: FALSE
[15:32:27.980] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:27.980] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:28.011] Chunk #1 of 2 ... DONE
[15:32:28.011] Chunk #2 of 2 ...
[15:32:28.011]  - Finding globals in 'X' for chunk #2 ...
[15:32:28.012] getGlobalsAndPackages() ...
[15:32:28.012] Searching for globals...
[15:32:28.012] 
[15:32:28.013] Searching for globals ... DONE
[15:32:28.013] - globals: [0] <none>
[15:32:28.013] getGlobalsAndPackages() ... DONE
[15:32:28.013]    + additional globals found: [n=0] 
[15:32:28.014]    + additional namespaces needed: [n=0] 
[15:32:28.014]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:28.014]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:28.014]  - seeds: <none>
[15:32:28.015]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:28.015] getGlobalsAndPackages() ...
[15:32:28.015] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:28.016] Resolving globals: FALSE
[15:32:28.016] Tweak future expression to call with '...' arguments ...
[15:32:28.016] {
[15:32:28.016]     do.call(function(...) {
[15:32:28.016]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:28.016]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:28.016]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:28.016]             on.exit(options(oopts), add = TRUE)
[15:32:28.016]         }
[15:32:28.016]         {
[15:32:28.016]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:28.016]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:28.016]                 ...future.FUN(...future.X_jj, ...)
[15:32:28.016]             })
[15:32:28.016]         }
[15:32:28.016]     }, args = future.call.arguments)
[15:32:28.016] }
[15:32:28.017] Tweak future expression to call with '...' arguments ... DONE
[15:32:28.018] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:28.018] 
[15:32:28.018] getGlobalsAndPackages() ... DONE
[15:32:28.019] run() for 'Future' ...
[15:32:28.019] - state: 'created'
[15:32:28.019] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:28.038] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:28.038] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:28.038]   - Field: 'node'
[15:32:28.039]   - Field: 'label'
[15:32:28.039]   - Field: 'local'
[15:32:28.039]   - Field: 'owner'
[15:32:28.040]   - Field: 'envir'
[15:32:28.040]   - Field: 'workers'
[15:32:28.040]   - Field: 'packages'
[15:32:28.041]   - Field: 'gc'
[15:32:28.041]   - Field: 'conditions'
[15:32:28.042]   - Field: 'persistent'
[15:32:28.042]   - Field: 'expr'
[15:32:28.042]   - Field: 'uuid'
[15:32:28.042]   - Field: 'seed'
[15:32:28.043]   - Field: 'version'
[15:32:28.043]   - Field: 'result'
[15:32:28.043]   - Field: 'asynchronous'
[15:32:28.044]   - Field: 'calls'
[15:32:28.044]   - Field: 'globals'
[15:32:28.044]   - Field: 'stdout'
[15:32:28.044]   - Field: 'earlySignal'
[15:32:28.045]   - Field: 'lazy'
[15:32:28.045]   - Field: 'state'
[15:32:28.045] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:28.046] - Launch lazy future ...
[15:32:28.046] Packages needed by the future expression (n = 0): <none>
[15:32:28.046] Packages needed by future strategies (n = 0): <none>
[15:32:28.047] {
[15:32:28.047]     {
[15:32:28.047]         {
[15:32:28.047]             ...future.startTime <- base::Sys.time()
[15:32:28.047]             {
[15:32:28.047]                 {
[15:32:28.047]                   {
[15:32:28.047]                     {
[15:32:28.047]                       base::local({
[15:32:28.047]                         has_future <- base::requireNamespace("future", 
[15:32:28.047]                           quietly = TRUE)
[15:32:28.047]                         if (has_future) {
[15:32:28.047]                           ns <- base::getNamespace("future")
[15:32:28.047]                           version <- ns[[".package"]][["version"]]
[15:32:28.047]                           if (is.null(version)) 
[15:32:28.047]                             version <- utils::packageVersion("future")
[15:32:28.047]                         }
[15:32:28.047]                         else {
[15:32:28.047]                           version <- NULL
[15:32:28.047]                         }
[15:32:28.047]                         if (!has_future || version < "1.8.0") {
[15:32:28.047]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:28.047]                             "", base::R.version$version.string), 
[15:32:28.047]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:28.047]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:28.047]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:28.047]                               "release", "version")], collapse = " "), 
[15:32:28.047]                             hostname = base::Sys.info()[["nodename"]])
[15:32:28.047]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:28.047]                             info)
[15:32:28.047]                           info <- base::paste(info, collapse = "; ")
[15:32:28.047]                           if (!has_future) {
[15:32:28.047]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:28.047]                               info)
[15:32:28.047]                           }
[15:32:28.047]                           else {
[15:32:28.047]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:28.047]                               info, version)
[15:32:28.047]                           }
[15:32:28.047]                           base::stop(msg)
[15:32:28.047]                         }
[15:32:28.047]                       })
[15:32:28.047]                     }
[15:32:28.047]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:28.047]                     base::options(mc.cores = 1L)
[15:32:28.047]                   }
[15:32:28.047]                   ...future.strategy.old <- future::plan("list")
[15:32:28.047]                   options(future.plan = NULL)
[15:32:28.047]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:28.047]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:28.047]                 }
[15:32:28.047]                 ...future.workdir <- getwd()
[15:32:28.047]             }
[15:32:28.047]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:28.047]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:28.047]         }
[15:32:28.047]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:28.047]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:28.047]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:28.047]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:28.047]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:28.047]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:28.047]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:28.047]             base::names(...future.oldOptions))
[15:32:28.047]     }
[15:32:28.047]     if (FALSE) {
[15:32:28.047]     }
[15:32:28.047]     else {
[15:32:28.047]         if (TRUE) {
[15:32:28.047]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:28.047]                 open = "w")
[15:32:28.047]         }
[15:32:28.047]         else {
[15:32:28.047]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:28.047]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:28.047]         }
[15:32:28.047]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:28.047]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:28.047]             base::sink(type = "output", split = FALSE)
[15:32:28.047]             base::close(...future.stdout)
[15:32:28.047]         }, add = TRUE)
[15:32:28.047]     }
[15:32:28.047]     ...future.frame <- base::sys.nframe()
[15:32:28.047]     ...future.conditions <- base::list()
[15:32:28.047]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:28.047]     if (FALSE) {
[15:32:28.047]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:28.047]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:28.047]     }
[15:32:28.047]     ...future.result <- base::tryCatch({
[15:32:28.047]         base::withCallingHandlers({
[15:32:28.047]             ...future.value <- base::withVisible(base::local({
[15:32:28.047]                 ...future.makeSendCondition <- base::local({
[15:32:28.047]                   sendCondition <- NULL
[15:32:28.047]                   function(frame = 1L) {
[15:32:28.047]                     if (is.function(sendCondition)) 
[15:32:28.047]                       return(sendCondition)
[15:32:28.047]                     ns <- getNamespace("parallel")
[15:32:28.047]                     if (exists("sendData", mode = "function", 
[15:32:28.047]                       envir = ns)) {
[15:32:28.047]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:28.047]                         envir = ns)
[15:32:28.047]                       envir <- sys.frame(frame)
[15:32:28.047]                       master <- NULL
[15:32:28.047]                       while (!identical(envir, .GlobalEnv) && 
[15:32:28.047]                         !identical(envir, emptyenv())) {
[15:32:28.047]                         if (exists("master", mode = "list", envir = envir, 
[15:32:28.047]                           inherits = FALSE)) {
[15:32:28.047]                           master <- get("master", mode = "list", 
[15:32:28.047]                             envir = envir, inherits = FALSE)
[15:32:28.047]                           if (inherits(master, c("SOCKnode", 
[15:32:28.047]                             "SOCK0node"))) {
[15:32:28.047]                             sendCondition <<- function(cond) {
[15:32:28.047]                               data <- list(type = "VALUE", value = cond, 
[15:32:28.047]                                 success = TRUE)
[15:32:28.047]                               parallel_sendData(master, data)
[15:32:28.047]                             }
[15:32:28.047]                             return(sendCondition)
[15:32:28.047]                           }
[15:32:28.047]                         }
[15:32:28.047]                         frame <- frame + 1L
[15:32:28.047]                         envir <- sys.frame(frame)
[15:32:28.047]                       }
[15:32:28.047]                     }
[15:32:28.047]                     sendCondition <<- function(cond) NULL
[15:32:28.047]                   }
[15:32:28.047]                 })
[15:32:28.047]                 withCallingHandlers({
[15:32:28.047]                   {
[15:32:28.047]                     do.call(function(...) {
[15:32:28.047]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:28.047]                       if (!identical(...future.globals.maxSize.org, 
[15:32:28.047]                         ...future.globals.maxSize)) {
[15:32:28.047]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:28.047]                         on.exit(options(oopts), add = TRUE)
[15:32:28.047]                       }
[15:32:28.047]                       {
[15:32:28.047]                         lapply(seq_along(...future.elements_ii), 
[15:32:28.047]                           FUN = function(jj) {
[15:32:28.047]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:28.047]                             ...future.FUN(...future.X_jj, ...)
[15:32:28.047]                           })
[15:32:28.047]                       }
[15:32:28.047]                     }, args = future.call.arguments)
[15:32:28.047]                   }
[15:32:28.047]                 }, immediateCondition = function(cond) {
[15:32:28.047]                   sendCondition <- ...future.makeSendCondition()
[15:32:28.047]                   sendCondition(cond)
[15:32:28.047]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:28.047]                   {
[15:32:28.047]                     inherits <- base::inherits
[15:32:28.047]                     invokeRestart <- base::invokeRestart
[15:32:28.047]                     is.null <- base::is.null
[15:32:28.047]                     muffled <- FALSE
[15:32:28.047]                     if (inherits(cond, "message")) {
[15:32:28.047]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:28.047]                       if (muffled) 
[15:32:28.047]                         invokeRestart("muffleMessage")
[15:32:28.047]                     }
[15:32:28.047]                     else if (inherits(cond, "warning")) {
[15:32:28.047]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:28.047]                       if (muffled) 
[15:32:28.047]                         invokeRestart("muffleWarning")
[15:32:28.047]                     }
[15:32:28.047]                     else if (inherits(cond, "condition")) {
[15:32:28.047]                       if (!is.null(pattern)) {
[15:32:28.047]                         computeRestarts <- base::computeRestarts
[15:32:28.047]                         grepl <- base::grepl
[15:32:28.047]                         restarts <- computeRestarts(cond)
[15:32:28.047]                         for (restart in restarts) {
[15:32:28.047]                           name <- restart$name
[15:32:28.047]                           if (is.null(name)) 
[15:32:28.047]                             next
[15:32:28.047]                           if (!grepl(pattern, name)) 
[15:32:28.047]                             next
[15:32:28.047]                           invokeRestart(restart)
[15:32:28.047]                           muffled <- TRUE
[15:32:28.047]                           break
[15:32:28.047]                         }
[15:32:28.047]                       }
[15:32:28.047]                     }
[15:32:28.047]                     invisible(muffled)
[15:32:28.047]                   }
[15:32:28.047]                   muffleCondition(cond)
[15:32:28.047]                 })
[15:32:28.047]             }))
[15:32:28.047]             future::FutureResult(value = ...future.value$value, 
[15:32:28.047]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:28.047]                   ...future.rng), globalenv = if (FALSE) 
[15:32:28.047]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:28.047]                     ...future.globalenv.names))
[15:32:28.047]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:28.047]         }, condition = base::local({
[15:32:28.047]             c <- base::c
[15:32:28.047]             inherits <- base::inherits
[15:32:28.047]             invokeRestart <- base::invokeRestart
[15:32:28.047]             length <- base::length
[15:32:28.047]             list <- base::list
[15:32:28.047]             seq.int <- base::seq.int
[15:32:28.047]             signalCondition <- base::signalCondition
[15:32:28.047]             sys.calls <- base::sys.calls
[15:32:28.047]             `[[` <- base::`[[`
[15:32:28.047]             `+` <- base::`+`
[15:32:28.047]             `<<-` <- base::`<<-`
[15:32:28.047]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:28.047]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:28.047]                   3L)]
[15:32:28.047]             }
[15:32:28.047]             function(cond) {
[15:32:28.047]                 is_error <- inherits(cond, "error")
[15:32:28.047]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:28.047]                   NULL)
[15:32:28.047]                 if (is_error) {
[15:32:28.047]                   sessionInformation <- function() {
[15:32:28.047]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:28.047]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:28.047]                       search = base::search(), system = base::Sys.info())
[15:32:28.047]                   }
[15:32:28.047]                   ...future.conditions[[length(...future.conditions) + 
[15:32:28.047]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:28.047]                     cond$call), session = sessionInformation(), 
[15:32:28.047]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:28.047]                   signalCondition(cond)
[15:32:28.047]                 }
[15:32:28.047]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:28.047]                 "immediateCondition"))) {
[15:32:28.047]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:28.047]                   ...future.conditions[[length(...future.conditions) + 
[15:32:28.047]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:28.047]                   if (TRUE && !signal) {
[15:32:28.047]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:28.047]                     {
[15:32:28.047]                       inherits <- base::inherits
[15:32:28.047]                       invokeRestart <- base::invokeRestart
[15:32:28.047]                       is.null <- base::is.null
[15:32:28.047]                       muffled <- FALSE
[15:32:28.047]                       if (inherits(cond, "message")) {
[15:32:28.047]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:28.047]                         if (muffled) 
[15:32:28.047]                           invokeRestart("muffleMessage")
[15:32:28.047]                       }
[15:32:28.047]                       else if (inherits(cond, "warning")) {
[15:32:28.047]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:28.047]                         if (muffled) 
[15:32:28.047]                           invokeRestart("muffleWarning")
[15:32:28.047]                       }
[15:32:28.047]                       else if (inherits(cond, "condition")) {
[15:32:28.047]                         if (!is.null(pattern)) {
[15:32:28.047]                           computeRestarts <- base::computeRestarts
[15:32:28.047]                           grepl <- base::grepl
[15:32:28.047]                           restarts <- computeRestarts(cond)
[15:32:28.047]                           for (restart in restarts) {
[15:32:28.047]                             name <- restart$name
[15:32:28.047]                             if (is.null(name)) 
[15:32:28.047]                               next
[15:32:28.047]                             if (!grepl(pattern, name)) 
[15:32:28.047]                               next
[15:32:28.047]                             invokeRestart(restart)
[15:32:28.047]                             muffled <- TRUE
[15:32:28.047]                             break
[15:32:28.047]                           }
[15:32:28.047]                         }
[15:32:28.047]                       }
[15:32:28.047]                       invisible(muffled)
[15:32:28.047]                     }
[15:32:28.047]                     muffleCondition(cond, pattern = "^muffle")
[15:32:28.047]                   }
[15:32:28.047]                 }
[15:32:28.047]                 else {
[15:32:28.047]                   if (TRUE) {
[15:32:28.047]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:28.047]                     {
[15:32:28.047]                       inherits <- base::inherits
[15:32:28.047]                       invokeRestart <- base::invokeRestart
[15:32:28.047]                       is.null <- base::is.null
[15:32:28.047]                       muffled <- FALSE
[15:32:28.047]                       if (inherits(cond, "message")) {
[15:32:28.047]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:28.047]                         if (muffled) 
[15:32:28.047]                           invokeRestart("muffleMessage")
[15:32:28.047]                       }
[15:32:28.047]                       else if (inherits(cond, "warning")) {
[15:32:28.047]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:28.047]                         if (muffled) 
[15:32:28.047]                           invokeRestart("muffleWarning")
[15:32:28.047]                       }
[15:32:28.047]                       else if (inherits(cond, "condition")) {
[15:32:28.047]                         if (!is.null(pattern)) {
[15:32:28.047]                           computeRestarts <- base::computeRestarts
[15:32:28.047]                           grepl <- base::grepl
[15:32:28.047]                           restarts <- computeRestarts(cond)
[15:32:28.047]                           for (restart in restarts) {
[15:32:28.047]                             name <- restart$name
[15:32:28.047]                             if (is.null(name)) 
[15:32:28.047]                               next
[15:32:28.047]                             if (!grepl(pattern, name)) 
[15:32:28.047]                               next
[15:32:28.047]                             invokeRestart(restart)
[15:32:28.047]                             muffled <- TRUE
[15:32:28.047]                             break
[15:32:28.047]                           }
[15:32:28.047]                         }
[15:32:28.047]                       }
[15:32:28.047]                       invisible(muffled)
[15:32:28.047]                     }
[15:32:28.047]                     muffleCondition(cond, pattern = "^muffle")
[15:32:28.047]                   }
[15:32:28.047]                 }
[15:32:28.047]             }
[15:32:28.047]         }))
[15:32:28.047]     }, error = function(ex) {
[15:32:28.047]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:28.047]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:28.047]                 ...future.rng), started = ...future.startTime, 
[15:32:28.047]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:28.047]             version = "1.8"), class = "FutureResult")
[15:32:28.047]     }, finally = {
[15:32:28.047]         if (!identical(...future.workdir, getwd())) 
[15:32:28.047]             setwd(...future.workdir)
[15:32:28.047]         {
[15:32:28.047]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:28.047]                 ...future.oldOptions$nwarnings <- NULL
[15:32:28.047]             }
[15:32:28.047]             base::options(...future.oldOptions)
[15:32:28.047]             if (.Platform$OS.type == "windows") {
[15:32:28.047]                 old_names <- names(...future.oldEnvVars)
[15:32:28.047]                 envs <- base::Sys.getenv()
[15:32:28.047]                 names <- names(envs)
[15:32:28.047]                 common <- intersect(names, old_names)
[15:32:28.047]                 added <- setdiff(names, old_names)
[15:32:28.047]                 removed <- setdiff(old_names, names)
[15:32:28.047]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:28.047]                   envs[common]]
[15:32:28.047]                 NAMES <- toupper(changed)
[15:32:28.047]                 args <- list()
[15:32:28.047]                 for (kk in seq_along(NAMES)) {
[15:32:28.047]                   name <- changed[[kk]]
[15:32:28.047]                   NAME <- NAMES[[kk]]
[15:32:28.047]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:28.047]                     next
[15:32:28.047]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:28.047]                 }
[15:32:28.047]                 NAMES <- toupper(added)
[15:32:28.047]                 for (kk in seq_along(NAMES)) {
[15:32:28.047]                   name <- added[[kk]]
[15:32:28.047]                   NAME <- NAMES[[kk]]
[15:32:28.047]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:28.047]                     next
[15:32:28.047]                   args[[name]] <- ""
[15:32:28.047]                 }
[15:32:28.047]                 NAMES <- toupper(removed)
[15:32:28.047]                 for (kk in seq_along(NAMES)) {
[15:32:28.047]                   name <- removed[[kk]]
[15:32:28.047]                   NAME <- NAMES[[kk]]
[15:32:28.047]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:28.047]                     next
[15:32:28.047]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:28.047]                 }
[15:32:28.047]                 if (length(args) > 0) 
[15:32:28.047]                   base::do.call(base::Sys.setenv, args = args)
[15:32:28.047]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:28.047]             }
[15:32:28.047]             else {
[15:32:28.047]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:28.047]             }
[15:32:28.047]             {
[15:32:28.047]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:28.047]                   0L) {
[15:32:28.047]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:28.047]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:28.047]                   base::options(opts)
[15:32:28.047]                 }
[15:32:28.047]                 {
[15:32:28.047]                   {
[15:32:28.047]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:28.047]                     NULL
[15:32:28.047]                   }
[15:32:28.047]                   options(future.plan = NULL)
[15:32:28.047]                   if (is.na(NA_character_)) 
[15:32:28.047]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:28.047]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:28.047]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:28.047]                     .init = FALSE)
[15:32:28.047]                 }
[15:32:28.047]             }
[15:32:28.047]         }
[15:32:28.047]     })
[15:32:28.047]     if (TRUE) {
[15:32:28.047]         base::sink(type = "output", split = FALSE)
[15:32:28.047]         if (TRUE) {
[15:32:28.047]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:28.047]         }
[15:32:28.047]         else {
[15:32:28.047]             ...future.result["stdout"] <- base::list(NULL)
[15:32:28.047]         }
[15:32:28.047]         base::close(...future.stdout)
[15:32:28.047]         ...future.stdout <- NULL
[15:32:28.047]     }
[15:32:28.047]     ...future.result$conditions <- ...future.conditions
[15:32:28.047]     ...future.result$finished <- base::Sys.time()
[15:32:28.047]     ...future.result
[15:32:28.047] }
[15:32:28.055] Exporting 5 global objects (1.22 KiB) to cluster node #1 ...
[15:32:28.056] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ...
[15:32:28.057] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ... DONE
[15:32:28.057] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:28.058] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:28.058] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:28.059] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:28.059] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:28.060] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:28.060] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:28.061] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:28.061] Exporting 5 global objects (1.22 KiB) to cluster node #1 ... DONE
[15:32:28.062] MultisessionFuture started
[15:32:28.062] - Launch lazy future ... done
[15:32:28.062] run() for 'MultisessionFuture' ... done
[15:32:28.063] Created future:
[15:32:28.086] receiveMessageFromWorker() for ClusterFuture ...
[15:32:28.086] - Validating connection of MultisessionFuture
[15:32:28.087] - received message: FutureResult
[15:32:28.087] - Received FutureResult
[15:32:28.087] - Erased future from FutureRegistry
[15:32:28.088] result() for ClusterFuture ...
[15:32:28.088] - result already collected: FutureResult
[15:32:28.088] result() for ClusterFuture ... done
[15:32:28.088] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:28.063] MultisessionFuture:
[15:32:28.063] Label: 'future_sapply-2'
[15:32:28.063] Expression:
[15:32:28.063] {
[15:32:28.063]     do.call(function(...) {
[15:32:28.063]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:28.063]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:28.063]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:28.063]             on.exit(options(oopts), add = TRUE)
[15:32:28.063]         }
[15:32:28.063]         {
[15:32:28.063]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:28.063]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:28.063]                 ...future.FUN(...future.X_jj, ...)
[15:32:28.063]             })
[15:32:28.063]         }
[15:32:28.063]     }, args = future.call.arguments)
[15:32:28.063] }
[15:32:28.063] Lazy evaluation: FALSE
[15:32:28.063] Asynchronous evaluation: TRUE
[15:32:28.063] Local evaluation: TRUE
[15:32:28.063] Environment: R_GlobalEnv
[15:32:28.063] Capture standard output: TRUE
[15:32:28.063] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:28.063] Globals: 5 objects totaling 1.33 KiB (function '...future.FUN' of 1.22 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)
[15:32:28.063] Packages: <none>
[15:32:28.063] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:28.063] Resolved: TRUE
[15:32:28.063] Value: <not collected>
[15:32:28.063] Conditions captured: <none>
[15:32:28.063] Early signaling: FALSE
[15:32:28.063] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:28.063] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:28.089] Chunk #2 of 2 ... DONE
[15:32:28.089] Launching 2 futures (chunks) ... DONE
[15:32:28.090] Resolving 2 futures (chunks) ...
[15:32:28.090] resolve() on list ...
[15:32:28.090]  recursive: 0
[15:32:28.090]  length: 2
[15:32:28.091] 
[15:32:28.091] Future #1
[15:32:28.091] result() for ClusterFuture ...
[15:32:28.091] - result already collected: FutureResult
[15:32:28.092] result() for ClusterFuture ... done
[15:32:28.092] result() for ClusterFuture ...
[15:32:28.092] - result already collected: FutureResult
[15:32:28.092] result() for ClusterFuture ... done
[15:32:28.093] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:28.093] - nx: 2
[15:32:28.093] - relay: TRUE
[15:32:28.094] - stdout: TRUE
[15:32:28.094] - signal: TRUE
[15:32:28.094] - resignal: FALSE
[15:32:28.094] - force: TRUE
[15:32:28.094] - relayed: [n=2] FALSE, FALSE
[15:32:28.095] - queued futures: [n=2] FALSE, FALSE
[15:32:28.095]  - until=1
[15:32:28.095]  - relaying element #1
[15:32:28.096] result() for ClusterFuture ...
[15:32:28.096] - result already collected: FutureResult
[15:32:28.096] result() for ClusterFuture ... done
[15:32:28.096] result() for ClusterFuture ...
[15:32:28.097] - result already collected: FutureResult
[15:32:28.097] result() for ClusterFuture ... done
[15:32:28.097] result() for ClusterFuture ...
[15:32:28.097] - result already collected: FutureResult
[15:32:28.098] result() for ClusterFuture ... done
[15:32:28.098] result() for ClusterFuture ...
[15:32:28.098] - result already collected: FutureResult
[15:32:28.098] result() for ClusterFuture ... done
[15:32:28.099] - relayed: [n=2] TRUE, FALSE
[15:32:28.099] - queued futures: [n=2] TRUE, FALSE
[15:32:28.099] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:28.099]  length: 1 (resolved future 1)
[15:32:28.100] Future #2
[15:32:28.100] result() for ClusterFuture ...
[15:32:28.100] - result already collected: FutureResult
[15:32:28.100] result() for ClusterFuture ... done
[15:32:28.101] result() for ClusterFuture ...
[15:32:28.101] - result already collected: FutureResult
[15:32:28.101] result() for ClusterFuture ... done
[15:32:28.102] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:28.102] - nx: 2
[15:32:28.102] - relay: TRUE
[15:32:28.102] - stdout: TRUE
[15:32:28.103] - signal: TRUE
[15:32:28.103] - resignal: FALSE
[15:32:28.103] - force: TRUE
[15:32:28.103] - relayed: [n=2] TRUE, FALSE
[15:32:28.103] - queued futures: [n=2] TRUE, FALSE
[15:32:28.104]  - until=2
[15:32:28.104]  - relaying element #2
[15:32:28.104] result() for ClusterFuture ...
[15:32:28.104] - result already collected: FutureResult
[15:32:28.105] result() for ClusterFuture ... done
[15:32:28.105] result() for ClusterFuture ...
[15:32:28.105] - result already collected: FutureResult
[15:32:28.105] result() for ClusterFuture ... done
[15:32:28.106] result() for ClusterFuture ...
[15:32:28.106] - result already collected: FutureResult
[15:32:28.106] result() for ClusterFuture ... done
[15:32:28.107] result() for ClusterFuture ...
[15:32:28.107] - result already collected: FutureResult
[15:32:28.107] result() for ClusterFuture ... done
[15:32:28.107] - relayed: [n=2] TRUE, TRUE
[15:32:28.108] - queued futures: [n=2] TRUE, TRUE
[15:32:28.108] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:28.108]  length: 0 (resolved future 2)
[15:32:28.108] Relaying remaining futures
[15:32:28.109] signalConditionsASAP(NULL, pos=0) ...
[15:32:28.109] - nx: 2
[15:32:28.109] - relay: TRUE
[15:32:28.109] - stdout: TRUE
[15:32:28.110] - signal: TRUE
[15:32:28.110] - resignal: FALSE
[15:32:28.110] - force: TRUE
[15:32:28.110] - relayed: [n=2] TRUE, TRUE
[15:32:28.111] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:28.111] - relayed: [n=2] TRUE, TRUE
[15:32:28.111] - queued futures: [n=2] TRUE, TRUE
[15:32:28.112] signalConditionsASAP(NULL, pos=0) ... done
[15:32:28.112] resolve() on list ... DONE
[15:32:28.112] result() for ClusterFuture ...
[15:32:28.112] - result already collected: FutureResult
[15:32:28.112] result() for ClusterFuture ... done
[15:32:28.113] result() for ClusterFuture ...
[15:32:28.113] - result already collected: FutureResult
[15:32:28.113] result() for ClusterFuture ... done
[15:32:28.114] result() for ClusterFuture ...
[15:32:28.114] - result already collected: FutureResult
[15:32:28.114] result() for ClusterFuture ... done
[15:32:28.114] result() for ClusterFuture ...
[15:32:28.114] - result already collected: FutureResult
[15:32:28.115] result() for ClusterFuture ... done
[15:32:28.115]  - Number of value chunks collected: 2
[15:32:28.115] Resolving 2 futures (chunks) ... DONE
[15:32:28.115] Reducing values from 2 chunks ...
[15:32:28.116]  - Number of values collected after concatenation: 3
[15:32:28.116]  - Number of values expected: 3
[15:32:28.116] Reducing values from 2 chunks ... DONE
[15:32:28.116] future_lapply() ... DONE
List of 2
 $ y0: Named num [1:3] 1 2 3
  ..- attr(*, "names")= chr [1:3] "a" "b" "c"
 $ y1: Named num [1:3] 1 2 3
  ..- attr(*, "names")= chr [1:3] "a" "b" "c"
[15:32:28.120] future_lapply() ...
[15:32:28.125] Number of chunks: 2
[15:32:28.125] getGlobalsAndPackagesXApply() ...
[15:32:28.125]  - future.globals: TRUE
[15:32:28.125] getGlobalsAndPackages() ...
[15:32:28.126] Searching for globals...
[15:32:28.129] - globals found: [5] 'FUN', '*', ':', 'outer', 'rep'
[15:32:28.129] Searching for globals ... DONE
[15:32:28.129] Resolving globals: FALSE
[15:32:28.130] The total size of the 1 globals is 4.62 KiB (4728 bytes)
[15:32:28.131] The total size of the 1 globals exported for future expression ('FUN()') is 4.62 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.62 KiB of class 'function')
[15:32:28.131] - globals: [1] 'FUN'
[15:32:28.132] 
[15:32:28.132] getGlobalsAndPackages() ... DONE
[15:32:28.132]  - globals found/used: [n=1] 'FUN'
[15:32:28.132]  - needed namespaces: [n=0] 
[15:32:28.133] Finding globals ... DONE
[15:32:28.133]  - use_args: TRUE
[15:32:28.133]  - Getting '...' globals ...
[15:32:28.134] resolve() on list ...
[15:32:28.134]  recursive: 0
[15:32:28.134]  length: 1
[15:32:28.135]  elements: '...'
[15:32:28.135]  length: 0 (resolved future 1)
[15:32:28.135] resolve() on list ... DONE
[15:32:28.136]    - '...' content: [n=0] 
[15:32:28.136] List of 1
[15:32:28.136]  $ ...: list()
[15:32:28.136]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:28.136]  - attr(*, "where")=List of 1
[15:32:28.136]   ..$ ...:<environment: 0x00000276e528bed0> 
[15:32:28.136]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:28.136]  - attr(*, "resolved")= logi TRUE
[15:32:28.136]  - attr(*, "total_size")= num NA
[15:32:28.140]  - Getting '...' globals ... DONE
[15:32:28.141] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:28.141] List of 2
[15:32:28.141]  $ ...future.FUN:function (x, y = 2 * 1:5)  
[15:32:28.141]  $ ...          : list()
[15:32:28.141]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:28.141]  - attr(*, "where")=List of 2
[15:32:28.141]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:28.141]   ..$ ...          :<environment: 0x00000276e528bed0> 
[15:32:28.141]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:28.141]  - attr(*, "resolved")= logi FALSE
[15:32:28.141]  - attr(*, "total_size")= num 4728
[15:32:28.146] Packages to be attached in all futures: [n=0] 
[15:32:28.146] getGlobalsAndPackagesXApply() ... DONE
[15:32:28.147] Number of futures (= number of chunks): 2
[15:32:28.147] Launching 2 futures (chunks) ...
[15:32:28.147] Chunk #1 of 2 ...
[15:32:28.148]  - Finding globals in 'X' for chunk #1 ...
[15:32:28.148] getGlobalsAndPackages() ...
[15:32:28.148] Searching for globals...
[15:32:28.149] 
[15:32:28.149] Searching for globals ... DONE
[15:32:28.149] - globals: [0] <none>
[15:32:28.150] getGlobalsAndPackages() ... DONE
[15:32:28.150]    + additional globals found: [n=0] 
[15:32:28.150]    + additional namespaces needed: [n=0] 
[15:32:28.150]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:28.151]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:28.151]  - seeds: <none>
[15:32:28.151]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:28.152] getGlobalsAndPackages() ...
[15:32:28.152] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:28.152] Resolving globals: FALSE
[15:32:28.152] Tweak future expression to call with '...' arguments ...
[15:32:28.153] {
[15:32:28.153]     do.call(function(...) {
[15:32:28.153]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:28.153]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:28.153]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:28.153]             on.exit(options(oopts), add = TRUE)
[15:32:28.153]         }
[15:32:28.153]         {
[15:32:28.153]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:28.153]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:28.153]                 ...future.FUN(...future.X_jj, ...)
[15:32:28.153]             })
[15:32:28.153]         }
[15:32:28.153]     }, args = future.call.arguments)
[15:32:28.153] }
[15:32:28.153] Tweak future expression to call with '...' arguments ... DONE
[15:32:28.154] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:28.155] 
[15:32:28.155] getGlobalsAndPackages() ... DONE
[15:32:28.155] run() for 'Future' ...
[15:32:28.156] - state: 'created'
[15:32:28.156] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:28.173] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:28.174] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:28.174]   - Field: 'node'
[15:32:28.174]   - Field: 'label'
[15:32:28.174]   - Field: 'local'
[15:32:28.174]   - Field: 'owner'
[15:32:28.175]   - Field: 'envir'
[15:32:28.175]   - Field: 'workers'
[15:32:28.175]   - Field: 'packages'
[15:32:28.175]   - Field: 'gc'
[15:32:28.175]   - Field: 'conditions'
[15:32:28.176]   - Field: 'persistent'
[15:32:28.176]   - Field: 'expr'
[15:32:28.176]   - Field: 'uuid'
[15:32:28.176]   - Field: 'seed'
[15:32:28.176]   - Field: 'version'
[15:32:28.177]   - Field: 'result'
[15:32:28.177]   - Field: 'asynchronous'
[15:32:28.177]   - Field: 'calls'
[15:32:28.177]   - Field: 'globals'
[15:32:28.177]   - Field: 'stdout'
[15:32:28.178]   - Field: 'earlySignal'
[15:32:28.178]   - Field: 'lazy'
[15:32:28.178]   - Field: 'state'
[15:32:28.178] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:28.178] - Launch lazy future ...
[15:32:28.179] Packages needed by the future expression (n = 0): <none>
[15:32:28.179] Packages needed by future strategies (n = 0): <none>
[15:32:28.179] {
[15:32:28.179]     {
[15:32:28.179]         {
[15:32:28.179]             ...future.startTime <- base::Sys.time()
[15:32:28.179]             {
[15:32:28.179]                 {
[15:32:28.179]                   {
[15:32:28.179]                     {
[15:32:28.179]                       base::local({
[15:32:28.179]                         has_future <- base::requireNamespace("future", 
[15:32:28.179]                           quietly = TRUE)
[15:32:28.179]                         if (has_future) {
[15:32:28.179]                           ns <- base::getNamespace("future")
[15:32:28.179]                           version <- ns[[".package"]][["version"]]
[15:32:28.179]                           if (is.null(version)) 
[15:32:28.179]                             version <- utils::packageVersion("future")
[15:32:28.179]                         }
[15:32:28.179]                         else {
[15:32:28.179]                           version <- NULL
[15:32:28.179]                         }
[15:32:28.179]                         if (!has_future || version < "1.8.0") {
[15:32:28.179]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:28.179]                             "", base::R.version$version.string), 
[15:32:28.179]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:28.179]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:28.179]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:28.179]                               "release", "version")], collapse = " "), 
[15:32:28.179]                             hostname = base::Sys.info()[["nodename"]])
[15:32:28.179]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:28.179]                             info)
[15:32:28.179]                           info <- base::paste(info, collapse = "; ")
[15:32:28.179]                           if (!has_future) {
[15:32:28.179]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:28.179]                               info)
[15:32:28.179]                           }
[15:32:28.179]                           else {
[15:32:28.179]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:28.179]                               info, version)
[15:32:28.179]                           }
[15:32:28.179]                           base::stop(msg)
[15:32:28.179]                         }
[15:32:28.179]                       })
[15:32:28.179]                     }
[15:32:28.179]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:28.179]                     base::options(mc.cores = 1L)
[15:32:28.179]                   }
[15:32:28.179]                   ...future.strategy.old <- future::plan("list")
[15:32:28.179]                   options(future.plan = NULL)
[15:32:28.179]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:28.179]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:28.179]                 }
[15:32:28.179]                 ...future.workdir <- getwd()
[15:32:28.179]             }
[15:32:28.179]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:28.179]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:28.179]         }
[15:32:28.179]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:28.179]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:28.179]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:28.179]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:28.179]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:28.179]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:28.179]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:28.179]             base::names(...future.oldOptions))
[15:32:28.179]     }
[15:32:28.179]     if (FALSE) {
[15:32:28.179]     }
[15:32:28.179]     else {
[15:32:28.179]         if (TRUE) {
[15:32:28.179]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:28.179]                 open = "w")
[15:32:28.179]         }
[15:32:28.179]         else {
[15:32:28.179]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:28.179]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:28.179]         }
[15:32:28.179]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:28.179]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:28.179]             base::sink(type = "output", split = FALSE)
[15:32:28.179]             base::close(...future.stdout)
[15:32:28.179]         }, add = TRUE)
[15:32:28.179]     }
[15:32:28.179]     ...future.frame <- base::sys.nframe()
[15:32:28.179]     ...future.conditions <- base::list()
[15:32:28.179]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:28.179]     if (FALSE) {
[15:32:28.179]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:28.179]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:28.179]     }
[15:32:28.179]     ...future.result <- base::tryCatch({
[15:32:28.179]         base::withCallingHandlers({
[15:32:28.179]             ...future.value <- base::withVisible(base::local({
[15:32:28.179]                 ...future.makeSendCondition <- base::local({
[15:32:28.179]                   sendCondition <- NULL
[15:32:28.179]                   function(frame = 1L) {
[15:32:28.179]                     if (is.function(sendCondition)) 
[15:32:28.179]                       return(sendCondition)
[15:32:28.179]                     ns <- getNamespace("parallel")
[15:32:28.179]                     if (exists("sendData", mode = "function", 
[15:32:28.179]                       envir = ns)) {
[15:32:28.179]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:28.179]                         envir = ns)
[15:32:28.179]                       envir <- sys.frame(frame)
[15:32:28.179]                       master <- NULL
[15:32:28.179]                       while (!identical(envir, .GlobalEnv) && 
[15:32:28.179]                         !identical(envir, emptyenv())) {
[15:32:28.179]                         if (exists("master", mode = "list", envir = envir, 
[15:32:28.179]                           inherits = FALSE)) {
[15:32:28.179]                           master <- get("master", mode = "list", 
[15:32:28.179]                             envir = envir, inherits = FALSE)
[15:32:28.179]                           if (inherits(master, c("SOCKnode", 
[15:32:28.179]                             "SOCK0node"))) {
[15:32:28.179]                             sendCondition <<- function(cond) {
[15:32:28.179]                               data <- list(type = "VALUE", value = cond, 
[15:32:28.179]                                 success = TRUE)
[15:32:28.179]                               parallel_sendData(master, data)
[15:32:28.179]                             }
[15:32:28.179]                             return(sendCondition)
[15:32:28.179]                           }
[15:32:28.179]                         }
[15:32:28.179]                         frame <- frame + 1L
[15:32:28.179]                         envir <- sys.frame(frame)
[15:32:28.179]                       }
[15:32:28.179]                     }
[15:32:28.179]                     sendCondition <<- function(cond) NULL
[15:32:28.179]                   }
[15:32:28.179]                 })
[15:32:28.179]                 withCallingHandlers({
[15:32:28.179]                   {
[15:32:28.179]                     do.call(function(...) {
[15:32:28.179]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:28.179]                       if (!identical(...future.globals.maxSize.org, 
[15:32:28.179]                         ...future.globals.maxSize)) {
[15:32:28.179]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:28.179]                         on.exit(options(oopts), add = TRUE)
[15:32:28.179]                       }
[15:32:28.179]                       {
[15:32:28.179]                         lapply(seq_along(...future.elements_ii), 
[15:32:28.179]                           FUN = function(jj) {
[15:32:28.179]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:28.179]                             ...future.FUN(...future.X_jj, ...)
[15:32:28.179]                           })
[15:32:28.179]                       }
[15:32:28.179]                     }, args = future.call.arguments)
[15:32:28.179]                   }
[15:32:28.179]                 }, immediateCondition = function(cond) {
[15:32:28.179]                   sendCondition <- ...future.makeSendCondition()
[15:32:28.179]                   sendCondition(cond)
[15:32:28.179]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:28.179]                   {
[15:32:28.179]                     inherits <- base::inherits
[15:32:28.179]                     invokeRestart <- base::invokeRestart
[15:32:28.179]                     is.null <- base::is.null
[15:32:28.179]                     muffled <- FALSE
[15:32:28.179]                     if (inherits(cond, "message")) {
[15:32:28.179]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:28.179]                       if (muffled) 
[15:32:28.179]                         invokeRestart("muffleMessage")
[15:32:28.179]                     }
[15:32:28.179]                     else if (inherits(cond, "warning")) {
[15:32:28.179]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:28.179]                       if (muffled) 
[15:32:28.179]                         invokeRestart("muffleWarning")
[15:32:28.179]                     }
[15:32:28.179]                     else if (inherits(cond, "condition")) {
[15:32:28.179]                       if (!is.null(pattern)) {
[15:32:28.179]                         computeRestarts <- base::computeRestarts
[15:32:28.179]                         grepl <- base::grepl
[15:32:28.179]                         restarts <- computeRestarts(cond)
[15:32:28.179]                         for (restart in restarts) {
[15:32:28.179]                           name <- restart$name
[15:32:28.179]                           if (is.null(name)) 
[15:32:28.179]                             next
[15:32:28.179]                           if (!grepl(pattern, name)) 
[15:32:28.179]                             next
[15:32:28.179]                           invokeRestart(restart)
[15:32:28.179]                           muffled <- TRUE
[15:32:28.179]                           break
[15:32:28.179]                         }
[15:32:28.179]                       }
[15:32:28.179]                     }
[15:32:28.179]                     invisible(muffled)
[15:32:28.179]                   }
[15:32:28.179]                   muffleCondition(cond)
[15:32:28.179]                 })
[15:32:28.179]             }))
[15:32:28.179]             future::FutureResult(value = ...future.value$value, 
[15:32:28.179]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:28.179]                   ...future.rng), globalenv = if (FALSE) 
[15:32:28.179]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:28.179]                     ...future.globalenv.names))
[15:32:28.179]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:28.179]         }, condition = base::local({
[15:32:28.179]             c <- base::c
[15:32:28.179]             inherits <- base::inherits
[15:32:28.179]             invokeRestart <- base::invokeRestart
[15:32:28.179]             length <- base::length
[15:32:28.179]             list <- base::list
[15:32:28.179]             seq.int <- base::seq.int
[15:32:28.179]             signalCondition <- base::signalCondition
[15:32:28.179]             sys.calls <- base::sys.calls
[15:32:28.179]             `[[` <- base::`[[`
[15:32:28.179]             `+` <- base::`+`
[15:32:28.179]             `<<-` <- base::`<<-`
[15:32:28.179]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:28.179]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:28.179]                   3L)]
[15:32:28.179]             }
[15:32:28.179]             function(cond) {
[15:32:28.179]                 is_error <- inherits(cond, "error")
[15:32:28.179]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:28.179]                   NULL)
[15:32:28.179]                 if (is_error) {
[15:32:28.179]                   sessionInformation <- function() {
[15:32:28.179]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:28.179]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:28.179]                       search = base::search(), system = base::Sys.info())
[15:32:28.179]                   }
[15:32:28.179]                   ...future.conditions[[length(...future.conditions) + 
[15:32:28.179]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:28.179]                     cond$call), session = sessionInformation(), 
[15:32:28.179]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:28.179]                   signalCondition(cond)
[15:32:28.179]                 }
[15:32:28.179]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:28.179]                 "immediateCondition"))) {
[15:32:28.179]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:28.179]                   ...future.conditions[[length(...future.conditions) + 
[15:32:28.179]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:28.179]                   if (TRUE && !signal) {
[15:32:28.179]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:28.179]                     {
[15:32:28.179]                       inherits <- base::inherits
[15:32:28.179]                       invokeRestart <- base::invokeRestart
[15:32:28.179]                       is.null <- base::is.null
[15:32:28.179]                       muffled <- FALSE
[15:32:28.179]                       if (inherits(cond, "message")) {
[15:32:28.179]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:28.179]                         if (muffled) 
[15:32:28.179]                           invokeRestart("muffleMessage")
[15:32:28.179]                       }
[15:32:28.179]                       else if (inherits(cond, "warning")) {
[15:32:28.179]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:28.179]                         if (muffled) 
[15:32:28.179]                           invokeRestart("muffleWarning")
[15:32:28.179]                       }
[15:32:28.179]                       else if (inherits(cond, "condition")) {
[15:32:28.179]                         if (!is.null(pattern)) {
[15:32:28.179]                           computeRestarts <- base::computeRestarts
[15:32:28.179]                           grepl <- base::grepl
[15:32:28.179]                           restarts <- computeRestarts(cond)
[15:32:28.179]                           for (restart in restarts) {
[15:32:28.179]                             name <- restart$name
[15:32:28.179]                             if (is.null(name)) 
[15:32:28.179]                               next
[15:32:28.179]                             if (!grepl(pattern, name)) 
[15:32:28.179]                               next
[15:32:28.179]                             invokeRestart(restart)
[15:32:28.179]                             muffled <- TRUE
[15:32:28.179]                             break
[15:32:28.179]                           }
[15:32:28.179]                         }
[15:32:28.179]                       }
[15:32:28.179]                       invisible(muffled)
[15:32:28.179]                     }
[15:32:28.179]                     muffleCondition(cond, pattern = "^muffle")
[15:32:28.179]                   }
[15:32:28.179]                 }
[15:32:28.179]                 else {
[15:32:28.179]                   if (TRUE) {
[15:32:28.179]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:28.179]                     {
[15:32:28.179]                       inherits <- base::inherits
[15:32:28.179]                       invokeRestart <- base::invokeRestart
[15:32:28.179]                       is.null <- base::is.null
[15:32:28.179]                       muffled <- FALSE
[15:32:28.179]                       if (inherits(cond, "message")) {
[15:32:28.179]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:28.179]                         if (muffled) 
[15:32:28.179]                           invokeRestart("muffleMessage")
[15:32:28.179]                       }
[15:32:28.179]                       else if (inherits(cond, "warning")) {
[15:32:28.179]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:28.179]                         if (muffled) 
[15:32:28.179]                           invokeRestart("muffleWarning")
[15:32:28.179]                       }
[15:32:28.179]                       else if (inherits(cond, "condition")) {
[15:32:28.179]                         if (!is.null(pattern)) {
[15:32:28.179]                           computeRestarts <- base::computeRestarts
[15:32:28.179]                           grepl <- base::grepl
[15:32:28.179]                           restarts <- computeRestarts(cond)
[15:32:28.179]                           for (restart in restarts) {
[15:32:28.179]                             name <- restart$name
[15:32:28.179]                             if (is.null(name)) 
[15:32:28.179]                               next
[15:32:28.179]                             if (!grepl(pattern, name)) 
[15:32:28.179]                               next
[15:32:28.179]                             invokeRestart(restart)
[15:32:28.179]                             muffled <- TRUE
[15:32:28.179]                             break
[15:32:28.179]                           }
[15:32:28.179]                         }
[15:32:28.179]                       }
[15:32:28.179]                       invisible(muffled)
[15:32:28.179]                     }
[15:32:28.179]                     muffleCondition(cond, pattern = "^muffle")
[15:32:28.179]                   }
[15:32:28.179]                 }
[15:32:28.179]             }
[15:32:28.179]         }))
[15:32:28.179]     }, error = function(ex) {
[15:32:28.179]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:28.179]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:28.179]                 ...future.rng), started = ...future.startTime, 
[15:32:28.179]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:28.179]             version = "1.8"), class = "FutureResult")
[15:32:28.179]     }, finally = {
[15:32:28.179]         if (!identical(...future.workdir, getwd())) 
[15:32:28.179]             setwd(...future.workdir)
[15:32:28.179]         {
[15:32:28.179]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:28.179]                 ...future.oldOptions$nwarnings <- NULL
[15:32:28.179]             }
[15:32:28.179]             base::options(...future.oldOptions)
[15:32:28.179]             if (.Platform$OS.type == "windows") {
[15:32:28.179]                 old_names <- names(...future.oldEnvVars)
[15:32:28.179]                 envs <- base::Sys.getenv()
[15:32:28.179]                 names <- names(envs)
[15:32:28.179]                 common <- intersect(names, old_names)
[15:32:28.179]                 added <- setdiff(names, old_names)
[15:32:28.179]                 removed <- setdiff(old_names, names)
[15:32:28.179]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:28.179]                   envs[common]]
[15:32:28.179]                 NAMES <- toupper(changed)
[15:32:28.179]                 args <- list()
[15:32:28.179]                 for (kk in seq_along(NAMES)) {
[15:32:28.179]                   name <- changed[[kk]]
[15:32:28.179]                   NAME <- NAMES[[kk]]
[15:32:28.179]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:28.179]                     next
[15:32:28.179]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:28.179]                 }
[15:32:28.179]                 NAMES <- toupper(added)
[15:32:28.179]                 for (kk in seq_along(NAMES)) {
[15:32:28.179]                   name <- added[[kk]]
[15:32:28.179]                   NAME <- NAMES[[kk]]
[15:32:28.179]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:28.179]                     next
[15:32:28.179]                   args[[name]] <- ""
[15:32:28.179]                 }
[15:32:28.179]                 NAMES <- toupper(removed)
[15:32:28.179]                 for (kk in seq_along(NAMES)) {
[15:32:28.179]                   name <- removed[[kk]]
[15:32:28.179]                   NAME <- NAMES[[kk]]
[15:32:28.179]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:28.179]                     next
[15:32:28.179]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:28.179]                 }
[15:32:28.179]                 if (length(args) > 0) 
[15:32:28.179]                   base::do.call(base::Sys.setenv, args = args)
[15:32:28.179]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:28.179]             }
[15:32:28.179]             else {
[15:32:28.179]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:28.179]             }
[15:32:28.179]             {
[15:32:28.179]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:28.179]                   0L) {
[15:32:28.179]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:28.179]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:28.179]                   base::options(opts)
[15:32:28.179]                 }
[15:32:28.179]                 {
[15:32:28.179]                   {
[15:32:28.179]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:28.179]                     NULL
[15:32:28.179]                   }
[15:32:28.179]                   options(future.plan = NULL)
[15:32:28.179]                   if (is.na(NA_character_)) 
[15:32:28.179]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:28.179]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:28.179]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:28.179]                     .init = FALSE)
[15:32:28.179]                 }
[15:32:28.179]             }
[15:32:28.179]         }
[15:32:28.179]     })
[15:32:28.179]     if (TRUE) {
[15:32:28.179]         base::sink(type = "output", split = FALSE)
[15:32:28.179]         if (TRUE) {
[15:32:28.179]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:28.179]         }
[15:32:28.179]         else {
[15:32:28.179]             ...future.result["stdout"] <- base::list(NULL)
[15:32:28.179]         }
[15:32:28.179]         base::close(...future.stdout)
[15:32:28.179]         ...future.stdout <- NULL
[15:32:28.179]     }
[15:32:28.179]     ...future.result$conditions <- ...future.conditions
[15:32:28.179]     ...future.result$finished <- base::Sys.time()
[15:32:28.179]     ...future.result
[15:32:28.179] }
[15:32:28.185] Exporting 5 global objects (4.62 KiB) to cluster node #1 ...
[15:32:28.185] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ...
[15:32:28.186] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ... DONE
[15:32:28.186] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:28.187] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:28.187] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ...
[15:32:28.187] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ... DONE
[15:32:28.188] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:28.188] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:28.188] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:28.189] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:28.189] Exporting 5 global objects (4.62 KiB) to cluster node #1 ... DONE
[15:32:28.190] MultisessionFuture started
[15:32:28.190] - Launch lazy future ... done
[15:32:28.192] run() for 'MultisessionFuture' ... done
[15:32:28.192] Created future:
[15:32:28.215] receiveMessageFromWorker() for ClusterFuture ...
[15:32:28.216] - Validating connection of MultisessionFuture
[15:32:28.217] - received message: FutureResult
[15:32:28.217] - Received FutureResult
[15:32:28.217] - Erased future from FutureRegistry
[15:32:28.218] result() for ClusterFuture ...
[15:32:28.218] - result already collected: FutureResult
[15:32:28.218] result() for ClusterFuture ... done
[15:32:28.218] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:28.192] MultisessionFuture:
[15:32:28.192] Label: 'future_sapply-1'
[15:32:28.192] Expression:
[15:32:28.192] {
[15:32:28.192]     do.call(function(...) {
[15:32:28.192]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:28.192]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:28.192]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:28.192]             on.exit(options(oopts), add = TRUE)
[15:32:28.192]         }
[15:32:28.192]         {
[15:32:28.192]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:28.192]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:28.192]                 ...future.FUN(...future.X_jj, ...)
[15:32:28.192]             })
[15:32:28.192]         }
[15:32:28.192]     }, args = future.call.arguments)
[15:32:28.192] }
[15:32:28.192] Lazy evaluation: FALSE
[15:32:28.192] Asynchronous evaluation: TRUE
[15:32:28.192] Local evaluation: TRUE
[15:32:28.192] Environment: R_GlobalEnv
[15:32:28.192] Capture standard output: TRUE
[15:32:28.192] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:28.192] Globals: 5 objects totaling 4.67 KiB (function '...future.FUN' of 4.62 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)
[15:32:28.192] Packages: <none>
[15:32:28.192] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:28.192] Resolved: TRUE
[15:32:28.192] Value: <not collected>
[15:32:28.192] Conditions captured: <none>
[15:32:28.192] Early signaling: FALSE
[15:32:28.192] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:28.192] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:28.219] Chunk #1 of 2 ... DONE
[15:32:28.219] Chunk #2 of 2 ...
[15:32:28.220]  - Finding globals in 'X' for chunk #2 ...
[15:32:28.220] getGlobalsAndPackages() ...
[15:32:28.220] Searching for globals...
[15:32:28.221] 
[15:32:28.221] Searching for globals ... DONE
[15:32:28.221] - globals: [0] <none>
[15:32:28.221] getGlobalsAndPackages() ... DONE
[15:32:28.222]    + additional globals found: [n=0] 
[15:32:28.222]    + additional namespaces needed: [n=0] 
[15:32:28.222]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:28.222]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:28.223]  - seeds: <none>
[15:32:28.223]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:28.223] getGlobalsAndPackages() ...
[15:32:28.223] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:28.224] Resolving globals: FALSE
[15:32:28.224] Tweak future expression to call with '...' arguments ...
[15:32:28.224] {
[15:32:28.224]     do.call(function(...) {
[15:32:28.224]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:28.224]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:28.224]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:28.224]             on.exit(options(oopts), add = TRUE)
[15:32:28.224]         }
[15:32:28.224]         {
[15:32:28.224]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:28.224]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:28.224]                 ...future.FUN(...future.X_jj, ...)
[15:32:28.224]             })
[15:32:28.224]         }
[15:32:28.224]     }, args = future.call.arguments)
[15:32:28.224] }
[15:32:28.225] Tweak future expression to call with '...' arguments ... DONE
[15:32:28.226] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:28.226] 
[15:32:28.226] getGlobalsAndPackages() ... DONE
[15:32:28.227] run() for 'Future' ...
[15:32:28.227] - state: 'created'
[15:32:28.228] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:28.245] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:28.245] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:28.246]   - Field: 'node'
[15:32:28.246]   - Field: 'label'
[15:32:28.246]   - Field: 'local'
[15:32:28.247]   - Field: 'owner'
[15:32:28.247]   - Field: 'envir'
[15:32:28.247]   - Field: 'workers'
[15:32:28.248]   - Field: 'packages'
[15:32:28.248]   - Field: 'gc'
[15:32:28.248]   - Field: 'conditions'
[15:32:28.248]   - Field: 'persistent'
[15:32:28.249]   - Field: 'expr'
[15:32:28.249]   - Field: 'uuid'
[15:32:28.249]   - Field: 'seed'
[15:32:28.250]   - Field: 'version'
[15:32:28.250]   - Field: 'result'
[15:32:28.250]   - Field: 'asynchronous'
[15:32:28.251]   - Field: 'calls'
[15:32:28.251]   - Field: 'globals'
[15:32:28.251]   - Field: 'stdout'
[15:32:28.251]   - Field: 'earlySignal'
[15:32:28.252]   - Field: 'lazy'
[15:32:28.252]   - Field: 'state'
[15:32:28.252] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:28.253] - Launch lazy future ...
[15:32:28.253] Packages needed by the future expression (n = 0): <none>
[15:32:28.253] Packages needed by future strategies (n = 0): <none>
[15:32:28.254] {
[15:32:28.254]     {
[15:32:28.254]         {
[15:32:28.254]             ...future.startTime <- base::Sys.time()
[15:32:28.254]             {
[15:32:28.254]                 {
[15:32:28.254]                   {
[15:32:28.254]                     {
[15:32:28.254]                       base::local({
[15:32:28.254]                         has_future <- base::requireNamespace("future", 
[15:32:28.254]                           quietly = TRUE)
[15:32:28.254]                         if (has_future) {
[15:32:28.254]                           ns <- base::getNamespace("future")
[15:32:28.254]                           version <- ns[[".package"]][["version"]]
[15:32:28.254]                           if (is.null(version)) 
[15:32:28.254]                             version <- utils::packageVersion("future")
[15:32:28.254]                         }
[15:32:28.254]                         else {
[15:32:28.254]                           version <- NULL
[15:32:28.254]                         }
[15:32:28.254]                         if (!has_future || version < "1.8.0") {
[15:32:28.254]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:28.254]                             "", base::R.version$version.string), 
[15:32:28.254]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:28.254]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:28.254]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:28.254]                               "release", "version")], collapse = " "), 
[15:32:28.254]                             hostname = base::Sys.info()[["nodename"]])
[15:32:28.254]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:28.254]                             info)
[15:32:28.254]                           info <- base::paste(info, collapse = "; ")
[15:32:28.254]                           if (!has_future) {
[15:32:28.254]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:28.254]                               info)
[15:32:28.254]                           }
[15:32:28.254]                           else {
[15:32:28.254]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:28.254]                               info, version)
[15:32:28.254]                           }
[15:32:28.254]                           base::stop(msg)
[15:32:28.254]                         }
[15:32:28.254]                       })
[15:32:28.254]                     }
[15:32:28.254]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:28.254]                     base::options(mc.cores = 1L)
[15:32:28.254]                   }
[15:32:28.254]                   ...future.strategy.old <- future::plan("list")
[15:32:28.254]                   options(future.plan = NULL)
[15:32:28.254]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:28.254]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:28.254]                 }
[15:32:28.254]                 ...future.workdir <- getwd()
[15:32:28.254]             }
[15:32:28.254]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:28.254]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:28.254]         }
[15:32:28.254]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:28.254]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:28.254]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:28.254]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:28.254]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:28.254]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:28.254]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:28.254]             base::names(...future.oldOptions))
[15:32:28.254]     }
[15:32:28.254]     if (FALSE) {
[15:32:28.254]     }
[15:32:28.254]     else {
[15:32:28.254]         if (TRUE) {
[15:32:28.254]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:28.254]                 open = "w")
[15:32:28.254]         }
[15:32:28.254]         else {
[15:32:28.254]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:28.254]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:28.254]         }
[15:32:28.254]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:28.254]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:28.254]             base::sink(type = "output", split = FALSE)
[15:32:28.254]             base::close(...future.stdout)
[15:32:28.254]         }, add = TRUE)
[15:32:28.254]     }
[15:32:28.254]     ...future.frame <- base::sys.nframe()
[15:32:28.254]     ...future.conditions <- base::list()
[15:32:28.254]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:28.254]     if (FALSE) {
[15:32:28.254]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:28.254]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:28.254]     }
[15:32:28.254]     ...future.result <- base::tryCatch({
[15:32:28.254]         base::withCallingHandlers({
[15:32:28.254]             ...future.value <- base::withVisible(base::local({
[15:32:28.254]                 ...future.makeSendCondition <- base::local({
[15:32:28.254]                   sendCondition <- NULL
[15:32:28.254]                   function(frame = 1L) {
[15:32:28.254]                     if (is.function(sendCondition)) 
[15:32:28.254]                       return(sendCondition)
[15:32:28.254]                     ns <- getNamespace("parallel")
[15:32:28.254]                     if (exists("sendData", mode = "function", 
[15:32:28.254]                       envir = ns)) {
[15:32:28.254]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:28.254]                         envir = ns)
[15:32:28.254]                       envir <- sys.frame(frame)
[15:32:28.254]                       master <- NULL
[15:32:28.254]                       while (!identical(envir, .GlobalEnv) && 
[15:32:28.254]                         !identical(envir, emptyenv())) {
[15:32:28.254]                         if (exists("master", mode = "list", envir = envir, 
[15:32:28.254]                           inherits = FALSE)) {
[15:32:28.254]                           master <- get("master", mode = "list", 
[15:32:28.254]                             envir = envir, inherits = FALSE)
[15:32:28.254]                           if (inherits(master, c("SOCKnode", 
[15:32:28.254]                             "SOCK0node"))) {
[15:32:28.254]                             sendCondition <<- function(cond) {
[15:32:28.254]                               data <- list(type = "VALUE", value = cond, 
[15:32:28.254]                                 success = TRUE)
[15:32:28.254]                               parallel_sendData(master, data)
[15:32:28.254]                             }
[15:32:28.254]                             return(sendCondition)
[15:32:28.254]                           }
[15:32:28.254]                         }
[15:32:28.254]                         frame <- frame + 1L
[15:32:28.254]                         envir <- sys.frame(frame)
[15:32:28.254]                       }
[15:32:28.254]                     }
[15:32:28.254]                     sendCondition <<- function(cond) NULL
[15:32:28.254]                   }
[15:32:28.254]                 })
[15:32:28.254]                 withCallingHandlers({
[15:32:28.254]                   {
[15:32:28.254]                     do.call(function(...) {
[15:32:28.254]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:28.254]                       if (!identical(...future.globals.maxSize.org, 
[15:32:28.254]                         ...future.globals.maxSize)) {
[15:32:28.254]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:28.254]                         on.exit(options(oopts), add = TRUE)
[15:32:28.254]                       }
[15:32:28.254]                       {
[15:32:28.254]                         lapply(seq_along(...future.elements_ii), 
[15:32:28.254]                           FUN = function(jj) {
[15:32:28.254]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:28.254]                             ...future.FUN(...future.X_jj, ...)
[15:32:28.254]                           })
[15:32:28.254]                       }
[15:32:28.254]                     }, args = future.call.arguments)
[15:32:28.254]                   }
[15:32:28.254]                 }, immediateCondition = function(cond) {
[15:32:28.254]                   sendCondition <- ...future.makeSendCondition()
[15:32:28.254]                   sendCondition(cond)
[15:32:28.254]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:28.254]                   {
[15:32:28.254]                     inherits <- base::inherits
[15:32:28.254]                     invokeRestart <- base::invokeRestart
[15:32:28.254]                     is.null <- base::is.null
[15:32:28.254]                     muffled <- FALSE
[15:32:28.254]                     if (inherits(cond, "message")) {
[15:32:28.254]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:28.254]                       if (muffled) 
[15:32:28.254]                         invokeRestart("muffleMessage")
[15:32:28.254]                     }
[15:32:28.254]                     else if (inherits(cond, "warning")) {
[15:32:28.254]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:28.254]                       if (muffled) 
[15:32:28.254]                         invokeRestart("muffleWarning")
[15:32:28.254]                     }
[15:32:28.254]                     else if (inherits(cond, "condition")) {
[15:32:28.254]                       if (!is.null(pattern)) {
[15:32:28.254]                         computeRestarts <- base::computeRestarts
[15:32:28.254]                         grepl <- base::grepl
[15:32:28.254]                         restarts <- computeRestarts(cond)
[15:32:28.254]                         for (restart in restarts) {
[15:32:28.254]                           name <- restart$name
[15:32:28.254]                           if (is.null(name)) 
[15:32:28.254]                             next
[15:32:28.254]                           if (!grepl(pattern, name)) 
[15:32:28.254]                             next
[15:32:28.254]                           invokeRestart(restart)
[15:32:28.254]                           muffled <- TRUE
[15:32:28.254]                           break
[15:32:28.254]                         }
[15:32:28.254]                       }
[15:32:28.254]                     }
[15:32:28.254]                     invisible(muffled)
[15:32:28.254]                   }
[15:32:28.254]                   muffleCondition(cond)
[15:32:28.254]                 })
[15:32:28.254]             }))
[15:32:28.254]             future::FutureResult(value = ...future.value$value, 
[15:32:28.254]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:28.254]                   ...future.rng), globalenv = if (FALSE) 
[15:32:28.254]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:28.254]                     ...future.globalenv.names))
[15:32:28.254]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:28.254]         }, condition = base::local({
[15:32:28.254]             c <- base::c
[15:32:28.254]             inherits <- base::inherits
[15:32:28.254]             invokeRestart <- base::invokeRestart
[15:32:28.254]             length <- base::length
[15:32:28.254]             list <- base::list
[15:32:28.254]             seq.int <- base::seq.int
[15:32:28.254]             signalCondition <- base::signalCondition
[15:32:28.254]             sys.calls <- base::sys.calls
[15:32:28.254]             `[[` <- base::`[[`
[15:32:28.254]             `+` <- base::`+`
[15:32:28.254]             `<<-` <- base::`<<-`
[15:32:28.254]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:28.254]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:28.254]                   3L)]
[15:32:28.254]             }
[15:32:28.254]             function(cond) {
[15:32:28.254]                 is_error <- inherits(cond, "error")
[15:32:28.254]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:28.254]                   NULL)
[15:32:28.254]                 if (is_error) {
[15:32:28.254]                   sessionInformation <- function() {
[15:32:28.254]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:28.254]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:28.254]                       search = base::search(), system = base::Sys.info())
[15:32:28.254]                   }
[15:32:28.254]                   ...future.conditions[[length(...future.conditions) + 
[15:32:28.254]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:28.254]                     cond$call), session = sessionInformation(), 
[15:32:28.254]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:28.254]                   signalCondition(cond)
[15:32:28.254]                 }
[15:32:28.254]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:28.254]                 "immediateCondition"))) {
[15:32:28.254]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:28.254]                   ...future.conditions[[length(...future.conditions) + 
[15:32:28.254]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:28.254]                   if (TRUE && !signal) {
[15:32:28.254]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:28.254]                     {
[15:32:28.254]                       inherits <- base::inherits
[15:32:28.254]                       invokeRestart <- base::invokeRestart
[15:32:28.254]                       is.null <- base::is.null
[15:32:28.254]                       muffled <- FALSE
[15:32:28.254]                       if (inherits(cond, "message")) {
[15:32:28.254]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:28.254]                         if (muffled) 
[15:32:28.254]                           invokeRestart("muffleMessage")
[15:32:28.254]                       }
[15:32:28.254]                       else if (inherits(cond, "warning")) {
[15:32:28.254]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:28.254]                         if (muffled) 
[15:32:28.254]                           invokeRestart("muffleWarning")
[15:32:28.254]                       }
[15:32:28.254]                       else if (inherits(cond, "condition")) {
[15:32:28.254]                         if (!is.null(pattern)) {
[15:32:28.254]                           computeRestarts <- base::computeRestarts
[15:32:28.254]                           grepl <- base::grepl
[15:32:28.254]                           restarts <- computeRestarts(cond)
[15:32:28.254]                           for (restart in restarts) {
[15:32:28.254]                             name <- restart$name
[15:32:28.254]                             if (is.null(name)) 
[15:32:28.254]                               next
[15:32:28.254]                             if (!grepl(pattern, name)) 
[15:32:28.254]                               next
[15:32:28.254]                             invokeRestart(restart)
[15:32:28.254]                             muffled <- TRUE
[15:32:28.254]                             break
[15:32:28.254]                           }
[15:32:28.254]                         }
[15:32:28.254]                       }
[15:32:28.254]                       invisible(muffled)
[15:32:28.254]                     }
[15:32:28.254]                     muffleCondition(cond, pattern = "^muffle")
[15:32:28.254]                   }
[15:32:28.254]                 }
[15:32:28.254]                 else {
[15:32:28.254]                   if (TRUE) {
[15:32:28.254]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:28.254]                     {
[15:32:28.254]                       inherits <- base::inherits
[15:32:28.254]                       invokeRestart <- base::invokeRestart
[15:32:28.254]                       is.null <- base::is.null
[15:32:28.254]                       muffled <- FALSE
[15:32:28.254]                       if (inherits(cond, "message")) {
[15:32:28.254]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:28.254]                         if (muffled) 
[15:32:28.254]                           invokeRestart("muffleMessage")
[15:32:28.254]                       }
[15:32:28.254]                       else if (inherits(cond, "warning")) {
[15:32:28.254]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:28.254]                         if (muffled) 
[15:32:28.254]                           invokeRestart("muffleWarning")
[15:32:28.254]                       }
[15:32:28.254]                       else if (inherits(cond, "condition")) {
[15:32:28.254]                         if (!is.null(pattern)) {
[15:32:28.254]                           computeRestarts <- base::computeRestarts
[15:32:28.254]                           grepl <- base::grepl
[15:32:28.254]                           restarts <- computeRestarts(cond)
[15:32:28.254]                           for (restart in restarts) {
[15:32:28.254]                             name <- restart$name
[15:32:28.254]                             if (is.null(name)) 
[15:32:28.254]                               next
[15:32:28.254]                             if (!grepl(pattern, name)) 
[15:32:28.254]                               next
[15:32:28.254]                             invokeRestart(restart)
[15:32:28.254]                             muffled <- TRUE
[15:32:28.254]                             break
[15:32:28.254]                           }
[15:32:28.254]                         }
[15:32:28.254]                       }
[15:32:28.254]                       invisible(muffled)
[15:32:28.254]                     }
[15:32:28.254]                     muffleCondition(cond, pattern = "^muffle")
[15:32:28.254]                   }
[15:32:28.254]                 }
[15:32:28.254]             }
[15:32:28.254]         }))
[15:32:28.254]     }, error = function(ex) {
[15:32:28.254]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:28.254]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:28.254]                 ...future.rng), started = ...future.startTime, 
[15:32:28.254]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:28.254]             version = "1.8"), class = "FutureResult")
[15:32:28.254]     }, finally = {
[15:32:28.254]         if (!identical(...future.workdir, getwd())) 
[15:32:28.254]             setwd(...future.workdir)
[15:32:28.254]         {
[15:32:28.254]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:28.254]                 ...future.oldOptions$nwarnings <- NULL
[15:32:28.254]             }
[15:32:28.254]             base::options(...future.oldOptions)
[15:32:28.254]             if (.Platform$OS.type == "windows") {
[15:32:28.254]                 old_names <- names(...future.oldEnvVars)
[15:32:28.254]                 envs <- base::Sys.getenv()
[15:32:28.254]                 names <- names(envs)
[15:32:28.254]                 common <- intersect(names, old_names)
[15:32:28.254]                 added <- setdiff(names, old_names)
[15:32:28.254]                 removed <- setdiff(old_names, names)
[15:32:28.254]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:28.254]                   envs[common]]
[15:32:28.254]                 NAMES <- toupper(changed)
[15:32:28.254]                 args <- list()
[15:32:28.254]                 for (kk in seq_along(NAMES)) {
[15:32:28.254]                   name <- changed[[kk]]
[15:32:28.254]                   NAME <- NAMES[[kk]]
[15:32:28.254]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:28.254]                     next
[15:32:28.254]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:28.254]                 }
[15:32:28.254]                 NAMES <- toupper(added)
[15:32:28.254]                 for (kk in seq_along(NAMES)) {
[15:32:28.254]                   name <- added[[kk]]
[15:32:28.254]                   NAME <- NAMES[[kk]]
[15:32:28.254]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:28.254]                     next
[15:32:28.254]                   args[[name]] <- ""
[15:32:28.254]                 }
[15:32:28.254]                 NAMES <- toupper(removed)
[15:32:28.254]                 for (kk in seq_along(NAMES)) {
[15:32:28.254]                   name <- removed[[kk]]
[15:32:28.254]                   NAME <- NAMES[[kk]]
[15:32:28.254]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:28.254]                     next
[15:32:28.254]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:28.254]                 }
[15:32:28.254]                 if (length(args) > 0) 
[15:32:28.254]                   base::do.call(base::Sys.setenv, args = args)
[15:32:28.254]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:28.254]             }
[15:32:28.254]             else {
[15:32:28.254]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:28.254]             }
[15:32:28.254]             {
[15:32:28.254]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:28.254]                   0L) {
[15:32:28.254]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:28.254]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:28.254]                   base::options(opts)
[15:32:28.254]                 }
[15:32:28.254]                 {
[15:32:28.254]                   {
[15:32:28.254]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:28.254]                     NULL
[15:32:28.254]                   }
[15:32:28.254]                   options(future.plan = NULL)
[15:32:28.254]                   if (is.na(NA_character_)) 
[15:32:28.254]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:28.254]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:28.254]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:28.254]                     .init = FALSE)
[15:32:28.254]                 }
[15:32:28.254]             }
[15:32:28.254]         }
[15:32:28.254]     })
[15:32:28.254]     if (TRUE) {
[15:32:28.254]         base::sink(type = "output", split = FALSE)
[15:32:28.254]         if (TRUE) {
[15:32:28.254]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:28.254]         }
[15:32:28.254]         else {
[15:32:28.254]             ...future.result["stdout"] <- base::list(NULL)
[15:32:28.254]         }
[15:32:28.254]         base::close(...future.stdout)
[15:32:28.254]         ...future.stdout <- NULL
[15:32:28.254]     }
[15:32:28.254]     ...future.result$conditions <- ...future.conditions
[15:32:28.254]     ...future.result$finished <- base::Sys.time()
[15:32:28.254]     ...future.result
[15:32:28.254] }
[15:32:28.260] Exporting 5 global objects (4.62 KiB) to cluster node #1 ...
[15:32:28.260] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ...
[15:32:28.261] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ... DONE
[15:32:28.261] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:28.261] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:28.262] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:28.262] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:28.262] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:28.263] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:28.263] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:28.263] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:28.263] Exporting 5 global objects (4.62 KiB) to cluster node #1 ... DONE
[15:32:28.264] MultisessionFuture started
[15:32:28.264] - Launch lazy future ... done
[15:32:28.265] run() for 'MultisessionFuture' ... done
[15:32:28.265] Created future:
[15:32:28.290] receiveMessageFromWorker() for ClusterFuture ...
[15:32:28.290] - Validating connection of MultisessionFuture
[15:32:28.291] - received message: FutureResult
[15:32:28.291] - Received FutureResult
[15:32:28.291] - Erased future from FutureRegistry
[15:32:28.292] result() for ClusterFuture ...
[15:32:28.292] - result already collected: FutureResult
[15:32:28.292] result() for ClusterFuture ... done
[15:32:28.293] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:28.265] MultisessionFuture:
[15:32:28.265] Label: 'future_sapply-2'
[15:32:28.265] Expression:
[15:32:28.265] {
[15:32:28.265]     do.call(function(...) {
[15:32:28.265]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:28.265]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:28.265]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:28.265]             on.exit(options(oopts), add = TRUE)
[15:32:28.265]         }
[15:32:28.265]         {
[15:32:28.265]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:28.265]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:28.265]                 ...future.FUN(...future.X_jj, ...)
[15:32:28.265]             })
[15:32:28.265]         }
[15:32:28.265]     }, args = future.call.arguments)
[15:32:28.265] }
[15:32:28.265] Lazy evaluation: FALSE
[15:32:28.265] Asynchronous evaluation: TRUE
[15:32:28.265] Local evaluation: TRUE
[15:32:28.265] Environment: R_GlobalEnv
[15:32:28.265] Capture standard output: TRUE
[15:32:28.265] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:28.265] Globals: 5 objects totaling 4.73 KiB (function '...future.FUN' of 4.62 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)
[15:32:28.265] Packages: <none>
[15:32:28.265] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:28.265] Resolved: TRUE
[15:32:28.265] Value: <not collected>
[15:32:28.265] Conditions captured: <none>
[15:32:28.265] Early signaling: FALSE
[15:32:28.265] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:28.265] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:28.293] Chunk #2 of 2 ... DONE
[15:32:28.294] Launching 2 futures (chunks) ... DONE
[15:32:28.294] Resolving 2 futures (chunks) ...
[15:32:28.294] resolve() on list ...
[15:32:28.294]  recursive: 0
[15:32:28.295]  length: 2
[15:32:28.295] 
[15:32:28.295] Future #1
[15:32:28.295] result() for ClusterFuture ...
[15:32:28.296] - result already collected: FutureResult
[15:32:28.296] result() for ClusterFuture ... done
[15:32:28.296] result() for ClusterFuture ...
[15:32:28.296] - result already collected: FutureResult
[15:32:28.297] result() for ClusterFuture ... done
[15:32:28.297] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:28.297] - nx: 2
[15:32:28.297] - relay: TRUE
[15:32:28.298] - stdout: TRUE
[15:32:28.298] - signal: TRUE
[15:32:28.298] - resignal: FALSE
[15:32:28.298] - force: TRUE
[15:32:28.299] - relayed: [n=2] FALSE, FALSE
[15:32:28.299] - queued futures: [n=2] FALSE, FALSE
[15:32:28.299]  - until=1
[15:32:28.299]  - relaying element #1
[15:32:28.300] result() for ClusterFuture ...
[15:32:28.300] - result already collected: FutureResult
[15:32:28.300] result() for ClusterFuture ... done
[15:32:28.300] result() for ClusterFuture ...
[15:32:28.301] - result already collected: FutureResult
[15:32:28.301] result() for ClusterFuture ... done
[15:32:28.301] result() for ClusterFuture ...
[15:32:28.301] - result already collected: FutureResult
[15:32:28.302] result() for ClusterFuture ... done
[15:32:28.302] result() for ClusterFuture ...
[15:32:28.302] - result already collected: FutureResult
[15:32:28.302] result() for ClusterFuture ... done
[15:32:28.303] - relayed: [n=2] TRUE, FALSE
[15:32:28.303] - queued futures: [n=2] TRUE, FALSE
[15:32:28.303] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:28.303]  length: 1 (resolved future 1)
[15:32:28.304] Future #2
[15:32:28.304] result() for ClusterFuture ...
[15:32:28.304] - result already collected: FutureResult
[15:32:28.305] result() for ClusterFuture ... done
[15:32:28.305] result() for ClusterFuture ...
[15:32:28.305] - result already collected: FutureResult
[15:32:28.305] result() for ClusterFuture ... done
[15:32:28.306] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:28.306] - nx: 2
[15:32:28.306] - relay: TRUE
[15:32:28.306] - stdout: TRUE
[15:32:28.306] - signal: TRUE
[15:32:28.307] - resignal: FALSE
[15:32:28.307] - force: TRUE
[15:32:28.307] - relayed: [n=2] TRUE, FALSE
[15:32:28.307] - queued futures: [n=2] TRUE, FALSE
[15:32:28.307]  - until=2
[15:32:28.307]  - relaying element #2
[15:32:28.307] result() for ClusterFuture ...
[15:32:28.308] - result already collected: FutureResult
[15:32:28.308] result() for ClusterFuture ... done
[15:32:28.308] result() for ClusterFuture ...
[15:32:28.308] - result already collected: FutureResult
[15:32:28.308] result() for ClusterFuture ... done
[15:32:28.308] result() for ClusterFuture ...
[15:32:28.309] - result already collected: FutureResult
[15:32:28.309] result() for ClusterFuture ... done
[15:32:28.309] result() for ClusterFuture ...
[15:32:28.309] - result already collected: FutureResult
[15:32:28.309] result() for ClusterFuture ... done
[15:32:28.309] - relayed: [n=2] TRUE, TRUE
[15:32:28.309] - queued futures: [n=2] TRUE, TRUE
[15:32:28.310] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:28.310]  length: 0 (resolved future 2)
[15:32:28.310] Relaying remaining futures
[15:32:28.310] signalConditionsASAP(NULL, pos=0) ...
[15:32:28.310] - nx: 2
[15:32:28.310] - relay: TRUE
[15:32:28.311] - stdout: TRUE
[15:32:28.311] - signal: TRUE
[15:32:28.311] - resignal: FALSE
[15:32:28.311] - force: TRUE
[15:32:28.311] - relayed: [n=2] TRUE, TRUE
[15:32:28.311] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:28.311] - relayed: [n=2] TRUE, TRUE
[15:32:28.312] - queued futures: [n=2] TRUE, TRUE
[15:32:28.312] signalConditionsASAP(NULL, pos=0) ... done
[15:32:28.312] resolve() on list ... DONE
[15:32:28.312] result() for ClusterFuture ...
[15:32:28.312] - result already collected: FutureResult
[15:32:28.312] result() for ClusterFuture ... done
[15:32:28.313] result() for ClusterFuture ...
[15:32:28.313] - result already collected: FutureResult
[15:32:28.313] result() for ClusterFuture ... done
[15:32:28.313] result() for ClusterFuture ...
[15:32:28.313] - result already collected: FutureResult
[15:32:28.313] result() for ClusterFuture ... done
[15:32:28.314] result() for ClusterFuture ...
[15:32:28.314] - result already collected: FutureResult
[15:32:28.314] result() for ClusterFuture ... done
[15:32:28.314]  - Number of value chunks collected: 2
[15:32:28.315] Resolving 2 futures (chunks) ... DONE
[15:32:28.315] Reducing values from 2 chunks ...
[15:32:28.315]  - Number of values collected after concatenation: 3
[15:32:28.315]  - Number of values expected: 3
[15:32:28.316] Reducing values from 2 chunks ... DONE
[15:32:28.316] future_lapply() ... DONE
List of 2
 $ y0: num [1:15, 1:3] 2 2 2 4 4 4 6 6 6 8 ...
  ..- attr(*, "dimnames")=List of 2
  .. ..$ : NULL
  .. ..$ : chr [1:3] "a" "b" "c"
 $ y1: num [1:15, 1:3] 2 2 2 4 4 4 6 6 6 8 ...
  ..- attr(*, "dimnames")=List of 2
  .. ..$ : NULL
  .. ..$ : chr [1:3] "a" "b" "c"
[15:32:28.320] future_lapply() ...
[15:32:28.324] Number of chunks: 2
[15:32:28.324] getGlobalsAndPackagesXApply() ...
[15:32:28.324]  - future.globals: TRUE
[15:32:28.325] getGlobalsAndPackages() ...
[15:32:28.325] Searching for globals...
[15:32:28.326] - globals found: [1] 'FUN'
[15:32:28.326] Searching for globals ... DONE
[15:32:28.327] Resolving globals: FALSE
[15:32:28.327] The total size of the 1 globals is 848 bytes (848 bytes)
[15:32:28.327] The total size of the 1 globals exported for future expression ('FUN()') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:32:28.328] - globals: [1] 'FUN'
[15:32:28.328] 
[15:32:28.328] getGlobalsAndPackages() ... DONE
[15:32:28.328]  - globals found/used: [n=1] 'FUN'
[15:32:28.328]  - needed namespaces: [n=0] 
[15:32:28.328] Finding globals ... DONE
[15:32:28.328]  - use_args: TRUE
[15:32:28.329]  - Getting '...' globals ...
[15:32:28.329] resolve() on list ...
[15:32:28.329]  recursive: 0
[15:32:28.329]  length: 1
[15:32:28.329]  elements: '...'
[15:32:28.330]  length: 0 (resolved future 1)
[15:32:28.330] resolve() on list ... DONE
[15:32:28.330]    - '...' content: [n=0] 
[15:32:28.330] List of 1
[15:32:28.330]  $ ...: list()
[15:32:28.330]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:28.330]  - attr(*, "where")=List of 1
[15:32:28.330]   ..$ ...:<environment: 0x00000276e5c1bb50> 
[15:32:28.330]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:28.330]  - attr(*, "resolved")= logi TRUE
[15:32:28.330]  - attr(*, "total_size")= num NA
[15:32:28.334]  - Getting '...' globals ... DONE
[15:32:28.334] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:28.334] List of 2
[15:32:28.334]  $ ...future.FUN:function (x)  
[15:32:28.334]  $ ...          : list()
[15:32:28.334]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:28.334]  - attr(*, "where")=List of 2
[15:32:28.334]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:28.334]   ..$ ...          :<environment: 0x00000276e5c1bb50> 
[15:32:28.334]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:28.334]  - attr(*, "resolved")= logi FALSE
[15:32:28.334]  - attr(*, "total_size")= num 848
[15:32:28.339] Packages to be attached in all futures: [n=0] 
[15:32:28.339] getGlobalsAndPackagesXApply() ... DONE
[15:32:28.340] Number of futures (= number of chunks): 2
[15:32:28.340] Launching 2 futures (chunks) ...
[15:32:28.340] Chunk #1 of 2 ...
[15:32:28.341]  - Finding globals in 'X' for chunk #1 ...
[15:32:28.341] getGlobalsAndPackages() ...
[15:32:28.341] Searching for globals...
[15:32:28.342] 
[15:32:28.342] Searching for globals ... DONE
[15:32:28.342] - globals: [0] <none>
[15:32:28.343] getGlobalsAndPackages() ... DONE
[15:32:28.343]    + additional globals found: [n=0] 
[15:32:28.343]    + additional namespaces needed: [n=0] 
[15:32:28.343]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:28.344]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:28.344]  - seeds: <none>
[15:32:28.344]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:28.344] getGlobalsAndPackages() ...
[15:32:28.345] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:28.345] Resolving globals: FALSE
[15:32:28.345] Tweak future expression to call with '...' arguments ...
[15:32:28.346] {
[15:32:28.346]     do.call(function(...) {
[15:32:28.346]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:28.346]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:28.346]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:28.346]             on.exit(options(oopts), add = TRUE)
[15:32:28.346]         }
[15:32:28.346]         {
[15:32:28.346]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:28.346]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:28.346]                 ...future.FUN(...future.X_jj, ...)
[15:32:28.346]             })
[15:32:28.346]         }
[15:32:28.346]     }, args = future.call.arguments)
[15:32:28.346] }
[15:32:28.346] Tweak future expression to call with '...' arguments ... DONE
[15:32:28.347] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:28.347] 
[15:32:28.348] getGlobalsAndPackages() ... DONE
[15:32:28.348] run() for 'Future' ...
[15:32:28.349] - state: 'created'
[15:32:28.349] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:28.365] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:28.365] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:28.366]   - Field: 'node'
[15:32:28.366]   - Field: 'label'
[15:32:28.366]   - Field: 'local'
[15:32:28.367]   - Field: 'owner'
[15:32:28.367]   - Field: 'envir'
[15:32:28.367]   - Field: 'workers'
[15:32:28.367]   - Field: 'packages'
[15:32:28.367]   - Field: 'gc'
[15:32:28.367]   - Field: 'conditions'
[15:32:28.368]   - Field: 'persistent'
[15:32:28.368]   - Field: 'expr'
[15:32:28.368]   - Field: 'uuid'
[15:32:28.368]   - Field: 'seed'
[15:32:28.368]   - Field: 'version'
[15:32:28.368]   - Field: 'result'
[15:32:28.369]   - Field: 'asynchronous'
[15:32:28.369]   - Field: 'calls'
[15:32:28.369]   - Field: 'globals'
[15:32:28.369]   - Field: 'stdout'
[15:32:28.369]   - Field: 'earlySignal'
[15:32:28.369]   - Field: 'lazy'
[15:32:28.369]   - Field: 'state'
[15:32:28.370] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:28.370] - Launch lazy future ...
[15:32:28.370] Packages needed by the future expression (n = 0): <none>
[15:32:28.370] Packages needed by future strategies (n = 0): <none>
[15:32:28.371] {
[15:32:28.371]     {
[15:32:28.371]         {
[15:32:28.371]             ...future.startTime <- base::Sys.time()
[15:32:28.371]             {
[15:32:28.371]                 {
[15:32:28.371]                   {
[15:32:28.371]                     {
[15:32:28.371]                       base::local({
[15:32:28.371]                         has_future <- base::requireNamespace("future", 
[15:32:28.371]                           quietly = TRUE)
[15:32:28.371]                         if (has_future) {
[15:32:28.371]                           ns <- base::getNamespace("future")
[15:32:28.371]                           version <- ns[[".package"]][["version"]]
[15:32:28.371]                           if (is.null(version)) 
[15:32:28.371]                             version <- utils::packageVersion("future")
[15:32:28.371]                         }
[15:32:28.371]                         else {
[15:32:28.371]                           version <- NULL
[15:32:28.371]                         }
[15:32:28.371]                         if (!has_future || version < "1.8.0") {
[15:32:28.371]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:28.371]                             "", base::R.version$version.string), 
[15:32:28.371]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:28.371]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:28.371]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:28.371]                               "release", "version")], collapse = " "), 
[15:32:28.371]                             hostname = base::Sys.info()[["nodename"]])
[15:32:28.371]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:28.371]                             info)
[15:32:28.371]                           info <- base::paste(info, collapse = "; ")
[15:32:28.371]                           if (!has_future) {
[15:32:28.371]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:28.371]                               info)
[15:32:28.371]                           }
[15:32:28.371]                           else {
[15:32:28.371]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:28.371]                               info, version)
[15:32:28.371]                           }
[15:32:28.371]                           base::stop(msg)
[15:32:28.371]                         }
[15:32:28.371]                       })
[15:32:28.371]                     }
[15:32:28.371]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:28.371]                     base::options(mc.cores = 1L)
[15:32:28.371]                   }
[15:32:28.371]                   ...future.strategy.old <- future::plan("list")
[15:32:28.371]                   options(future.plan = NULL)
[15:32:28.371]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:28.371]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:28.371]                 }
[15:32:28.371]                 ...future.workdir <- getwd()
[15:32:28.371]             }
[15:32:28.371]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:28.371]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:28.371]         }
[15:32:28.371]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:28.371]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:28.371]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:28.371]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:28.371]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:28.371]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:28.371]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:28.371]             base::names(...future.oldOptions))
[15:32:28.371]     }
[15:32:28.371]     if (FALSE) {
[15:32:28.371]     }
[15:32:28.371]     else {
[15:32:28.371]         if (TRUE) {
[15:32:28.371]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:28.371]                 open = "w")
[15:32:28.371]         }
[15:32:28.371]         else {
[15:32:28.371]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:28.371]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:28.371]         }
[15:32:28.371]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:28.371]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:28.371]             base::sink(type = "output", split = FALSE)
[15:32:28.371]             base::close(...future.stdout)
[15:32:28.371]         }, add = TRUE)
[15:32:28.371]     }
[15:32:28.371]     ...future.frame <- base::sys.nframe()
[15:32:28.371]     ...future.conditions <- base::list()
[15:32:28.371]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:28.371]     if (FALSE) {
[15:32:28.371]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:28.371]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:28.371]     }
[15:32:28.371]     ...future.result <- base::tryCatch({
[15:32:28.371]         base::withCallingHandlers({
[15:32:28.371]             ...future.value <- base::withVisible(base::local({
[15:32:28.371]                 ...future.makeSendCondition <- base::local({
[15:32:28.371]                   sendCondition <- NULL
[15:32:28.371]                   function(frame = 1L) {
[15:32:28.371]                     if (is.function(sendCondition)) 
[15:32:28.371]                       return(sendCondition)
[15:32:28.371]                     ns <- getNamespace("parallel")
[15:32:28.371]                     if (exists("sendData", mode = "function", 
[15:32:28.371]                       envir = ns)) {
[15:32:28.371]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:28.371]                         envir = ns)
[15:32:28.371]                       envir <- sys.frame(frame)
[15:32:28.371]                       master <- NULL
[15:32:28.371]                       while (!identical(envir, .GlobalEnv) && 
[15:32:28.371]                         !identical(envir, emptyenv())) {
[15:32:28.371]                         if (exists("master", mode = "list", envir = envir, 
[15:32:28.371]                           inherits = FALSE)) {
[15:32:28.371]                           master <- get("master", mode = "list", 
[15:32:28.371]                             envir = envir, inherits = FALSE)
[15:32:28.371]                           if (inherits(master, c("SOCKnode", 
[15:32:28.371]                             "SOCK0node"))) {
[15:32:28.371]                             sendCondition <<- function(cond) {
[15:32:28.371]                               data <- list(type = "VALUE", value = cond, 
[15:32:28.371]                                 success = TRUE)
[15:32:28.371]                               parallel_sendData(master, data)
[15:32:28.371]                             }
[15:32:28.371]                             return(sendCondition)
[15:32:28.371]                           }
[15:32:28.371]                         }
[15:32:28.371]                         frame <- frame + 1L
[15:32:28.371]                         envir <- sys.frame(frame)
[15:32:28.371]                       }
[15:32:28.371]                     }
[15:32:28.371]                     sendCondition <<- function(cond) NULL
[15:32:28.371]                   }
[15:32:28.371]                 })
[15:32:28.371]                 withCallingHandlers({
[15:32:28.371]                   {
[15:32:28.371]                     do.call(function(...) {
[15:32:28.371]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:28.371]                       if (!identical(...future.globals.maxSize.org, 
[15:32:28.371]                         ...future.globals.maxSize)) {
[15:32:28.371]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:28.371]                         on.exit(options(oopts), add = TRUE)
[15:32:28.371]                       }
[15:32:28.371]                       {
[15:32:28.371]                         lapply(seq_along(...future.elements_ii), 
[15:32:28.371]                           FUN = function(jj) {
[15:32:28.371]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:28.371]                             ...future.FUN(...future.X_jj, ...)
[15:32:28.371]                           })
[15:32:28.371]                       }
[15:32:28.371]                     }, args = future.call.arguments)
[15:32:28.371]                   }
[15:32:28.371]                 }, immediateCondition = function(cond) {
[15:32:28.371]                   sendCondition <- ...future.makeSendCondition()
[15:32:28.371]                   sendCondition(cond)
[15:32:28.371]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:28.371]                   {
[15:32:28.371]                     inherits <- base::inherits
[15:32:28.371]                     invokeRestart <- base::invokeRestart
[15:32:28.371]                     is.null <- base::is.null
[15:32:28.371]                     muffled <- FALSE
[15:32:28.371]                     if (inherits(cond, "message")) {
[15:32:28.371]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:28.371]                       if (muffled) 
[15:32:28.371]                         invokeRestart("muffleMessage")
[15:32:28.371]                     }
[15:32:28.371]                     else if (inherits(cond, "warning")) {
[15:32:28.371]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:28.371]                       if (muffled) 
[15:32:28.371]                         invokeRestart("muffleWarning")
[15:32:28.371]                     }
[15:32:28.371]                     else if (inherits(cond, "condition")) {
[15:32:28.371]                       if (!is.null(pattern)) {
[15:32:28.371]                         computeRestarts <- base::computeRestarts
[15:32:28.371]                         grepl <- base::grepl
[15:32:28.371]                         restarts <- computeRestarts(cond)
[15:32:28.371]                         for (restart in restarts) {
[15:32:28.371]                           name <- restart$name
[15:32:28.371]                           if (is.null(name)) 
[15:32:28.371]                             next
[15:32:28.371]                           if (!grepl(pattern, name)) 
[15:32:28.371]                             next
[15:32:28.371]                           invokeRestart(restart)
[15:32:28.371]                           muffled <- TRUE
[15:32:28.371]                           break
[15:32:28.371]                         }
[15:32:28.371]                       }
[15:32:28.371]                     }
[15:32:28.371]                     invisible(muffled)
[15:32:28.371]                   }
[15:32:28.371]                   muffleCondition(cond)
[15:32:28.371]                 })
[15:32:28.371]             }))
[15:32:28.371]             future::FutureResult(value = ...future.value$value, 
[15:32:28.371]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:28.371]                   ...future.rng), globalenv = if (FALSE) 
[15:32:28.371]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:28.371]                     ...future.globalenv.names))
[15:32:28.371]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:28.371]         }, condition = base::local({
[15:32:28.371]             c <- base::c
[15:32:28.371]             inherits <- base::inherits
[15:32:28.371]             invokeRestart <- base::invokeRestart
[15:32:28.371]             length <- base::length
[15:32:28.371]             list <- base::list
[15:32:28.371]             seq.int <- base::seq.int
[15:32:28.371]             signalCondition <- base::signalCondition
[15:32:28.371]             sys.calls <- base::sys.calls
[15:32:28.371]             `[[` <- base::`[[`
[15:32:28.371]             `+` <- base::`+`
[15:32:28.371]             `<<-` <- base::`<<-`
[15:32:28.371]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:28.371]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:28.371]                   3L)]
[15:32:28.371]             }
[15:32:28.371]             function(cond) {
[15:32:28.371]                 is_error <- inherits(cond, "error")
[15:32:28.371]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:28.371]                   NULL)
[15:32:28.371]                 if (is_error) {
[15:32:28.371]                   sessionInformation <- function() {
[15:32:28.371]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:28.371]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:28.371]                       search = base::search(), system = base::Sys.info())
[15:32:28.371]                   }
[15:32:28.371]                   ...future.conditions[[length(...future.conditions) + 
[15:32:28.371]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:28.371]                     cond$call), session = sessionInformation(), 
[15:32:28.371]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:28.371]                   signalCondition(cond)
[15:32:28.371]                 }
[15:32:28.371]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:28.371]                 "immediateCondition"))) {
[15:32:28.371]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:28.371]                   ...future.conditions[[length(...future.conditions) + 
[15:32:28.371]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:28.371]                   if (TRUE && !signal) {
[15:32:28.371]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:28.371]                     {
[15:32:28.371]                       inherits <- base::inherits
[15:32:28.371]                       invokeRestart <- base::invokeRestart
[15:32:28.371]                       is.null <- base::is.null
[15:32:28.371]                       muffled <- FALSE
[15:32:28.371]                       if (inherits(cond, "message")) {
[15:32:28.371]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:28.371]                         if (muffled) 
[15:32:28.371]                           invokeRestart("muffleMessage")
[15:32:28.371]                       }
[15:32:28.371]                       else if (inherits(cond, "warning")) {
[15:32:28.371]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:28.371]                         if (muffled) 
[15:32:28.371]                           invokeRestart("muffleWarning")
[15:32:28.371]                       }
[15:32:28.371]                       else if (inherits(cond, "condition")) {
[15:32:28.371]                         if (!is.null(pattern)) {
[15:32:28.371]                           computeRestarts <- base::computeRestarts
[15:32:28.371]                           grepl <- base::grepl
[15:32:28.371]                           restarts <- computeRestarts(cond)
[15:32:28.371]                           for (restart in restarts) {
[15:32:28.371]                             name <- restart$name
[15:32:28.371]                             if (is.null(name)) 
[15:32:28.371]                               next
[15:32:28.371]                             if (!grepl(pattern, name)) 
[15:32:28.371]                               next
[15:32:28.371]                             invokeRestart(restart)
[15:32:28.371]                             muffled <- TRUE
[15:32:28.371]                             break
[15:32:28.371]                           }
[15:32:28.371]                         }
[15:32:28.371]                       }
[15:32:28.371]                       invisible(muffled)
[15:32:28.371]                     }
[15:32:28.371]                     muffleCondition(cond, pattern = "^muffle")
[15:32:28.371]                   }
[15:32:28.371]                 }
[15:32:28.371]                 else {
[15:32:28.371]                   if (TRUE) {
[15:32:28.371]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:28.371]                     {
[15:32:28.371]                       inherits <- base::inherits
[15:32:28.371]                       invokeRestart <- base::invokeRestart
[15:32:28.371]                       is.null <- base::is.null
[15:32:28.371]                       muffled <- FALSE
[15:32:28.371]                       if (inherits(cond, "message")) {
[15:32:28.371]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:28.371]                         if (muffled) 
[15:32:28.371]                           invokeRestart("muffleMessage")
[15:32:28.371]                       }
[15:32:28.371]                       else if (inherits(cond, "warning")) {
[15:32:28.371]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:28.371]                         if (muffled) 
[15:32:28.371]                           invokeRestart("muffleWarning")
[15:32:28.371]                       }
[15:32:28.371]                       else if (inherits(cond, "condition")) {
[15:32:28.371]                         if (!is.null(pattern)) {
[15:32:28.371]                           computeRestarts <- base::computeRestarts
[15:32:28.371]                           grepl <- base::grepl
[15:32:28.371]                           restarts <- computeRestarts(cond)
[15:32:28.371]                           for (restart in restarts) {
[15:32:28.371]                             name <- restart$name
[15:32:28.371]                             if (is.null(name)) 
[15:32:28.371]                               next
[15:32:28.371]                             if (!grepl(pattern, name)) 
[15:32:28.371]                               next
[15:32:28.371]                             invokeRestart(restart)
[15:32:28.371]                             muffled <- TRUE
[15:32:28.371]                             break
[15:32:28.371]                           }
[15:32:28.371]                         }
[15:32:28.371]                       }
[15:32:28.371]                       invisible(muffled)
[15:32:28.371]                     }
[15:32:28.371]                     muffleCondition(cond, pattern = "^muffle")
[15:32:28.371]                   }
[15:32:28.371]                 }
[15:32:28.371]             }
[15:32:28.371]         }))
[15:32:28.371]     }, error = function(ex) {
[15:32:28.371]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:28.371]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:28.371]                 ...future.rng), started = ...future.startTime, 
[15:32:28.371]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:28.371]             version = "1.8"), class = "FutureResult")
[15:32:28.371]     }, finally = {
[15:32:28.371]         if (!identical(...future.workdir, getwd())) 
[15:32:28.371]             setwd(...future.workdir)
[15:32:28.371]         {
[15:32:28.371]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:28.371]                 ...future.oldOptions$nwarnings <- NULL
[15:32:28.371]             }
[15:32:28.371]             base::options(...future.oldOptions)
[15:32:28.371]             if (.Platform$OS.type == "windows") {
[15:32:28.371]                 old_names <- names(...future.oldEnvVars)
[15:32:28.371]                 envs <- base::Sys.getenv()
[15:32:28.371]                 names <- names(envs)
[15:32:28.371]                 common <- intersect(names, old_names)
[15:32:28.371]                 added <- setdiff(names, old_names)
[15:32:28.371]                 removed <- setdiff(old_names, names)
[15:32:28.371]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:28.371]                   envs[common]]
[15:32:28.371]                 NAMES <- toupper(changed)
[15:32:28.371]                 args <- list()
[15:32:28.371]                 for (kk in seq_along(NAMES)) {
[15:32:28.371]                   name <- changed[[kk]]
[15:32:28.371]                   NAME <- NAMES[[kk]]
[15:32:28.371]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:28.371]                     next
[15:32:28.371]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:28.371]                 }
[15:32:28.371]                 NAMES <- toupper(added)
[15:32:28.371]                 for (kk in seq_along(NAMES)) {
[15:32:28.371]                   name <- added[[kk]]
[15:32:28.371]                   NAME <- NAMES[[kk]]
[15:32:28.371]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:28.371]                     next
[15:32:28.371]                   args[[name]] <- ""
[15:32:28.371]                 }
[15:32:28.371]                 NAMES <- toupper(removed)
[15:32:28.371]                 for (kk in seq_along(NAMES)) {
[15:32:28.371]                   name <- removed[[kk]]
[15:32:28.371]                   NAME <- NAMES[[kk]]
[15:32:28.371]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:28.371]                     next
[15:32:28.371]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:28.371]                 }
[15:32:28.371]                 if (length(args) > 0) 
[15:32:28.371]                   base::do.call(base::Sys.setenv, args = args)
[15:32:28.371]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:28.371]             }
[15:32:28.371]             else {
[15:32:28.371]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:28.371]             }
[15:32:28.371]             {
[15:32:28.371]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:28.371]                   0L) {
[15:32:28.371]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:28.371]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:28.371]                   base::options(opts)
[15:32:28.371]                 }
[15:32:28.371]                 {
[15:32:28.371]                   {
[15:32:28.371]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:28.371]                     NULL
[15:32:28.371]                   }
[15:32:28.371]                   options(future.plan = NULL)
[15:32:28.371]                   if (is.na(NA_character_)) 
[15:32:28.371]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:28.371]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:28.371]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:28.371]                     .init = FALSE)
[15:32:28.371]                 }
[15:32:28.371]             }
[15:32:28.371]         }
[15:32:28.371]     })
[15:32:28.371]     if (TRUE) {
[15:32:28.371]         base::sink(type = "output", split = FALSE)
[15:32:28.371]         if (TRUE) {
[15:32:28.371]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:28.371]         }
[15:32:28.371]         else {
[15:32:28.371]             ...future.result["stdout"] <- base::list(NULL)
[15:32:28.371]         }
[15:32:28.371]         base::close(...future.stdout)
[15:32:28.371]         ...future.stdout <- NULL
[15:32:28.371]     }
[15:32:28.371]     ...future.result$conditions <- ...future.conditions
[15:32:28.371]     ...future.result$finished <- base::Sys.time()
[15:32:28.371]     ...future.result
[15:32:28.371] }
[15:32:28.376] Exporting 5 global objects (848 bytes) to cluster node #1 ...
[15:32:28.377] Exporting '...future.FUN' (848 bytes) to cluster node #1 ...
[15:32:28.377] Exporting '...future.FUN' (848 bytes) to cluster node #1 ... DONE
[15:32:28.378] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:28.378] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:28.378] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ...
[15:32:28.379] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ... DONE
[15:32:28.379] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:28.380] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:28.380] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:28.381] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:28.381] Exporting 5 global objects (848 bytes) to cluster node #1 ... DONE
[15:32:28.382] MultisessionFuture started
[15:32:28.382] - Launch lazy future ... done
[15:32:28.382] run() for 'MultisessionFuture' ... done
[15:32:28.383] Created future:
[15:32:28.404] receiveMessageFromWorker() for ClusterFuture ...
[15:32:28.405] - Validating connection of MultisessionFuture
[15:32:28.405] - received message: FutureResult
[15:32:28.405] - Received FutureResult
[15:32:28.406] - Erased future from FutureRegistry
[15:32:28.406] result() for ClusterFuture ...
[15:32:28.406] - result already collected: FutureResult
[15:32:28.406] result() for ClusterFuture ... done
[15:32:28.407] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:28.383] MultisessionFuture:
[15:32:28.383] Label: 'future_sapply-1'
[15:32:28.383] Expression:
[15:32:28.383] {
[15:32:28.383]     do.call(function(...) {
[15:32:28.383]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:28.383]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:28.383]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:28.383]             on.exit(options(oopts), add = TRUE)
[15:32:28.383]         }
[15:32:28.383]         {
[15:32:28.383]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:28.383]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:28.383]                 ...future.FUN(...future.X_jj, ...)
[15:32:28.383]             })
[15:32:28.383]         }
[15:32:28.383]     }, args = future.call.arguments)
[15:32:28.383] }
[15:32:28.383] Lazy evaluation: FALSE
[15:32:28.383] Asynchronous evaluation: TRUE
[15:32:28.383] Local evaluation: TRUE
[15:32:28.383] Environment: R_GlobalEnv
[15:32:28.383] Capture standard output: TRUE
[15:32:28.383] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:28.383] Globals: 5 objects totaling 904 bytes (function '...future.FUN' of 848 bytes, 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)
[15:32:28.383] Packages: <none>
[15:32:28.383] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:28.383] Resolved: TRUE
[15:32:28.383] Value: <not collected>
[15:32:28.383] Conditions captured: <none>
[15:32:28.383] Early signaling: FALSE
[15:32:28.383] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:28.383] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:28.407] Chunk #1 of 2 ... DONE
[15:32:28.408] Chunk #2 of 2 ...
[15:32:28.408]  - Finding globals in 'X' for chunk #2 ...
[15:32:28.408] getGlobalsAndPackages() ...
[15:32:28.408] Searching for globals...
[15:32:28.409] 
[15:32:28.409] Searching for globals ... DONE
[15:32:28.409] - globals: [0] <none>
[15:32:28.410] getGlobalsAndPackages() ... DONE
[15:32:28.410]    + additional globals found: [n=0] 
[15:32:28.410]    + additional namespaces needed: [n=0] 
[15:32:28.410]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:28.411]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:28.411]  - seeds: <none>
[15:32:28.411]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:28.411] getGlobalsAndPackages() ...
[15:32:28.412] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:28.412] Resolving globals: FALSE
[15:32:28.412] Tweak future expression to call with '...' arguments ...
[15:32:28.412] {
[15:32:28.412]     do.call(function(...) {
[15:32:28.412]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:28.412]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:28.412]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:28.412]             on.exit(options(oopts), add = TRUE)
[15:32:28.412]         }
[15:32:28.412]         {
[15:32:28.412]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:28.412]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:28.412]                 ...future.FUN(...future.X_jj, ...)
[15:32:28.412]             })
[15:32:28.412]         }
[15:32:28.412]     }, args = future.call.arguments)
[15:32:28.412] }
[15:32:28.413] Tweak future expression to call with '...' arguments ... DONE
[15:32:28.414] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:28.414] 
[15:32:28.414] getGlobalsAndPackages() ... DONE
[15:32:28.415] run() for 'Future' ...
[15:32:28.415] - state: 'created'
[15:32:28.416] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:28.432] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:28.432] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:28.433]   - Field: 'node'
[15:32:28.433]   - Field: 'label'
[15:32:28.433]   - Field: 'local'
[15:32:28.434]   - Field: 'owner'
[15:32:28.434]   - Field: 'envir'
[15:32:28.434]   - Field: 'workers'
[15:32:28.434]   - Field: 'packages'
[15:32:28.435]   - Field: 'gc'
[15:32:28.435]   - Field: 'conditions'
[15:32:28.435]   - Field: 'persistent'
[15:32:28.435]   - Field: 'expr'
[15:32:28.436]   - Field: 'uuid'
[15:32:28.436]   - Field: 'seed'
[15:32:28.436]   - Field: 'version'
[15:32:28.437]   - Field: 'result'
[15:32:28.437]   - Field: 'asynchronous'
[15:32:28.437]   - Field: 'calls'
[15:32:28.437]   - Field: 'globals'
[15:32:28.438]   - Field: 'stdout'
[15:32:28.438]   - Field: 'earlySignal'
[15:32:28.438]   - Field: 'lazy'
[15:32:28.438]   - Field: 'state'
[15:32:28.439] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:28.439] - Launch lazy future ...
[15:32:28.440] Packages needed by the future expression (n = 0): <none>
[15:32:28.440] Packages needed by future strategies (n = 0): <none>
[15:32:28.441] {
[15:32:28.441]     {
[15:32:28.441]         {
[15:32:28.441]             ...future.startTime <- base::Sys.time()
[15:32:28.441]             {
[15:32:28.441]                 {
[15:32:28.441]                   {
[15:32:28.441]                     {
[15:32:28.441]                       base::local({
[15:32:28.441]                         has_future <- base::requireNamespace("future", 
[15:32:28.441]                           quietly = TRUE)
[15:32:28.441]                         if (has_future) {
[15:32:28.441]                           ns <- base::getNamespace("future")
[15:32:28.441]                           version <- ns[[".package"]][["version"]]
[15:32:28.441]                           if (is.null(version)) 
[15:32:28.441]                             version <- utils::packageVersion("future")
[15:32:28.441]                         }
[15:32:28.441]                         else {
[15:32:28.441]                           version <- NULL
[15:32:28.441]                         }
[15:32:28.441]                         if (!has_future || version < "1.8.0") {
[15:32:28.441]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:28.441]                             "", base::R.version$version.string), 
[15:32:28.441]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:28.441]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:28.441]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:28.441]                               "release", "version")], collapse = " "), 
[15:32:28.441]                             hostname = base::Sys.info()[["nodename"]])
[15:32:28.441]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:28.441]                             info)
[15:32:28.441]                           info <- base::paste(info, collapse = "; ")
[15:32:28.441]                           if (!has_future) {
[15:32:28.441]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:28.441]                               info)
[15:32:28.441]                           }
[15:32:28.441]                           else {
[15:32:28.441]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:28.441]                               info, version)
[15:32:28.441]                           }
[15:32:28.441]                           base::stop(msg)
[15:32:28.441]                         }
[15:32:28.441]                       })
[15:32:28.441]                     }
[15:32:28.441]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:28.441]                     base::options(mc.cores = 1L)
[15:32:28.441]                   }
[15:32:28.441]                   ...future.strategy.old <- future::plan("list")
[15:32:28.441]                   options(future.plan = NULL)
[15:32:28.441]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:28.441]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:28.441]                 }
[15:32:28.441]                 ...future.workdir <- getwd()
[15:32:28.441]             }
[15:32:28.441]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:28.441]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:28.441]         }
[15:32:28.441]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:28.441]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:28.441]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:28.441]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:28.441]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:28.441]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:28.441]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:28.441]             base::names(...future.oldOptions))
[15:32:28.441]     }
[15:32:28.441]     if (FALSE) {
[15:32:28.441]     }
[15:32:28.441]     else {
[15:32:28.441]         if (TRUE) {
[15:32:28.441]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:28.441]                 open = "w")
[15:32:28.441]         }
[15:32:28.441]         else {
[15:32:28.441]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:28.441]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:28.441]         }
[15:32:28.441]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:28.441]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:28.441]             base::sink(type = "output", split = FALSE)
[15:32:28.441]             base::close(...future.stdout)
[15:32:28.441]         }, add = TRUE)
[15:32:28.441]     }
[15:32:28.441]     ...future.frame <- base::sys.nframe()
[15:32:28.441]     ...future.conditions <- base::list()
[15:32:28.441]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:28.441]     if (FALSE) {
[15:32:28.441]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:28.441]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:28.441]     }
[15:32:28.441]     ...future.result <- base::tryCatch({
[15:32:28.441]         base::withCallingHandlers({
[15:32:28.441]             ...future.value <- base::withVisible(base::local({
[15:32:28.441]                 ...future.makeSendCondition <- base::local({
[15:32:28.441]                   sendCondition <- NULL
[15:32:28.441]                   function(frame = 1L) {
[15:32:28.441]                     if (is.function(sendCondition)) 
[15:32:28.441]                       return(sendCondition)
[15:32:28.441]                     ns <- getNamespace("parallel")
[15:32:28.441]                     if (exists("sendData", mode = "function", 
[15:32:28.441]                       envir = ns)) {
[15:32:28.441]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:28.441]                         envir = ns)
[15:32:28.441]                       envir <- sys.frame(frame)
[15:32:28.441]                       master <- NULL
[15:32:28.441]                       while (!identical(envir, .GlobalEnv) && 
[15:32:28.441]                         !identical(envir, emptyenv())) {
[15:32:28.441]                         if (exists("master", mode = "list", envir = envir, 
[15:32:28.441]                           inherits = FALSE)) {
[15:32:28.441]                           master <- get("master", mode = "list", 
[15:32:28.441]                             envir = envir, inherits = FALSE)
[15:32:28.441]                           if (inherits(master, c("SOCKnode", 
[15:32:28.441]                             "SOCK0node"))) {
[15:32:28.441]                             sendCondition <<- function(cond) {
[15:32:28.441]                               data <- list(type = "VALUE", value = cond, 
[15:32:28.441]                                 success = TRUE)
[15:32:28.441]                               parallel_sendData(master, data)
[15:32:28.441]                             }
[15:32:28.441]                             return(sendCondition)
[15:32:28.441]                           }
[15:32:28.441]                         }
[15:32:28.441]                         frame <- frame + 1L
[15:32:28.441]                         envir <- sys.frame(frame)
[15:32:28.441]                       }
[15:32:28.441]                     }
[15:32:28.441]                     sendCondition <<- function(cond) NULL
[15:32:28.441]                   }
[15:32:28.441]                 })
[15:32:28.441]                 withCallingHandlers({
[15:32:28.441]                   {
[15:32:28.441]                     do.call(function(...) {
[15:32:28.441]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:28.441]                       if (!identical(...future.globals.maxSize.org, 
[15:32:28.441]                         ...future.globals.maxSize)) {
[15:32:28.441]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:28.441]                         on.exit(options(oopts), add = TRUE)
[15:32:28.441]                       }
[15:32:28.441]                       {
[15:32:28.441]                         lapply(seq_along(...future.elements_ii), 
[15:32:28.441]                           FUN = function(jj) {
[15:32:28.441]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:28.441]                             ...future.FUN(...future.X_jj, ...)
[15:32:28.441]                           })
[15:32:28.441]                       }
[15:32:28.441]                     }, args = future.call.arguments)
[15:32:28.441]                   }
[15:32:28.441]                 }, immediateCondition = function(cond) {
[15:32:28.441]                   sendCondition <- ...future.makeSendCondition()
[15:32:28.441]                   sendCondition(cond)
[15:32:28.441]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:28.441]                   {
[15:32:28.441]                     inherits <- base::inherits
[15:32:28.441]                     invokeRestart <- base::invokeRestart
[15:32:28.441]                     is.null <- base::is.null
[15:32:28.441]                     muffled <- FALSE
[15:32:28.441]                     if (inherits(cond, "message")) {
[15:32:28.441]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:28.441]                       if (muffled) 
[15:32:28.441]                         invokeRestart("muffleMessage")
[15:32:28.441]                     }
[15:32:28.441]                     else if (inherits(cond, "warning")) {
[15:32:28.441]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:28.441]                       if (muffled) 
[15:32:28.441]                         invokeRestart("muffleWarning")
[15:32:28.441]                     }
[15:32:28.441]                     else if (inherits(cond, "condition")) {
[15:32:28.441]                       if (!is.null(pattern)) {
[15:32:28.441]                         computeRestarts <- base::computeRestarts
[15:32:28.441]                         grepl <- base::grepl
[15:32:28.441]                         restarts <- computeRestarts(cond)
[15:32:28.441]                         for (restart in restarts) {
[15:32:28.441]                           name <- restart$name
[15:32:28.441]                           if (is.null(name)) 
[15:32:28.441]                             next
[15:32:28.441]                           if (!grepl(pattern, name)) 
[15:32:28.441]                             next
[15:32:28.441]                           invokeRestart(restart)
[15:32:28.441]                           muffled <- TRUE
[15:32:28.441]                           break
[15:32:28.441]                         }
[15:32:28.441]                       }
[15:32:28.441]                     }
[15:32:28.441]                     invisible(muffled)
[15:32:28.441]                   }
[15:32:28.441]                   muffleCondition(cond)
[15:32:28.441]                 })
[15:32:28.441]             }))
[15:32:28.441]             future::FutureResult(value = ...future.value$value, 
[15:32:28.441]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:28.441]                   ...future.rng), globalenv = if (FALSE) 
[15:32:28.441]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:28.441]                     ...future.globalenv.names))
[15:32:28.441]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:28.441]         }, condition = base::local({
[15:32:28.441]             c <- base::c
[15:32:28.441]             inherits <- base::inherits
[15:32:28.441]             invokeRestart <- base::invokeRestart
[15:32:28.441]             length <- base::length
[15:32:28.441]             list <- base::list
[15:32:28.441]             seq.int <- base::seq.int
[15:32:28.441]             signalCondition <- base::signalCondition
[15:32:28.441]             sys.calls <- base::sys.calls
[15:32:28.441]             `[[` <- base::`[[`
[15:32:28.441]             `+` <- base::`+`
[15:32:28.441]             `<<-` <- base::`<<-`
[15:32:28.441]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:28.441]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:28.441]                   3L)]
[15:32:28.441]             }
[15:32:28.441]             function(cond) {
[15:32:28.441]                 is_error <- inherits(cond, "error")
[15:32:28.441]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:28.441]                   NULL)
[15:32:28.441]                 if (is_error) {
[15:32:28.441]                   sessionInformation <- function() {
[15:32:28.441]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:28.441]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:28.441]                       search = base::search(), system = base::Sys.info())
[15:32:28.441]                   }
[15:32:28.441]                   ...future.conditions[[length(...future.conditions) + 
[15:32:28.441]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:28.441]                     cond$call), session = sessionInformation(), 
[15:32:28.441]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:28.441]                   signalCondition(cond)
[15:32:28.441]                 }
[15:32:28.441]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:28.441]                 "immediateCondition"))) {
[15:32:28.441]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:28.441]                   ...future.conditions[[length(...future.conditions) + 
[15:32:28.441]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:28.441]                   if (TRUE && !signal) {
[15:32:28.441]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:28.441]                     {
[15:32:28.441]                       inherits <- base::inherits
[15:32:28.441]                       invokeRestart <- base::invokeRestart
[15:32:28.441]                       is.null <- base::is.null
[15:32:28.441]                       muffled <- FALSE
[15:32:28.441]                       if (inherits(cond, "message")) {
[15:32:28.441]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:28.441]                         if (muffled) 
[15:32:28.441]                           invokeRestart("muffleMessage")
[15:32:28.441]                       }
[15:32:28.441]                       else if (inherits(cond, "warning")) {
[15:32:28.441]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:28.441]                         if (muffled) 
[15:32:28.441]                           invokeRestart("muffleWarning")
[15:32:28.441]                       }
[15:32:28.441]                       else if (inherits(cond, "condition")) {
[15:32:28.441]                         if (!is.null(pattern)) {
[15:32:28.441]                           computeRestarts <- base::computeRestarts
[15:32:28.441]                           grepl <- base::grepl
[15:32:28.441]                           restarts <- computeRestarts(cond)
[15:32:28.441]                           for (restart in restarts) {
[15:32:28.441]                             name <- restart$name
[15:32:28.441]                             if (is.null(name)) 
[15:32:28.441]                               next
[15:32:28.441]                             if (!grepl(pattern, name)) 
[15:32:28.441]                               next
[15:32:28.441]                             invokeRestart(restart)
[15:32:28.441]                             muffled <- TRUE
[15:32:28.441]                             break
[15:32:28.441]                           }
[15:32:28.441]                         }
[15:32:28.441]                       }
[15:32:28.441]                       invisible(muffled)
[15:32:28.441]                     }
[15:32:28.441]                     muffleCondition(cond, pattern = "^muffle")
[15:32:28.441]                   }
[15:32:28.441]                 }
[15:32:28.441]                 else {
[15:32:28.441]                   if (TRUE) {
[15:32:28.441]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:28.441]                     {
[15:32:28.441]                       inherits <- base::inherits
[15:32:28.441]                       invokeRestart <- base::invokeRestart
[15:32:28.441]                       is.null <- base::is.null
[15:32:28.441]                       muffled <- FALSE
[15:32:28.441]                       if (inherits(cond, "message")) {
[15:32:28.441]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:28.441]                         if (muffled) 
[15:32:28.441]                           invokeRestart("muffleMessage")
[15:32:28.441]                       }
[15:32:28.441]                       else if (inherits(cond, "warning")) {
[15:32:28.441]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:28.441]                         if (muffled) 
[15:32:28.441]                           invokeRestart("muffleWarning")
[15:32:28.441]                       }
[15:32:28.441]                       else if (inherits(cond, "condition")) {
[15:32:28.441]                         if (!is.null(pattern)) {
[15:32:28.441]                           computeRestarts <- base::computeRestarts
[15:32:28.441]                           grepl <- base::grepl
[15:32:28.441]                           restarts <- computeRestarts(cond)
[15:32:28.441]                           for (restart in restarts) {
[15:32:28.441]                             name <- restart$name
[15:32:28.441]                             if (is.null(name)) 
[15:32:28.441]                               next
[15:32:28.441]                             if (!grepl(pattern, name)) 
[15:32:28.441]                               next
[15:32:28.441]                             invokeRestart(restart)
[15:32:28.441]                             muffled <- TRUE
[15:32:28.441]                             break
[15:32:28.441]                           }
[15:32:28.441]                         }
[15:32:28.441]                       }
[15:32:28.441]                       invisible(muffled)
[15:32:28.441]                     }
[15:32:28.441]                     muffleCondition(cond, pattern = "^muffle")
[15:32:28.441]                   }
[15:32:28.441]                 }
[15:32:28.441]             }
[15:32:28.441]         }))
[15:32:28.441]     }, error = function(ex) {
[15:32:28.441]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:28.441]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:28.441]                 ...future.rng), started = ...future.startTime, 
[15:32:28.441]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:28.441]             version = "1.8"), class = "FutureResult")
[15:32:28.441]     }, finally = {
[15:32:28.441]         if (!identical(...future.workdir, getwd())) 
[15:32:28.441]             setwd(...future.workdir)
[15:32:28.441]         {
[15:32:28.441]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:28.441]                 ...future.oldOptions$nwarnings <- NULL
[15:32:28.441]             }
[15:32:28.441]             base::options(...future.oldOptions)
[15:32:28.441]             if (.Platform$OS.type == "windows") {
[15:32:28.441]                 old_names <- names(...future.oldEnvVars)
[15:32:28.441]                 envs <- base::Sys.getenv()
[15:32:28.441]                 names <- names(envs)
[15:32:28.441]                 common <- intersect(names, old_names)
[15:32:28.441]                 added <- setdiff(names, old_names)
[15:32:28.441]                 removed <- setdiff(old_names, names)
[15:32:28.441]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:28.441]                   envs[common]]
[15:32:28.441]                 NAMES <- toupper(changed)
[15:32:28.441]                 args <- list()
[15:32:28.441]                 for (kk in seq_along(NAMES)) {
[15:32:28.441]                   name <- changed[[kk]]
[15:32:28.441]                   NAME <- NAMES[[kk]]
[15:32:28.441]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:28.441]                     next
[15:32:28.441]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:28.441]                 }
[15:32:28.441]                 NAMES <- toupper(added)
[15:32:28.441]                 for (kk in seq_along(NAMES)) {
[15:32:28.441]                   name <- added[[kk]]
[15:32:28.441]                   NAME <- NAMES[[kk]]
[15:32:28.441]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:28.441]                     next
[15:32:28.441]                   args[[name]] <- ""
[15:32:28.441]                 }
[15:32:28.441]                 NAMES <- toupper(removed)
[15:32:28.441]                 for (kk in seq_along(NAMES)) {
[15:32:28.441]                   name <- removed[[kk]]
[15:32:28.441]                   NAME <- NAMES[[kk]]
[15:32:28.441]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:28.441]                     next
[15:32:28.441]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:28.441]                 }
[15:32:28.441]                 if (length(args) > 0) 
[15:32:28.441]                   base::do.call(base::Sys.setenv, args = args)
[15:32:28.441]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:28.441]             }
[15:32:28.441]             else {
[15:32:28.441]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:28.441]             }
[15:32:28.441]             {
[15:32:28.441]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:28.441]                   0L) {
[15:32:28.441]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:28.441]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:28.441]                   base::options(opts)
[15:32:28.441]                 }
[15:32:28.441]                 {
[15:32:28.441]                   {
[15:32:28.441]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:28.441]                     NULL
[15:32:28.441]                   }
[15:32:28.441]                   options(future.plan = NULL)
[15:32:28.441]                   if (is.na(NA_character_)) 
[15:32:28.441]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:28.441]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:28.441]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:28.441]                     .init = FALSE)
[15:32:28.441]                 }
[15:32:28.441]             }
[15:32:28.441]         }
[15:32:28.441]     })
[15:32:28.441]     if (TRUE) {
[15:32:28.441]         base::sink(type = "output", split = FALSE)
[15:32:28.441]         if (TRUE) {
[15:32:28.441]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:28.441]         }
[15:32:28.441]         else {
[15:32:28.441]             ...future.result["stdout"] <- base::list(NULL)
[15:32:28.441]         }
[15:32:28.441]         base::close(...future.stdout)
[15:32:28.441]         ...future.stdout <- NULL
[15:32:28.441]     }
[15:32:28.441]     ...future.result$conditions <- ...future.conditions
[15:32:28.441]     ...future.result$finished <- base::Sys.time()
[15:32:28.441]     ...future.result
[15:32:28.441] }
[15:32:28.449] Exporting 5 global objects (848 bytes) to cluster node #1 ...
[15:32:28.449] Exporting '...future.FUN' (848 bytes) to cluster node #1 ...
[15:32:28.450] Exporting '...future.FUN' (848 bytes) to cluster node #1 ... DONE
[15:32:28.450] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:28.451] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:28.451] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:28.452] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:28.453] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:28.453] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:28.457] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:28.457] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:28.458] Exporting 5 global objects (848 bytes) to cluster node #1 ... DONE
[15:32:28.459] MultisessionFuture started
[15:32:28.459] - Launch lazy future ... done
[15:32:28.459] run() for 'MultisessionFuture' ... done
[15:32:28.459] Created future:
[15:32:28.479] receiveMessageFromWorker() for ClusterFuture ...
[15:32:28.479] - Validating connection of MultisessionFuture
[15:32:28.480] - received message: FutureResult
[15:32:28.480] - Received FutureResult
[15:32:28.480] - Erased future from FutureRegistry
[15:32:28.481] result() for ClusterFuture ...
[15:32:28.481] - result already collected: FutureResult
[15:32:28.481] result() for ClusterFuture ... done
[15:32:28.481] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:28.460] MultisessionFuture:
[15:32:28.460] Label: 'future_sapply-2'
[15:32:28.460] Expression:
[15:32:28.460] {
[15:32:28.460]     do.call(function(...) {
[15:32:28.460]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:28.460]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:28.460]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:28.460]             on.exit(options(oopts), add = TRUE)
[15:32:28.460]         }
[15:32:28.460]         {
[15:32:28.460]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:28.460]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:28.460]                 ...future.FUN(...future.X_jj, ...)
[15:32:28.460]             })
[15:32:28.460]         }
[15:32:28.460]     }, args = future.call.arguments)
[15:32:28.460] }
[15:32:28.460] Lazy evaluation: FALSE
[15:32:28.460] Asynchronous evaluation: TRUE
[15:32:28.460] Local evaluation: TRUE
[15:32:28.460] Environment: R_GlobalEnv
[15:32:28.460] Capture standard output: TRUE
[15:32:28.460] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:28.460] Globals: 5 objects totaling 960 bytes (function '...future.FUN' of 848 bytes, 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)
[15:32:28.460] Packages: <none>
[15:32:28.460] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:28.460] Resolved: TRUE
[15:32:28.460] Value: <not collected>
[15:32:28.460] Conditions captured: <none>
[15:32:28.460] Early signaling: FALSE
[15:32:28.460] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:28.460] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:28.482] Chunk #2 of 2 ... DONE
[15:32:28.482] Launching 2 futures (chunks) ... DONE
[15:32:28.482] Resolving 2 futures (chunks) ...
[15:32:28.483] resolve() on list ...
[15:32:28.483]  recursive: 0
[15:32:28.483]  length: 2
[15:32:28.483] 
[15:32:28.483] Future #1
[15:32:28.484] result() for ClusterFuture ...
[15:32:28.484] - result already collected: FutureResult
[15:32:28.484] result() for ClusterFuture ... done
[15:32:28.484] result() for ClusterFuture ...
[15:32:28.485] - result already collected: FutureResult
[15:32:28.485] result() for ClusterFuture ... done
[15:32:28.485] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:28.485] - nx: 2
[15:32:28.486] - relay: TRUE
[15:32:28.486] - stdout: TRUE
[15:32:28.486] - signal: TRUE
[15:32:28.486] - resignal: FALSE
[15:32:28.486] - force: TRUE
[15:32:28.487] - relayed: [n=2] FALSE, FALSE
[15:32:28.487] - queued futures: [n=2] FALSE, FALSE
[15:32:28.487]  - until=1
[15:32:28.487]  - relaying element #1
[15:32:28.488] result() for ClusterFuture ...
[15:32:28.488] - result already collected: FutureResult
[15:32:28.488] result() for ClusterFuture ... done
[15:32:28.488] result() for ClusterFuture ...
[15:32:28.488] - result already collected: FutureResult
[15:32:28.488] result() for ClusterFuture ... done
[15:32:28.489] result() for ClusterFuture ...
[15:32:28.489] - result already collected: FutureResult
[15:32:28.489] result() for ClusterFuture ... done
[15:32:28.489] result() for ClusterFuture ...
[15:32:28.489] - result already collected: FutureResult
[15:32:28.489] result() for ClusterFuture ... done
[15:32:28.490] - relayed: [n=2] TRUE, FALSE
[15:32:28.490] - queued futures: [n=2] TRUE, FALSE
[15:32:28.490] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:28.490]  length: 1 (resolved future 1)
[15:32:28.491] Future #2
[15:32:28.491] result() for ClusterFuture ...
[15:32:28.491] - result already collected: FutureResult
[15:32:28.492] result() for ClusterFuture ... done
[15:32:28.492] result() for ClusterFuture ...
[15:32:28.492] - result already collected: FutureResult
[15:32:28.492] result() for ClusterFuture ... done
[15:32:28.492] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:28.493] - nx: 2
[15:32:28.493] - relay: TRUE
[15:32:28.493] - stdout: TRUE
[15:32:28.493] - signal: TRUE
[15:32:28.493] - resignal: FALSE
[15:32:28.493] - force: TRUE
[15:32:28.494] - relayed: [n=2] TRUE, FALSE
[15:32:28.494] - queued futures: [n=2] TRUE, FALSE
[15:32:28.494]  - until=2
[15:32:28.494]  - relaying element #2
[15:32:28.494] result() for ClusterFuture ...
[15:32:28.494] - result already collected: FutureResult
[15:32:28.495] result() for ClusterFuture ... done
[15:32:28.495] result() for ClusterFuture ...
[15:32:28.495] - result already collected: FutureResult
[15:32:28.495] result() for ClusterFuture ... done
[15:32:28.495] result() for ClusterFuture ...
[15:32:28.496] - result already collected: FutureResult
[15:32:28.496] result() for ClusterFuture ... done
[15:32:28.496] result() for ClusterFuture ...
[15:32:28.496] - result already collected: FutureResult
[15:32:28.496] result() for ClusterFuture ... done
[15:32:28.496] - relayed: [n=2] TRUE, TRUE
[15:32:28.497] - queued futures: [n=2] TRUE, TRUE
[15:32:28.497] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:28.497]  length: 0 (resolved future 2)
[15:32:28.497] Relaying remaining futures
[15:32:28.497] signalConditionsASAP(NULL, pos=0) ...
[15:32:28.498] - nx: 2
[15:32:28.498] - relay: TRUE
[15:32:28.498] - stdout: TRUE
[15:32:28.498] - signal: TRUE
[15:32:28.498] - resignal: FALSE
[15:32:28.498] - force: TRUE
[15:32:28.498] - relayed: [n=2] TRUE, TRUE
[15:32:28.499] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:28.499] - relayed: [n=2] TRUE, TRUE
[15:32:28.499] - queued futures: [n=2] TRUE, TRUE
[15:32:28.500] signalConditionsASAP(NULL, pos=0) ... done
[15:32:28.500] resolve() on list ... DONE
[15:32:28.500] result() for ClusterFuture ...
[15:32:28.500] - result already collected: FutureResult
[15:32:28.501] result() for ClusterFuture ... done
[15:32:28.501] result() for ClusterFuture ...
[15:32:28.501] - result already collected: FutureResult
[15:32:28.501] result() for ClusterFuture ... done
[15:32:28.501] result() for ClusterFuture ...
[15:32:28.502] - result already collected: FutureResult
[15:32:28.502] result() for ClusterFuture ... done
[15:32:28.502] result() for ClusterFuture ...
[15:32:28.502] - result already collected: FutureResult
[15:32:28.502] result() for ClusterFuture ... done
[15:32:28.502]  - Number of value chunks collected: 2
[15:32:28.503] Resolving 2 futures (chunks) ... DONE
[15:32:28.503] Reducing values from 2 chunks ...
[15:32:28.503]  - Number of values collected after concatenation: 3
[15:32:28.503]  - Number of values expected: 3
[15:32:28.503] Reducing values from 2 chunks ... DONE
[15:32:28.504] future_lapply() ... DONE
List of 2
 $ y0: Named num [1:3] 1 2 3
  ..- attr(*, "names")= chr [1:3] "a" "b" "c"
 $ y1: Named num [1:3] 1 2 3
  ..- attr(*, "names")= chr [1:3] "a" "b" "c"
[15:32:28.507] future_lapply() ...
[15:32:28.510] Number of chunks: 2
[15:32:28.510] getGlobalsAndPackagesXApply() ...
[15:32:28.510]  - future.globals: TRUE
[15:32:28.510] getGlobalsAndPackages() ...
[15:32:28.511] Searching for globals...
[15:32:28.512] - globals found: [2] 'FUN', 'UseMethod'
[15:32:28.513] Searching for globals ... DONE
[15:32:28.513] Resolving globals: FALSE
[15:32:28.514] The total size of the 1 globals is 1.22 KiB (1248 bytes)
[15:32:28.514] The total size of the 1 globals exported for future expression ('FUN()') is 1.22 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.22 KiB of class 'function')
[15:32:28.514] - globals: [1] 'FUN'
[15:32:28.515] 
[15:32:28.515] getGlobalsAndPackages() ... DONE
[15:32:28.515]  - globals found/used: [n=1] 'FUN'
[15:32:28.515]  - needed namespaces: [n=0] 
[15:32:28.516] Finding globals ... DONE
[15:32:28.516]  - use_args: TRUE
[15:32:28.516]  - Getting '...' globals ...
[15:32:28.517] resolve() on list ...
[15:32:28.517]  recursive: 0
[15:32:28.518]  length: 1
[15:32:28.518]  elements: '...'
[15:32:28.518]  length: 0 (resolved future 1)
[15:32:28.518] resolve() on list ... DONE
[15:32:28.519]    - '...' content: [n=0] 
[15:32:28.519] List of 1
[15:32:28.519]  $ ...: list()
[15:32:28.519]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:28.519]  - attr(*, "where")=List of 1
[15:32:28.519]   ..$ ...:<environment: 0x00000276e1c989d0> 
[15:32:28.519]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:28.519]  - attr(*, "resolved")= logi TRUE
[15:32:28.519]  - attr(*, "total_size")= num NA
[15:32:28.524]  - Getting '...' globals ... DONE
[15:32:28.524] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:28.524] List of 2
[15:32:28.524]  $ ...future.FUN:function (x, ...)  
[15:32:28.524]  $ ...          : list()
[15:32:28.524]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:28.524]  - attr(*, "where")=List of 2
[15:32:28.524]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:28.524]   ..$ ...          :<environment: 0x00000276e1c989d0> 
[15:32:28.524]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:28.524]  - attr(*, "resolved")= logi FALSE
[15:32:28.524]  - attr(*, "total_size")= num 1248
[15:32:28.528] Packages to be attached in all futures: [n=0] 
[15:32:28.528] getGlobalsAndPackagesXApply() ... DONE
[15:32:28.528] Number of futures (= number of chunks): 2
[15:32:28.529] Launching 2 futures (chunks) ...
[15:32:28.529] Chunk #1 of 2 ...
[15:32:28.529]  - Finding globals in 'X' for chunk #1 ...
[15:32:28.529] getGlobalsAndPackages() ...
[15:32:28.529] Searching for globals...
[15:32:28.530] 
[15:32:28.530] Searching for globals ... DONE
[15:32:28.530] - globals: [0] <none>
[15:32:28.530] getGlobalsAndPackages() ... DONE
[15:32:28.531]    + additional globals found: [n=0] 
[15:32:28.531]    + additional namespaces needed: [n=0] 
[15:32:28.531]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:28.532]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:28.532]  - seeds: <none>
[15:32:28.532]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:28.532] getGlobalsAndPackages() ...
[15:32:28.533] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:28.533] Resolving globals: FALSE
[15:32:28.533] Tweak future expression to call with '...' arguments ...
[15:32:28.533] {
[15:32:28.533]     do.call(function(...) {
[15:32:28.533]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:28.533]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:28.533]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:28.533]             on.exit(options(oopts), add = TRUE)
[15:32:28.533]         }
[15:32:28.533]         {
[15:32:28.533]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:28.533]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:28.533]                 ...future.FUN(...future.X_jj, ...)
[15:32:28.533]             })
[15:32:28.533]         }
[15:32:28.533]     }, args = future.call.arguments)
[15:32:28.533] }
[15:32:28.534] Tweak future expression to call with '...' arguments ... DONE
[15:32:28.534] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:28.534] 
[15:32:28.535] getGlobalsAndPackages() ... DONE
[15:32:28.535] run() for 'Future' ...
[15:32:28.535] - state: 'created'
[15:32:28.536] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:28.552] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:28.553] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:28.553]   - Field: 'node'
[15:32:28.553]   - Field: 'label'
[15:32:28.554]   - Field: 'local'
[15:32:28.554]   - Field: 'owner'
[15:32:28.554]   - Field: 'envir'
[15:32:28.555]   - Field: 'workers'
[15:32:28.555]   - Field: 'packages'
[15:32:28.555]   - Field: 'gc'
[15:32:28.556]   - Field: 'conditions'
[15:32:28.556]   - Field: 'persistent'
[15:32:28.556]   - Field: 'expr'
[15:32:28.557]   - Field: 'uuid'
[15:32:28.557]   - Field: 'seed'
[15:32:28.557]   - Field: 'version'
[15:32:28.558]   - Field: 'result'
[15:32:28.558]   - Field: 'asynchronous'
[15:32:28.558]   - Field: 'calls'
[15:32:28.559]   - Field: 'globals'
[15:32:28.559]   - Field: 'stdout'
[15:32:28.559]   - Field: 'earlySignal'
[15:32:28.560]   - Field: 'lazy'
[15:32:28.560]   - Field: 'state'
[15:32:28.560] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:28.561] - Launch lazy future ...
[15:32:28.562] Packages needed by the future expression (n = 0): <none>
[15:32:28.562] Packages needed by future strategies (n = 0): <none>
[15:32:28.563] {
[15:32:28.563]     {
[15:32:28.563]         {
[15:32:28.563]             ...future.startTime <- base::Sys.time()
[15:32:28.563]             {
[15:32:28.563]                 {
[15:32:28.563]                   {
[15:32:28.563]                     {
[15:32:28.563]                       base::local({
[15:32:28.563]                         has_future <- base::requireNamespace("future", 
[15:32:28.563]                           quietly = TRUE)
[15:32:28.563]                         if (has_future) {
[15:32:28.563]                           ns <- base::getNamespace("future")
[15:32:28.563]                           version <- ns[[".package"]][["version"]]
[15:32:28.563]                           if (is.null(version)) 
[15:32:28.563]                             version <- utils::packageVersion("future")
[15:32:28.563]                         }
[15:32:28.563]                         else {
[15:32:28.563]                           version <- NULL
[15:32:28.563]                         }
[15:32:28.563]                         if (!has_future || version < "1.8.0") {
[15:32:28.563]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:28.563]                             "", base::R.version$version.string), 
[15:32:28.563]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:28.563]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:28.563]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:28.563]                               "release", "version")], collapse = " "), 
[15:32:28.563]                             hostname = base::Sys.info()[["nodename"]])
[15:32:28.563]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:28.563]                             info)
[15:32:28.563]                           info <- base::paste(info, collapse = "; ")
[15:32:28.563]                           if (!has_future) {
[15:32:28.563]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:28.563]                               info)
[15:32:28.563]                           }
[15:32:28.563]                           else {
[15:32:28.563]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:28.563]                               info, version)
[15:32:28.563]                           }
[15:32:28.563]                           base::stop(msg)
[15:32:28.563]                         }
[15:32:28.563]                       })
[15:32:28.563]                     }
[15:32:28.563]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:28.563]                     base::options(mc.cores = 1L)
[15:32:28.563]                   }
[15:32:28.563]                   ...future.strategy.old <- future::plan("list")
[15:32:28.563]                   options(future.plan = NULL)
[15:32:28.563]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:28.563]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:28.563]                 }
[15:32:28.563]                 ...future.workdir <- getwd()
[15:32:28.563]             }
[15:32:28.563]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:28.563]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:28.563]         }
[15:32:28.563]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:28.563]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:28.563]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:28.563]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:28.563]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:28.563]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:28.563]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:28.563]             base::names(...future.oldOptions))
[15:32:28.563]     }
[15:32:28.563]     if (FALSE) {
[15:32:28.563]     }
[15:32:28.563]     else {
[15:32:28.563]         if (TRUE) {
[15:32:28.563]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:28.563]                 open = "w")
[15:32:28.563]         }
[15:32:28.563]         else {
[15:32:28.563]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:28.563]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:28.563]         }
[15:32:28.563]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:28.563]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:28.563]             base::sink(type = "output", split = FALSE)
[15:32:28.563]             base::close(...future.stdout)
[15:32:28.563]         }, add = TRUE)
[15:32:28.563]     }
[15:32:28.563]     ...future.frame <- base::sys.nframe()
[15:32:28.563]     ...future.conditions <- base::list()
[15:32:28.563]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:28.563]     if (FALSE) {
[15:32:28.563]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:28.563]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:28.563]     }
[15:32:28.563]     ...future.result <- base::tryCatch({
[15:32:28.563]         base::withCallingHandlers({
[15:32:28.563]             ...future.value <- base::withVisible(base::local({
[15:32:28.563]                 ...future.makeSendCondition <- base::local({
[15:32:28.563]                   sendCondition <- NULL
[15:32:28.563]                   function(frame = 1L) {
[15:32:28.563]                     if (is.function(sendCondition)) 
[15:32:28.563]                       return(sendCondition)
[15:32:28.563]                     ns <- getNamespace("parallel")
[15:32:28.563]                     if (exists("sendData", mode = "function", 
[15:32:28.563]                       envir = ns)) {
[15:32:28.563]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:28.563]                         envir = ns)
[15:32:28.563]                       envir <- sys.frame(frame)
[15:32:28.563]                       master <- NULL
[15:32:28.563]                       while (!identical(envir, .GlobalEnv) && 
[15:32:28.563]                         !identical(envir, emptyenv())) {
[15:32:28.563]                         if (exists("master", mode = "list", envir = envir, 
[15:32:28.563]                           inherits = FALSE)) {
[15:32:28.563]                           master <- get("master", mode = "list", 
[15:32:28.563]                             envir = envir, inherits = FALSE)
[15:32:28.563]                           if (inherits(master, c("SOCKnode", 
[15:32:28.563]                             "SOCK0node"))) {
[15:32:28.563]                             sendCondition <<- function(cond) {
[15:32:28.563]                               data <- list(type = "VALUE", value = cond, 
[15:32:28.563]                                 success = TRUE)
[15:32:28.563]                               parallel_sendData(master, data)
[15:32:28.563]                             }
[15:32:28.563]                             return(sendCondition)
[15:32:28.563]                           }
[15:32:28.563]                         }
[15:32:28.563]                         frame <- frame + 1L
[15:32:28.563]                         envir <- sys.frame(frame)
[15:32:28.563]                       }
[15:32:28.563]                     }
[15:32:28.563]                     sendCondition <<- function(cond) NULL
[15:32:28.563]                   }
[15:32:28.563]                 })
[15:32:28.563]                 withCallingHandlers({
[15:32:28.563]                   {
[15:32:28.563]                     do.call(function(...) {
[15:32:28.563]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:28.563]                       if (!identical(...future.globals.maxSize.org, 
[15:32:28.563]                         ...future.globals.maxSize)) {
[15:32:28.563]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:28.563]                         on.exit(options(oopts), add = TRUE)
[15:32:28.563]                       }
[15:32:28.563]                       {
[15:32:28.563]                         lapply(seq_along(...future.elements_ii), 
[15:32:28.563]                           FUN = function(jj) {
[15:32:28.563]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:28.563]                             ...future.FUN(...future.X_jj, ...)
[15:32:28.563]                           })
[15:32:28.563]                       }
[15:32:28.563]                     }, args = future.call.arguments)
[15:32:28.563]                   }
[15:32:28.563]                 }, immediateCondition = function(cond) {
[15:32:28.563]                   sendCondition <- ...future.makeSendCondition()
[15:32:28.563]                   sendCondition(cond)
[15:32:28.563]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:28.563]                   {
[15:32:28.563]                     inherits <- base::inherits
[15:32:28.563]                     invokeRestart <- base::invokeRestart
[15:32:28.563]                     is.null <- base::is.null
[15:32:28.563]                     muffled <- FALSE
[15:32:28.563]                     if (inherits(cond, "message")) {
[15:32:28.563]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:28.563]                       if (muffled) 
[15:32:28.563]                         invokeRestart("muffleMessage")
[15:32:28.563]                     }
[15:32:28.563]                     else if (inherits(cond, "warning")) {
[15:32:28.563]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:28.563]                       if (muffled) 
[15:32:28.563]                         invokeRestart("muffleWarning")
[15:32:28.563]                     }
[15:32:28.563]                     else if (inherits(cond, "condition")) {
[15:32:28.563]                       if (!is.null(pattern)) {
[15:32:28.563]                         computeRestarts <- base::computeRestarts
[15:32:28.563]                         grepl <- base::grepl
[15:32:28.563]                         restarts <- computeRestarts(cond)
[15:32:28.563]                         for (restart in restarts) {
[15:32:28.563]                           name <- restart$name
[15:32:28.563]                           if (is.null(name)) 
[15:32:28.563]                             next
[15:32:28.563]                           if (!grepl(pattern, name)) 
[15:32:28.563]                             next
[15:32:28.563]                           invokeRestart(restart)
[15:32:28.563]                           muffled <- TRUE
[15:32:28.563]                           break
[15:32:28.563]                         }
[15:32:28.563]                       }
[15:32:28.563]                     }
[15:32:28.563]                     invisible(muffled)
[15:32:28.563]                   }
[15:32:28.563]                   muffleCondition(cond)
[15:32:28.563]                 })
[15:32:28.563]             }))
[15:32:28.563]             future::FutureResult(value = ...future.value$value, 
[15:32:28.563]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:28.563]                   ...future.rng), globalenv = if (FALSE) 
[15:32:28.563]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:28.563]                     ...future.globalenv.names))
[15:32:28.563]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:28.563]         }, condition = base::local({
[15:32:28.563]             c <- base::c
[15:32:28.563]             inherits <- base::inherits
[15:32:28.563]             invokeRestart <- base::invokeRestart
[15:32:28.563]             length <- base::length
[15:32:28.563]             list <- base::list
[15:32:28.563]             seq.int <- base::seq.int
[15:32:28.563]             signalCondition <- base::signalCondition
[15:32:28.563]             sys.calls <- base::sys.calls
[15:32:28.563]             `[[` <- base::`[[`
[15:32:28.563]             `+` <- base::`+`
[15:32:28.563]             `<<-` <- base::`<<-`
[15:32:28.563]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:28.563]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:28.563]                   3L)]
[15:32:28.563]             }
[15:32:28.563]             function(cond) {
[15:32:28.563]                 is_error <- inherits(cond, "error")
[15:32:28.563]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:28.563]                   NULL)
[15:32:28.563]                 if (is_error) {
[15:32:28.563]                   sessionInformation <- function() {
[15:32:28.563]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:28.563]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:28.563]                       search = base::search(), system = base::Sys.info())
[15:32:28.563]                   }
[15:32:28.563]                   ...future.conditions[[length(...future.conditions) + 
[15:32:28.563]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:28.563]                     cond$call), session = sessionInformation(), 
[15:32:28.563]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:28.563]                   signalCondition(cond)
[15:32:28.563]                 }
[15:32:28.563]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:28.563]                 "immediateCondition"))) {
[15:32:28.563]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:28.563]                   ...future.conditions[[length(...future.conditions) + 
[15:32:28.563]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:28.563]                   if (TRUE && !signal) {
[15:32:28.563]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:28.563]                     {
[15:32:28.563]                       inherits <- base::inherits
[15:32:28.563]                       invokeRestart <- base::invokeRestart
[15:32:28.563]                       is.null <- base::is.null
[15:32:28.563]                       muffled <- FALSE
[15:32:28.563]                       if (inherits(cond, "message")) {
[15:32:28.563]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:28.563]                         if (muffled) 
[15:32:28.563]                           invokeRestart("muffleMessage")
[15:32:28.563]                       }
[15:32:28.563]                       else if (inherits(cond, "warning")) {
[15:32:28.563]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:28.563]                         if (muffled) 
[15:32:28.563]                           invokeRestart("muffleWarning")
[15:32:28.563]                       }
[15:32:28.563]                       else if (inherits(cond, "condition")) {
[15:32:28.563]                         if (!is.null(pattern)) {
[15:32:28.563]                           computeRestarts <- base::computeRestarts
[15:32:28.563]                           grepl <- base::grepl
[15:32:28.563]                           restarts <- computeRestarts(cond)
[15:32:28.563]                           for (restart in restarts) {
[15:32:28.563]                             name <- restart$name
[15:32:28.563]                             if (is.null(name)) 
[15:32:28.563]                               next
[15:32:28.563]                             if (!grepl(pattern, name)) 
[15:32:28.563]                               next
[15:32:28.563]                             invokeRestart(restart)
[15:32:28.563]                             muffled <- TRUE
[15:32:28.563]                             break
[15:32:28.563]                           }
[15:32:28.563]                         }
[15:32:28.563]                       }
[15:32:28.563]                       invisible(muffled)
[15:32:28.563]                     }
[15:32:28.563]                     muffleCondition(cond, pattern = "^muffle")
[15:32:28.563]                   }
[15:32:28.563]                 }
[15:32:28.563]                 else {
[15:32:28.563]                   if (TRUE) {
[15:32:28.563]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:28.563]                     {
[15:32:28.563]                       inherits <- base::inherits
[15:32:28.563]                       invokeRestart <- base::invokeRestart
[15:32:28.563]                       is.null <- base::is.null
[15:32:28.563]                       muffled <- FALSE
[15:32:28.563]                       if (inherits(cond, "message")) {
[15:32:28.563]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:28.563]                         if (muffled) 
[15:32:28.563]                           invokeRestart("muffleMessage")
[15:32:28.563]                       }
[15:32:28.563]                       else if (inherits(cond, "warning")) {
[15:32:28.563]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:28.563]                         if (muffled) 
[15:32:28.563]                           invokeRestart("muffleWarning")
[15:32:28.563]                       }
[15:32:28.563]                       else if (inherits(cond, "condition")) {
[15:32:28.563]                         if (!is.null(pattern)) {
[15:32:28.563]                           computeRestarts <- base::computeRestarts
[15:32:28.563]                           grepl <- base::grepl
[15:32:28.563]                           restarts <- computeRestarts(cond)
[15:32:28.563]                           for (restart in restarts) {
[15:32:28.563]                             name <- restart$name
[15:32:28.563]                             if (is.null(name)) 
[15:32:28.563]                               next
[15:32:28.563]                             if (!grepl(pattern, name)) 
[15:32:28.563]                               next
[15:32:28.563]                             invokeRestart(restart)
[15:32:28.563]                             muffled <- TRUE
[15:32:28.563]                             break
[15:32:28.563]                           }
[15:32:28.563]                         }
[15:32:28.563]                       }
[15:32:28.563]                       invisible(muffled)
[15:32:28.563]                     }
[15:32:28.563]                     muffleCondition(cond, pattern = "^muffle")
[15:32:28.563]                   }
[15:32:28.563]                 }
[15:32:28.563]             }
[15:32:28.563]         }))
[15:32:28.563]     }, error = function(ex) {
[15:32:28.563]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:28.563]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:28.563]                 ...future.rng), started = ...future.startTime, 
[15:32:28.563]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:28.563]             version = "1.8"), class = "FutureResult")
[15:32:28.563]     }, finally = {
[15:32:28.563]         if (!identical(...future.workdir, getwd())) 
[15:32:28.563]             setwd(...future.workdir)
[15:32:28.563]         {
[15:32:28.563]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:28.563]                 ...future.oldOptions$nwarnings <- NULL
[15:32:28.563]             }
[15:32:28.563]             base::options(...future.oldOptions)
[15:32:28.563]             if (.Platform$OS.type == "windows") {
[15:32:28.563]                 old_names <- names(...future.oldEnvVars)
[15:32:28.563]                 envs <- base::Sys.getenv()
[15:32:28.563]                 names <- names(envs)
[15:32:28.563]                 common <- intersect(names, old_names)
[15:32:28.563]                 added <- setdiff(names, old_names)
[15:32:28.563]                 removed <- setdiff(old_names, names)
[15:32:28.563]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:28.563]                   envs[common]]
[15:32:28.563]                 NAMES <- toupper(changed)
[15:32:28.563]                 args <- list()
[15:32:28.563]                 for (kk in seq_along(NAMES)) {
[15:32:28.563]                   name <- changed[[kk]]
[15:32:28.563]                   NAME <- NAMES[[kk]]
[15:32:28.563]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:28.563]                     next
[15:32:28.563]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:28.563]                 }
[15:32:28.563]                 NAMES <- toupper(added)
[15:32:28.563]                 for (kk in seq_along(NAMES)) {
[15:32:28.563]                   name <- added[[kk]]
[15:32:28.563]                   NAME <- NAMES[[kk]]
[15:32:28.563]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:28.563]                     next
[15:32:28.563]                   args[[name]] <- ""
[15:32:28.563]                 }
[15:32:28.563]                 NAMES <- toupper(removed)
[15:32:28.563]                 for (kk in seq_along(NAMES)) {
[15:32:28.563]                   name <- removed[[kk]]
[15:32:28.563]                   NAME <- NAMES[[kk]]
[15:32:28.563]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:28.563]                     next
[15:32:28.563]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:28.563]                 }
[15:32:28.563]                 if (length(args) > 0) 
[15:32:28.563]                   base::do.call(base::Sys.setenv, args = args)
[15:32:28.563]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:28.563]             }
[15:32:28.563]             else {
[15:32:28.563]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:28.563]             }
[15:32:28.563]             {
[15:32:28.563]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:28.563]                   0L) {
[15:32:28.563]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:28.563]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:28.563]                   base::options(opts)
[15:32:28.563]                 }
[15:32:28.563]                 {
[15:32:28.563]                   {
[15:32:28.563]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:28.563]                     NULL
[15:32:28.563]                   }
[15:32:28.563]                   options(future.plan = NULL)
[15:32:28.563]                   if (is.na(NA_character_)) 
[15:32:28.563]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:28.563]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:28.563]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:28.563]                     .init = FALSE)
[15:32:28.563]                 }
[15:32:28.563]             }
[15:32:28.563]         }
[15:32:28.563]     })
[15:32:28.563]     if (TRUE) {
[15:32:28.563]         base::sink(type = "output", split = FALSE)
[15:32:28.563]         if (TRUE) {
[15:32:28.563]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:28.563]         }
[15:32:28.563]         else {
[15:32:28.563]             ...future.result["stdout"] <- base::list(NULL)
[15:32:28.563]         }
[15:32:28.563]         base::close(...future.stdout)
[15:32:28.563]         ...future.stdout <- NULL
[15:32:28.563]     }
[15:32:28.563]     ...future.result$conditions <- ...future.conditions
[15:32:28.563]     ...future.result$finished <- base::Sys.time()
[15:32:28.563]     ...future.result
[15:32:28.563] }
[15:32:28.572] Exporting 5 global objects (1.22 KiB) to cluster node #1 ...
[15:32:28.573] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ...
[15:32:28.574] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ... DONE
[15:32:28.574] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:28.575] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:28.575] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ...
[15:32:28.576] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ... DONE
[15:32:28.576] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:28.577] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:28.577] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:28.578] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:28.578] Exporting 5 global objects (1.22 KiB) to cluster node #1 ... DONE
[15:32:28.579] MultisessionFuture started
[15:32:28.580] - Launch lazy future ... done
[15:32:28.580] run() for 'MultisessionFuture' ... done
[15:32:28.580] Created future:
[15:32:28.606] receiveMessageFromWorker() for ClusterFuture ...
[15:32:28.606] - Validating connection of MultisessionFuture
[15:32:28.607] - received message: FutureResult
[15:32:28.607] - Received FutureResult
[15:32:28.607] - Erased future from FutureRegistry
[15:32:28.607] result() for ClusterFuture ...
[15:32:28.608] - result already collected: FutureResult
[15:32:28.608] result() for ClusterFuture ... done
[15:32:28.608] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:28.581] MultisessionFuture:
[15:32:28.581] Label: 'future_sapply-1'
[15:32:28.581] Expression:
[15:32:28.581] {
[15:32:28.581]     do.call(function(...) {
[15:32:28.581]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:28.581]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:28.581]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:28.581]             on.exit(options(oopts), add = TRUE)
[15:32:28.581]         }
[15:32:28.581]         {
[15:32:28.581]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:28.581]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:28.581]                 ...future.FUN(...future.X_jj, ...)
[15:32:28.581]             })
[15:32:28.581]         }
[15:32:28.581]     }, args = future.call.arguments)
[15:32:28.581] }
[15:32:28.581] Lazy evaluation: FALSE
[15:32:28.581] Asynchronous evaluation: TRUE
[15:32:28.581] Local evaluation: TRUE
[15:32:28.581] Environment: R_GlobalEnv
[15:32:28.581] Capture standard output: TRUE
[15:32:28.581] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:28.581] Globals: 5 objects totaling 1.27 KiB (function '...future.FUN' of 1.22 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)
[15:32:28.581] Packages: <none>
[15:32:28.581] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:28.581] Resolved: TRUE
[15:32:28.581] Value: <not collected>
[15:32:28.581] Conditions captured: <none>
[15:32:28.581] Early signaling: FALSE
[15:32:28.581] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:28.581] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:28.609] Chunk #1 of 2 ... DONE
[15:32:28.609] Chunk #2 of 2 ...
[15:32:28.609]  - Finding globals in 'X' for chunk #2 ...
[15:32:28.609] getGlobalsAndPackages() ...
[15:32:28.609] Searching for globals...
[15:32:28.610] 
[15:32:28.610] Searching for globals ... DONE
[15:32:28.610] - globals: [0] <none>
[15:32:28.610] getGlobalsAndPackages() ... DONE
[15:32:28.610]    + additional globals found: [n=0] 
[15:32:28.611]    + additional namespaces needed: [n=0] 
[15:32:28.611]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:28.611]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:28.611]  - seeds: <none>
[15:32:28.611]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:28.612] getGlobalsAndPackages() ...
[15:32:28.612] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:28.612] Resolving globals: FALSE
[15:32:28.612] Tweak future expression to call with '...' arguments ...
[15:32:28.613] {
[15:32:28.613]     do.call(function(...) {
[15:32:28.613]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:28.613]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:28.613]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:28.613]             on.exit(options(oopts), add = TRUE)
[15:32:28.613]         }
[15:32:28.613]         {
[15:32:28.613]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:28.613]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:28.613]                 ...future.FUN(...future.X_jj, ...)
[15:32:28.613]             })
[15:32:28.613]         }
[15:32:28.613]     }, args = future.call.arguments)
[15:32:28.613] }
[15:32:28.613] Tweak future expression to call with '...' arguments ... DONE
[15:32:28.614] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:28.614] 
[15:32:28.614] getGlobalsAndPackages() ... DONE
[15:32:28.615] run() for 'Future' ...
[15:32:28.615] - state: 'created'
[15:32:28.615] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:28.631] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:28.632] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:28.632]   - Field: 'node'
[15:32:28.632]   - Field: 'label'
[15:32:28.633]   - Field: 'local'
[15:32:28.633]   - Field: 'owner'
[15:32:28.633]   - Field: 'envir'
[15:32:28.633]   - Field: 'workers'
[15:32:28.633]   - Field: 'packages'
[15:32:28.634]   - Field: 'gc'
[15:32:28.634]   - Field: 'conditions'
[15:32:28.634]   - Field: 'persistent'
[15:32:28.634]   - Field: 'expr'
[15:32:28.634]   - Field: 'uuid'
[15:32:28.634]   - Field: 'seed'
[15:32:28.635]   - Field: 'version'
[15:32:28.635]   - Field: 'result'
[15:32:28.635]   - Field: 'asynchronous'
[15:32:28.635]   - Field: 'calls'
[15:32:28.635]   - Field: 'globals'
[15:32:28.636]   - Field: 'stdout'
[15:32:28.636]   - Field: 'earlySignal'
[15:32:28.636]   - Field: 'lazy'
[15:32:28.636]   - Field: 'state'
[15:32:28.636] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:28.636] - Launch lazy future ...
[15:32:28.637] Packages needed by the future expression (n = 0): <none>
[15:32:28.637] Packages needed by future strategies (n = 0): <none>
[15:32:28.638] {
[15:32:28.638]     {
[15:32:28.638]         {
[15:32:28.638]             ...future.startTime <- base::Sys.time()
[15:32:28.638]             {
[15:32:28.638]                 {
[15:32:28.638]                   {
[15:32:28.638]                     {
[15:32:28.638]                       base::local({
[15:32:28.638]                         has_future <- base::requireNamespace("future", 
[15:32:28.638]                           quietly = TRUE)
[15:32:28.638]                         if (has_future) {
[15:32:28.638]                           ns <- base::getNamespace("future")
[15:32:28.638]                           version <- ns[[".package"]][["version"]]
[15:32:28.638]                           if (is.null(version)) 
[15:32:28.638]                             version <- utils::packageVersion("future")
[15:32:28.638]                         }
[15:32:28.638]                         else {
[15:32:28.638]                           version <- NULL
[15:32:28.638]                         }
[15:32:28.638]                         if (!has_future || version < "1.8.0") {
[15:32:28.638]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:28.638]                             "", base::R.version$version.string), 
[15:32:28.638]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:28.638]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:28.638]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:28.638]                               "release", "version")], collapse = " "), 
[15:32:28.638]                             hostname = base::Sys.info()[["nodename"]])
[15:32:28.638]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:28.638]                             info)
[15:32:28.638]                           info <- base::paste(info, collapse = "; ")
[15:32:28.638]                           if (!has_future) {
[15:32:28.638]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:28.638]                               info)
[15:32:28.638]                           }
[15:32:28.638]                           else {
[15:32:28.638]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:28.638]                               info, version)
[15:32:28.638]                           }
[15:32:28.638]                           base::stop(msg)
[15:32:28.638]                         }
[15:32:28.638]                       })
[15:32:28.638]                     }
[15:32:28.638]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:28.638]                     base::options(mc.cores = 1L)
[15:32:28.638]                   }
[15:32:28.638]                   ...future.strategy.old <- future::plan("list")
[15:32:28.638]                   options(future.plan = NULL)
[15:32:28.638]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:28.638]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:28.638]                 }
[15:32:28.638]                 ...future.workdir <- getwd()
[15:32:28.638]             }
[15:32:28.638]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:28.638]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:28.638]         }
[15:32:28.638]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:28.638]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:28.638]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:28.638]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:28.638]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:28.638]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:28.638]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:28.638]             base::names(...future.oldOptions))
[15:32:28.638]     }
[15:32:28.638]     if (FALSE) {
[15:32:28.638]     }
[15:32:28.638]     else {
[15:32:28.638]         if (TRUE) {
[15:32:28.638]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:28.638]                 open = "w")
[15:32:28.638]         }
[15:32:28.638]         else {
[15:32:28.638]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:28.638]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:28.638]         }
[15:32:28.638]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:28.638]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:28.638]             base::sink(type = "output", split = FALSE)
[15:32:28.638]             base::close(...future.stdout)
[15:32:28.638]         }, add = TRUE)
[15:32:28.638]     }
[15:32:28.638]     ...future.frame <- base::sys.nframe()
[15:32:28.638]     ...future.conditions <- base::list()
[15:32:28.638]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:28.638]     if (FALSE) {
[15:32:28.638]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:28.638]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:28.638]     }
[15:32:28.638]     ...future.result <- base::tryCatch({
[15:32:28.638]         base::withCallingHandlers({
[15:32:28.638]             ...future.value <- base::withVisible(base::local({
[15:32:28.638]                 ...future.makeSendCondition <- base::local({
[15:32:28.638]                   sendCondition <- NULL
[15:32:28.638]                   function(frame = 1L) {
[15:32:28.638]                     if (is.function(sendCondition)) 
[15:32:28.638]                       return(sendCondition)
[15:32:28.638]                     ns <- getNamespace("parallel")
[15:32:28.638]                     if (exists("sendData", mode = "function", 
[15:32:28.638]                       envir = ns)) {
[15:32:28.638]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:28.638]                         envir = ns)
[15:32:28.638]                       envir <- sys.frame(frame)
[15:32:28.638]                       master <- NULL
[15:32:28.638]                       while (!identical(envir, .GlobalEnv) && 
[15:32:28.638]                         !identical(envir, emptyenv())) {
[15:32:28.638]                         if (exists("master", mode = "list", envir = envir, 
[15:32:28.638]                           inherits = FALSE)) {
[15:32:28.638]                           master <- get("master", mode = "list", 
[15:32:28.638]                             envir = envir, inherits = FALSE)
[15:32:28.638]                           if (inherits(master, c("SOCKnode", 
[15:32:28.638]                             "SOCK0node"))) {
[15:32:28.638]                             sendCondition <<- function(cond) {
[15:32:28.638]                               data <- list(type = "VALUE", value = cond, 
[15:32:28.638]                                 success = TRUE)
[15:32:28.638]                               parallel_sendData(master, data)
[15:32:28.638]                             }
[15:32:28.638]                             return(sendCondition)
[15:32:28.638]                           }
[15:32:28.638]                         }
[15:32:28.638]                         frame <- frame + 1L
[15:32:28.638]                         envir <- sys.frame(frame)
[15:32:28.638]                       }
[15:32:28.638]                     }
[15:32:28.638]                     sendCondition <<- function(cond) NULL
[15:32:28.638]                   }
[15:32:28.638]                 })
[15:32:28.638]                 withCallingHandlers({
[15:32:28.638]                   {
[15:32:28.638]                     do.call(function(...) {
[15:32:28.638]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:28.638]                       if (!identical(...future.globals.maxSize.org, 
[15:32:28.638]                         ...future.globals.maxSize)) {
[15:32:28.638]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:28.638]                         on.exit(options(oopts), add = TRUE)
[15:32:28.638]                       }
[15:32:28.638]                       {
[15:32:28.638]                         lapply(seq_along(...future.elements_ii), 
[15:32:28.638]                           FUN = function(jj) {
[15:32:28.638]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:28.638]                             ...future.FUN(...future.X_jj, ...)
[15:32:28.638]                           })
[15:32:28.638]                       }
[15:32:28.638]                     }, args = future.call.arguments)
[15:32:28.638]                   }
[15:32:28.638]                 }, immediateCondition = function(cond) {
[15:32:28.638]                   sendCondition <- ...future.makeSendCondition()
[15:32:28.638]                   sendCondition(cond)
[15:32:28.638]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:28.638]                   {
[15:32:28.638]                     inherits <- base::inherits
[15:32:28.638]                     invokeRestart <- base::invokeRestart
[15:32:28.638]                     is.null <- base::is.null
[15:32:28.638]                     muffled <- FALSE
[15:32:28.638]                     if (inherits(cond, "message")) {
[15:32:28.638]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:28.638]                       if (muffled) 
[15:32:28.638]                         invokeRestart("muffleMessage")
[15:32:28.638]                     }
[15:32:28.638]                     else if (inherits(cond, "warning")) {
[15:32:28.638]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:28.638]                       if (muffled) 
[15:32:28.638]                         invokeRestart("muffleWarning")
[15:32:28.638]                     }
[15:32:28.638]                     else if (inherits(cond, "condition")) {
[15:32:28.638]                       if (!is.null(pattern)) {
[15:32:28.638]                         computeRestarts <- base::computeRestarts
[15:32:28.638]                         grepl <- base::grepl
[15:32:28.638]                         restarts <- computeRestarts(cond)
[15:32:28.638]                         for (restart in restarts) {
[15:32:28.638]                           name <- restart$name
[15:32:28.638]                           if (is.null(name)) 
[15:32:28.638]                             next
[15:32:28.638]                           if (!grepl(pattern, name)) 
[15:32:28.638]                             next
[15:32:28.638]                           invokeRestart(restart)
[15:32:28.638]                           muffled <- TRUE
[15:32:28.638]                           break
[15:32:28.638]                         }
[15:32:28.638]                       }
[15:32:28.638]                     }
[15:32:28.638]                     invisible(muffled)
[15:32:28.638]                   }
[15:32:28.638]                   muffleCondition(cond)
[15:32:28.638]                 })
[15:32:28.638]             }))
[15:32:28.638]             future::FutureResult(value = ...future.value$value, 
[15:32:28.638]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:28.638]                   ...future.rng), globalenv = if (FALSE) 
[15:32:28.638]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:28.638]                     ...future.globalenv.names))
[15:32:28.638]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:28.638]         }, condition = base::local({
[15:32:28.638]             c <- base::c
[15:32:28.638]             inherits <- base::inherits
[15:32:28.638]             invokeRestart <- base::invokeRestart
[15:32:28.638]             length <- base::length
[15:32:28.638]             list <- base::list
[15:32:28.638]             seq.int <- base::seq.int
[15:32:28.638]             signalCondition <- base::signalCondition
[15:32:28.638]             sys.calls <- base::sys.calls
[15:32:28.638]             `[[` <- base::`[[`
[15:32:28.638]             `+` <- base::`+`
[15:32:28.638]             `<<-` <- base::`<<-`
[15:32:28.638]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:28.638]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:28.638]                   3L)]
[15:32:28.638]             }
[15:32:28.638]             function(cond) {
[15:32:28.638]                 is_error <- inherits(cond, "error")
[15:32:28.638]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:28.638]                   NULL)
[15:32:28.638]                 if (is_error) {
[15:32:28.638]                   sessionInformation <- function() {
[15:32:28.638]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:28.638]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:28.638]                       search = base::search(), system = base::Sys.info())
[15:32:28.638]                   }
[15:32:28.638]                   ...future.conditions[[length(...future.conditions) + 
[15:32:28.638]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:28.638]                     cond$call), session = sessionInformation(), 
[15:32:28.638]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:28.638]                   signalCondition(cond)
[15:32:28.638]                 }
[15:32:28.638]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:28.638]                 "immediateCondition"))) {
[15:32:28.638]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:28.638]                   ...future.conditions[[length(...future.conditions) + 
[15:32:28.638]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:28.638]                   if (TRUE && !signal) {
[15:32:28.638]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:28.638]                     {
[15:32:28.638]                       inherits <- base::inherits
[15:32:28.638]                       invokeRestart <- base::invokeRestart
[15:32:28.638]                       is.null <- base::is.null
[15:32:28.638]                       muffled <- FALSE
[15:32:28.638]                       if (inherits(cond, "message")) {
[15:32:28.638]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:28.638]                         if (muffled) 
[15:32:28.638]                           invokeRestart("muffleMessage")
[15:32:28.638]                       }
[15:32:28.638]                       else if (inherits(cond, "warning")) {
[15:32:28.638]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:28.638]                         if (muffled) 
[15:32:28.638]                           invokeRestart("muffleWarning")
[15:32:28.638]                       }
[15:32:28.638]                       else if (inherits(cond, "condition")) {
[15:32:28.638]                         if (!is.null(pattern)) {
[15:32:28.638]                           computeRestarts <- base::computeRestarts
[15:32:28.638]                           grepl <- base::grepl
[15:32:28.638]                           restarts <- computeRestarts(cond)
[15:32:28.638]                           for (restart in restarts) {
[15:32:28.638]                             name <- restart$name
[15:32:28.638]                             if (is.null(name)) 
[15:32:28.638]                               next
[15:32:28.638]                             if (!grepl(pattern, name)) 
[15:32:28.638]                               next
[15:32:28.638]                             invokeRestart(restart)
[15:32:28.638]                             muffled <- TRUE
[15:32:28.638]                             break
[15:32:28.638]                           }
[15:32:28.638]                         }
[15:32:28.638]                       }
[15:32:28.638]                       invisible(muffled)
[15:32:28.638]                     }
[15:32:28.638]                     muffleCondition(cond, pattern = "^muffle")
[15:32:28.638]                   }
[15:32:28.638]                 }
[15:32:28.638]                 else {
[15:32:28.638]                   if (TRUE) {
[15:32:28.638]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:28.638]                     {
[15:32:28.638]                       inherits <- base::inherits
[15:32:28.638]                       invokeRestart <- base::invokeRestart
[15:32:28.638]                       is.null <- base::is.null
[15:32:28.638]                       muffled <- FALSE
[15:32:28.638]                       if (inherits(cond, "message")) {
[15:32:28.638]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:28.638]                         if (muffled) 
[15:32:28.638]                           invokeRestart("muffleMessage")
[15:32:28.638]                       }
[15:32:28.638]                       else if (inherits(cond, "warning")) {
[15:32:28.638]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:28.638]                         if (muffled) 
[15:32:28.638]                           invokeRestart("muffleWarning")
[15:32:28.638]                       }
[15:32:28.638]                       else if (inherits(cond, "condition")) {
[15:32:28.638]                         if (!is.null(pattern)) {
[15:32:28.638]                           computeRestarts <- base::computeRestarts
[15:32:28.638]                           grepl <- base::grepl
[15:32:28.638]                           restarts <- computeRestarts(cond)
[15:32:28.638]                           for (restart in restarts) {
[15:32:28.638]                             name <- restart$name
[15:32:28.638]                             if (is.null(name)) 
[15:32:28.638]                               next
[15:32:28.638]                             if (!grepl(pattern, name)) 
[15:32:28.638]                               next
[15:32:28.638]                             invokeRestart(restart)
[15:32:28.638]                             muffled <- TRUE
[15:32:28.638]                             break
[15:32:28.638]                           }
[15:32:28.638]                         }
[15:32:28.638]                       }
[15:32:28.638]                       invisible(muffled)
[15:32:28.638]                     }
[15:32:28.638]                     muffleCondition(cond, pattern = "^muffle")
[15:32:28.638]                   }
[15:32:28.638]                 }
[15:32:28.638]             }
[15:32:28.638]         }))
[15:32:28.638]     }, error = function(ex) {
[15:32:28.638]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:28.638]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:28.638]                 ...future.rng), started = ...future.startTime, 
[15:32:28.638]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:28.638]             version = "1.8"), class = "FutureResult")
[15:32:28.638]     }, finally = {
[15:32:28.638]         if (!identical(...future.workdir, getwd())) 
[15:32:28.638]             setwd(...future.workdir)
[15:32:28.638]         {
[15:32:28.638]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:28.638]                 ...future.oldOptions$nwarnings <- NULL
[15:32:28.638]             }
[15:32:28.638]             base::options(...future.oldOptions)
[15:32:28.638]             if (.Platform$OS.type == "windows") {
[15:32:28.638]                 old_names <- names(...future.oldEnvVars)
[15:32:28.638]                 envs <- base::Sys.getenv()
[15:32:28.638]                 names <- names(envs)
[15:32:28.638]                 common <- intersect(names, old_names)
[15:32:28.638]                 added <- setdiff(names, old_names)
[15:32:28.638]                 removed <- setdiff(old_names, names)
[15:32:28.638]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:28.638]                   envs[common]]
[15:32:28.638]                 NAMES <- toupper(changed)
[15:32:28.638]                 args <- list()
[15:32:28.638]                 for (kk in seq_along(NAMES)) {
[15:32:28.638]                   name <- changed[[kk]]
[15:32:28.638]                   NAME <- NAMES[[kk]]
[15:32:28.638]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:28.638]                     next
[15:32:28.638]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:28.638]                 }
[15:32:28.638]                 NAMES <- toupper(added)
[15:32:28.638]                 for (kk in seq_along(NAMES)) {
[15:32:28.638]                   name <- added[[kk]]
[15:32:28.638]                   NAME <- NAMES[[kk]]
[15:32:28.638]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:28.638]                     next
[15:32:28.638]                   args[[name]] <- ""
[15:32:28.638]                 }
[15:32:28.638]                 NAMES <- toupper(removed)
[15:32:28.638]                 for (kk in seq_along(NAMES)) {
[15:32:28.638]                   name <- removed[[kk]]
[15:32:28.638]                   NAME <- NAMES[[kk]]
[15:32:28.638]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:28.638]                     next
[15:32:28.638]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:28.638]                 }
[15:32:28.638]                 if (length(args) > 0) 
[15:32:28.638]                   base::do.call(base::Sys.setenv, args = args)
[15:32:28.638]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:28.638]             }
[15:32:28.638]             else {
[15:32:28.638]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:28.638]             }
[15:32:28.638]             {
[15:32:28.638]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:28.638]                   0L) {
[15:32:28.638]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:28.638]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:28.638]                   base::options(opts)
[15:32:28.638]                 }
[15:32:28.638]                 {
[15:32:28.638]                   {
[15:32:28.638]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:28.638]                     NULL
[15:32:28.638]                   }
[15:32:28.638]                   options(future.plan = NULL)
[15:32:28.638]                   if (is.na(NA_character_)) 
[15:32:28.638]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:28.638]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:28.638]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:28.638]                     .init = FALSE)
[15:32:28.638]                 }
[15:32:28.638]             }
[15:32:28.638]         }
[15:32:28.638]     })
[15:32:28.638]     if (TRUE) {
[15:32:28.638]         base::sink(type = "output", split = FALSE)
[15:32:28.638]         if (TRUE) {
[15:32:28.638]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:28.638]         }
[15:32:28.638]         else {
[15:32:28.638]             ...future.result["stdout"] <- base::list(NULL)
[15:32:28.638]         }
[15:32:28.638]         base::close(...future.stdout)
[15:32:28.638]         ...future.stdout <- NULL
[15:32:28.638]     }
[15:32:28.638]     ...future.result$conditions <- ...future.conditions
[15:32:28.638]     ...future.result$finished <- base::Sys.time()
[15:32:28.638]     ...future.result
[15:32:28.638] }
[15:32:28.644] Exporting 5 global objects (1.22 KiB) to cluster node #1 ...
[15:32:28.645] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ...
[15:32:28.645] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ... DONE
[15:32:28.645] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:28.646] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:28.646] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:28.647] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:28.647] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:28.647] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:28.648] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:28.648] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:28.648] Exporting 5 global objects (1.22 KiB) to cluster node #1 ... DONE
[15:32:28.649] MultisessionFuture started
[15:32:28.649] - Launch lazy future ... done
[15:32:28.650] run() for 'MultisessionFuture' ... done
[15:32:28.650] Created future:
[15:32:28.667] receiveMessageFromWorker() for ClusterFuture ...
[15:32:28.667] - Validating connection of MultisessionFuture
[15:32:28.667] - received message: FutureResult
[15:32:28.668] - Received FutureResult
[15:32:28.668] - Erased future from FutureRegistry
[15:32:28.668] result() for ClusterFuture ...
[15:32:28.668] - result already collected: FutureResult
[15:32:28.668] result() for ClusterFuture ... done
[15:32:28.669] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:28.650] MultisessionFuture:
[15:32:28.650] Label: 'future_sapply-2'
[15:32:28.650] Expression:
[15:32:28.650] {
[15:32:28.650]     do.call(function(...) {
[15:32:28.650]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:28.650]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:28.650]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:28.650]             on.exit(options(oopts), add = TRUE)
[15:32:28.650]         }
[15:32:28.650]         {
[15:32:28.650]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:28.650]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:28.650]                 ...future.FUN(...future.X_jj, ...)
[15:32:28.650]             })
[15:32:28.650]         }
[15:32:28.650]     }, args = future.call.arguments)
[15:32:28.650] }
[15:32:28.650] Lazy evaluation: FALSE
[15:32:28.650] Asynchronous evaluation: TRUE
[15:32:28.650] Local evaluation: TRUE
[15:32:28.650] Environment: R_GlobalEnv
[15:32:28.650] Capture standard output: TRUE
[15:32:28.650] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:28.650] Globals: 5 objects totaling 1.33 KiB (function '...future.FUN' of 1.22 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)
[15:32:28.650] Packages: <none>
[15:32:28.650] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:28.650] Resolved: TRUE
[15:32:28.650] Value: <not collected>
[15:32:28.650] Conditions captured: <none>
[15:32:28.650] Early signaling: FALSE
[15:32:28.650] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:28.650] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:28.669] Chunk #2 of 2 ... DONE
[15:32:28.669] Launching 2 futures (chunks) ... DONE
[15:32:28.669] Resolving 2 futures (chunks) ...
[15:32:28.670] resolve() on list ...
[15:32:28.670]  recursive: 0
[15:32:28.670]  length: 2
[15:32:28.670] 
[15:32:28.670] Future #1
[15:32:28.671] result() for ClusterFuture ...
[15:32:28.671] - result already collected: FutureResult
[15:32:28.671] result() for ClusterFuture ... done
[15:32:28.671] result() for ClusterFuture ...
[15:32:28.672] - result already collected: FutureResult
[15:32:28.672] result() for ClusterFuture ... done
[15:32:28.672] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:28.672] - nx: 2
[15:32:28.673] - relay: TRUE
[15:32:28.673] - stdout: TRUE
[15:32:28.673] - signal: TRUE
[15:32:28.673] - resignal: FALSE
[15:32:28.674] - force: TRUE
[15:32:28.674] - relayed: [n=2] FALSE, FALSE
[15:32:28.674] - queued futures: [n=2] FALSE, FALSE
[15:32:28.674]  - until=1
[15:32:28.674]  - relaying element #1
[15:32:28.674] result() for ClusterFuture ...
[15:32:28.675] - result already collected: FutureResult
[15:32:28.675] result() for ClusterFuture ... done
[15:32:28.675] result() for ClusterFuture ...
[15:32:28.675] - result already collected: FutureResult
[15:32:28.675] result() for ClusterFuture ... done
[15:32:28.676] result() for ClusterFuture ...
[15:32:28.676] - result already collected: FutureResult
[15:32:28.676] result() for ClusterFuture ... done
[15:32:28.676] result() for ClusterFuture ...
[15:32:28.676] - result already collected: FutureResult
[15:32:28.676] result() for ClusterFuture ... done
[15:32:28.677] - relayed: [n=2] TRUE, FALSE
[15:32:28.677] - queued futures: [n=2] TRUE, FALSE
[15:32:28.677] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:28.677]  length: 1 (resolved future 1)
[15:32:28.677] Future #2
[15:32:28.678] result() for ClusterFuture ...
[15:32:28.678] - result already collected: FutureResult
[15:32:28.678] result() for ClusterFuture ... done
[15:32:28.678] result() for ClusterFuture ...
[15:32:28.678] - result already collected: FutureResult
[15:32:28.679] result() for ClusterFuture ... done
[15:32:28.679] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:28.679] - nx: 2
[15:32:28.679] - relay: TRUE
[15:32:28.679] - stdout: TRUE
[15:32:28.679] - signal: TRUE
[15:32:28.680] - resignal: FALSE
[15:32:28.680] - force: TRUE
[15:32:28.680] - relayed: [n=2] TRUE, FALSE
[15:32:28.680] - queued futures: [n=2] TRUE, FALSE
[15:32:28.680]  - until=2
[15:32:28.680]  - relaying element #2
[15:32:28.681] result() for ClusterFuture ...
[15:32:28.681] - result already collected: FutureResult
[15:32:28.681] result() for ClusterFuture ... done
[15:32:28.681] result() for ClusterFuture ...
[15:32:28.681] - result already collected: FutureResult
[15:32:28.681] result() for ClusterFuture ... done
[15:32:28.682] result() for ClusterFuture ...
[15:32:28.682] - result already collected: FutureResult
[15:32:28.682] result() for ClusterFuture ... done
[15:32:28.682] result() for ClusterFuture ...
[15:32:28.682] - result already collected: FutureResult
[15:32:28.682] result() for ClusterFuture ... done
[15:32:28.683] - relayed: [n=2] TRUE, TRUE
[15:32:28.683] - queued futures: [n=2] TRUE, TRUE
[15:32:28.683] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:28.683]  length: 0 (resolved future 2)
[15:32:28.683] Relaying remaining futures
[15:32:28.684] signalConditionsASAP(NULL, pos=0) ...
[15:32:28.684] - nx: 2
[15:32:28.684] - relay: TRUE
[15:32:28.684] - stdout: TRUE
[15:32:28.684] - signal: TRUE
[15:32:28.684] - resignal: FALSE
[15:32:28.684] - force: TRUE
[15:32:28.685] - relayed: [n=2] TRUE, TRUE
[15:32:28.685] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:28.685] - relayed: [n=2] TRUE, TRUE
[15:32:28.685] - queued futures: [n=2] TRUE, TRUE
[15:32:28.685] signalConditionsASAP(NULL, pos=0) ... done
[15:32:28.686] resolve() on list ... DONE
[15:32:28.686] result() for ClusterFuture ...
[15:32:28.686] - result already collected: FutureResult
[15:32:28.686] result() for ClusterFuture ... done
[15:32:28.686] result() for ClusterFuture ...
[15:32:28.686] - result already collected: FutureResult
[15:32:28.687] result() for ClusterFuture ... done
[15:32:28.687] result() for ClusterFuture ...
[15:32:28.687] - result already collected: FutureResult
[15:32:28.688] result() for ClusterFuture ... done
[15:32:28.688] result() for ClusterFuture ...
[15:32:28.688] - result already collected: FutureResult
[15:32:28.688] result() for ClusterFuture ... done
[15:32:28.689]  - Number of value chunks collected: 2
[15:32:28.689] Resolving 2 futures (chunks) ... DONE
[15:32:28.690] Reducing values from 2 chunks ...
[15:32:28.690]  - Number of values collected after concatenation: 3
[15:32:28.690]  - Number of values expected: 3
[15:32:28.690] Reducing values from 2 chunks ... DONE
[15:32:28.690] future_lapply() ... DONE
List of 2
 $ y0: Named num [1:3] 1 2 3
  ..- attr(*, "names")= chr [1:3] "a" "b" "c"
 $ y1: Named num [1:3] 1 2 3
  ..- attr(*, "names")= chr [1:3] "a" "b" "c"
[15:32:28.696] future_lapply() ...
[15:32:28.699] Number of chunks: 2
[15:32:28.700] getGlobalsAndPackagesXApply() ...
[15:32:28.700]  - future.globals: TRUE
[15:32:28.700] getGlobalsAndPackages() ...
[15:32:28.700] Searching for globals...
[15:32:28.703] - globals found: [5] 'FUN', '*', ':', 'outer', 'rep'
[15:32:28.703] Searching for globals ... DONE
[15:32:28.704] Resolving globals: FALSE
[15:32:28.705] The total size of the 1 globals is 4.62 KiB (4728 bytes)
[15:32:28.705] The total size of the 1 globals exported for future expression ('FUN()') is 4.62 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.62 KiB of class 'function')
[15:32:28.706] - globals: [1] 'FUN'
[15:32:28.706] 
[15:32:28.706] getGlobalsAndPackages() ... DONE
[15:32:28.706]  - globals found/used: [n=1] 'FUN'
[15:32:28.707]  - needed namespaces: [n=0] 
[15:32:28.707] Finding globals ... DONE
[15:32:28.707]  - use_args: TRUE
[15:32:28.707]  - Getting '...' globals ...
[15:32:28.708] resolve() on list ...
[15:32:28.708]  recursive: 0
[15:32:28.709]  length: 1
[15:32:28.709]  elements: '...'
[15:32:28.709]  length: 0 (resolved future 1)
[15:32:28.709] resolve() on list ... DONE
[15:32:28.710]    - '...' content: [n=0] 
[15:32:28.710] List of 1
[15:32:28.710]  $ ...: list()
[15:32:28.710]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:28.710]  - attr(*, "where")=List of 1
[15:32:28.710]   ..$ ...:<environment: 0x00000276e43c0298> 
[15:32:28.710]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:28.710]  - attr(*, "resolved")= logi TRUE
[15:32:28.710]  - attr(*, "total_size")= num NA
[15:32:28.715]  - Getting '...' globals ... DONE
[15:32:28.715] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:28.715] List of 2
[15:32:28.715]  $ ...future.FUN:function (x, y = 2 * 1:5)  
[15:32:28.715]  $ ...          : list()
[15:32:28.715]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:28.715]  - attr(*, "where")=List of 2
[15:32:28.715]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:28.715]   ..$ ...          :<environment: 0x00000276e43c0298> 
[15:32:28.715]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:28.715]  - attr(*, "resolved")= logi FALSE
[15:32:28.715]  - attr(*, "total_size")= num 4728
[15:32:28.720] Packages to be attached in all futures: [n=0] 
[15:32:28.720] getGlobalsAndPackagesXApply() ... DONE
[15:32:28.721] Number of futures (= number of chunks): 2
[15:32:28.721] Launching 2 futures (chunks) ...
[15:32:28.721] Chunk #1 of 2 ...
[15:32:28.722]  - Finding globals in 'X' for chunk #1 ...
[15:32:28.722] getGlobalsAndPackages() ...
[15:32:28.722] Searching for globals...
[15:32:28.722] 
[15:32:28.723] Searching for globals ... DONE
[15:32:28.723] - globals: [0] <none>
[15:32:28.723] getGlobalsAndPackages() ... DONE
[15:32:28.723]    + additional globals found: [n=0] 
[15:32:28.723]    + additional namespaces needed: [n=0] 
[15:32:28.724]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:28.724]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:28.724]  - seeds: <none>
[15:32:28.724]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:28.725] getGlobalsAndPackages() ...
[15:32:28.725] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:28.725] Resolving globals: FALSE
[15:32:28.725] Tweak future expression to call with '...' arguments ...
[15:32:28.726] {
[15:32:28.726]     do.call(function(...) {
[15:32:28.726]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:28.726]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:28.726]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:28.726]             on.exit(options(oopts), add = TRUE)
[15:32:28.726]         }
[15:32:28.726]         {
[15:32:28.726]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:28.726]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:28.726]                 ...future.FUN(...future.X_jj, ...)
[15:32:28.726]             })
[15:32:28.726]         }
[15:32:28.726]     }, args = future.call.arguments)
[15:32:28.726] }
[15:32:28.726] Tweak future expression to call with '...' arguments ... DONE
[15:32:28.727] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:28.727] 
[15:32:28.727] getGlobalsAndPackages() ... DONE
[15:32:28.728] run() for 'Future' ...
[15:32:28.728] - state: 'created'
[15:32:28.728] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:28.743] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:28.744] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:28.744]   - Field: 'node'
[15:32:28.744]   - Field: 'label'
[15:32:28.744]   - Field: 'local'
[15:32:28.745]   - Field: 'owner'
[15:32:28.745]   - Field: 'envir'
[15:32:28.745]   - Field: 'workers'
[15:32:28.745]   - Field: 'packages'
[15:32:28.746]   - Field: 'gc'
[15:32:28.746]   - Field: 'conditions'
[15:32:28.746]   - Field: 'persistent'
[15:32:28.746]   - Field: 'expr'
[15:32:28.747]   - Field: 'uuid'
[15:32:28.747]   - Field: 'seed'
[15:32:28.747]   - Field: 'version'
[15:32:28.747]   - Field: 'result'
[15:32:28.747]   - Field: 'asynchronous'
[15:32:28.748]   - Field: 'calls'
[15:32:28.748]   - Field: 'globals'
[15:32:28.748]   - Field: 'stdout'
[15:32:28.748]   - Field: 'earlySignal'
[15:32:28.749]   - Field: 'lazy'
[15:32:28.749]   - Field: 'state'
[15:32:28.749] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:28.749] - Launch lazy future ...
[15:32:28.750] Packages needed by the future expression (n = 0): <none>
[15:32:28.750] Packages needed by future strategies (n = 0): <none>
[15:32:28.751] {
[15:32:28.751]     {
[15:32:28.751]         {
[15:32:28.751]             ...future.startTime <- base::Sys.time()
[15:32:28.751]             {
[15:32:28.751]                 {
[15:32:28.751]                   {
[15:32:28.751]                     {
[15:32:28.751]                       base::local({
[15:32:28.751]                         has_future <- base::requireNamespace("future", 
[15:32:28.751]                           quietly = TRUE)
[15:32:28.751]                         if (has_future) {
[15:32:28.751]                           ns <- base::getNamespace("future")
[15:32:28.751]                           version <- ns[[".package"]][["version"]]
[15:32:28.751]                           if (is.null(version)) 
[15:32:28.751]                             version <- utils::packageVersion("future")
[15:32:28.751]                         }
[15:32:28.751]                         else {
[15:32:28.751]                           version <- NULL
[15:32:28.751]                         }
[15:32:28.751]                         if (!has_future || version < "1.8.0") {
[15:32:28.751]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:28.751]                             "", base::R.version$version.string), 
[15:32:28.751]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:28.751]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:28.751]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:28.751]                               "release", "version")], collapse = " "), 
[15:32:28.751]                             hostname = base::Sys.info()[["nodename"]])
[15:32:28.751]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:28.751]                             info)
[15:32:28.751]                           info <- base::paste(info, collapse = "; ")
[15:32:28.751]                           if (!has_future) {
[15:32:28.751]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:28.751]                               info)
[15:32:28.751]                           }
[15:32:28.751]                           else {
[15:32:28.751]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:28.751]                               info, version)
[15:32:28.751]                           }
[15:32:28.751]                           base::stop(msg)
[15:32:28.751]                         }
[15:32:28.751]                       })
[15:32:28.751]                     }
[15:32:28.751]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:28.751]                     base::options(mc.cores = 1L)
[15:32:28.751]                   }
[15:32:28.751]                   ...future.strategy.old <- future::plan("list")
[15:32:28.751]                   options(future.plan = NULL)
[15:32:28.751]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:28.751]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:28.751]                 }
[15:32:28.751]                 ...future.workdir <- getwd()
[15:32:28.751]             }
[15:32:28.751]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:28.751]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:28.751]         }
[15:32:28.751]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:28.751]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:28.751]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:28.751]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:28.751]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:28.751]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:28.751]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:28.751]             base::names(...future.oldOptions))
[15:32:28.751]     }
[15:32:28.751]     if (FALSE) {
[15:32:28.751]     }
[15:32:28.751]     else {
[15:32:28.751]         if (TRUE) {
[15:32:28.751]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:28.751]                 open = "w")
[15:32:28.751]         }
[15:32:28.751]         else {
[15:32:28.751]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:28.751]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:28.751]         }
[15:32:28.751]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:28.751]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:28.751]             base::sink(type = "output", split = FALSE)
[15:32:28.751]             base::close(...future.stdout)
[15:32:28.751]         }, add = TRUE)
[15:32:28.751]     }
[15:32:28.751]     ...future.frame <- base::sys.nframe()
[15:32:28.751]     ...future.conditions <- base::list()
[15:32:28.751]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:28.751]     if (FALSE) {
[15:32:28.751]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:28.751]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:28.751]     }
[15:32:28.751]     ...future.result <- base::tryCatch({
[15:32:28.751]         base::withCallingHandlers({
[15:32:28.751]             ...future.value <- base::withVisible(base::local({
[15:32:28.751]                 ...future.makeSendCondition <- base::local({
[15:32:28.751]                   sendCondition <- NULL
[15:32:28.751]                   function(frame = 1L) {
[15:32:28.751]                     if (is.function(sendCondition)) 
[15:32:28.751]                       return(sendCondition)
[15:32:28.751]                     ns <- getNamespace("parallel")
[15:32:28.751]                     if (exists("sendData", mode = "function", 
[15:32:28.751]                       envir = ns)) {
[15:32:28.751]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:28.751]                         envir = ns)
[15:32:28.751]                       envir <- sys.frame(frame)
[15:32:28.751]                       master <- NULL
[15:32:28.751]                       while (!identical(envir, .GlobalEnv) && 
[15:32:28.751]                         !identical(envir, emptyenv())) {
[15:32:28.751]                         if (exists("master", mode = "list", envir = envir, 
[15:32:28.751]                           inherits = FALSE)) {
[15:32:28.751]                           master <- get("master", mode = "list", 
[15:32:28.751]                             envir = envir, inherits = FALSE)
[15:32:28.751]                           if (inherits(master, c("SOCKnode", 
[15:32:28.751]                             "SOCK0node"))) {
[15:32:28.751]                             sendCondition <<- function(cond) {
[15:32:28.751]                               data <- list(type = "VALUE", value = cond, 
[15:32:28.751]                                 success = TRUE)
[15:32:28.751]                               parallel_sendData(master, data)
[15:32:28.751]                             }
[15:32:28.751]                             return(sendCondition)
[15:32:28.751]                           }
[15:32:28.751]                         }
[15:32:28.751]                         frame <- frame + 1L
[15:32:28.751]                         envir <- sys.frame(frame)
[15:32:28.751]                       }
[15:32:28.751]                     }
[15:32:28.751]                     sendCondition <<- function(cond) NULL
[15:32:28.751]                   }
[15:32:28.751]                 })
[15:32:28.751]                 withCallingHandlers({
[15:32:28.751]                   {
[15:32:28.751]                     do.call(function(...) {
[15:32:28.751]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:28.751]                       if (!identical(...future.globals.maxSize.org, 
[15:32:28.751]                         ...future.globals.maxSize)) {
[15:32:28.751]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:28.751]                         on.exit(options(oopts), add = TRUE)
[15:32:28.751]                       }
[15:32:28.751]                       {
[15:32:28.751]                         lapply(seq_along(...future.elements_ii), 
[15:32:28.751]                           FUN = function(jj) {
[15:32:28.751]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:28.751]                             ...future.FUN(...future.X_jj, ...)
[15:32:28.751]                           })
[15:32:28.751]                       }
[15:32:28.751]                     }, args = future.call.arguments)
[15:32:28.751]                   }
[15:32:28.751]                 }, immediateCondition = function(cond) {
[15:32:28.751]                   sendCondition <- ...future.makeSendCondition()
[15:32:28.751]                   sendCondition(cond)
[15:32:28.751]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:28.751]                   {
[15:32:28.751]                     inherits <- base::inherits
[15:32:28.751]                     invokeRestart <- base::invokeRestart
[15:32:28.751]                     is.null <- base::is.null
[15:32:28.751]                     muffled <- FALSE
[15:32:28.751]                     if (inherits(cond, "message")) {
[15:32:28.751]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:28.751]                       if (muffled) 
[15:32:28.751]                         invokeRestart("muffleMessage")
[15:32:28.751]                     }
[15:32:28.751]                     else if (inherits(cond, "warning")) {
[15:32:28.751]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:28.751]                       if (muffled) 
[15:32:28.751]                         invokeRestart("muffleWarning")
[15:32:28.751]                     }
[15:32:28.751]                     else if (inherits(cond, "condition")) {
[15:32:28.751]                       if (!is.null(pattern)) {
[15:32:28.751]                         computeRestarts <- base::computeRestarts
[15:32:28.751]                         grepl <- base::grepl
[15:32:28.751]                         restarts <- computeRestarts(cond)
[15:32:28.751]                         for (restart in restarts) {
[15:32:28.751]                           name <- restart$name
[15:32:28.751]                           if (is.null(name)) 
[15:32:28.751]                             next
[15:32:28.751]                           if (!grepl(pattern, name)) 
[15:32:28.751]                             next
[15:32:28.751]                           invokeRestart(restart)
[15:32:28.751]                           muffled <- TRUE
[15:32:28.751]                           break
[15:32:28.751]                         }
[15:32:28.751]                       }
[15:32:28.751]                     }
[15:32:28.751]                     invisible(muffled)
[15:32:28.751]                   }
[15:32:28.751]                   muffleCondition(cond)
[15:32:28.751]                 })
[15:32:28.751]             }))
[15:32:28.751]             future::FutureResult(value = ...future.value$value, 
[15:32:28.751]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:28.751]                   ...future.rng), globalenv = if (FALSE) 
[15:32:28.751]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:28.751]                     ...future.globalenv.names))
[15:32:28.751]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:28.751]         }, condition = base::local({
[15:32:28.751]             c <- base::c
[15:32:28.751]             inherits <- base::inherits
[15:32:28.751]             invokeRestart <- base::invokeRestart
[15:32:28.751]             length <- base::length
[15:32:28.751]             list <- base::list
[15:32:28.751]             seq.int <- base::seq.int
[15:32:28.751]             signalCondition <- base::signalCondition
[15:32:28.751]             sys.calls <- base::sys.calls
[15:32:28.751]             `[[` <- base::`[[`
[15:32:28.751]             `+` <- base::`+`
[15:32:28.751]             `<<-` <- base::`<<-`
[15:32:28.751]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:28.751]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:28.751]                   3L)]
[15:32:28.751]             }
[15:32:28.751]             function(cond) {
[15:32:28.751]                 is_error <- inherits(cond, "error")
[15:32:28.751]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:28.751]                   NULL)
[15:32:28.751]                 if (is_error) {
[15:32:28.751]                   sessionInformation <- function() {
[15:32:28.751]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:28.751]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:28.751]                       search = base::search(), system = base::Sys.info())
[15:32:28.751]                   }
[15:32:28.751]                   ...future.conditions[[length(...future.conditions) + 
[15:32:28.751]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:28.751]                     cond$call), session = sessionInformation(), 
[15:32:28.751]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:28.751]                   signalCondition(cond)
[15:32:28.751]                 }
[15:32:28.751]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:28.751]                 "immediateCondition"))) {
[15:32:28.751]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:28.751]                   ...future.conditions[[length(...future.conditions) + 
[15:32:28.751]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:28.751]                   if (TRUE && !signal) {
[15:32:28.751]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:28.751]                     {
[15:32:28.751]                       inherits <- base::inherits
[15:32:28.751]                       invokeRestart <- base::invokeRestart
[15:32:28.751]                       is.null <- base::is.null
[15:32:28.751]                       muffled <- FALSE
[15:32:28.751]                       if (inherits(cond, "message")) {
[15:32:28.751]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:28.751]                         if (muffled) 
[15:32:28.751]                           invokeRestart("muffleMessage")
[15:32:28.751]                       }
[15:32:28.751]                       else if (inherits(cond, "warning")) {
[15:32:28.751]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:28.751]                         if (muffled) 
[15:32:28.751]                           invokeRestart("muffleWarning")
[15:32:28.751]                       }
[15:32:28.751]                       else if (inherits(cond, "condition")) {
[15:32:28.751]                         if (!is.null(pattern)) {
[15:32:28.751]                           computeRestarts <- base::computeRestarts
[15:32:28.751]                           grepl <- base::grepl
[15:32:28.751]                           restarts <- computeRestarts(cond)
[15:32:28.751]                           for (restart in restarts) {
[15:32:28.751]                             name <- restart$name
[15:32:28.751]                             if (is.null(name)) 
[15:32:28.751]                               next
[15:32:28.751]                             if (!grepl(pattern, name)) 
[15:32:28.751]                               next
[15:32:28.751]                             invokeRestart(restart)
[15:32:28.751]                             muffled <- TRUE
[15:32:28.751]                             break
[15:32:28.751]                           }
[15:32:28.751]                         }
[15:32:28.751]                       }
[15:32:28.751]                       invisible(muffled)
[15:32:28.751]                     }
[15:32:28.751]                     muffleCondition(cond, pattern = "^muffle")
[15:32:28.751]                   }
[15:32:28.751]                 }
[15:32:28.751]                 else {
[15:32:28.751]                   if (TRUE) {
[15:32:28.751]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:28.751]                     {
[15:32:28.751]                       inherits <- base::inherits
[15:32:28.751]                       invokeRestart <- base::invokeRestart
[15:32:28.751]                       is.null <- base::is.null
[15:32:28.751]                       muffled <- FALSE
[15:32:28.751]                       if (inherits(cond, "message")) {
[15:32:28.751]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:28.751]                         if (muffled) 
[15:32:28.751]                           invokeRestart("muffleMessage")
[15:32:28.751]                       }
[15:32:28.751]                       else if (inherits(cond, "warning")) {
[15:32:28.751]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:28.751]                         if (muffled) 
[15:32:28.751]                           invokeRestart("muffleWarning")
[15:32:28.751]                       }
[15:32:28.751]                       else if (inherits(cond, "condition")) {
[15:32:28.751]                         if (!is.null(pattern)) {
[15:32:28.751]                           computeRestarts <- base::computeRestarts
[15:32:28.751]                           grepl <- base::grepl
[15:32:28.751]                           restarts <- computeRestarts(cond)
[15:32:28.751]                           for (restart in restarts) {
[15:32:28.751]                             name <- restart$name
[15:32:28.751]                             if (is.null(name)) 
[15:32:28.751]                               next
[15:32:28.751]                             if (!grepl(pattern, name)) 
[15:32:28.751]                               next
[15:32:28.751]                             invokeRestart(restart)
[15:32:28.751]                             muffled <- TRUE
[15:32:28.751]                             break
[15:32:28.751]                           }
[15:32:28.751]                         }
[15:32:28.751]                       }
[15:32:28.751]                       invisible(muffled)
[15:32:28.751]                     }
[15:32:28.751]                     muffleCondition(cond, pattern = "^muffle")
[15:32:28.751]                   }
[15:32:28.751]                 }
[15:32:28.751]             }
[15:32:28.751]         }))
[15:32:28.751]     }, error = function(ex) {
[15:32:28.751]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:28.751]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:28.751]                 ...future.rng), started = ...future.startTime, 
[15:32:28.751]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:28.751]             version = "1.8"), class = "FutureResult")
[15:32:28.751]     }, finally = {
[15:32:28.751]         if (!identical(...future.workdir, getwd())) 
[15:32:28.751]             setwd(...future.workdir)
[15:32:28.751]         {
[15:32:28.751]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:28.751]                 ...future.oldOptions$nwarnings <- NULL
[15:32:28.751]             }
[15:32:28.751]             base::options(...future.oldOptions)
[15:32:28.751]             if (.Platform$OS.type == "windows") {
[15:32:28.751]                 old_names <- names(...future.oldEnvVars)
[15:32:28.751]                 envs <- base::Sys.getenv()
[15:32:28.751]                 names <- names(envs)
[15:32:28.751]                 common <- intersect(names, old_names)
[15:32:28.751]                 added <- setdiff(names, old_names)
[15:32:28.751]                 removed <- setdiff(old_names, names)
[15:32:28.751]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:28.751]                   envs[common]]
[15:32:28.751]                 NAMES <- toupper(changed)
[15:32:28.751]                 args <- list()
[15:32:28.751]                 for (kk in seq_along(NAMES)) {
[15:32:28.751]                   name <- changed[[kk]]
[15:32:28.751]                   NAME <- NAMES[[kk]]
[15:32:28.751]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:28.751]                     next
[15:32:28.751]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:28.751]                 }
[15:32:28.751]                 NAMES <- toupper(added)
[15:32:28.751]                 for (kk in seq_along(NAMES)) {
[15:32:28.751]                   name <- added[[kk]]
[15:32:28.751]                   NAME <- NAMES[[kk]]
[15:32:28.751]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:28.751]                     next
[15:32:28.751]                   args[[name]] <- ""
[15:32:28.751]                 }
[15:32:28.751]                 NAMES <- toupper(removed)
[15:32:28.751]                 for (kk in seq_along(NAMES)) {
[15:32:28.751]                   name <- removed[[kk]]
[15:32:28.751]                   NAME <- NAMES[[kk]]
[15:32:28.751]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:28.751]                     next
[15:32:28.751]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:28.751]                 }
[15:32:28.751]                 if (length(args) > 0) 
[15:32:28.751]                   base::do.call(base::Sys.setenv, args = args)
[15:32:28.751]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:28.751]             }
[15:32:28.751]             else {
[15:32:28.751]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:28.751]             }
[15:32:28.751]             {
[15:32:28.751]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:28.751]                   0L) {
[15:32:28.751]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:28.751]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:28.751]                   base::options(opts)
[15:32:28.751]                 }
[15:32:28.751]                 {
[15:32:28.751]                   {
[15:32:28.751]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:28.751]                     NULL
[15:32:28.751]                   }
[15:32:28.751]                   options(future.plan = NULL)
[15:32:28.751]                   if (is.na(NA_character_)) 
[15:32:28.751]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:28.751]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:28.751]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:28.751]                     .init = FALSE)
[15:32:28.751]                 }
[15:32:28.751]             }
[15:32:28.751]         }
[15:32:28.751]     })
[15:32:28.751]     if (TRUE) {
[15:32:28.751]         base::sink(type = "output", split = FALSE)
[15:32:28.751]         if (TRUE) {
[15:32:28.751]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:28.751]         }
[15:32:28.751]         else {
[15:32:28.751]             ...future.result["stdout"] <- base::list(NULL)
[15:32:28.751]         }
[15:32:28.751]         base::close(...future.stdout)
[15:32:28.751]         ...future.stdout <- NULL
[15:32:28.751]     }
[15:32:28.751]     ...future.result$conditions <- ...future.conditions
[15:32:28.751]     ...future.result$finished <- base::Sys.time()
[15:32:28.751]     ...future.result
[15:32:28.751] }
[15:32:28.759] Exporting 5 global objects (4.62 KiB) to cluster node #1 ...
[15:32:28.759] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ...
[15:32:28.760] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ... DONE
[15:32:28.760] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:28.761] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:28.761] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ...
[15:32:28.762] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ... DONE
[15:32:28.762] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:28.763] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:28.763] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:28.763] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:28.764] Exporting 5 global objects (4.62 KiB) to cluster node #1 ... DONE
[15:32:28.765] MultisessionFuture started
[15:32:28.765] - Launch lazy future ... done
[15:32:28.765] run() for 'MultisessionFuture' ... done
[15:32:28.766] Created future:
[15:32:28.787] receiveMessageFromWorker() for ClusterFuture ...
[15:32:28.788] - Validating connection of MultisessionFuture
[15:32:28.788] - received message: FutureResult
[15:32:28.788] - Received FutureResult
[15:32:28.789] - Erased future from FutureRegistry
[15:32:28.789] result() for ClusterFuture ...
[15:32:28.789] - result already collected: FutureResult
[15:32:28.790] result() for ClusterFuture ... done
[15:32:28.790] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:28.766] MultisessionFuture:
[15:32:28.766] Label: 'future_sapply-1'
[15:32:28.766] Expression:
[15:32:28.766] {
[15:32:28.766]     do.call(function(...) {
[15:32:28.766]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:28.766]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:28.766]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:28.766]             on.exit(options(oopts), add = TRUE)
[15:32:28.766]         }
[15:32:28.766]         {
[15:32:28.766]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:28.766]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:28.766]                 ...future.FUN(...future.X_jj, ...)
[15:32:28.766]             })
[15:32:28.766]         }
[15:32:28.766]     }, args = future.call.arguments)
[15:32:28.766] }
[15:32:28.766] Lazy evaluation: FALSE
[15:32:28.766] Asynchronous evaluation: TRUE
[15:32:28.766] Local evaluation: TRUE
[15:32:28.766] Environment: R_GlobalEnv
[15:32:28.766] Capture standard output: TRUE
[15:32:28.766] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:28.766] Globals: 5 objects totaling 4.67 KiB (function '...future.FUN' of 4.62 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)
[15:32:28.766] Packages: <none>
[15:32:28.766] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:28.766] Resolved: TRUE
[15:32:28.766] Value: <not collected>
[15:32:28.766] Conditions captured: <none>
[15:32:28.766] Early signaling: FALSE
[15:32:28.766] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:28.766] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:28.791] Chunk #1 of 2 ... DONE
[15:32:28.791] Chunk #2 of 2 ...
[15:32:28.791]  - Finding globals in 'X' for chunk #2 ...
[15:32:28.791] getGlobalsAndPackages() ...
[15:32:28.792] Searching for globals...
[15:32:28.792] 
[15:32:28.793] Searching for globals ... DONE
[15:32:28.793] - globals: [0] <none>
[15:32:28.793] getGlobalsAndPackages() ... DONE
[15:32:28.793]    + additional globals found: [n=0] 
[15:32:28.794]    + additional namespaces needed: [n=0] 
[15:32:28.794]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:28.794]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:28.794]  - seeds: <none>
[15:32:28.795]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:28.795] getGlobalsAndPackages() ...
[15:32:28.795] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:28.796] Resolving globals: FALSE
[15:32:28.796] Tweak future expression to call with '...' arguments ...
[15:32:28.796] {
[15:32:28.796]     do.call(function(...) {
[15:32:28.796]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:28.796]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:28.796]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:28.796]             on.exit(options(oopts), add = TRUE)
[15:32:28.796]         }
[15:32:28.796]         {
[15:32:28.796]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:28.796]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:28.796]                 ...future.FUN(...future.X_jj, ...)
[15:32:28.796]             })
[15:32:28.796]         }
[15:32:28.796]     }, args = future.call.arguments)
[15:32:28.796] }
[15:32:28.797] Tweak future expression to call with '...' arguments ... DONE
[15:32:28.798] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:28.798] 
[15:32:28.798] getGlobalsAndPackages() ... DONE
[15:32:28.798] run() for 'Future' ...
[15:32:28.799] - state: 'created'
[15:32:28.799] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:28.816] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:28.817] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:28.817]   - Field: 'node'
[15:32:28.817]   - Field: 'label'
[15:32:28.817]   - Field: 'local'
[15:32:28.817]   - Field: 'owner'
[15:32:28.818]   - Field: 'envir'
[15:32:28.818]   - Field: 'workers'
[15:32:28.818]   - Field: 'packages'
[15:32:28.818]   - Field: 'gc'
[15:32:28.818]   - Field: 'conditions'
[15:32:28.818]   - Field: 'persistent'
[15:32:28.819]   - Field: 'expr'
[15:32:28.819]   - Field: 'uuid'
[15:32:28.819]   - Field: 'seed'
[15:32:28.819]   - Field: 'version'
[15:32:28.819]   - Field: 'result'
[15:32:28.820]   - Field: 'asynchronous'
[15:32:28.820]   - Field: 'calls'
[15:32:28.820]   - Field: 'globals'
[15:32:28.820]   - Field: 'stdout'
[15:32:28.820]   - Field: 'earlySignal'
[15:32:28.820]   - Field: 'lazy'
[15:32:28.821]   - Field: 'state'
[15:32:28.821] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:28.821] - Launch lazy future ...
[15:32:28.821] Packages needed by the future expression (n = 0): <none>
[15:32:28.822] Packages needed by future strategies (n = 0): <none>
[15:32:28.822] {
[15:32:28.822]     {
[15:32:28.822]         {
[15:32:28.822]             ...future.startTime <- base::Sys.time()
[15:32:28.822]             {
[15:32:28.822]                 {
[15:32:28.822]                   {
[15:32:28.822]                     {
[15:32:28.822]                       base::local({
[15:32:28.822]                         has_future <- base::requireNamespace("future", 
[15:32:28.822]                           quietly = TRUE)
[15:32:28.822]                         if (has_future) {
[15:32:28.822]                           ns <- base::getNamespace("future")
[15:32:28.822]                           version <- ns[[".package"]][["version"]]
[15:32:28.822]                           if (is.null(version)) 
[15:32:28.822]                             version <- utils::packageVersion("future")
[15:32:28.822]                         }
[15:32:28.822]                         else {
[15:32:28.822]                           version <- NULL
[15:32:28.822]                         }
[15:32:28.822]                         if (!has_future || version < "1.8.0") {
[15:32:28.822]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:28.822]                             "", base::R.version$version.string), 
[15:32:28.822]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:28.822]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:28.822]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:28.822]                               "release", "version")], collapse = " "), 
[15:32:28.822]                             hostname = base::Sys.info()[["nodename"]])
[15:32:28.822]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:28.822]                             info)
[15:32:28.822]                           info <- base::paste(info, collapse = "; ")
[15:32:28.822]                           if (!has_future) {
[15:32:28.822]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:28.822]                               info)
[15:32:28.822]                           }
[15:32:28.822]                           else {
[15:32:28.822]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:28.822]                               info, version)
[15:32:28.822]                           }
[15:32:28.822]                           base::stop(msg)
[15:32:28.822]                         }
[15:32:28.822]                       })
[15:32:28.822]                     }
[15:32:28.822]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:28.822]                     base::options(mc.cores = 1L)
[15:32:28.822]                   }
[15:32:28.822]                   ...future.strategy.old <- future::plan("list")
[15:32:28.822]                   options(future.plan = NULL)
[15:32:28.822]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:28.822]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:28.822]                 }
[15:32:28.822]                 ...future.workdir <- getwd()
[15:32:28.822]             }
[15:32:28.822]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:28.822]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:28.822]         }
[15:32:28.822]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:28.822]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:28.822]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:28.822]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:28.822]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:28.822]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:28.822]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:28.822]             base::names(...future.oldOptions))
[15:32:28.822]     }
[15:32:28.822]     if (FALSE) {
[15:32:28.822]     }
[15:32:28.822]     else {
[15:32:28.822]         if (TRUE) {
[15:32:28.822]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:28.822]                 open = "w")
[15:32:28.822]         }
[15:32:28.822]         else {
[15:32:28.822]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:28.822]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:28.822]         }
[15:32:28.822]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:28.822]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:28.822]             base::sink(type = "output", split = FALSE)
[15:32:28.822]             base::close(...future.stdout)
[15:32:28.822]         }, add = TRUE)
[15:32:28.822]     }
[15:32:28.822]     ...future.frame <- base::sys.nframe()
[15:32:28.822]     ...future.conditions <- base::list()
[15:32:28.822]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:28.822]     if (FALSE) {
[15:32:28.822]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:28.822]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:28.822]     }
[15:32:28.822]     ...future.result <- base::tryCatch({
[15:32:28.822]         base::withCallingHandlers({
[15:32:28.822]             ...future.value <- base::withVisible(base::local({
[15:32:28.822]                 ...future.makeSendCondition <- base::local({
[15:32:28.822]                   sendCondition <- NULL
[15:32:28.822]                   function(frame = 1L) {
[15:32:28.822]                     if (is.function(sendCondition)) 
[15:32:28.822]                       return(sendCondition)
[15:32:28.822]                     ns <- getNamespace("parallel")
[15:32:28.822]                     if (exists("sendData", mode = "function", 
[15:32:28.822]                       envir = ns)) {
[15:32:28.822]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:28.822]                         envir = ns)
[15:32:28.822]                       envir <- sys.frame(frame)
[15:32:28.822]                       master <- NULL
[15:32:28.822]                       while (!identical(envir, .GlobalEnv) && 
[15:32:28.822]                         !identical(envir, emptyenv())) {
[15:32:28.822]                         if (exists("master", mode = "list", envir = envir, 
[15:32:28.822]                           inherits = FALSE)) {
[15:32:28.822]                           master <- get("master", mode = "list", 
[15:32:28.822]                             envir = envir, inherits = FALSE)
[15:32:28.822]                           if (inherits(master, c("SOCKnode", 
[15:32:28.822]                             "SOCK0node"))) {
[15:32:28.822]                             sendCondition <<- function(cond) {
[15:32:28.822]                               data <- list(type = "VALUE", value = cond, 
[15:32:28.822]                                 success = TRUE)
[15:32:28.822]                               parallel_sendData(master, data)
[15:32:28.822]                             }
[15:32:28.822]                             return(sendCondition)
[15:32:28.822]                           }
[15:32:28.822]                         }
[15:32:28.822]                         frame <- frame + 1L
[15:32:28.822]                         envir <- sys.frame(frame)
[15:32:28.822]                       }
[15:32:28.822]                     }
[15:32:28.822]                     sendCondition <<- function(cond) NULL
[15:32:28.822]                   }
[15:32:28.822]                 })
[15:32:28.822]                 withCallingHandlers({
[15:32:28.822]                   {
[15:32:28.822]                     do.call(function(...) {
[15:32:28.822]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:28.822]                       if (!identical(...future.globals.maxSize.org, 
[15:32:28.822]                         ...future.globals.maxSize)) {
[15:32:28.822]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:28.822]                         on.exit(options(oopts), add = TRUE)
[15:32:28.822]                       }
[15:32:28.822]                       {
[15:32:28.822]                         lapply(seq_along(...future.elements_ii), 
[15:32:28.822]                           FUN = function(jj) {
[15:32:28.822]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:28.822]                             ...future.FUN(...future.X_jj, ...)
[15:32:28.822]                           })
[15:32:28.822]                       }
[15:32:28.822]                     }, args = future.call.arguments)
[15:32:28.822]                   }
[15:32:28.822]                 }, immediateCondition = function(cond) {
[15:32:28.822]                   sendCondition <- ...future.makeSendCondition()
[15:32:28.822]                   sendCondition(cond)
[15:32:28.822]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:28.822]                   {
[15:32:28.822]                     inherits <- base::inherits
[15:32:28.822]                     invokeRestart <- base::invokeRestart
[15:32:28.822]                     is.null <- base::is.null
[15:32:28.822]                     muffled <- FALSE
[15:32:28.822]                     if (inherits(cond, "message")) {
[15:32:28.822]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:28.822]                       if (muffled) 
[15:32:28.822]                         invokeRestart("muffleMessage")
[15:32:28.822]                     }
[15:32:28.822]                     else if (inherits(cond, "warning")) {
[15:32:28.822]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:28.822]                       if (muffled) 
[15:32:28.822]                         invokeRestart("muffleWarning")
[15:32:28.822]                     }
[15:32:28.822]                     else if (inherits(cond, "condition")) {
[15:32:28.822]                       if (!is.null(pattern)) {
[15:32:28.822]                         computeRestarts <- base::computeRestarts
[15:32:28.822]                         grepl <- base::grepl
[15:32:28.822]                         restarts <- computeRestarts(cond)
[15:32:28.822]                         for (restart in restarts) {
[15:32:28.822]                           name <- restart$name
[15:32:28.822]                           if (is.null(name)) 
[15:32:28.822]                             next
[15:32:28.822]                           if (!grepl(pattern, name)) 
[15:32:28.822]                             next
[15:32:28.822]                           invokeRestart(restart)
[15:32:28.822]                           muffled <- TRUE
[15:32:28.822]                           break
[15:32:28.822]                         }
[15:32:28.822]                       }
[15:32:28.822]                     }
[15:32:28.822]                     invisible(muffled)
[15:32:28.822]                   }
[15:32:28.822]                   muffleCondition(cond)
[15:32:28.822]                 })
[15:32:28.822]             }))
[15:32:28.822]             future::FutureResult(value = ...future.value$value, 
[15:32:28.822]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:28.822]                   ...future.rng), globalenv = if (FALSE) 
[15:32:28.822]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:28.822]                     ...future.globalenv.names))
[15:32:28.822]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:28.822]         }, condition = base::local({
[15:32:28.822]             c <- base::c
[15:32:28.822]             inherits <- base::inherits
[15:32:28.822]             invokeRestart <- base::invokeRestart
[15:32:28.822]             length <- base::length
[15:32:28.822]             list <- base::list
[15:32:28.822]             seq.int <- base::seq.int
[15:32:28.822]             signalCondition <- base::signalCondition
[15:32:28.822]             sys.calls <- base::sys.calls
[15:32:28.822]             `[[` <- base::`[[`
[15:32:28.822]             `+` <- base::`+`
[15:32:28.822]             `<<-` <- base::`<<-`
[15:32:28.822]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:28.822]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:28.822]                   3L)]
[15:32:28.822]             }
[15:32:28.822]             function(cond) {
[15:32:28.822]                 is_error <- inherits(cond, "error")
[15:32:28.822]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:28.822]                   NULL)
[15:32:28.822]                 if (is_error) {
[15:32:28.822]                   sessionInformation <- function() {
[15:32:28.822]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:28.822]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:28.822]                       search = base::search(), system = base::Sys.info())
[15:32:28.822]                   }
[15:32:28.822]                   ...future.conditions[[length(...future.conditions) + 
[15:32:28.822]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:28.822]                     cond$call), session = sessionInformation(), 
[15:32:28.822]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:28.822]                   signalCondition(cond)
[15:32:28.822]                 }
[15:32:28.822]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:28.822]                 "immediateCondition"))) {
[15:32:28.822]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:28.822]                   ...future.conditions[[length(...future.conditions) + 
[15:32:28.822]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:28.822]                   if (TRUE && !signal) {
[15:32:28.822]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:28.822]                     {
[15:32:28.822]                       inherits <- base::inherits
[15:32:28.822]                       invokeRestart <- base::invokeRestart
[15:32:28.822]                       is.null <- base::is.null
[15:32:28.822]                       muffled <- FALSE
[15:32:28.822]                       if (inherits(cond, "message")) {
[15:32:28.822]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:28.822]                         if (muffled) 
[15:32:28.822]                           invokeRestart("muffleMessage")
[15:32:28.822]                       }
[15:32:28.822]                       else if (inherits(cond, "warning")) {
[15:32:28.822]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:28.822]                         if (muffled) 
[15:32:28.822]                           invokeRestart("muffleWarning")
[15:32:28.822]                       }
[15:32:28.822]                       else if (inherits(cond, "condition")) {
[15:32:28.822]                         if (!is.null(pattern)) {
[15:32:28.822]                           computeRestarts <- base::computeRestarts
[15:32:28.822]                           grepl <- base::grepl
[15:32:28.822]                           restarts <- computeRestarts(cond)
[15:32:28.822]                           for (restart in restarts) {
[15:32:28.822]                             name <- restart$name
[15:32:28.822]                             if (is.null(name)) 
[15:32:28.822]                               next
[15:32:28.822]                             if (!grepl(pattern, name)) 
[15:32:28.822]                               next
[15:32:28.822]                             invokeRestart(restart)
[15:32:28.822]                             muffled <- TRUE
[15:32:28.822]                             break
[15:32:28.822]                           }
[15:32:28.822]                         }
[15:32:28.822]                       }
[15:32:28.822]                       invisible(muffled)
[15:32:28.822]                     }
[15:32:28.822]                     muffleCondition(cond, pattern = "^muffle")
[15:32:28.822]                   }
[15:32:28.822]                 }
[15:32:28.822]                 else {
[15:32:28.822]                   if (TRUE) {
[15:32:28.822]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:28.822]                     {
[15:32:28.822]                       inherits <- base::inherits
[15:32:28.822]                       invokeRestart <- base::invokeRestart
[15:32:28.822]                       is.null <- base::is.null
[15:32:28.822]                       muffled <- FALSE
[15:32:28.822]                       if (inherits(cond, "message")) {
[15:32:28.822]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:28.822]                         if (muffled) 
[15:32:28.822]                           invokeRestart("muffleMessage")
[15:32:28.822]                       }
[15:32:28.822]                       else if (inherits(cond, "warning")) {
[15:32:28.822]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:28.822]                         if (muffled) 
[15:32:28.822]                           invokeRestart("muffleWarning")
[15:32:28.822]                       }
[15:32:28.822]                       else if (inherits(cond, "condition")) {
[15:32:28.822]                         if (!is.null(pattern)) {
[15:32:28.822]                           computeRestarts <- base::computeRestarts
[15:32:28.822]                           grepl <- base::grepl
[15:32:28.822]                           restarts <- computeRestarts(cond)
[15:32:28.822]                           for (restart in restarts) {
[15:32:28.822]                             name <- restart$name
[15:32:28.822]                             if (is.null(name)) 
[15:32:28.822]                               next
[15:32:28.822]                             if (!grepl(pattern, name)) 
[15:32:28.822]                               next
[15:32:28.822]                             invokeRestart(restart)
[15:32:28.822]                             muffled <- TRUE
[15:32:28.822]                             break
[15:32:28.822]                           }
[15:32:28.822]                         }
[15:32:28.822]                       }
[15:32:28.822]                       invisible(muffled)
[15:32:28.822]                     }
[15:32:28.822]                     muffleCondition(cond, pattern = "^muffle")
[15:32:28.822]                   }
[15:32:28.822]                 }
[15:32:28.822]             }
[15:32:28.822]         }))
[15:32:28.822]     }, error = function(ex) {
[15:32:28.822]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:28.822]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:28.822]                 ...future.rng), started = ...future.startTime, 
[15:32:28.822]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:28.822]             version = "1.8"), class = "FutureResult")
[15:32:28.822]     }, finally = {
[15:32:28.822]         if (!identical(...future.workdir, getwd())) 
[15:32:28.822]             setwd(...future.workdir)
[15:32:28.822]         {
[15:32:28.822]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:28.822]                 ...future.oldOptions$nwarnings <- NULL
[15:32:28.822]             }
[15:32:28.822]             base::options(...future.oldOptions)
[15:32:28.822]             if (.Platform$OS.type == "windows") {
[15:32:28.822]                 old_names <- names(...future.oldEnvVars)
[15:32:28.822]                 envs <- base::Sys.getenv()
[15:32:28.822]                 names <- names(envs)
[15:32:28.822]                 common <- intersect(names, old_names)
[15:32:28.822]                 added <- setdiff(names, old_names)
[15:32:28.822]                 removed <- setdiff(old_names, names)
[15:32:28.822]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:28.822]                   envs[common]]
[15:32:28.822]                 NAMES <- toupper(changed)
[15:32:28.822]                 args <- list()
[15:32:28.822]                 for (kk in seq_along(NAMES)) {
[15:32:28.822]                   name <- changed[[kk]]
[15:32:28.822]                   NAME <- NAMES[[kk]]
[15:32:28.822]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:28.822]                     next
[15:32:28.822]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:28.822]                 }
[15:32:28.822]                 NAMES <- toupper(added)
[15:32:28.822]                 for (kk in seq_along(NAMES)) {
[15:32:28.822]                   name <- added[[kk]]
[15:32:28.822]                   NAME <- NAMES[[kk]]
[15:32:28.822]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:28.822]                     next
[15:32:28.822]                   args[[name]] <- ""
[15:32:28.822]                 }
[15:32:28.822]                 NAMES <- toupper(removed)
[15:32:28.822]                 for (kk in seq_along(NAMES)) {
[15:32:28.822]                   name <- removed[[kk]]
[15:32:28.822]                   NAME <- NAMES[[kk]]
[15:32:28.822]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:28.822]                     next
[15:32:28.822]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:28.822]                 }
[15:32:28.822]                 if (length(args) > 0) 
[15:32:28.822]                   base::do.call(base::Sys.setenv, args = args)
[15:32:28.822]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:28.822]             }
[15:32:28.822]             else {
[15:32:28.822]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:28.822]             }
[15:32:28.822]             {
[15:32:28.822]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:28.822]                   0L) {
[15:32:28.822]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:28.822]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:28.822]                   base::options(opts)
[15:32:28.822]                 }
[15:32:28.822]                 {
[15:32:28.822]                   {
[15:32:28.822]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:28.822]                     NULL
[15:32:28.822]                   }
[15:32:28.822]                   options(future.plan = NULL)
[15:32:28.822]                   if (is.na(NA_character_)) 
[15:32:28.822]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:28.822]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:28.822]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:28.822]                     .init = FALSE)
[15:32:28.822]                 }
[15:32:28.822]             }
[15:32:28.822]         }
[15:32:28.822]     })
[15:32:28.822]     if (TRUE) {
[15:32:28.822]         base::sink(type = "output", split = FALSE)
[15:32:28.822]         if (TRUE) {
[15:32:28.822]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:28.822]         }
[15:32:28.822]         else {
[15:32:28.822]             ...future.result["stdout"] <- base::list(NULL)
[15:32:28.822]         }
[15:32:28.822]         base::close(...future.stdout)
[15:32:28.822]         ...future.stdout <- NULL
[15:32:28.822]     }
[15:32:28.822]     ...future.result$conditions <- ...future.conditions
[15:32:28.822]     ...future.result$finished <- base::Sys.time()
[15:32:28.822]     ...future.result
[15:32:28.822] }
[15:32:28.828] Exporting 5 global objects (4.62 KiB) to cluster node #1 ...
[15:32:28.828] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ...
[15:32:28.829] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ... DONE
[15:32:28.829] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:28.830] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:28.830] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:28.830] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:28.831] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:28.831] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:28.831] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:28.832] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:28.832] Exporting 5 global objects (4.62 KiB) to cluster node #1 ... DONE
[15:32:28.832] MultisessionFuture started
[15:32:28.833] - Launch lazy future ... done
[15:32:28.833] run() for 'MultisessionFuture' ... done
[15:32:28.833] Created future:
[15:32:28.850] receiveMessageFromWorker() for ClusterFuture ...
[15:32:28.850] - Validating connection of MultisessionFuture
[15:32:28.850] - received message: FutureResult
[15:32:28.850] - Received FutureResult
[15:32:28.851] - Erased future from FutureRegistry
[15:32:28.851] result() for ClusterFuture ...
[15:32:28.851] - result already collected: FutureResult
[15:32:28.851] result() for ClusterFuture ... done
[15:32:28.851] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:28.833] MultisessionFuture:
[15:32:28.833] Label: 'future_sapply-2'
[15:32:28.833] Expression:
[15:32:28.833] {
[15:32:28.833]     do.call(function(...) {
[15:32:28.833]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:28.833]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:28.833]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:28.833]             on.exit(options(oopts), add = TRUE)
[15:32:28.833]         }
[15:32:28.833]         {
[15:32:28.833]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:28.833]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:28.833]                 ...future.FUN(...future.X_jj, ...)
[15:32:28.833]             })
[15:32:28.833]         }
[15:32:28.833]     }, args = future.call.arguments)
[15:32:28.833] }
[15:32:28.833] Lazy evaluation: FALSE
[15:32:28.833] Asynchronous evaluation: TRUE
[15:32:28.833] Local evaluation: TRUE
[15:32:28.833] Environment: R_GlobalEnv
[15:32:28.833] Capture standard output: TRUE
[15:32:28.833] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:28.833] Globals: 5 objects totaling 4.73 KiB (function '...future.FUN' of 4.62 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)
[15:32:28.833] Packages: <none>
[15:32:28.833] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:28.833] Resolved: TRUE
[15:32:28.833] Value: <not collected>
[15:32:28.833] Conditions captured: <none>
[15:32:28.833] Early signaling: FALSE
[15:32:28.833] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:28.833] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:28.852] Chunk #2 of 2 ... DONE
[15:32:28.852] Launching 2 futures (chunks) ... DONE
[15:32:28.852] Resolving 2 futures (chunks) ...
[15:32:28.853] resolve() on list ...
[15:32:28.853]  recursive: 0
[15:32:28.853]  length: 2
[15:32:28.853] 
[15:32:28.853] Future #1
[15:32:28.853] result() for ClusterFuture ...
[15:32:28.854] - result already collected: FutureResult
[15:32:28.854] result() for ClusterFuture ... done
[15:32:28.854] result() for ClusterFuture ...
[15:32:28.854] - result already collected: FutureResult
[15:32:28.854] result() for ClusterFuture ... done
[15:32:28.854] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:28.855] - nx: 2
[15:32:28.855] - relay: TRUE
[15:32:28.855] - stdout: TRUE
[15:32:28.855] - signal: TRUE
[15:32:28.855] - resignal: FALSE
[15:32:28.855] - force: TRUE
[15:32:28.856] - relayed: [n=2] FALSE, FALSE
[15:32:28.856] - queued futures: [n=2] FALSE, FALSE
[15:32:28.856]  - until=1
[15:32:28.856]  - relaying element #1
[15:32:28.856] result() for ClusterFuture ...
[15:32:28.856] - result already collected: FutureResult
[15:32:28.857] result() for ClusterFuture ... done
[15:32:28.857] result() for ClusterFuture ...
[15:32:28.857] - result already collected: FutureResult
[15:32:28.857] result() for ClusterFuture ... done
[15:32:28.857] result() for ClusterFuture ...
[15:32:28.857] - result already collected: FutureResult
[15:32:28.858] result() for ClusterFuture ... done
[15:32:28.858] result() for ClusterFuture ...
[15:32:28.858] - result already collected: FutureResult
[15:32:28.858] result() for ClusterFuture ... done
[15:32:28.858] - relayed: [n=2] TRUE, FALSE
[15:32:28.858] - queued futures: [n=2] TRUE, FALSE
[15:32:28.859] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:28.859]  length: 1 (resolved future 1)
[15:32:28.859] Future #2
[15:32:28.859] result() for ClusterFuture ...
[15:32:28.859] - result already collected: FutureResult
[15:32:28.860] result() for ClusterFuture ... done
[15:32:28.860] result() for ClusterFuture ...
[15:32:28.860] - result already collected: FutureResult
[15:32:28.860] result() for ClusterFuture ... done
[15:32:28.860] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:28.860] - nx: 2
[15:32:28.861] - relay: TRUE
[15:32:28.861] - stdout: TRUE
[15:32:28.861] - signal: TRUE
[15:32:28.861] - resignal: FALSE
[15:32:28.861] - force: TRUE
[15:32:28.861] - relayed: [n=2] TRUE, FALSE
[15:32:28.861] - queued futures: [n=2] TRUE, FALSE
[15:32:28.862]  - until=2
[15:32:28.862]  - relaying element #2
[15:32:28.862] result() for ClusterFuture ...
[15:32:28.862] - result already collected: FutureResult
[15:32:28.862] result() for ClusterFuture ... done
[15:32:28.862] result() for ClusterFuture ...
[15:32:28.863] - result already collected: FutureResult
[15:32:28.863] result() for ClusterFuture ... done
[15:32:28.863] result() for ClusterFuture ...
[15:32:28.863] - result already collected: FutureResult
[15:32:28.863] result() for ClusterFuture ... done
[15:32:28.863] result() for ClusterFuture ...
[15:32:28.864] - result already collected: FutureResult
[15:32:28.864] result() for ClusterFuture ... done
[15:32:28.864] - relayed: [n=2] TRUE, TRUE
[15:32:28.864] - queued futures: [n=2] TRUE, TRUE
[15:32:28.864] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:28.864]  length: 0 (resolved future 2)
[15:32:28.865] Relaying remaining futures
[15:32:28.865] signalConditionsASAP(NULL, pos=0) ...
[15:32:28.865] - nx: 2
[15:32:28.865] - relay: TRUE
[15:32:28.865] - stdout: TRUE
[15:32:28.865] - signal: TRUE
[15:32:28.866] - resignal: FALSE
[15:32:28.866] - force: TRUE
[15:32:28.866] - relayed: [n=2] TRUE, TRUE
[15:32:28.866] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:28.866] - relayed: [n=2] TRUE, TRUE
[15:32:28.867] - queued futures: [n=2] TRUE, TRUE
[15:32:28.867] signalConditionsASAP(NULL, pos=0) ... done
[15:32:28.867] resolve() on list ... DONE
[15:32:28.867] result() for ClusterFuture ...
[15:32:28.867] - result already collected: FutureResult
[15:32:28.867] result() for ClusterFuture ... done
[15:32:28.868] result() for ClusterFuture ...
[15:32:28.868] - result already collected: FutureResult
[15:32:28.868] result() for ClusterFuture ... done
[15:32:28.868] result() for ClusterFuture ...
[15:32:28.868] - result already collected: FutureResult
[15:32:28.868] result() for ClusterFuture ... done
[15:32:28.869] result() for ClusterFuture ...
[15:32:28.869] - result already collected: FutureResult
[15:32:28.869] result() for ClusterFuture ... done
[15:32:28.869]  - Number of value chunks collected: 2
[15:32:28.869] Resolving 2 futures (chunks) ... DONE
[15:32:28.869] Reducing values from 2 chunks ...
[15:32:28.870]  - Number of values collected after concatenation: 3
[15:32:28.870]  - Number of values expected: 3
[15:32:28.870] Reducing values from 2 chunks ... DONE
[15:32:28.870] future_lapply() ... DONE
List of 2
 $ y0: num [1:3, 1:5, 1:3] 2 2 2 4 4 4 6 6 6 8 ...
  ..- attr(*, "dimnames")=List of 3
  .. ..$ : NULL
  .. ..$ : NULL
  .. ..$ : chr [1:3] "a" "b" "c"
 $ y1: num [1:3, 1:5, 1:3] 2 2 2 4 4 4 6 6 6 8 ...
  ..- attr(*, "dimnames")=List of 3
  .. ..$ : NULL
  .. ..$ : NULL
  .. ..$ : chr [1:3] "a" "b" "c"
[15:32:28.874] future_lapply() ...
[15:32:28.877] Number of chunks: 2
[15:32:28.877] getGlobalsAndPackagesXApply() ...
[15:32:28.878]  - future.globals: TRUE
[15:32:28.878] getGlobalsAndPackages() ...
[15:32:28.878] Searching for globals...
[15:32:28.879] - globals found: [1] 'FUN'
[15:32:28.880] Searching for globals ... DONE
[15:32:28.880] Resolving globals: FALSE
[15:32:28.880] The total size of the 1 globals is 848 bytes (848 bytes)
[15:32:28.881] The total size of the 1 globals exported for future expression ('FUN()') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:32:28.881] - globals: [1] 'FUN'
[15:32:28.881] 
[15:32:28.881] getGlobalsAndPackages() ... DONE
[15:32:28.881]  - globals found/used: [n=1] 'FUN'
[15:32:28.882]  - needed namespaces: [n=0] 
[15:32:28.882] Finding globals ... DONE
[15:32:28.882]  - use_args: TRUE
[15:32:28.882]  - Getting '...' globals ...
[15:32:28.883] resolve() on list ...
[15:32:28.883]  recursive: 0
[15:32:28.883]  length: 1
[15:32:28.883]  elements: '...'
[15:32:28.883]  length: 0 (resolved future 1)
[15:32:28.883] resolve() on list ... DONE
[15:32:28.884]    - '...' content: [n=0] 
[15:32:28.884] List of 1
[15:32:28.884]  $ ...: list()
[15:32:28.884]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:28.884]  - attr(*, "where")=List of 1
[15:32:28.884]   ..$ ...:<environment: 0x00000276e474d1b8> 
[15:32:28.884]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:28.884]  - attr(*, "resolved")= logi TRUE
[15:32:28.884]  - attr(*, "total_size")= num NA
[15:32:28.887]  - Getting '...' globals ... DONE
[15:32:28.887] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:28.888] List of 2
[15:32:28.888]  $ ...future.FUN:function (x)  
[15:32:28.888]  $ ...          : list()
[15:32:28.888]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:28.888]  - attr(*, "where")=List of 2
[15:32:28.888]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:28.888]   ..$ ...          :<environment: 0x00000276e474d1b8> 
[15:32:28.888]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:28.888]  - attr(*, "resolved")= logi FALSE
[15:32:28.888]  - attr(*, "total_size")= num 848
[15:32:28.893] Packages to be attached in all futures: [n=0] 
[15:32:28.894] getGlobalsAndPackagesXApply() ... DONE
[15:32:28.894] Number of futures (= number of chunks): 2
[15:32:28.894] Launching 2 futures (chunks) ...
[15:32:28.894] Chunk #1 of 2 ...
[15:32:28.894]  - Finding globals in 'X' for chunk #1 ...
[15:32:28.895] getGlobalsAndPackages() ...
[15:32:28.895] Searching for globals...
[15:32:28.895] 
[15:32:28.895] Searching for globals ... DONE
[15:32:28.896] - globals: [0] <none>
[15:32:28.896] getGlobalsAndPackages() ... DONE
[15:32:28.896]    + additional globals found: [n=0] 
[15:32:28.896]    + additional namespaces needed: [n=0] 
[15:32:28.896]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:28.896]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:28.897]  - seeds: <none>
[15:32:28.897]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:28.897] getGlobalsAndPackages() ...
[15:32:28.897] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:28.897] Resolving globals: FALSE
[15:32:28.897] Tweak future expression to call with '...' arguments ...
[15:32:28.898] {
[15:32:28.898]     do.call(function(...) {
[15:32:28.898]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:28.898]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:28.898]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:28.898]             on.exit(options(oopts), add = TRUE)
[15:32:28.898]         }
[15:32:28.898]         {
[15:32:28.898]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:28.898]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:28.898]                 ...future.FUN(...future.X_jj, ...)
[15:32:28.898]             })
[15:32:28.898]         }
[15:32:28.898]     }, args = future.call.arguments)
[15:32:28.898] }
[15:32:28.898] Tweak future expression to call with '...' arguments ... DONE
[15:32:28.899] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:28.899] 
[15:32:28.899] getGlobalsAndPackages() ... DONE
[15:32:28.899] run() for 'Future' ...
[15:32:28.900] - state: 'created'
[15:32:28.900] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:28.916] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:28.916] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:28.917]   - Field: 'node'
[15:32:28.917]   - Field: 'label'
[15:32:28.917]   - Field: 'local'
[15:32:28.918]   - Field: 'owner'
[15:32:28.918]   - Field: 'envir'
[15:32:28.918]   - Field: 'workers'
[15:32:28.919]   - Field: 'packages'
[15:32:28.919]   - Field: 'gc'
[15:32:28.919]   - Field: 'conditions'
[15:32:28.920]   - Field: 'persistent'
[15:32:28.920]   - Field: 'expr'
[15:32:28.920]   - Field: 'uuid'
[15:32:28.921]   - Field: 'seed'
[15:32:28.921]   - Field: 'version'
[15:32:28.921]   - Field: 'result'
[15:32:28.921]   - Field: 'asynchronous'
[15:32:28.922]   - Field: 'calls'
[15:32:28.922]   - Field: 'globals'
[15:32:28.922]   - Field: 'stdout'
[15:32:28.923]   - Field: 'earlySignal'
[15:32:28.923]   - Field: 'lazy'
[15:32:28.923]   - Field: 'state'
[15:32:28.924] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:28.924] - Launch lazy future ...
[15:32:28.924] Packages needed by the future expression (n = 0): <none>
[15:32:28.925] Packages needed by future strategies (n = 0): <none>
[15:32:28.926] {
[15:32:28.926]     {
[15:32:28.926]         {
[15:32:28.926]             ...future.startTime <- base::Sys.time()
[15:32:28.926]             {
[15:32:28.926]                 {
[15:32:28.926]                   {
[15:32:28.926]                     {
[15:32:28.926]                       base::local({
[15:32:28.926]                         has_future <- base::requireNamespace("future", 
[15:32:28.926]                           quietly = TRUE)
[15:32:28.926]                         if (has_future) {
[15:32:28.926]                           ns <- base::getNamespace("future")
[15:32:28.926]                           version <- ns[[".package"]][["version"]]
[15:32:28.926]                           if (is.null(version)) 
[15:32:28.926]                             version <- utils::packageVersion("future")
[15:32:28.926]                         }
[15:32:28.926]                         else {
[15:32:28.926]                           version <- NULL
[15:32:28.926]                         }
[15:32:28.926]                         if (!has_future || version < "1.8.0") {
[15:32:28.926]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:28.926]                             "", base::R.version$version.string), 
[15:32:28.926]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:28.926]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:28.926]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:28.926]                               "release", "version")], collapse = " "), 
[15:32:28.926]                             hostname = base::Sys.info()[["nodename"]])
[15:32:28.926]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:28.926]                             info)
[15:32:28.926]                           info <- base::paste(info, collapse = "; ")
[15:32:28.926]                           if (!has_future) {
[15:32:28.926]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:28.926]                               info)
[15:32:28.926]                           }
[15:32:28.926]                           else {
[15:32:28.926]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:28.926]                               info, version)
[15:32:28.926]                           }
[15:32:28.926]                           base::stop(msg)
[15:32:28.926]                         }
[15:32:28.926]                       })
[15:32:28.926]                     }
[15:32:28.926]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:28.926]                     base::options(mc.cores = 1L)
[15:32:28.926]                   }
[15:32:28.926]                   ...future.strategy.old <- future::plan("list")
[15:32:28.926]                   options(future.plan = NULL)
[15:32:28.926]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:28.926]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:28.926]                 }
[15:32:28.926]                 ...future.workdir <- getwd()
[15:32:28.926]             }
[15:32:28.926]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:28.926]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:28.926]         }
[15:32:28.926]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:28.926]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:28.926]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:28.926]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:28.926]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:28.926]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:28.926]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:28.926]             base::names(...future.oldOptions))
[15:32:28.926]     }
[15:32:28.926]     if (FALSE) {
[15:32:28.926]     }
[15:32:28.926]     else {
[15:32:28.926]         if (TRUE) {
[15:32:28.926]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:28.926]                 open = "w")
[15:32:28.926]         }
[15:32:28.926]         else {
[15:32:28.926]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:28.926]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:28.926]         }
[15:32:28.926]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:28.926]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:28.926]             base::sink(type = "output", split = FALSE)
[15:32:28.926]             base::close(...future.stdout)
[15:32:28.926]         }, add = TRUE)
[15:32:28.926]     }
[15:32:28.926]     ...future.frame <- base::sys.nframe()
[15:32:28.926]     ...future.conditions <- base::list()
[15:32:28.926]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:28.926]     if (FALSE) {
[15:32:28.926]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:28.926]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:28.926]     }
[15:32:28.926]     ...future.result <- base::tryCatch({
[15:32:28.926]         base::withCallingHandlers({
[15:32:28.926]             ...future.value <- base::withVisible(base::local({
[15:32:28.926]                 ...future.makeSendCondition <- base::local({
[15:32:28.926]                   sendCondition <- NULL
[15:32:28.926]                   function(frame = 1L) {
[15:32:28.926]                     if (is.function(sendCondition)) 
[15:32:28.926]                       return(sendCondition)
[15:32:28.926]                     ns <- getNamespace("parallel")
[15:32:28.926]                     if (exists("sendData", mode = "function", 
[15:32:28.926]                       envir = ns)) {
[15:32:28.926]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:28.926]                         envir = ns)
[15:32:28.926]                       envir <- sys.frame(frame)
[15:32:28.926]                       master <- NULL
[15:32:28.926]                       while (!identical(envir, .GlobalEnv) && 
[15:32:28.926]                         !identical(envir, emptyenv())) {
[15:32:28.926]                         if (exists("master", mode = "list", envir = envir, 
[15:32:28.926]                           inherits = FALSE)) {
[15:32:28.926]                           master <- get("master", mode = "list", 
[15:32:28.926]                             envir = envir, inherits = FALSE)
[15:32:28.926]                           if (inherits(master, c("SOCKnode", 
[15:32:28.926]                             "SOCK0node"))) {
[15:32:28.926]                             sendCondition <<- function(cond) {
[15:32:28.926]                               data <- list(type = "VALUE", value = cond, 
[15:32:28.926]                                 success = TRUE)
[15:32:28.926]                               parallel_sendData(master, data)
[15:32:28.926]                             }
[15:32:28.926]                             return(sendCondition)
[15:32:28.926]                           }
[15:32:28.926]                         }
[15:32:28.926]                         frame <- frame + 1L
[15:32:28.926]                         envir <- sys.frame(frame)
[15:32:28.926]                       }
[15:32:28.926]                     }
[15:32:28.926]                     sendCondition <<- function(cond) NULL
[15:32:28.926]                   }
[15:32:28.926]                 })
[15:32:28.926]                 withCallingHandlers({
[15:32:28.926]                   {
[15:32:28.926]                     do.call(function(...) {
[15:32:28.926]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:28.926]                       if (!identical(...future.globals.maxSize.org, 
[15:32:28.926]                         ...future.globals.maxSize)) {
[15:32:28.926]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:28.926]                         on.exit(options(oopts), add = TRUE)
[15:32:28.926]                       }
[15:32:28.926]                       {
[15:32:28.926]                         lapply(seq_along(...future.elements_ii), 
[15:32:28.926]                           FUN = function(jj) {
[15:32:28.926]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:28.926]                             ...future.FUN(...future.X_jj, ...)
[15:32:28.926]                           })
[15:32:28.926]                       }
[15:32:28.926]                     }, args = future.call.arguments)
[15:32:28.926]                   }
[15:32:28.926]                 }, immediateCondition = function(cond) {
[15:32:28.926]                   sendCondition <- ...future.makeSendCondition()
[15:32:28.926]                   sendCondition(cond)
[15:32:28.926]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:28.926]                   {
[15:32:28.926]                     inherits <- base::inherits
[15:32:28.926]                     invokeRestart <- base::invokeRestart
[15:32:28.926]                     is.null <- base::is.null
[15:32:28.926]                     muffled <- FALSE
[15:32:28.926]                     if (inherits(cond, "message")) {
[15:32:28.926]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:28.926]                       if (muffled) 
[15:32:28.926]                         invokeRestart("muffleMessage")
[15:32:28.926]                     }
[15:32:28.926]                     else if (inherits(cond, "warning")) {
[15:32:28.926]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:28.926]                       if (muffled) 
[15:32:28.926]                         invokeRestart("muffleWarning")
[15:32:28.926]                     }
[15:32:28.926]                     else if (inherits(cond, "condition")) {
[15:32:28.926]                       if (!is.null(pattern)) {
[15:32:28.926]                         computeRestarts <- base::computeRestarts
[15:32:28.926]                         grepl <- base::grepl
[15:32:28.926]                         restarts <- computeRestarts(cond)
[15:32:28.926]                         for (restart in restarts) {
[15:32:28.926]                           name <- restart$name
[15:32:28.926]                           if (is.null(name)) 
[15:32:28.926]                             next
[15:32:28.926]                           if (!grepl(pattern, name)) 
[15:32:28.926]                             next
[15:32:28.926]                           invokeRestart(restart)
[15:32:28.926]                           muffled <- TRUE
[15:32:28.926]                           break
[15:32:28.926]                         }
[15:32:28.926]                       }
[15:32:28.926]                     }
[15:32:28.926]                     invisible(muffled)
[15:32:28.926]                   }
[15:32:28.926]                   muffleCondition(cond)
[15:32:28.926]                 })
[15:32:28.926]             }))
[15:32:28.926]             future::FutureResult(value = ...future.value$value, 
[15:32:28.926]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:28.926]                   ...future.rng), globalenv = if (FALSE) 
[15:32:28.926]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:28.926]                     ...future.globalenv.names))
[15:32:28.926]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:28.926]         }, condition = base::local({
[15:32:28.926]             c <- base::c
[15:32:28.926]             inherits <- base::inherits
[15:32:28.926]             invokeRestart <- base::invokeRestart
[15:32:28.926]             length <- base::length
[15:32:28.926]             list <- base::list
[15:32:28.926]             seq.int <- base::seq.int
[15:32:28.926]             signalCondition <- base::signalCondition
[15:32:28.926]             sys.calls <- base::sys.calls
[15:32:28.926]             `[[` <- base::`[[`
[15:32:28.926]             `+` <- base::`+`
[15:32:28.926]             `<<-` <- base::`<<-`
[15:32:28.926]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:28.926]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:28.926]                   3L)]
[15:32:28.926]             }
[15:32:28.926]             function(cond) {
[15:32:28.926]                 is_error <- inherits(cond, "error")
[15:32:28.926]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:28.926]                   NULL)
[15:32:28.926]                 if (is_error) {
[15:32:28.926]                   sessionInformation <- function() {
[15:32:28.926]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:28.926]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:28.926]                       search = base::search(), system = base::Sys.info())
[15:32:28.926]                   }
[15:32:28.926]                   ...future.conditions[[length(...future.conditions) + 
[15:32:28.926]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:28.926]                     cond$call), session = sessionInformation(), 
[15:32:28.926]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:28.926]                   signalCondition(cond)
[15:32:28.926]                 }
[15:32:28.926]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:28.926]                 "immediateCondition"))) {
[15:32:28.926]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:28.926]                   ...future.conditions[[length(...future.conditions) + 
[15:32:28.926]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:28.926]                   if (TRUE && !signal) {
[15:32:28.926]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:28.926]                     {
[15:32:28.926]                       inherits <- base::inherits
[15:32:28.926]                       invokeRestart <- base::invokeRestart
[15:32:28.926]                       is.null <- base::is.null
[15:32:28.926]                       muffled <- FALSE
[15:32:28.926]                       if (inherits(cond, "message")) {
[15:32:28.926]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:28.926]                         if (muffled) 
[15:32:28.926]                           invokeRestart("muffleMessage")
[15:32:28.926]                       }
[15:32:28.926]                       else if (inherits(cond, "warning")) {
[15:32:28.926]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:28.926]                         if (muffled) 
[15:32:28.926]                           invokeRestart("muffleWarning")
[15:32:28.926]                       }
[15:32:28.926]                       else if (inherits(cond, "condition")) {
[15:32:28.926]                         if (!is.null(pattern)) {
[15:32:28.926]                           computeRestarts <- base::computeRestarts
[15:32:28.926]                           grepl <- base::grepl
[15:32:28.926]                           restarts <- computeRestarts(cond)
[15:32:28.926]                           for (restart in restarts) {
[15:32:28.926]                             name <- restart$name
[15:32:28.926]                             if (is.null(name)) 
[15:32:28.926]                               next
[15:32:28.926]                             if (!grepl(pattern, name)) 
[15:32:28.926]                               next
[15:32:28.926]                             invokeRestart(restart)
[15:32:28.926]                             muffled <- TRUE
[15:32:28.926]                             break
[15:32:28.926]                           }
[15:32:28.926]                         }
[15:32:28.926]                       }
[15:32:28.926]                       invisible(muffled)
[15:32:28.926]                     }
[15:32:28.926]                     muffleCondition(cond, pattern = "^muffle")
[15:32:28.926]                   }
[15:32:28.926]                 }
[15:32:28.926]                 else {
[15:32:28.926]                   if (TRUE) {
[15:32:28.926]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:28.926]                     {
[15:32:28.926]                       inherits <- base::inherits
[15:32:28.926]                       invokeRestart <- base::invokeRestart
[15:32:28.926]                       is.null <- base::is.null
[15:32:28.926]                       muffled <- FALSE
[15:32:28.926]                       if (inherits(cond, "message")) {
[15:32:28.926]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:28.926]                         if (muffled) 
[15:32:28.926]                           invokeRestart("muffleMessage")
[15:32:28.926]                       }
[15:32:28.926]                       else if (inherits(cond, "warning")) {
[15:32:28.926]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:28.926]                         if (muffled) 
[15:32:28.926]                           invokeRestart("muffleWarning")
[15:32:28.926]                       }
[15:32:28.926]                       else if (inherits(cond, "condition")) {
[15:32:28.926]                         if (!is.null(pattern)) {
[15:32:28.926]                           computeRestarts <- base::computeRestarts
[15:32:28.926]                           grepl <- base::grepl
[15:32:28.926]                           restarts <- computeRestarts(cond)
[15:32:28.926]                           for (restart in restarts) {
[15:32:28.926]                             name <- restart$name
[15:32:28.926]                             if (is.null(name)) 
[15:32:28.926]                               next
[15:32:28.926]                             if (!grepl(pattern, name)) 
[15:32:28.926]                               next
[15:32:28.926]                             invokeRestart(restart)
[15:32:28.926]                             muffled <- TRUE
[15:32:28.926]                             break
[15:32:28.926]                           }
[15:32:28.926]                         }
[15:32:28.926]                       }
[15:32:28.926]                       invisible(muffled)
[15:32:28.926]                     }
[15:32:28.926]                     muffleCondition(cond, pattern = "^muffle")
[15:32:28.926]                   }
[15:32:28.926]                 }
[15:32:28.926]             }
[15:32:28.926]         }))
[15:32:28.926]     }, error = function(ex) {
[15:32:28.926]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:28.926]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:28.926]                 ...future.rng), started = ...future.startTime, 
[15:32:28.926]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:28.926]             version = "1.8"), class = "FutureResult")
[15:32:28.926]     }, finally = {
[15:32:28.926]         if (!identical(...future.workdir, getwd())) 
[15:32:28.926]             setwd(...future.workdir)
[15:32:28.926]         {
[15:32:28.926]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:28.926]                 ...future.oldOptions$nwarnings <- NULL
[15:32:28.926]             }
[15:32:28.926]             base::options(...future.oldOptions)
[15:32:28.926]             if (.Platform$OS.type == "windows") {
[15:32:28.926]                 old_names <- names(...future.oldEnvVars)
[15:32:28.926]                 envs <- base::Sys.getenv()
[15:32:28.926]                 names <- names(envs)
[15:32:28.926]                 common <- intersect(names, old_names)
[15:32:28.926]                 added <- setdiff(names, old_names)
[15:32:28.926]                 removed <- setdiff(old_names, names)
[15:32:28.926]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:28.926]                   envs[common]]
[15:32:28.926]                 NAMES <- toupper(changed)
[15:32:28.926]                 args <- list()
[15:32:28.926]                 for (kk in seq_along(NAMES)) {
[15:32:28.926]                   name <- changed[[kk]]
[15:32:28.926]                   NAME <- NAMES[[kk]]
[15:32:28.926]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:28.926]                     next
[15:32:28.926]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:28.926]                 }
[15:32:28.926]                 NAMES <- toupper(added)
[15:32:28.926]                 for (kk in seq_along(NAMES)) {
[15:32:28.926]                   name <- added[[kk]]
[15:32:28.926]                   NAME <- NAMES[[kk]]
[15:32:28.926]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:28.926]                     next
[15:32:28.926]                   args[[name]] <- ""
[15:32:28.926]                 }
[15:32:28.926]                 NAMES <- toupper(removed)
[15:32:28.926]                 for (kk in seq_along(NAMES)) {
[15:32:28.926]                   name <- removed[[kk]]
[15:32:28.926]                   NAME <- NAMES[[kk]]
[15:32:28.926]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:28.926]                     next
[15:32:28.926]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:28.926]                 }
[15:32:28.926]                 if (length(args) > 0) 
[15:32:28.926]                   base::do.call(base::Sys.setenv, args = args)
[15:32:28.926]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:28.926]             }
[15:32:28.926]             else {
[15:32:28.926]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:28.926]             }
[15:32:28.926]             {
[15:32:28.926]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:28.926]                   0L) {
[15:32:28.926]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:28.926]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:28.926]                   base::options(opts)
[15:32:28.926]                 }
[15:32:28.926]                 {
[15:32:28.926]                   {
[15:32:28.926]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:28.926]                     NULL
[15:32:28.926]                   }
[15:32:28.926]                   options(future.plan = NULL)
[15:32:28.926]                   if (is.na(NA_character_)) 
[15:32:28.926]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:28.926]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:28.926]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:28.926]                     .init = FALSE)
[15:32:28.926]                 }
[15:32:28.926]             }
[15:32:28.926]         }
[15:32:28.926]     })
[15:32:28.926]     if (TRUE) {
[15:32:28.926]         base::sink(type = "output", split = FALSE)
[15:32:28.926]         if (TRUE) {
[15:32:28.926]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:28.926]         }
[15:32:28.926]         else {
[15:32:28.926]             ...future.result["stdout"] <- base::list(NULL)
[15:32:28.926]         }
[15:32:28.926]         base::close(...future.stdout)
[15:32:28.926]         ...future.stdout <- NULL
[15:32:28.926]     }
[15:32:28.926]     ...future.result$conditions <- ...future.conditions
[15:32:28.926]     ...future.result$finished <- base::Sys.time()
[15:32:28.926]     ...future.result
[15:32:28.926] }
[15:32:28.935] Exporting 5 global objects (848 bytes) to cluster node #1 ...
[15:32:28.936] Exporting '...future.FUN' (848 bytes) to cluster node #1 ...
[15:32:28.936] Exporting '...future.FUN' (848 bytes) to cluster node #1 ... DONE
[15:32:28.937] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:28.938] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:28.938] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ...
[15:32:28.939] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ... DONE
[15:32:28.939] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:28.940] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:28.940] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:28.941] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:28.941] Exporting 5 global objects (848 bytes) to cluster node #1 ... DONE
[15:32:28.942] MultisessionFuture started
[15:32:28.943] - Launch lazy future ... done
[15:32:28.943] run() for 'MultisessionFuture' ... done
[15:32:28.943] Created future:
[15:32:28.961] receiveMessageFromWorker() for ClusterFuture ...
[15:32:28.961] - Validating connection of MultisessionFuture
[15:32:28.962] - received message: FutureResult
[15:32:28.962] - Received FutureResult
[15:32:28.962] - Erased future from FutureRegistry
[15:32:28.962] result() for ClusterFuture ...
[15:32:28.962] - result already collected: FutureResult
[15:32:28.963] result() for ClusterFuture ... done
[15:32:28.963] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:28.944] MultisessionFuture:
[15:32:28.944] Label: 'future_sapply-1'
[15:32:28.944] Expression:
[15:32:28.944] {
[15:32:28.944]     do.call(function(...) {
[15:32:28.944]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:28.944]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:28.944]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:28.944]             on.exit(options(oopts), add = TRUE)
[15:32:28.944]         }
[15:32:28.944]         {
[15:32:28.944]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:28.944]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:28.944]                 ...future.FUN(...future.X_jj, ...)
[15:32:28.944]             })
[15:32:28.944]         }
[15:32:28.944]     }, args = future.call.arguments)
[15:32:28.944] }
[15:32:28.944] Lazy evaluation: FALSE
[15:32:28.944] Asynchronous evaluation: TRUE
[15:32:28.944] Local evaluation: TRUE
[15:32:28.944] Environment: R_GlobalEnv
[15:32:28.944] Capture standard output: TRUE
[15:32:28.944] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:28.944] Globals: 5 objects totaling 904 bytes (function '...future.FUN' of 848 bytes, 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)
[15:32:28.944] Packages: <none>
[15:32:28.944] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:28.944] Resolved: TRUE
[15:32:28.944] Value: <not collected>
[15:32:28.944] Conditions captured: <none>
[15:32:28.944] Early signaling: FALSE
[15:32:28.944] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:28.944] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:28.963] Chunk #1 of 2 ... DONE
[15:32:28.964] Chunk #2 of 2 ...
[15:32:28.964]  - Finding globals in 'X' for chunk #2 ...
[15:32:28.964] getGlobalsAndPackages() ...
[15:32:28.964] Searching for globals...
[15:32:28.965] 
[15:32:28.965] Searching for globals ... DONE
[15:32:28.966] - globals: [0] <none>
[15:32:28.966] getGlobalsAndPackages() ... DONE
[15:32:28.966]    + additional globals found: [n=0] 
[15:32:28.966]    + additional namespaces needed: [n=0] 
[15:32:28.967]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:28.967]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:28.967]  - seeds: <none>
[15:32:28.967]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:28.968] getGlobalsAndPackages() ...
[15:32:28.968] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:28.969] Resolving globals: FALSE
[15:32:28.969] Tweak future expression to call with '...' arguments ...
[15:32:28.969] {
[15:32:28.969]     do.call(function(...) {
[15:32:28.969]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:28.969]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:28.969]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:28.969]             on.exit(options(oopts), add = TRUE)
[15:32:28.969]         }
[15:32:28.969]         {
[15:32:28.969]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:28.969]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:28.969]                 ...future.FUN(...future.X_jj, ...)
[15:32:28.969]             })
[15:32:28.969]         }
[15:32:28.969]     }, args = future.call.arguments)
[15:32:28.969] }
[15:32:28.970] Tweak future expression to call with '...' arguments ... DONE
[15:32:28.971] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:28.971] 
[15:32:28.972] getGlobalsAndPackages() ... DONE
[15:32:28.972] run() for 'Future' ...
[15:32:28.973] - state: 'created'
[15:32:28.973] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:28.992] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:28.993] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:28.993]   - Field: 'node'
[15:32:28.993]   - Field: 'label'
[15:32:28.994]   - Field: 'local'
[15:32:28.994]   - Field: 'owner'
[15:32:28.994]   - Field: 'envir'
[15:32:28.995]   - Field: 'workers'
[15:32:28.995]   - Field: 'packages'
[15:32:28.995]   - Field: 'gc'
[15:32:28.996]   - Field: 'conditions'
[15:32:28.996]   - Field: 'persistent'
[15:32:28.996]   - Field: 'expr'
[15:32:28.997]   - Field: 'uuid'
[15:32:28.997]   - Field: 'seed'
[15:32:28.997]   - Field: 'version'
[15:32:28.998]   - Field: 'result'
[15:32:28.998]   - Field: 'asynchronous'
[15:32:28.998]   - Field: 'calls'
[15:32:28.999]   - Field: 'globals'
[15:32:28.999]   - Field: 'stdout'
[15:32:28.999]   - Field: 'earlySignal'
[15:32:29.000]   - Field: 'lazy'
[15:32:29.000]   - Field: 'state'
[15:32:29.000] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:29.001] - Launch lazy future ...
[15:32:29.001] Packages needed by the future expression (n = 0): <none>
[15:32:29.002] Packages needed by future strategies (n = 0): <none>
[15:32:29.003] {
[15:32:29.003]     {
[15:32:29.003]         {
[15:32:29.003]             ...future.startTime <- base::Sys.time()
[15:32:29.003]             {
[15:32:29.003]                 {
[15:32:29.003]                   {
[15:32:29.003]                     {
[15:32:29.003]                       base::local({
[15:32:29.003]                         has_future <- base::requireNamespace("future", 
[15:32:29.003]                           quietly = TRUE)
[15:32:29.003]                         if (has_future) {
[15:32:29.003]                           ns <- base::getNamespace("future")
[15:32:29.003]                           version <- ns[[".package"]][["version"]]
[15:32:29.003]                           if (is.null(version)) 
[15:32:29.003]                             version <- utils::packageVersion("future")
[15:32:29.003]                         }
[15:32:29.003]                         else {
[15:32:29.003]                           version <- NULL
[15:32:29.003]                         }
[15:32:29.003]                         if (!has_future || version < "1.8.0") {
[15:32:29.003]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:29.003]                             "", base::R.version$version.string), 
[15:32:29.003]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:29.003]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:29.003]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:29.003]                               "release", "version")], collapse = " "), 
[15:32:29.003]                             hostname = base::Sys.info()[["nodename"]])
[15:32:29.003]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:29.003]                             info)
[15:32:29.003]                           info <- base::paste(info, collapse = "; ")
[15:32:29.003]                           if (!has_future) {
[15:32:29.003]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:29.003]                               info)
[15:32:29.003]                           }
[15:32:29.003]                           else {
[15:32:29.003]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:29.003]                               info, version)
[15:32:29.003]                           }
[15:32:29.003]                           base::stop(msg)
[15:32:29.003]                         }
[15:32:29.003]                       })
[15:32:29.003]                     }
[15:32:29.003]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:29.003]                     base::options(mc.cores = 1L)
[15:32:29.003]                   }
[15:32:29.003]                   ...future.strategy.old <- future::plan("list")
[15:32:29.003]                   options(future.plan = NULL)
[15:32:29.003]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:29.003]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:29.003]                 }
[15:32:29.003]                 ...future.workdir <- getwd()
[15:32:29.003]             }
[15:32:29.003]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:29.003]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:29.003]         }
[15:32:29.003]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:29.003]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:29.003]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:29.003]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:29.003]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:29.003]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:29.003]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:29.003]             base::names(...future.oldOptions))
[15:32:29.003]     }
[15:32:29.003]     if (FALSE) {
[15:32:29.003]     }
[15:32:29.003]     else {
[15:32:29.003]         if (TRUE) {
[15:32:29.003]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:29.003]                 open = "w")
[15:32:29.003]         }
[15:32:29.003]         else {
[15:32:29.003]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:29.003]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:29.003]         }
[15:32:29.003]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:29.003]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:29.003]             base::sink(type = "output", split = FALSE)
[15:32:29.003]             base::close(...future.stdout)
[15:32:29.003]         }, add = TRUE)
[15:32:29.003]     }
[15:32:29.003]     ...future.frame <- base::sys.nframe()
[15:32:29.003]     ...future.conditions <- base::list()
[15:32:29.003]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:29.003]     if (FALSE) {
[15:32:29.003]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:29.003]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:29.003]     }
[15:32:29.003]     ...future.result <- base::tryCatch({
[15:32:29.003]         base::withCallingHandlers({
[15:32:29.003]             ...future.value <- base::withVisible(base::local({
[15:32:29.003]                 ...future.makeSendCondition <- base::local({
[15:32:29.003]                   sendCondition <- NULL
[15:32:29.003]                   function(frame = 1L) {
[15:32:29.003]                     if (is.function(sendCondition)) 
[15:32:29.003]                       return(sendCondition)
[15:32:29.003]                     ns <- getNamespace("parallel")
[15:32:29.003]                     if (exists("sendData", mode = "function", 
[15:32:29.003]                       envir = ns)) {
[15:32:29.003]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:29.003]                         envir = ns)
[15:32:29.003]                       envir <- sys.frame(frame)
[15:32:29.003]                       master <- NULL
[15:32:29.003]                       while (!identical(envir, .GlobalEnv) && 
[15:32:29.003]                         !identical(envir, emptyenv())) {
[15:32:29.003]                         if (exists("master", mode = "list", envir = envir, 
[15:32:29.003]                           inherits = FALSE)) {
[15:32:29.003]                           master <- get("master", mode = "list", 
[15:32:29.003]                             envir = envir, inherits = FALSE)
[15:32:29.003]                           if (inherits(master, c("SOCKnode", 
[15:32:29.003]                             "SOCK0node"))) {
[15:32:29.003]                             sendCondition <<- function(cond) {
[15:32:29.003]                               data <- list(type = "VALUE", value = cond, 
[15:32:29.003]                                 success = TRUE)
[15:32:29.003]                               parallel_sendData(master, data)
[15:32:29.003]                             }
[15:32:29.003]                             return(sendCondition)
[15:32:29.003]                           }
[15:32:29.003]                         }
[15:32:29.003]                         frame <- frame + 1L
[15:32:29.003]                         envir <- sys.frame(frame)
[15:32:29.003]                       }
[15:32:29.003]                     }
[15:32:29.003]                     sendCondition <<- function(cond) NULL
[15:32:29.003]                   }
[15:32:29.003]                 })
[15:32:29.003]                 withCallingHandlers({
[15:32:29.003]                   {
[15:32:29.003]                     do.call(function(...) {
[15:32:29.003]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:29.003]                       if (!identical(...future.globals.maxSize.org, 
[15:32:29.003]                         ...future.globals.maxSize)) {
[15:32:29.003]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:29.003]                         on.exit(options(oopts), add = TRUE)
[15:32:29.003]                       }
[15:32:29.003]                       {
[15:32:29.003]                         lapply(seq_along(...future.elements_ii), 
[15:32:29.003]                           FUN = function(jj) {
[15:32:29.003]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:29.003]                             ...future.FUN(...future.X_jj, ...)
[15:32:29.003]                           })
[15:32:29.003]                       }
[15:32:29.003]                     }, args = future.call.arguments)
[15:32:29.003]                   }
[15:32:29.003]                 }, immediateCondition = function(cond) {
[15:32:29.003]                   sendCondition <- ...future.makeSendCondition()
[15:32:29.003]                   sendCondition(cond)
[15:32:29.003]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:29.003]                   {
[15:32:29.003]                     inherits <- base::inherits
[15:32:29.003]                     invokeRestart <- base::invokeRestart
[15:32:29.003]                     is.null <- base::is.null
[15:32:29.003]                     muffled <- FALSE
[15:32:29.003]                     if (inherits(cond, "message")) {
[15:32:29.003]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:29.003]                       if (muffled) 
[15:32:29.003]                         invokeRestart("muffleMessage")
[15:32:29.003]                     }
[15:32:29.003]                     else if (inherits(cond, "warning")) {
[15:32:29.003]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:29.003]                       if (muffled) 
[15:32:29.003]                         invokeRestart("muffleWarning")
[15:32:29.003]                     }
[15:32:29.003]                     else if (inherits(cond, "condition")) {
[15:32:29.003]                       if (!is.null(pattern)) {
[15:32:29.003]                         computeRestarts <- base::computeRestarts
[15:32:29.003]                         grepl <- base::grepl
[15:32:29.003]                         restarts <- computeRestarts(cond)
[15:32:29.003]                         for (restart in restarts) {
[15:32:29.003]                           name <- restart$name
[15:32:29.003]                           if (is.null(name)) 
[15:32:29.003]                             next
[15:32:29.003]                           if (!grepl(pattern, name)) 
[15:32:29.003]                             next
[15:32:29.003]                           invokeRestart(restart)
[15:32:29.003]                           muffled <- TRUE
[15:32:29.003]                           break
[15:32:29.003]                         }
[15:32:29.003]                       }
[15:32:29.003]                     }
[15:32:29.003]                     invisible(muffled)
[15:32:29.003]                   }
[15:32:29.003]                   muffleCondition(cond)
[15:32:29.003]                 })
[15:32:29.003]             }))
[15:32:29.003]             future::FutureResult(value = ...future.value$value, 
[15:32:29.003]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:29.003]                   ...future.rng), globalenv = if (FALSE) 
[15:32:29.003]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:29.003]                     ...future.globalenv.names))
[15:32:29.003]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:29.003]         }, condition = base::local({
[15:32:29.003]             c <- base::c
[15:32:29.003]             inherits <- base::inherits
[15:32:29.003]             invokeRestart <- base::invokeRestart
[15:32:29.003]             length <- base::length
[15:32:29.003]             list <- base::list
[15:32:29.003]             seq.int <- base::seq.int
[15:32:29.003]             signalCondition <- base::signalCondition
[15:32:29.003]             sys.calls <- base::sys.calls
[15:32:29.003]             `[[` <- base::`[[`
[15:32:29.003]             `+` <- base::`+`
[15:32:29.003]             `<<-` <- base::`<<-`
[15:32:29.003]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:29.003]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:29.003]                   3L)]
[15:32:29.003]             }
[15:32:29.003]             function(cond) {
[15:32:29.003]                 is_error <- inherits(cond, "error")
[15:32:29.003]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:29.003]                   NULL)
[15:32:29.003]                 if (is_error) {
[15:32:29.003]                   sessionInformation <- function() {
[15:32:29.003]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:29.003]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:29.003]                       search = base::search(), system = base::Sys.info())
[15:32:29.003]                   }
[15:32:29.003]                   ...future.conditions[[length(...future.conditions) + 
[15:32:29.003]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:29.003]                     cond$call), session = sessionInformation(), 
[15:32:29.003]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:29.003]                   signalCondition(cond)
[15:32:29.003]                 }
[15:32:29.003]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:29.003]                 "immediateCondition"))) {
[15:32:29.003]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:29.003]                   ...future.conditions[[length(...future.conditions) + 
[15:32:29.003]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:29.003]                   if (TRUE && !signal) {
[15:32:29.003]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:29.003]                     {
[15:32:29.003]                       inherits <- base::inherits
[15:32:29.003]                       invokeRestart <- base::invokeRestart
[15:32:29.003]                       is.null <- base::is.null
[15:32:29.003]                       muffled <- FALSE
[15:32:29.003]                       if (inherits(cond, "message")) {
[15:32:29.003]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:29.003]                         if (muffled) 
[15:32:29.003]                           invokeRestart("muffleMessage")
[15:32:29.003]                       }
[15:32:29.003]                       else if (inherits(cond, "warning")) {
[15:32:29.003]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:29.003]                         if (muffled) 
[15:32:29.003]                           invokeRestart("muffleWarning")
[15:32:29.003]                       }
[15:32:29.003]                       else if (inherits(cond, "condition")) {
[15:32:29.003]                         if (!is.null(pattern)) {
[15:32:29.003]                           computeRestarts <- base::computeRestarts
[15:32:29.003]                           grepl <- base::grepl
[15:32:29.003]                           restarts <- computeRestarts(cond)
[15:32:29.003]                           for (restart in restarts) {
[15:32:29.003]                             name <- restart$name
[15:32:29.003]                             if (is.null(name)) 
[15:32:29.003]                               next
[15:32:29.003]                             if (!grepl(pattern, name)) 
[15:32:29.003]                               next
[15:32:29.003]                             invokeRestart(restart)
[15:32:29.003]                             muffled <- TRUE
[15:32:29.003]                             break
[15:32:29.003]                           }
[15:32:29.003]                         }
[15:32:29.003]                       }
[15:32:29.003]                       invisible(muffled)
[15:32:29.003]                     }
[15:32:29.003]                     muffleCondition(cond, pattern = "^muffle")
[15:32:29.003]                   }
[15:32:29.003]                 }
[15:32:29.003]                 else {
[15:32:29.003]                   if (TRUE) {
[15:32:29.003]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:29.003]                     {
[15:32:29.003]                       inherits <- base::inherits
[15:32:29.003]                       invokeRestart <- base::invokeRestart
[15:32:29.003]                       is.null <- base::is.null
[15:32:29.003]                       muffled <- FALSE
[15:32:29.003]                       if (inherits(cond, "message")) {
[15:32:29.003]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:29.003]                         if (muffled) 
[15:32:29.003]                           invokeRestart("muffleMessage")
[15:32:29.003]                       }
[15:32:29.003]                       else if (inherits(cond, "warning")) {
[15:32:29.003]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:29.003]                         if (muffled) 
[15:32:29.003]                           invokeRestart("muffleWarning")
[15:32:29.003]                       }
[15:32:29.003]                       else if (inherits(cond, "condition")) {
[15:32:29.003]                         if (!is.null(pattern)) {
[15:32:29.003]                           computeRestarts <- base::computeRestarts
[15:32:29.003]                           grepl <- base::grepl
[15:32:29.003]                           restarts <- computeRestarts(cond)
[15:32:29.003]                           for (restart in restarts) {
[15:32:29.003]                             name <- restart$name
[15:32:29.003]                             if (is.null(name)) 
[15:32:29.003]                               next
[15:32:29.003]                             if (!grepl(pattern, name)) 
[15:32:29.003]                               next
[15:32:29.003]                             invokeRestart(restart)
[15:32:29.003]                             muffled <- TRUE
[15:32:29.003]                             break
[15:32:29.003]                           }
[15:32:29.003]                         }
[15:32:29.003]                       }
[15:32:29.003]                       invisible(muffled)
[15:32:29.003]                     }
[15:32:29.003]                     muffleCondition(cond, pattern = "^muffle")
[15:32:29.003]                   }
[15:32:29.003]                 }
[15:32:29.003]             }
[15:32:29.003]         }))
[15:32:29.003]     }, error = function(ex) {
[15:32:29.003]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:29.003]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:29.003]                 ...future.rng), started = ...future.startTime, 
[15:32:29.003]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:29.003]             version = "1.8"), class = "FutureResult")
[15:32:29.003]     }, finally = {
[15:32:29.003]         if (!identical(...future.workdir, getwd())) 
[15:32:29.003]             setwd(...future.workdir)
[15:32:29.003]         {
[15:32:29.003]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:29.003]                 ...future.oldOptions$nwarnings <- NULL
[15:32:29.003]             }
[15:32:29.003]             base::options(...future.oldOptions)
[15:32:29.003]             if (.Platform$OS.type == "windows") {
[15:32:29.003]                 old_names <- names(...future.oldEnvVars)
[15:32:29.003]                 envs <- base::Sys.getenv()
[15:32:29.003]                 names <- names(envs)
[15:32:29.003]                 common <- intersect(names, old_names)
[15:32:29.003]                 added <- setdiff(names, old_names)
[15:32:29.003]                 removed <- setdiff(old_names, names)
[15:32:29.003]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:29.003]                   envs[common]]
[15:32:29.003]                 NAMES <- toupper(changed)
[15:32:29.003]                 args <- list()
[15:32:29.003]                 for (kk in seq_along(NAMES)) {
[15:32:29.003]                   name <- changed[[kk]]
[15:32:29.003]                   NAME <- NAMES[[kk]]
[15:32:29.003]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:29.003]                     next
[15:32:29.003]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:29.003]                 }
[15:32:29.003]                 NAMES <- toupper(added)
[15:32:29.003]                 for (kk in seq_along(NAMES)) {
[15:32:29.003]                   name <- added[[kk]]
[15:32:29.003]                   NAME <- NAMES[[kk]]
[15:32:29.003]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:29.003]                     next
[15:32:29.003]                   args[[name]] <- ""
[15:32:29.003]                 }
[15:32:29.003]                 NAMES <- toupper(removed)
[15:32:29.003]                 for (kk in seq_along(NAMES)) {
[15:32:29.003]                   name <- removed[[kk]]
[15:32:29.003]                   NAME <- NAMES[[kk]]
[15:32:29.003]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:29.003]                     next
[15:32:29.003]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:29.003]                 }
[15:32:29.003]                 if (length(args) > 0) 
[15:32:29.003]                   base::do.call(base::Sys.setenv, args = args)
[15:32:29.003]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:29.003]             }
[15:32:29.003]             else {
[15:32:29.003]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:29.003]             }
[15:32:29.003]             {
[15:32:29.003]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:29.003]                   0L) {
[15:32:29.003]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:29.003]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:29.003]                   base::options(opts)
[15:32:29.003]                 }
[15:32:29.003]                 {
[15:32:29.003]                   {
[15:32:29.003]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:29.003]                     NULL
[15:32:29.003]                   }
[15:32:29.003]                   options(future.plan = NULL)
[15:32:29.003]                   if (is.na(NA_character_)) 
[15:32:29.003]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:29.003]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:29.003]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:29.003]                     .init = FALSE)
[15:32:29.003]                 }
[15:32:29.003]             }
[15:32:29.003]         }
[15:32:29.003]     })
[15:32:29.003]     if (TRUE) {
[15:32:29.003]         base::sink(type = "output", split = FALSE)
[15:32:29.003]         if (TRUE) {
[15:32:29.003]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:29.003]         }
[15:32:29.003]         else {
[15:32:29.003]             ...future.result["stdout"] <- base::list(NULL)
[15:32:29.003]         }
[15:32:29.003]         base::close(...future.stdout)
[15:32:29.003]         ...future.stdout <- NULL
[15:32:29.003]     }
[15:32:29.003]     ...future.result$conditions <- ...future.conditions
[15:32:29.003]     ...future.result$finished <- base::Sys.time()
[15:32:29.003]     ...future.result
[15:32:29.003] }
[15:32:29.012] Exporting 5 global objects (848 bytes) to cluster node #1 ...
[15:32:29.013] Exporting '...future.FUN' (848 bytes) to cluster node #1 ...
[15:32:29.014] Exporting '...future.FUN' (848 bytes) to cluster node #1 ... DONE
[15:32:29.014] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:29.015] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:29.016] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:29.017] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:29.017] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:29.018] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:29.018] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:29.019] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:29.019] Exporting 5 global objects (848 bytes) to cluster node #1 ... DONE
[15:32:29.020] MultisessionFuture started
[15:32:29.020] - Launch lazy future ... done
[15:32:29.021] run() for 'MultisessionFuture' ... done
[15:32:29.021] Created future:
[15:32:29.048] receiveMessageFromWorker() for ClusterFuture ...
[15:32:29.049] - Validating connection of MultisessionFuture
[15:32:29.050] - received message: FutureResult
[15:32:29.050] - Received FutureResult
[15:32:29.051] - Erased future from FutureRegistry
[15:32:29.051] result() for ClusterFuture ...
[15:32:29.051] - result already collected: FutureResult
[15:32:29.052] result() for ClusterFuture ... done
[15:32:29.052] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:29.021] MultisessionFuture:
[15:32:29.021] Label: 'future_sapply-2'
[15:32:29.021] Expression:
[15:32:29.021] {
[15:32:29.021]     do.call(function(...) {
[15:32:29.021]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:29.021]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:29.021]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:29.021]             on.exit(options(oopts), add = TRUE)
[15:32:29.021]         }
[15:32:29.021]         {
[15:32:29.021]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:29.021]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:29.021]                 ...future.FUN(...future.X_jj, ...)
[15:32:29.021]             })
[15:32:29.021]         }
[15:32:29.021]     }, args = future.call.arguments)
[15:32:29.021] }
[15:32:29.021] Lazy evaluation: FALSE
[15:32:29.021] Asynchronous evaluation: TRUE
[15:32:29.021] Local evaluation: TRUE
[15:32:29.021] Environment: R_GlobalEnv
[15:32:29.021] Capture standard output: TRUE
[15:32:29.021] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:29.021] Globals: 5 objects totaling 960 bytes (function '...future.FUN' of 848 bytes, 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)
[15:32:29.021] Packages: <none>
[15:32:29.021] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:29.021] Resolved: TRUE
[15:32:29.021] Value: <not collected>
[15:32:29.021] Conditions captured: <none>
[15:32:29.021] Early signaling: FALSE
[15:32:29.021] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:29.021] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:29.053] Chunk #2 of 2 ... DONE
[15:32:29.053] Launching 2 futures (chunks) ... DONE
[15:32:29.054] Resolving 2 futures (chunks) ...
[15:32:29.054] resolve() on list ...
[15:32:29.054]  recursive: 0
[15:32:29.055]  length: 2
[15:32:29.055] 
[15:32:29.055] Future #1
[15:32:29.056] result() for ClusterFuture ...
[15:32:29.056] - result already collected: FutureResult
[15:32:29.056] result() for ClusterFuture ... done
[15:32:29.057] result() for ClusterFuture ...
[15:32:29.057] - result already collected: FutureResult
[15:32:29.057] result() for ClusterFuture ... done
[15:32:29.057] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:29.058] - nx: 2
[15:32:29.058] - relay: TRUE
[15:32:29.058] - stdout: TRUE
[15:32:29.059] - signal: TRUE
[15:32:29.059] - resignal: FALSE
[15:32:29.059] - force: TRUE
[15:32:29.059] - relayed: [n=2] FALSE, FALSE
[15:32:29.060] - queued futures: [n=2] FALSE, FALSE
[15:32:29.060]  - until=1
[15:32:29.060]  - relaying element #1
[15:32:29.061] result() for ClusterFuture ...
[15:32:29.061] - result already collected: FutureResult
[15:32:29.061] result() for ClusterFuture ... done
[15:32:29.062] result() for ClusterFuture ...
[15:32:29.062] - result already collected: FutureResult
[15:32:29.062] result() for ClusterFuture ... done
[15:32:29.063] result() for ClusterFuture ...
[15:32:29.063] - result already collected: FutureResult
[15:32:29.063] result() for ClusterFuture ... done
[15:32:29.063] result() for ClusterFuture ...
[15:32:29.064] - result already collected: FutureResult
[15:32:29.064] result() for ClusterFuture ... done
[15:32:29.064] - relayed: [n=2] TRUE, FALSE
[15:32:29.065] - queued futures: [n=2] TRUE, FALSE
[15:32:29.065] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:29.065]  length: 1 (resolved future 1)
[15:32:29.066] Future #2
[15:32:29.066] result() for ClusterFuture ...
[15:32:29.066] - result already collected: FutureResult
[15:32:29.066] result() for ClusterFuture ... done
[15:32:29.067] result() for ClusterFuture ...
[15:32:29.067] - result already collected: FutureResult
[15:32:29.067] result() for ClusterFuture ... done
[15:32:29.068] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:29.068] - nx: 2
[15:32:29.068] - relay: TRUE
[15:32:29.068] - stdout: TRUE
[15:32:29.069] - signal: TRUE
[15:32:29.069] - resignal: FALSE
[15:32:29.069] - force: TRUE
[15:32:29.070] - relayed: [n=2] TRUE, FALSE
[15:32:29.070] - queued futures: [n=2] TRUE, FALSE
[15:32:29.070]  - until=2
[15:32:29.070]  - relaying element #2
[15:32:29.071] result() for ClusterFuture ...
[15:32:29.071] - result already collected: FutureResult
[15:32:29.071] result() for ClusterFuture ... done
[15:32:29.072] result() for ClusterFuture ...
[15:32:29.072] - result already collected: FutureResult
[15:32:29.072] result() for ClusterFuture ... done
[15:32:29.073] result() for ClusterFuture ...
[15:32:29.073] - result already collected: FutureResult
[15:32:29.073] result() for ClusterFuture ... done
[15:32:29.074] result() for ClusterFuture ...
[15:32:29.074] - result already collected: FutureResult
[15:32:29.074] result() for ClusterFuture ... done
[15:32:29.074] - relayed: [n=2] TRUE, TRUE
[15:32:29.075] - queued futures: [n=2] TRUE, TRUE
[15:32:29.075] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:29.075]  length: 0 (resolved future 2)
[15:32:29.076] Relaying remaining futures
[15:32:29.076] signalConditionsASAP(NULL, pos=0) ...
[15:32:29.076] - nx: 2
[15:32:29.076] - relay: TRUE
[15:32:29.077] - stdout: TRUE
[15:32:29.077] - signal: TRUE
[15:32:29.077] - resignal: FALSE
[15:32:29.078] - force: TRUE
[15:32:29.078] - relayed: [n=2] TRUE, TRUE
[15:32:29.078] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:29.079] - relayed: [n=2] TRUE, TRUE
[15:32:29.079] - queued futures: [n=2] TRUE, TRUE
[15:32:29.079] signalConditionsASAP(NULL, pos=0) ... done
[15:32:29.080] resolve() on list ... DONE
[15:32:29.080] result() for ClusterFuture ...
[15:32:29.080] - result already collected: FutureResult
[15:32:29.080] result() for ClusterFuture ... done
[15:32:29.081] result() for ClusterFuture ...
[15:32:29.081] - result already collected: FutureResult
[15:32:29.081] result() for ClusterFuture ... done
[15:32:29.082] result() for ClusterFuture ...
[15:32:29.082] - result already collected: FutureResult
[15:32:29.082] result() for ClusterFuture ... done
[15:32:29.082] result() for ClusterFuture ...
[15:32:29.083] - result already collected: FutureResult
[15:32:29.083] result() for ClusterFuture ... done
[15:32:29.083]  - Number of value chunks collected: 2
[15:32:29.083] Resolving 2 futures (chunks) ... DONE
[15:32:29.084] Reducing values from 2 chunks ...
[15:32:29.084]  - Number of values collected after concatenation: 3
[15:32:29.084]  - Number of values expected: 3
[15:32:29.084] Reducing values from 2 chunks ... DONE
[15:32:29.085] future_lapply() ... DONE
List of 2
 $ y0:List of 3
  ..$ a: num 1
  ..$ b: num 2
  ..$ c: num 3
 $ y1:List of 3
  ..$ a: num 1
  ..$ b: num 2
  ..$ c: num 3
List of 2
 $ y0:List of 3
  ..$ a: num 1
  ..$ b: num 2
  ..$ c: num 3
 $ y2:List of 3
  ..$ a: num 1
  ..$ b: num 2
  ..$ c: num 3
[15:32:29.097] future_lapply() ...
[15:32:29.103] Number of chunks: 2
[15:32:29.104] getGlobalsAndPackagesXApply() ...
[15:32:29.104]  - future.globals: TRUE
[15:32:29.104] getGlobalsAndPackages() ...
[15:32:29.105] Searching for globals...
[15:32:29.107] - globals found: [2] 'FUN', 'UseMethod'
[15:32:29.108] Searching for globals ... DONE
[15:32:29.108] Resolving globals: FALSE
[15:32:29.109] The total size of the 1 globals is 1.22 KiB (1248 bytes)
[15:32:29.110] The total size of the 1 globals exported for future expression ('FUN()') is 1.22 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.22 KiB of class 'function')
[15:32:29.110] - globals: [1] 'FUN'
[15:32:29.110] 
[15:32:29.111] getGlobalsAndPackages() ... DONE
[15:32:29.111]  - globals found/used: [n=1] 'FUN'
[15:32:29.111]  - needed namespaces: [n=0] 
[15:32:29.112] Finding globals ... DONE
[15:32:29.112]  - use_args: TRUE
[15:32:29.112]  - Getting '...' globals ...
[15:32:29.113] resolve() on list ...
[15:32:29.113]  recursive: 0
[15:32:29.114]  length: 1
[15:32:29.114]  elements: '...'
[15:32:29.114]  length: 0 (resolved future 1)
[15:32:29.115] resolve() on list ... DONE
[15:32:29.115]    - '...' content: [n=0] 
[15:32:29.115] List of 1
[15:32:29.115]  $ ...: list()
[15:32:29.115]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:29.115]  - attr(*, "where")=List of 1
[15:32:29.115]   ..$ ...:<environment: 0x00000276e4d84b00> 
[15:32:29.115]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:29.115]  - attr(*, "resolved")= logi TRUE
[15:32:29.115]  - attr(*, "total_size")= num NA
[15:32:29.121]  - Getting '...' globals ... DONE
[15:32:29.121] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:29.122] List of 2
[15:32:29.122]  $ ...future.FUN:function (x, ...)  
[15:32:29.122]  $ ...          : list()
[15:32:29.122]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:29.122]  - attr(*, "where")=List of 2
[15:32:29.122]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:29.122]   ..$ ...          :<environment: 0x00000276e4d84b00> 
[15:32:29.122]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:29.122]  - attr(*, "resolved")= logi FALSE
[15:32:29.122]  - attr(*, "total_size")= num 1248
[15:32:29.127] Packages to be attached in all futures: [n=0] 
[15:32:29.128] getGlobalsAndPackagesXApply() ... DONE
[15:32:29.128] Number of futures (= number of chunks): 2
[15:32:29.129] Launching 2 futures (chunks) ...
[15:32:29.129] Chunk #1 of 2 ...
[15:32:29.129]  - Finding globals in 'X' for chunk #1 ...
[15:32:29.130] getGlobalsAndPackages() ...
[15:32:29.130] Searching for globals...
[15:32:29.131] 
[15:32:29.131] Searching for globals ... DONE
[15:32:29.131] - globals: [0] <none>
[15:32:29.131] getGlobalsAndPackages() ... DONE
[15:32:29.132]    + additional globals found: [n=0] 
[15:32:29.132]    + additional namespaces needed: [n=0] 
[15:32:29.132]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:29.133]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:29.133]  - seeds: <none>
[15:32:29.133]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:29.133] getGlobalsAndPackages() ...
[15:32:29.134] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:29.134] Resolving globals: FALSE
[15:32:29.134] Tweak future expression to call with '...' arguments ...
[15:32:29.135] {
[15:32:29.135]     do.call(function(...) {
[15:32:29.135]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:29.135]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:29.135]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:29.135]             on.exit(options(oopts), add = TRUE)
[15:32:29.135]         }
[15:32:29.135]         {
[15:32:29.135]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:29.135]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:29.135]                 ...future.FUN(...future.X_jj, ...)
[15:32:29.135]             })
[15:32:29.135]         }
[15:32:29.135]     }, args = future.call.arguments)
[15:32:29.135] }
[15:32:29.135] Tweak future expression to call with '...' arguments ... DONE
[15:32:29.136] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:29.137] 
[15:32:29.137] getGlobalsAndPackages() ... DONE
[15:32:29.137] run() for 'Future' ...
[15:32:29.138] - state: 'created'
[15:32:29.138] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:29.159] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:29.159] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:29.160]   - Field: 'node'
[15:32:29.160]   - Field: 'label'
[15:32:29.160]   - Field: 'local'
[15:32:29.161]   - Field: 'owner'
[15:32:29.161]   - Field: 'envir'
[15:32:29.167]   - Field: 'workers'
[15:32:29.168]   - Field: 'packages'
[15:32:29.168]   - Field: 'gc'
[15:32:29.168]   - Field: 'conditions'
[15:32:29.168]   - Field: 'persistent'
[15:32:29.169]   - Field: 'expr'
[15:32:29.169]   - Field: 'uuid'
[15:32:29.169]   - Field: 'seed'
[15:32:29.170]   - Field: 'version'
[15:32:29.170]   - Field: 'result'
[15:32:29.170]   - Field: 'asynchronous'
[15:32:29.170]   - Field: 'calls'
[15:32:29.171]   - Field: 'globals'
[15:32:29.171]   - Field: 'stdout'
[15:32:29.171]   - Field: 'earlySignal'
[15:32:29.172]   - Field: 'lazy'
[15:32:29.172]   - Field: 'state'
[15:32:29.172] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:29.173] - Launch lazy future ...
[15:32:29.173] Packages needed by the future expression (n = 0): <none>
[15:32:29.174] Packages needed by future strategies (n = 0): <none>
[15:32:29.175] {
[15:32:29.175]     {
[15:32:29.175]         {
[15:32:29.175]             ...future.startTime <- base::Sys.time()
[15:32:29.175]             {
[15:32:29.175]                 {
[15:32:29.175]                   {
[15:32:29.175]                     {
[15:32:29.175]                       base::local({
[15:32:29.175]                         has_future <- base::requireNamespace("future", 
[15:32:29.175]                           quietly = TRUE)
[15:32:29.175]                         if (has_future) {
[15:32:29.175]                           ns <- base::getNamespace("future")
[15:32:29.175]                           version <- ns[[".package"]][["version"]]
[15:32:29.175]                           if (is.null(version)) 
[15:32:29.175]                             version <- utils::packageVersion("future")
[15:32:29.175]                         }
[15:32:29.175]                         else {
[15:32:29.175]                           version <- NULL
[15:32:29.175]                         }
[15:32:29.175]                         if (!has_future || version < "1.8.0") {
[15:32:29.175]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:29.175]                             "", base::R.version$version.string), 
[15:32:29.175]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:29.175]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:29.175]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:29.175]                               "release", "version")], collapse = " "), 
[15:32:29.175]                             hostname = base::Sys.info()[["nodename"]])
[15:32:29.175]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:29.175]                             info)
[15:32:29.175]                           info <- base::paste(info, collapse = "; ")
[15:32:29.175]                           if (!has_future) {
[15:32:29.175]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:29.175]                               info)
[15:32:29.175]                           }
[15:32:29.175]                           else {
[15:32:29.175]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:29.175]                               info, version)
[15:32:29.175]                           }
[15:32:29.175]                           base::stop(msg)
[15:32:29.175]                         }
[15:32:29.175]                       })
[15:32:29.175]                     }
[15:32:29.175]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:29.175]                     base::options(mc.cores = 1L)
[15:32:29.175]                   }
[15:32:29.175]                   ...future.strategy.old <- future::plan("list")
[15:32:29.175]                   options(future.plan = NULL)
[15:32:29.175]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:29.175]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:29.175]                 }
[15:32:29.175]                 ...future.workdir <- getwd()
[15:32:29.175]             }
[15:32:29.175]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:29.175]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:29.175]         }
[15:32:29.175]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:29.175]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:29.175]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:29.175]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:29.175]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:29.175]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:29.175]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:29.175]             base::names(...future.oldOptions))
[15:32:29.175]     }
[15:32:29.175]     if (FALSE) {
[15:32:29.175]     }
[15:32:29.175]     else {
[15:32:29.175]         if (TRUE) {
[15:32:29.175]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:29.175]                 open = "w")
[15:32:29.175]         }
[15:32:29.175]         else {
[15:32:29.175]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:29.175]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:29.175]         }
[15:32:29.175]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:29.175]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:29.175]             base::sink(type = "output", split = FALSE)
[15:32:29.175]             base::close(...future.stdout)
[15:32:29.175]         }, add = TRUE)
[15:32:29.175]     }
[15:32:29.175]     ...future.frame <- base::sys.nframe()
[15:32:29.175]     ...future.conditions <- base::list()
[15:32:29.175]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:29.175]     if (FALSE) {
[15:32:29.175]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:29.175]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:29.175]     }
[15:32:29.175]     ...future.result <- base::tryCatch({
[15:32:29.175]         base::withCallingHandlers({
[15:32:29.175]             ...future.value <- base::withVisible(base::local({
[15:32:29.175]                 ...future.makeSendCondition <- base::local({
[15:32:29.175]                   sendCondition <- NULL
[15:32:29.175]                   function(frame = 1L) {
[15:32:29.175]                     if (is.function(sendCondition)) 
[15:32:29.175]                       return(sendCondition)
[15:32:29.175]                     ns <- getNamespace("parallel")
[15:32:29.175]                     if (exists("sendData", mode = "function", 
[15:32:29.175]                       envir = ns)) {
[15:32:29.175]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:29.175]                         envir = ns)
[15:32:29.175]                       envir <- sys.frame(frame)
[15:32:29.175]                       master <- NULL
[15:32:29.175]                       while (!identical(envir, .GlobalEnv) && 
[15:32:29.175]                         !identical(envir, emptyenv())) {
[15:32:29.175]                         if (exists("master", mode = "list", envir = envir, 
[15:32:29.175]                           inherits = FALSE)) {
[15:32:29.175]                           master <- get("master", mode = "list", 
[15:32:29.175]                             envir = envir, inherits = FALSE)
[15:32:29.175]                           if (inherits(master, c("SOCKnode", 
[15:32:29.175]                             "SOCK0node"))) {
[15:32:29.175]                             sendCondition <<- function(cond) {
[15:32:29.175]                               data <- list(type = "VALUE", value = cond, 
[15:32:29.175]                                 success = TRUE)
[15:32:29.175]                               parallel_sendData(master, data)
[15:32:29.175]                             }
[15:32:29.175]                             return(sendCondition)
[15:32:29.175]                           }
[15:32:29.175]                         }
[15:32:29.175]                         frame <- frame + 1L
[15:32:29.175]                         envir <- sys.frame(frame)
[15:32:29.175]                       }
[15:32:29.175]                     }
[15:32:29.175]                     sendCondition <<- function(cond) NULL
[15:32:29.175]                   }
[15:32:29.175]                 })
[15:32:29.175]                 withCallingHandlers({
[15:32:29.175]                   {
[15:32:29.175]                     do.call(function(...) {
[15:32:29.175]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:29.175]                       if (!identical(...future.globals.maxSize.org, 
[15:32:29.175]                         ...future.globals.maxSize)) {
[15:32:29.175]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:29.175]                         on.exit(options(oopts), add = TRUE)
[15:32:29.175]                       }
[15:32:29.175]                       {
[15:32:29.175]                         lapply(seq_along(...future.elements_ii), 
[15:32:29.175]                           FUN = function(jj) {
[15:32:29.175]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:29.175]                             ...future.FUN(...future.X_jj, ...)
[15:32:29.175]                           })
[15:32:29.175]                       }
[15:32:29.175]                     }, args = future.call.arguments)
[15:32:29.175]                   }
[15:32:29.175]                 }, immediateCondition = function(cond) {
[15:32:29.175]                   sendCondition <- ...future.makeSendCondition()
[15:32:29.175]                   sendCondition(cond)
[15:32:29.175]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:29.175]                   {
[15:32:29.175]                     inherits <- base::inherits
[15:32:29.175]                     invokeRestart <- base::invokeRestart
[15:32:29.175]                     is.null <- base::is.null
[15:32:29.175]                     muffled <- FALSE
[15:32:29.175]                     if (inherits(cond, "message")) {
[15:32:29.175]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:29.175]                       if (muffled) 
[15:32:29.175]                         invokeRestart("muffleMessage")
[15:32:29.175]                     }
[15:32:29.175]                     else if (inherits(cond, "warning")) {
[15:32:29.175]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:29.175]                       if (muffled) 
[15:32:29.175]                         invokeRestart("muffleWarning")
[15:32:29.175]                     }
[15:32:29.175]                     else if (inherits(cond, "condition")) {
[15:32:29.175]                       if (!is.null(pattern)) {
[15:32:29.175]                         computeRestarts <- base::computeRestarts
[15:32:29.175]                         grepl <- base::grepl
[15:32:29.175]                         restarts <- computeRestarts(cond)
[15:32:29.175]                         for (restart in restarts) {
[15:32:29.175]                           name <- restart$name
[15:32:29.175]                           if (is.null(name)) 
[15:32:29.175]                             next
[15:32:29.175]                           if (!grepl(pattern, name)) 
[15:32:29.175]                             next
[15:32:29.175]                           invokeRestart(restart)
[15:32:29.175]                           muffled <- TRUE
[15:32:29.175]                           break
[15:32:29.175]                         }
[15:32:29.175]                       }
[15:32:29.175]                     }
[15:32:29.175]                     invisible(muffled)
[15:32:29.175]                   }
[15:32:29.175]                   muffleCondition(cond)
[15:32:29.175]                 })
[15:32:29.175]             }))
[15:32:29.175]             future::FutureResult(value = ...future.value$value, 
[15:32:29.175]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:29.175]                   ...future.rng), globalenv = if (FALSE) 
[15:32:29.175]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:29.175]                     ...future.globalenv.names))
[15:32:29.175]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:29.175]         }, condition = base::local({
[15:32:29.175]             c <- base::c
[15:32:29.175]             inherits <- base::inherits
[15:32:29.175]             invokeRestart <- base::invokeRestart
[15:32:29.175]             length <- base::length
[15:32:29.175]             list <- base::list
[15:32:29.175]             seq.int <- base::seq.int
[15:32:29.175]             signalCondition <- base::signalCondition
[15:32:29.175]             sys.calls <- base::sys.calls
[15:32:29.175]             `[[` <- base::`[[`
[15:32:29.175]             `+` <- base::`+`
[15:32:29.175]             `<<-` <- base::`<<-`
[15:32:29.175]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:29.175]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:29.175]                   3L)]
[15:32:29.175]             }
[15:32:29.175]             function(cond) {
[15:32:29.175]                 is_error <- inherits(cond, "error")
[15:32:29.175]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:29.175]                   NULL)
[15:32:29.175]                 if (is_error) {
[15:32:29.175]                   sessionInformation <- function() {
[15:32:29.175]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:29.175]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:29.175]                       search = base::search(), system = base::Sys.info())
[15:32:29.175]                   }
[15:32:29.175]                   ...future.conditions[[length(...future.conditions) + 
[15:32:29.175]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:29.175]                     cond$call), session = sessionInformation(), 
[15:32:29.175]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:29.175]                   signalCondition(cond)
[15:32:29.175]                 }
[15:32:29.175]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:29.175]                 "immediateCondition"))) {
[15:32:29.175]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:29.175]                   ...future.conditions[[length(...future.conditions) + 
[15:32:29.175]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:29.175]                   if (TRUE && !signal) {
[15:32:29.175]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:29.175]                     {
[15:32:29.175]                       inherits <- base::inherits
[15:32:29.175]                       invokeRestart <- base::invokeRestart
[15:32:29.175]                       is.null <- base::is.null
[15:32:29.175]                       muffled <- FALSE
[15:32:29.175]                       if (inherits(cond, "message")) {
[15:32:29.175]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:29.175]                         if (muffled) 
[15:32:29.175]                           invokeRestart("muffleMessage")
[15:32:29.175]                       }
[15:32:29.175]                       else if (inherits(cond, "warning")) {
[15:32:29.175]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:29.175]                         if (muffled) 
[15:32:29.175]                           invokeRestart("muffleWarning")
[15:32:29.175]                       }
[15:32:29.175]                       else if (inherits(cond, "condition")) {
[15:32:29.175]                         if (!is.null(pattern)) {
[15:32:29.175]                           computeRestarts <- base::computeRestarts
[15:32:29.175]                           grepl <- base::grepl
[15:32:29.175]                           restarts <- computeRestarts(cond)
[15:32:29.175]                           for (restart in restarts) {
[15:32:29.175]                             name <- restart$name
[15:32:29.175]                             if (is.null(name)) 
[15:32:29.175]                               next
[15:32:29.175]                             if (!grepl(pattern, name)) 
[15:32:29.175]                               next
[15:32:29.175]                             invokeRestart(restart)
[15:32:29.175]                             muffled <- TRUE
[15:32:29.175]                             break
[15:32:29.175]                           }
[15:32:29.175]                         }
[15:32:29.175]                       }
[15:32:29.175]                       invisible(muffled)
[15:32:29.175]                     }
[15:32:29.175]                     muffleCondition(cond, pattern = "^muffle")
[15:32:29.175]                   }
[15:32:29.175]                 }
[15:32:29.175]                 else {
[15:32:29.175]                   if (TRUE) {
[15:32:29.175]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:29.175]                     {
[15:32:29.175]                       inherits <- base::inherits
[15:32:29.175]                       invokeRestart <- base::invokeRestart
[15:32:29.175]                       is.null <- base::is.null
[15:32:29.175]                       muffled <- FALSE
[15:32:29.175]                       if (inherits(cond, "message")) {
[15:32:29.175]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:29.175]                         if (muffled) 
[15:32:29.175]                           invokeRestart("muffleMessage")
[15:32:29.175]                       }
[15:32:29.175]                       else if (inherits(cond, "warning")) {
[15:32:29.175]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:29.175]                         if (muffled) 
[15:32:29.175]                           invokeRestart("muffleWarning")
[15:32:29.175]                       }
[15:32:29.175]                       else if (inherits(cond, "condition")) {
[15:32:29.175]                         if (!is.null(pattern)) {
[15:32:29.175]                           computeRestarts <- base::computeRestarts
[15:32:29.175]                           grepl <- base::grepl
[15:32:29.175]                           restarts <- computeRestarts(cond)
[15:32:29.175]                           for (restart in restarts) {
[15:32:29.175]                             name <- restart$name
[15:32:29.175]                             if (is.null(name)) 
[15:32:29.175]                               next
[15:32:29.175]                             if (!grepl(pattern, name)) 
[15:32:29.175]                               next
[15:32:29.175]                             invokeRestart(restart)
[15:32:29.175]                             muffled <- TRUE
[15:32:29.175]                             break
[15:32:29.175]                           }
[15:32:29.175]                         }
[15:32:29.175]                       }
[15:32:29.175]                       invisible(muffled)
[15:32:29.175]                     }
[15:32:29.175]                     muffleCondition(cond, pattern = "^muffle")
[15:32:29.175]                   }
[15:32:29.175]                 }
[15:32:29.175]             }
[15:32:29.175]         }))
[15:32:29.175]     }, error = function(ex) {
[15:32:29.175]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:29.175]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:29.175]                 ...future.rng), started = ...future.startTime, 
[15:32:29.175]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:29.175]             version = "1.8"), class = "FutureResult")
[15:32:29.175]     }, finally = {
[15:32:29.175]         if (!identical(...future.workdir, getwd())) 
[15:32:29.175]             setwd(...future.workdir)
[15:32:29.175]         {
[15:32:29.175]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:29.175]                 ...future.oldOptions$nwarnings <- NULL
[15:32:29.175]             }
[15:32:29.175]             base::options(...future.oldOptions)
[15:32:29.175]             if (.Platform$OS.type == "windows") {
[15:32:29.175]                 old_names <- names(...future.oldEnvVars)
[15:32:29.175]                 envs <- base::Sys.getenv()
[15:32:29.175]                 names <- names(envs)
[15:32:29.175]                 common <- intersect(names, old_names)
[15:32:29.175]                 added <- setdiff(names, old_names)
[15:32:29.175]                 removed <- setdiff(old_names, names)
[15:32:29.175]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:29.175]                   envs[common]]
[15:32:29.175]                 NAMES <- toupper(changed)
[15:32:29.175]                 args <- list()
[15:32:29.175]                 for (kk in seq_along(NAMES)) {
[15:32:29.175]                   name <- changed[[kk]]
[15:32:29.175]                   NAME <- NAMES[[kk]]
[15:32:29.175]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:29.175]                     next
[15:32:29.175]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:29.175]                 }
[15:32:29.175]                 NAMES <- toupper(added)
[15:32:29.175]                 for (kk in seq_along(NAMES)) {
[15:32:29.175]                   name <- added[[kk]]
[15:32:29.175]                   NAME <- NAMES[[kk]]
[15:32:29.175]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:29.175]                     next
[15:32:29.175]                   args[[name]] <- ""
[15:32:29.175]                 }
[15:32:29.175]                 NAMES <- toupper(removed)
[15:32:29.175]                 for (kk in seq_along(NAMES)) {
[15:32:29.175]                   name <- removed[[kk]]
[15:32:29.175]                   NAME <- NAMES[[kk]]
[15:32:29.175]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:29.175]                     next
[15:32:29.175]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:29.175]                 }
[15:32:29.175]                 if (length(args) > 0) 
[15:32:29.175]                   base::do.call(base::Sys.setenv, args = args)
[15:32:29.175]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:29.175]             }
[15:32:29.175]             else {
[15:32:29.175]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:29.175]             }
[15:32:29.175]             {
[15:32:29.175]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:29.175]                   0L) {
[15:32:29.175]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:29.175]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:29.175]                   base::options(opts)
[15:32:29.175]                 }
[15:32:29.175]                 {
[15:32:29.175]                   {
[15:32:29.175]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:29.175]                     NULL
[15:32:29.175]                   }
[15:32:29.175]                   options(future.plan = NULL)
[15:32:29.175]                   if (is.na(NA_character_)) 
[15:32:29.175]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:29.175]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:29.175]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:29.175]                     .init = FALSE)
[15:32:29.175]                 }
[15:32:29.175]             }
[15:32:29.175]         }
[15:32:29.175]     })
[15:32:29.175]     if (TRUE) {
[15:32:29.175]         base::sink(type = "output", split = FALSE)
[15:32:29.175]         if (TRUE) {
[15:32:29.175]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:29.175]         }
[15:32:29.175]         else {
[15:32:29.175]             ...future.result["stdout"] <- base::list(NULL)
[15:32:29.175]         }
[15:32:29.175]         base::close(...future.stdout)
[15:32:29.175]         ...future.stdout <- NULL
[15:32:29.175]     }
[15:32:29.175]     ...future.result$conditions <- ...future.conditions
[15:32:29.175]     ...future.result$finished <- base::Sys.time()
[15:32:29.175]     ...future.result
[15:32:29.175] }
[15:32:29.184] Exporting 5 global objects (1.22 KiB) to cluster node #1 ...
[15:32:29.185] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ...
[15:32:29.186] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ... DONE
[15:32:29.186] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:29.187] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:29.187] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ...
[15:32:29.188] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ... DONE
[15:32:29.189] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:29.189] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:29.190] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:29.190] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:29.191] Exporting 5 global objects (1.22 KiB) to cluster node #1 ... DONE
[15:32:29.192] MultisessionFuture started
[15:32:29.192] - Launch lazy future ... done
[15:32:29.192] run() for 'MultisessionFuture' ... done
[15:32:29.193] Created future:
[15:32:29.219] receiveMessageFromWorker() for ClusterFuture ...
[15:32:29.219] - Validating connection of MultisessionFuture
[15:32:29.220] - received message: FutureResult
[15:32:29.220] - Received FutureResult
[15:32:29.220] - Erased future from FutureRegistry
[15:32:29.221] result() for ClusterFuture ...
[15:32:29.221] - result already collected: FutureResult
[15:32:29.221] result() for ClusterFuture ... done
[15:32:29.222] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:29.193] MultisessionFuture:
[15:32:29.193] Label: 'future_sapply-1'
[15:32:29.193] Expression:
[15:32:29.193] {
[15:32:29.193]     do.call(function(...) {
[15:32:29.193]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:29.193]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:29.193]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:29.193]             on.exit(options(oopts), add = TRUE)
[15:32:29.193]         }
[15:32:29.193]         {
[15:32:29.193]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:29.193]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:29.193]                 ...future.FUN(...future.X_jj, ...)
[15:32:29.193]             })
[15:32:29.193]         }
[15:32:29.193]     }, args = future.call.arguments)
[15:32:29.193] }
[15:32:29.193] Lazy evaluation: FALSE
[15:32:29.193] Asynchronous evaluation: TRUE
[15:32:29.193] Local evaluation: TRUE
[15:32:29.193] Environment: R_GlobalEnv
[15:32:29.193] Capture standard output: TRUE
[15:32:29.193] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:29.193] Globals: 5 objects totaling 1.27 KiB (function '...future.FUN' of 1.22 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)
[15:32:29.193] Packages: <none>
[15:32:29.193] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:29.193] Resolved: TRUE
[15:32:29.193] Value: <not collected>
[15:32:29.193] Conditions captured: <none>
[15:32:29.193] Early signaling: FALSE
[15:32:29.193] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:29.193] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:29.222] Chunk #1 of 2 ... DONE
[15:32:29.223] Chunk #2 of 2 ...
[15:32:29.223]  - Finding globals in 'X' for chunk #2 ...
[15:32:29.223] getGlobalsAndPackages() ...
[15:32:29.223] Searching for globals...
[15:32:29.224] 
[15:32:29.224] Searching for globals ... DONE
[15:32:29.225] - globals: [0] <none>
[15:32:29.225] getGlobalsAndPackages() ... DONE
[15:32:29.225]    + additional globals found: [n=0] 
[15:32:29.225]    + additional namespaces needed: [n=0] 
[15:32:29.226]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:29.226]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:29.226]  - seeds: <none>
[15:32:29.227]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:29.227] getGlobalsAndPackages() ...
[15:32:29.227] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:29.227] Resolving globals: FALSE
[15:32:29.228] Tweak future expression to call with '...' arguments ...
[15:32:29.228] {
[15:32:29.228]     do.call(function(...) {
[15:32:29.228]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:29.228]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:29.228]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:29.228]             on.exit(options(oopts), add = TRUE)
[15:32:29.228]         }
[15:32:29.228]         {
[15:32:29.228]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:29.228]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:29.228]                 ...future.FUN(...future.X_jj, ...)
[15:32:29.228]             })
[15:32:29.228]         }
[15:32:29.228]     }, args = future.call.arguments)
[15:32:29.228] }
[15:32:29.229] Tweak future expression to call with '...' arguments ... DONE
[15:32:29.230] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:29.230] 
[15:32:29.230] getGlobalsAndPackages() ... DONE
[15:32:29.231] run() for 'Future' ...
[15:32:29.231] - state: 'created'
[15:32:29.232] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:29.249] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:29.249] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:29.250]   - Field: 'node'
[15:32:29.250]   - Field: 'label'
[15:32:29.250]   - Field: 'local'
[15:32:29.250]   - Field: 'owner'
[15:32:29.251]   - Field: 'envir'
[15:32:29.251]   - Field: 'workers'
[15:32:29.251]   - Field: 'packages'
[15:32:29.252]   - Field: 'gc'
[15:32:29.252]   - Field: 'conditions'
[15:32:29.252]   - Field: 'persistent'
[15:32:29.252]   - Field: 'expr'
[15:32:29.253]   - Field: 'uuid'
[15:32:29.253]   - Field: 'seed'
[15:32:29.253]   - Field: 'version'
[15:32:29.253]   - Field: 'result'
[15:32:29.254]   - Field: 'asynchronous'
[15:32:29.254]   - Field: 'calls'
[15:32:29.254]   - Field: 'globals'
[15:32:29.255]   - Field: 'stdout'
[15:32:29.255]   - Field: 'earlySignal'
[15:32:29.255]   - Field: 'lazy'
[15:32:29.255]   - Field: 'state'
[15:32:29.256] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:29.256] - Launch lazy future ...
[15:32:29.257] Packages needed by the future expression (n = 0): <none>
[15:32:29.257] Packages needed by future strategies (n = 0): <none>
[15:32:29.258] {
[15:32:29.258]     {
[15:32:29.258]         {
[15:32:29.258]             ...future.startTime <- base::Sys.time()
[15:32:29.258]             {
[15:32:29.258]                 {
[15:32:29.258]                   {
[15:32:29.258]                     {
[15:32:29.258]                       base::local({
[15:32:29.258]                         has_future <- base::requireNamespace("future", 
[15:32:29.258]                           quietly = TRUE)
[15:32:29.258]                         if (has_future) {
[15:32:29.258]                           ns <- base::getNamespace("future")
[15:32:29.258]                           version <- ns[[".package"]][["version"]]
[15:32:29.258]                           if (is.null(version)) 
[15:32:29.258]                             version <- utils::packageVersion("future")
[15:32:29.258]                         }
[15:32:29.258]                         else {
[15:32:29.258]                           version <- NULL
[15:32:29.258]                         }
[15:32:29.258]                         if (!has_future || version < "1.8.0") {
[15:32:29.258]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:29.258]                             "", base::R.version$version.string), 
[15:32:29.258]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:29.258]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:29.258]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:29.258]                               "release", "version")], collapse = " "), 
[15:32:29.258]                             hostname = base::Sys.info()[["nodename"]])
[15:32:29.258]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:29.258]                             info)
[15:32:29.258]                           info <- base::paste(info, collapse = "; ")
[15:32:29.258]                           if (!has_future) {
[15:32:29.258]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:29.258]                               info)
[15:32:29.258]                           }
[15:32:29.258]                           else {
[15:32:29.258]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:29.258]                               info, version)
[15:32:29.258]                           }
[15:32:29.258]                           base::stop(msg)
[15:32:29.258]                         }
[15:32:29.258]                       })
[15:32:29.258]                     }
[15:32:29.258]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:29.258]                     base::options(mc.cores = 1L)
[15:32:29.258]                   }
[15:32:29.258]                   ...future.strategy.old <- future::plan("list")
[15:32:29.258]                   options(future.plan = NULL)
[15:32:29.258]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:29.258]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:29.258]                 }
[15:32:29.258]                 ...future.workdir <- getwd()
[15:32:29.258]             }
[15:32:29.258]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:29.258]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:29.258]         }
[15:32:29.258]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:29.258]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:29.258]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:29.258]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:29.258]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:29.258]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:29.258]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:29.258]             base::names(...future.oldOptions))
[15:32:29.258]     }
[15:32:29.258]     if (FALSE) {
[15:32:29.258]     }
[15:32:29.258]     else {
[15:32:29.258]         if (TRUE) {
[15:32:29.258]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:29.258]                 open = "w")
[15:32:29.258]         }
[15:32:29.258]         else {
[15:32:29.258]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:29.258]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:29.258]         }
[15:32:29.258]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:29.258]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:29.258]             base::sink(type = "output", split = FALSE)
[15:32:29.258]             base::close(...future.stdout)
[15:32:29.258]         }, add = TRUE)
[15:32:29.258]     }
[15:32:29.258]     ...future.frame <- base::sys.nframe()
[15:32:29.258]     ...future.conditions <- base::list()
[15:32:29.258]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:29.258]     if (FALSE) {
[15:32:29.258]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:29.258]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:29.258]     }
[15:32:29.258]     ...future.result <- base::tryCatch({
[15:32:29.258]         base::withCallingHandlers({
[15:32:29.258]             ...future.value <- base::withVisible(base::local({
[15:32:29.258]                 ...future.makeSendCondition <- base::local({
[15:32:29.258]                   sendCondition <- NULL
[15:32:29.258]                   function(frame = 1L) {
[15:32:29.258]                     if (is.function(sendCondition)) 
[15:32:29.258]                       return(sendCondition)
[15:32:29.258]                     ns <- getNamespace("parallel")
[15:32:29.258]                     if (exists("sendData", mode = "function", 
[15:32:29.258]                       envir = ns)) {
[15:32:29.258]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:29.258]                         envir = ns)
[15:32:29.258]                       envir <- sys.frame(frame)
[15:32:29.258]                       master <- NULL
[15:32:29.258]                       while (!identical(envir, .GlobalEnv) && 
[15:32:29.258]                         !identical(envir, emptyenv())) {
[15:32:29.258]                         if (exists("master", mode = "list", envir = envir, 
[15:32:29.258]                           inherits = FALSE)) {
[15:32:29.258]                           master <- get("master", mode = "list", 
[15:32:29.258]                             envir = envir, inherits = FALSE)
[15:32:29.258]                           if (inherits(master, c("SOCKnode", 
[15:32:29.258]                             "SOCK0node"))) {
[15:32:29.258]                             sendCondition <<- function(cond) {
[15:32:29.258]                               data <- list(type = "VALUE", value = cond, 
[15:32:29.258]                                 success = TRUE)
[15:32:29.258]                               parallel_sendData(master, data)
[15:32:29.258]                             }
[15:32:29.258]                             return(sendCondition)
[15:32:29.258]                           }
[15:32:29.258]                         }
[15:32:29.258]                         frame <- frame + 1L
[15:32:29.258]                         envir <- sys.frame(frame)
[15:32:29.258]                       }
[15:32:29.258]                     }
[15:32:29.258]                     sendCondition <<- function(cond) NULL
[15:32:29.258]                   }
[15:32:29.258]                 })
[15:32:29.258]                 withCallingHandlers({
[15:32:29.258]                   {
[15:32:29.258]                     do.call(function(...) {
[15:32:29.258]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:29.258]                       if (!identical(...future.globals.maxSize.org, 
[15:32:29.258]                         ...future.globals.maxSize)) {
[15:32:29.258]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:29.258]                         on.exit(options(oopts), add = TRUE)
[15:32:29.258]                       }
[15:32:29.258]                       {
[15:32:29.258]                         lapply(seq_along(...future.elements_ii), 
[15:32:29.258]                           FUN = function(jj) {
[15:32:29.258]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:29.258]                             ...future.FUN(...future.X_jj, ...)
[15:32:29.258]                           })
[15:32:29.258]                       }
[15:32:29.258]                     }, args = future.call.arguments)
[15:32:29.258]                   }
[15:32:29.258]                 }, immediateCondition = function(cond) {
[15:32:29.258]                   sendCondition <- ...future.makeSendCondition()
[15:32:29.258]                   sendCondition(cond)
[15:32:29.258]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:29.258]                   {
[15:32:29.258]                     inherits <- base::inherits
[15:32:29.258]                     invokeRestart <- base::invokeRestart
[15:32:29.258]                     is.null <- base::is.null
[15:32:29.258]                     muffled <- FALSE
[15:32:29.258]                     if (inherits(cond, "message")) {
[15:32:29.258]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:29.258]                       if (muffled) 
[15:32:29.258]                         invokeRestart("muffleMessage")
[15:32:29.258]                     }
[15:32:29.258]                     else if (inherits(cond, "warning")) {
[15:32:29.258]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:29.258]                       if (muffled) 
[15:32:29.258]                         invokeRestart("muffleWarning")
[15:32:29.258]                     }
[15:32:29.258]                     else if (inherits(cond, "condition")) {
[15:32:29.258]                       if (!is.null(pattern)) {
[15:32:29.258]                         computeRestarts <- base::computeRestarts
[15:32:29.258]                         grepl <- base::grepl
[15:32:29.258]                         restarts <- computeRestarts(cond)
[15:32:29.258]                         for (restart in restarts) {
[15:32:29.258]                           name <- restart$name
[15:32:29.258]                           if (is.null(name)) 
[15:32:29.258]                             next
[15:32:29.258]                           if (!grepl(pattern, name)) 
[15:32:29.258]                             next
[15:32:29.258]                           invokeRestart(restart)
[15:32:29.258]                           muffled <- TRUE
[15:32:29.258]                           break
[15:32:29.258]                         }
[15:32:29.258]                       }
[15:32:29.258]                     }
[15:32:29.258]                     invisible(muffled)
[15:32:29.258]                   }
[15:32:29.258]                   muffleCondition(cond)
[15:32:29.258]                 })
[15:32:29.258]             }))
[15:32:29.258]             future::FutureResult(value = ...future.value$value, 
[15:32:29.258]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:29.258]                   ...future.rng), globalenv = if (FALSE) 
[15:32:29.258]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:29.258]                     ...future.globalenv.names))
[15:32:29.258]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:29.258]         }, condition = base::local({
[15:32:29.258]             c <- base::c
[15:32:29.258]             inherits <- base::inherits
[15:32:29.258]             invokeRestart <- base::invokeRestart
[15:32:29.258]             length <- base::length
[15:32:29.258]             list <- base::list
[15:32:29.258]             seq.int <- base::seq.int
[15:32:29.258]             signalCondition <- base::signalCondition
[15:32:29.258]             sys.calls <- base::sys.calls
[15:32:29.258]             `[[` <- base::`[[`
[15:32:29.258]             `+` <- base::`+`
[15:32:29.258]             `<<-` <- base::`<<-`
[15:32:29.258]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:29.258]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:29.258]                   3L)]
[15:32:29.258]             }
[15:32:29.258]             function(cond) {
[15:32:29.258]                 is_error <- inherits(cond, "error")
[15:32:29.258]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:29.258]                   NULL)
[15:32:29.258]                 if (is_error) {
[15:32:29.258]                   sessionInformation <- function() {
[15:32:29.258]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:29.258]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:29.258]                       search = base::search(), system = base::Sys.info())
[15:32:29.258]                   }
[15:32:29.258]                   ...future.conditions[[length(...future.conditions) + 
[15:32:29.258]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:29.258]                     cond$call), session = sessionInformation(), 
[15:32:29.258]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:29.258]                   signalCondition(cond)
[15:32:29.258]                 }
[15:32:29.258]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:29.258]                 "immediateCondition"))) {
[15:32:29.258]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:29.258]                   ...future.conditions[[length(...future.conditions) + 
[15:32:29.258]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:29.258]                   if (TRUE && !signal) {
[15:32:29.258]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:29.258]                     {
[15:32:29.258]                       inherits <- base::inherits
[15:32:29.258]                       invokeRestart <- base::invokeRestart
[15:32:29.258]                       is.null <- base::is.null
[15:32:29.258]                       muffled <- FALSE
[15:32:29.258]                       if (inherits(cond, "message")) {
[15:32:29.258]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:29.258]                         if (muffled) 
[15:32:29.258]                           invokeRestart("muffleMessage")
[15:32:29.258]                       }
[15:32:29.258]                       else if (inherits(cond, "warning")) {
[15:32:29.258]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:29.258]                         if (muffled) 
[15:32:29.258]                           invokeRestart("muffleWarning")
[15:32:29.258]                       }
[15:32:29.258]                       else if (inherits(cond, "condition")) {
[15:32:29.258]                         if (!is.null(pattern)) {
[15:32:29.258]                           computeRestarts <- base::computeRestarts
[15:32:29.258]                           grepl <- base::grepl
[15:32:29.258]                           restarts <- computeRestarts(cond)
[15:32:29.258]                           for (restart in restarts) {
[15:32:29.258]                             name <- restart$name
[15:32:29.258]                             if (is.null(name)) 
[15:32:29.258]                               next
[15:32:29.258]                             if (!grepl(pattern, name)) 
[15:32:29.258]                               next
[15:32:29.258]                             invokeRestart(restart)
[15:32:29.258]                             muffled <- TRUE
[15:32:29.258]                             break
[15:32:29.258]                           }
[15:32:29.258]                         }
[15:32:29.258]                       }
[15:32:29.258]                       invisible(muffled)
[15:32:29.258]                     }
[15:32:29.258]                     muffleCondition(cond, pattern = "^muffle")
[15:32:29.258]                   }
[15:32:29.258]                 }
[15:32:29.258]                 else {
[15:32:29.258]                   if (TRUE) {
[15:32:29.258]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:29.258]                     {
[15:32:29.258]                       inherits <- base::inherits
[15:32:29.258]                       invokeRestart <- base::invokeRestart
[15:32:29.258]                       is.null <- base::is.null
[15:32:29.258]                       muffled <- FALSE
[15:32:29.258]                       if (inherits(cond, "message")) {
[15:32:29.258]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:29.258]                         if (muffled) 
[15:32:29.258]                           invokeRestart("muffleMessage")
[15:32:29.258]                       }
[15:32:29.258]                       else if (inherits(cond, "warning")) {
[15:32:29.258]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:29.258]                         if (muffled) 
[15:32:29.258]                           invokeRestart("muffleWarning")
[15:32:29.258]                       }
[15:32:29.258]                       else if (inherits(cond, "condition")) {
[15:32:29.258]                         if (!is.null(pattern)) {
[15:32:29.258]                           computeRestarts <- base::computeRestarts
[15:32:29.258]                           grepl <- base::grepl
[15:32:29.258]                           restarts <- computeRestarts(cond)
[15:32:29.258]                           for (restart in restarts) {
[15:32:29.258]                             name <- restart$name
[15:32:29.258]                             if (is.null(name)) 
[15:32:29.258]                               next
[15:32:29.258]                             if (!grepl(pattern, name)) 
[15:32:29.258]                               next
[15:32:29.258]                             invokeRestart(restart)
[15:32:29.258]                             muffled <- TRUE
[15:32:29.258]                             break
[15:32:29.258]                           }
[15:32:29.258]                         }
[15:32:29.258]                       }
[15:32:29.258]                       invisible(muffled)
[15:32:29.258]                     }
[15:32:29.258]                     muffleCondition(cond, pattern = "^muffle")
[15:32:29.258]                   }
[15:32:29.258]                 }
[15:32:29.258]             }
[15:32:29.258]         }))
[15:32:29.258]     }, error = function(ex) {
[15:32:29.258]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:29.258]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:29.258]                 ...future.rng), started = ...future.startTime, 
[15:32:29.258]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:29.258]             version = "1.8"), class = "FutureResult")
[15:32:29.258]     }, finally = {
[15:32:29.258]         if (!identical(...future.workdir, getwd())) 
[15:32:29.258]             setwd(...future.workdir)
[15:32:29.258]         {
[15:32:29.258]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:29.258]                 ...future.oldOptions$nwarnings <- NULL
[15:32:29.258]             }
[15:32:29.258]             base::options(...future.oldOptions)
[15:32:29.258]             if (.Platform$OS.type == "windows") {
[15:32:29.258]                 old_names <- names(...future.oldEnvVars)
[15:32:29.258]                 envs <- base::Sys.getenv()
[15:32:29.258]                 names <- names(envs)
[15:32:29.258]                 common <- intersect(names, old_names)
[15:32:29.258]                 added <- setdiff(names, old_names)
[15:32:29.258]                 removed <- setdiff(old_names, names)
[15:32:29.258]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:29.258]                   envs[common]]
[15:32:29.258]                 NAMES <- toupper(changed)
[15:32:29.258]                 args <- list()
[15:32:29.258]                 for (kk in seq_along(NAMES)) {
[15:32:29.258]                   name <- changed[[kk]]
[15:32:29.258]                   NAME <- NAMES[[kk]]
[15:32:29.258]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:29.258]                     next
[15:32:29.258]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:29.258]                 }
[15:32:29.258]                 NAMES <- toupper(added)
[15:32:29.258]                 for (kk in seq_along(NAMES)) {
[15:32:29.258]                   name <- added[[kk]]
[15:32:29.258]                   NAME <- NAMES[[kk]]
[15:32:29.258]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:29.258]                     next
[15:32:29.258]                   args[[name]] <- ""
[15:32:29.258]                 }
[15:32:29.258]                 NAMES <- toupper(removed)
[15:32:29.258]                 for (kk in seq_along(NAMES)) {
[15:32:29.258]                   name <- removed[[kk]]
[15:32:29.258]                   NAME <- NAMES[[kk]]
[15:32:29.258]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:29.258]                     next
[15:32:29.258]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:29.258]                 }
[15:32:29.258]                 if (length(args) > 0) 
[15:32:29.258]                   base::do.call(base::Sys.setenv, args = args)
[15:32:29.258]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:29.258]             }
[15:32:29.258]             else {
[15:32:29.258]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:29.258]             }
[15:32:29.258]             {
[15:32:29.258]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:29.258]                   0L) {
[15:32:29.258]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:29.258]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:29.258]                   base::options(opts)
[15:32:29.258]                 }
[15:32:29.258]                 {
[15:32:29.258]                   {
[15:32:29.258]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:29.258]                     NULL
[15:32:29.258]                   }
[15:32:29.258]                   options(future.plan = NULL)
[15:32:29.258]                   if (is.na(NA_character_)) 
[15:32:29.258]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:29.258]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:29.258]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:29.258]                     .init = FALSE)
[15:32:29.258]                 }
[15:32:29.258]             }
[15:32:29.258]         }
[15:32:29.258]     })
[15:32:29.258]     if (TRUE) {
[15:32:29.258]         base::sink(type = "output", split = FALSE)
[15:32:29.258]         if (TRUE) {
[15:32:29.258]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:29.258]         }
[15:32:29.258]         else {
[15:32:29.258]             ...future.result["stdout"] <- base::list(NULL)
[15:32:29.258]         }
[15:32:29.258]         base::close(...future.stdout)
[15:32:29.258]         ...future.stdout <- NULL
[15:32:29.258]     }
[15:32:29.258]     ...future.result$conditions <- ...future.conditions
[15:32:29.258]     ...future.result$finished <- base::Sys.time()
[15:32:29.258]     ...future.result
[15:32:29.258] }
[15:32:29.267] Exporting 5 global objects (1.22 KiB) to cluster node #1 ...
[15:32:29.268] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ...
[15:32:29.268] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ... DONE
[15:32:29.269] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:29.270] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:29.270] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:29.271] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:29.272] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:29.273] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:29.273] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:29.274] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:29.274] Exporting 5 global objects (1.22 KiB) to cluster node #1 ... DONE
[15:32:29.276] MultisessionFuture started
[15:32:29.276] - Launch lazy future ... done
[15:32:29.276] run() for 'MultisessionFuture' ... done
[15:32:29.277] Created future:
[15:32:29.308] receiveMessageFromWorker() for ClusterFuture ...
[15:32:29.309] - Validating connection of MultisessionFuture
[15:32:29.309] - received message: FutureResult
[15:32:29.310] - Received FutureResult
[15:32:29.310] - Erased future from FutureRegistry
[15:32:29.310] result() for ClusterFuture ...
[15:32:29.311] - result already collected: FutureResult
[15:32:29.311] result() for ClusterFuture ... done
[15:32:29.311] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:29.277] MultisessionFuture:
[15:32:29.277] Label: 'future_sapply-2'
[15:32:29.277] Expression:
[15:32:29.277] {
[15:32:29.277]     do.call(function(...) {
[15:32:29.277]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:29.277]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:29.277]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:29.277]             on.exit(options(oopts), add = TRUE)
[15:32:29.277]         }
[15:32:29.277]         {
[15:32:29.277]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:29.277]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:29.277]                 ...future.FUN(...future.X_jj, ...)
[15:32:29.277]             })
[15:32:29.277]         }
[15:32:29.277]     }, args = future.call.arguments)
[15:32:29.277] }
[15:32:29.277] Lazy evaluation: FALSE
[15:32:29.277] Asynchronous evaluation: TRUE
[15:32:29.277] Local evaluation: TRUE
[15:32:29.277] Environment: R_GlobalEnv
[15:32:29.277] Capture standard output: TRUE
[15:32:29.277] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:29.277] Globals: 5 objects totaling 1.33 KiB (function '...future.FUN' of 1.22 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)
[15:32:29.277] Packages: <none>
[15:32:29.277] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:29.277] Resolved: TRUE
[15:32:29.277] Value: <not collected>
[15:32:29.277] Conditions captured: <none>
[15:32:29.277] Early signaling: FALSE
[15:32:29.277] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:29.277] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:29.312] Chunk #2 of 2 ... DONE
[15:32:29.312] Launching 2 futures (chunks) ... DONE
[15:32:29.313] Resolving 2 futures (chunks) ...
[15:32:29.313] resolve() on list ...
[15:32:29.313]  recursive: 0
[15:32:29.314]  length: 2
[15:32:29.314] 
[15:32:29.314] Future #1
[15:32:29.315] result() for ClusterFuture ...
[15:32:29.315] - result already collected: FutureResult
[15:32:29.315] result() for ClusterFuture ... done
[15:32:29.315] result() for ClusterFuture ...
[15:32:29.316] - result already collected: FutureResult
[15:32:29.316] result() for ClusterFuture ... done
[15:32:29.316] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:29.317] - nx: 2
[15:32:29.317] - relay: TRUE
[15:32:29.317] - stdout: TRUE
[15:32:29.317] - signal: TRUE
[15:32:29.318] - resignal: FALSE
[15:32:29.318] - force: TRUE
[15:32:29.318] - relayed: [n=2] FALSE, FALSE
[15:32:29.318] - queued futures: [n=2] FALSE, FALSE
[15:32:29.319]  - until=1
[15:32:29.319]  - relaying element #1
[15:32:29.319] result() for ClusterFuture ...
[15:32:29.320] - result already collected: FutureResult
[15:32:29.320] result() for ClusterFuture ... done
[15:32:29.320] result() for ClusterFuture ...
[15:32:29.320] - result already collected: FutureResult
[15:32:29.321] result() for ClusterFuture ... done
[15:32:29.321] result() for ClusterFuture ...
[15:32:29.321] - result already collected: FutureResult
[15:32:29.322] result() for ClusterFuture ... done
[15:32:29.322] result() for ClusterFuture ...
[15:32:29.322] - result already collected: FutureResult
[15:32:29.323] result() for ClusterFuture ... done
[15:32:29.323] - relayed: [n=2] TRUE, FALSE
[15:32:29.323] - queued futures: [n=2] TRUE, FALSE
[15:32:29.323] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:29.324]  length: 1 (resolved future 1)
[15:32:29.324] Future #2
[15:32:29.324] result() for ClusterFuture ...
[15:32:29.325] - result already collected: FutureResult
[15:32:29.325] result() for ClusterFuture ... done
[15:32:29.325] result() for ClusterFuture ...
[15:32:29.325] - result already collected: FutureResult
[15:32:29.326] result() for ClusterFuture ... done
[15:32:29.326] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:29.326] - nx: 2
[15:32:29.326] - relay: TRUE
[15:32:29.327] - stdout: TRUE
[15:32:29.327] - signal: TRUE
[15:32:29.327] - resignal: FALSE
[15:32:29.328] - force: TRUE
[15:32:29.328] - relayed: [n=2] TRUE, FALSE
[15:32:29.328] - queued futures: [n=2] TRUE, FALSE
[15:32:29.328]  - until=2
[15:32:29.329]  - relaying element #2
[15:32:29.329] result() for ClusterFuture ...
[15:32:29.329] - result already collected: FutureResult
[15:32:29.329] result() for ClusterFuture ... done
[15:32:29.330] result() for ClusterFuture ...
[15:32:29.330] - result already collected: FutureResult
[15:32:29.330] result() for ClusterFuture ... done
[15:32:29.330] result() for ClusterFuture ...
[15:32:29.331] - result already collected: FutureResult
[15:32:29.331] result() for ClusterFuture ... done
[15:32:29.331] result() for ClusterFuture ...
[15:32:29.331] - result already collected: FutureResult
[15:32:29.332] result() for ClusterFuture ... done
[15:32:29.332] - relayed: [n=2] TRUE, TRUE
[15:32:29.332] - queued futures: [n=2] TRUE, TRUE
[15:32:29.333] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:29.333]  length: 0 (resolved future 2)
[15:32:29.333] Relaying remaining futures
[15:32:29.333] signalConditionsASAP(NULL, pos=0) ...
[15:32:29.334] - nx: 2
[15:32:29.334] - relay: TRUE
[15:32:29.334] - stdout: TRUE
[15:32:29.335] - signal: TRUE
[15:32:29.335] - resignal: FALSE
[15:32:29.335] - force: TRUE
[15:32:29.335] - relayed: [n=2] TRUE, TRUE
[15:32:29.336] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:29.336] - relayed: [n=2] TRUE, TRUE
[15:32:29.336] - queued futures: [n=2] TRUE, TRUE
[15:32:29.337] signalConditionsASAP(NULL, pos=0) ... done
[15:32:29.337] resolve() on list ... DONE
[15:32:29.337] result() for ClusterFuture ...
[15:32:29.337] - result already collected: FutureResult
[15:32:29.338] result() for ClusterFuture ... done
[15:32:29.338] result() for ClusterFuture ...
[15:32:29.338] - result already collected: FutureResult
[15:32:29.339] result() for ClusterFuture ... done
[15:32:29.339] result() for ClusterFuture ...
[15:32:29.339] - result already collected: FutureResult
[15:32:29.339] result() for ClusterFuture ... done
[15:32:29.340] result() for ClusterFuture ...
[15:32:29.340] - result already collected: FutureResult
[15:32:29.340] result() for ClusterFuture ... done
[15:32:29.341]  - Number of value chunks collected: 2
[15:32:29.341] Resolving 2 futures (chunks) ... DONE
[15:32:29.341] Reducing values from 2 chunks ...
[15:32:29.341]  - Number of values collected after concatenation: 3
[15:32:29.342]  - Number of values expected: 3
[15:32:29.342] Reducing values from 2 chunks ... DONE
[15:32:29.342] future_lapply() ... DONE
List of 2
 $ y0:List of 3
  ..$ a: num [1, 1] 1
  ..$ b: num [1, 1] 2
  ..$ c: num [1, 1] 3
 $ y1:List of 3
  ..$ a: num [1, 1] 1
  ..$ b: num [1, 1] 2
  ..$ c: num [1, 1] 3
List of 2
 $ y0:List of 3
  ..$ a: num [1, 1] 1
  ..$ b: num [1, 1] 2
  ..$ c: num [1, 1] 3
 $ y2:List of 3
  ..$ a: num [1, 1] 1
  ..$ b: num [1, 1] 2
  ..$ c: num [1, 1] 3
[15:32:29.354] future_lapply() ...
[15:32:29.360] Number of chunks: 2
[15:32:29.360] getGlobalsAndPackagesXApply() ...
[15:32:29.361]  - future.globals: TRUE
[15:32:29.361] getGlobalsAndPackages() ...
[15:32:29.361] Searching for globals...
[15:32:29.364] - globals found: [5] 'FUN', '*', ':', 'outer', 'rep'
[15:32:29.365] Searching for globals ... DONE
[15:32:29.365] Resolving globals: FALSE
[15:32:29.366] The total size of the 1 globals is 4.62 KiB (4728 bytes)
[15:32:29.367] The total size of the 1 globals exported for future expression ('FUN()') is 4.62 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.62 KiB of class 'function')
[15:32:29.367] - globals: [1] 'FUN'
[15:32:29.367] 
[15:32:29.368] getGlobalsAndPackages() ... DONE
[15:32:29.368]  - globals found/used: [n=1] 'FUN'
[15:32:29.368]  - needed namespaces: [n=0] 
[15:32:29.368] Finding globals ... DONE
[15:32:29.369]  - use_args: TRUE
[15:32:29.369]  - Getting '...' globals ...
[15:32:29.370] resolve() on list ...
[15:32:29.370]  recursive: 0
[15:32:29.370]  length: 1
[15:32:29.371]  elements: '...'
[15:32:29.371]  length: 0 (resolved future 1)
[15:32:29.371] resolve() on list ... DONE
[15:32:29.372]    - '...' content: [n=0] 
[15:32:29.372] List of 1
[15:32:29.372]  $ ...: list()
[15:32:29.372]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:29.372]  - attr(*, "where")=List of 1
[15:32:29.372]   ..$ ...:<environment: 0x00000276e54889b0> 
[15:32:29.372]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:29.372]  - attr(*, "resolved")= logi TRUE
[15:32:29.372]  - attr(*, "total_size")= num NA
[15:32:29.377]  - Getting '...' globals ... DONE
[15:32:29.377] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:29.378] List of 2
[15:32:29.378]  $ ...future.FUN:function (x, y = 2 * 1:5)  
[15:32:29.378]  $ ...          : list()
[15:32:29.378]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:29.378]  - attr(*, "where")=List of 2
[15:32:29.378]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:29.378]   ..$ ...          :<environment: 0x00000276e54889b0> 
[15:32:29.378]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:29.378]  - attr(*, "resolved")= logi FALSE
[15:32:29.378]  - attr(*, "total_size")= num 4728
[15:32:29.383] Packages to be attached in all futures: [n=0] 
[15:32:29.384] getGlobalsAndPackagesXApply() ... DONE
[15:32:29.384] Number of futures (= number of chunks): 2
[15:32:29.384] Launching 2 futures (chunks) ...
[15:32:29.385] Chunk #1 of 2 ...
[15:32:29.385]  - Finding globals in 'X' for chunk #1 ...
[15:32:29.385] getGlobalsAndPackages() ...
[15:32:29.386] Searching for globals...
[15:32:29.386] 
[15:32:29.387] Searching for globals ... DONE
[15:32:29.387] - globals: [0] <none>
[15:32:29.387] getGlobalsAndPackages() ... DONE
[15:32:29.387]    + additional globals found: [n=0] 
[15:32:29.388]    + additional namespaces needed: [n=0] 
[15:32:29.388]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:29.388]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:29.389]  - seeds: <none>
[15:32:29.389]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:29.389] getGlobalsAndPackages() ...
[15:32:29.389] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:29.390] Resolving globals: FALSE
[15:32:29.390] Tweak future expression to call with '...' arguments ...
[15:32:29.390] {
[15:32:29.390]     do.call(function(...) {
[15:32:29.390]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:29.390]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:29.390]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:29.390]             on.exit(options(oopts), add = TRUE)
[15:32:29.390]         }
[15:32:29.390]         {
[15:32:29.390]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:29.390]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:29.390]                 ...future.FUN(...future.X_jj, ...)
[15:32:29.390]             })
[15:32:29.390]         }
[15:32:29.390]     }, args = future.call.arguments)
[15:32:29.390] }
[15:32:29.391] Tweak future expression to call with '...' arguments ... DONE
[15:32:29.392] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:29.392] 
[15:32:29.392] getGlobalsAndPackages() ... DONE
[15:32:29.393] run() for 'Future' ...
[15:32:29.393] - state: 'created'
[15:32:29.394] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:29.411] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:29.411] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:29.411]   - Field: 'node'
[15:32:29.412]   - Field: 'label'
[15:32:29.412]   - Field: 'local'
[15:32:29.412]   - Field: 'owner'
[15:32:29.412]   - Field: 'envir'
[15:32:29.413]   - Field: 'workers'
[15:32:29.413]   - Field: 'packages'
[15:32:29.413]   - Field: 'gc'
[15:32:29.413]   - Field: 'conditions'
[15:32:29.414]   - Field: 'persistent'
[15:32:29.414]   - Field: 'expr'
[15:32:29.414]   - Field: 'uuid'
[15:32:29.414]   - Field: 'seed'
[15:32:29.415]   - Field: 'version'
[15:32:29.415]   - Field: 'result'
[15:32:29.415]   - Field: 'asynchronous'
[15:32:29.415]   - Field: 'calls'
[15:32:29.415]   - Field: 'globals'
[15:32:29.416]   - Field: 'stdout'
[15:32:29.416]   - Field: 'earlySignal'
[15:32:29.416]   - Field: 'lazy'
[15:32:29.416]   - Field: 'state'
[15:32:29.417] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:29.417] - Launch lazy future ...
[15:32:29.418] Packages needed by the future expression (n = 0): <none>
[15:32:29.418] Packages needed by future strategies (n = 0): <none>
[15:32:29.419] {
[15:32:29.419]     {
[15:32:29.419]         {
[15:32:29.419]             ...future.startTime <- base::Sys.time()
[15:32:29.419]             {
[15:32:29.419]                 {
[15:32:29.419]                   {
[15:32:29.419]                     {
[15:32:29.419]                       base::local({
[15:32:29.419]                         has_future <- base::requireNamespace("future", 
[15:32:29.419]                           quietly = TRUE)
[15:32:29.419]                         if (has_future) {
[15:32:29.419]                           ns <- base::getNamespace("future")
[15:32:29.419]                           version <- ns[[".package"]][["version"]]
[15:32:29.419]                           if (is.null(version)) 
[15:32:29.419]                             version <- utils::packageVersion("future")
[15:32:29.419]                         }
[15:32:29.419]                         else {
[15:32:29.419]                           version <- NULL
[15:32:29.419]                         }
[15:32:29.419]                         if (!has_future || version < "1.8.0") {
[15:32:29.419]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:29.419]                             "", base::R.version$version.string), 
[15:32:29.419]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:29.419]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:29.419]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:29.419]                               "release", "version")], collapse = " "), 
[15:32:29.419]                             hostname = base::Sys.info()[["nodename"]])
[15:32:29.419]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:29.419]                             info)
[15:32:29.419]                           info <- base::paste(info, collapse = "; ")
[15:32:29.419]                           if (!has_future) {
[15:32:29.419]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:29.419]                               info)
[15:32:29.419]                           }
[15:32:29.419]                           else {
[15:32:29.419]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:29.419]                               info, version)
[15:32:29.419]                           }
[15:32:29.419]                           base::stop(msg)
[15:32:29.419]                         }
[15:32:29.419]                       })
[15:32:29.419]                     }
[15:32:29.419]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:29.419]                     base::options(mc.cores = 1L)
[15:32:29.419]                   }
[15:32:29.419]                   ...future.strategy.old <- future::plan("list")
[15:32:29.419]                   options(future.plan = NULL)
[15:32:29.419]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:29.419]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:29.419]                 }
[15:32:29.419]                 ...future.workdir <- getwd()
[15:32:29.419]             }
[15:32:29.419]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:29.419]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:29.419]         }
[15:32:29.419]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:29.419]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:29.419]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:29.419]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:29.419]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:29.419]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:29.419]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:29.419]             base::names(...future.oldOptions))
[15:32:29.419]     }
[15:32:29.419]     if (FALSE) {
[15:32:29.419]     }
[15:32:29.419]     else {
[15:32:29.419]         if (TRUE) {
[15:32:29.419]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:29.419]                 open = "w")
[15:32:29.419]         }
[15:32:29.419]         else {
[15:32:29.419]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:29.419]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:29.419]         }
[15:32:29.419]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:29.419]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:29.419]             base::sink(type = "output", split = FALSE)
[15:32:29.419]             base::close(...future.stdout)
[15:32:29.419]         }, add = TRUE)
[15:32:29.419]     }
[15:32:29.419]     ...future.frame <- base::sys.nframe()
[15:32:29.419]     ...future.conditions <- base::list()
[15:32:29.419]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:29.419]     if (FALSE) {
[15:32:29.419]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:29.419]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:29.419]     }
[15:32:29.419]     ...future.result <- base::tryCatch({
[15:32:29.419]         base::withCallingHandlers({
[15:32:29.419]             ...future.value <- base::withVisible(base::local({
[15:32:29.419]                 ...future.makeSendCondition <- base::local({
[15:32:29.419]                   sendCondition <- NULL
[15:32:29.419]                   function(frame = 1L) {
[15:32:29.419]                     if (is.function(sendCondition)) 
[15:32:29.419]                       return(sendCondition)
[15:32:29.419]                     ns <- getNamespace("parallel")
[15:32:29.419]                     if (exists("sendData", mode = "function", 
[15:32:29.419]                       envir = ns)) {
[15:32:29.419]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:29.419]                         envir = ns)
[15:32:29.419]                       envir <- sys.frame(frame)
[15:32:29.419]                       master <- NULL
[15:32:29.419]                       while (!identical(envir, .GlobalEnv) && 
[15:32:29.419]                         !identical(envir, emptyenv())) {
[15:32:29.419]                         if (exists("master", mode = "list", envir = envir, 
[15:32:29.419]                           inherits = FALSE)) {
[15:32:29.419]                           master <- get("master", mode = "list", 
[15:32:29.419]                             envir = envir, inherits = FALSE)
[15:32:29.419]                           if (inherits(master, c("SOCKnode", 
[15:32:29.419]                             "SOCK0node"))) {
[15:32:29.419]                             sendCondition <<- function(cond) {
[15:32:29.419]                               data <- list(type = "VALUE", value = cond, 
[15:32:29.419]                                 success = TRUE)
[15:32:29.419]                               parallel_sendData(master, data)
[15:32:29.419]                             }
[15:32:29.419]                             return(sendCondition)
[15:32:29.419]                           }
[15:32:29.419]                         }
[15:32:29.419]                         frame <- frame + 1L
[15:32:29.419]                         envir <- sys.frame(frame)
[15:32:29.419]                       }
[15:32:29.419]                     }
[15:32:29.419]                     sendCondition <<- function(cond) NULL
[15:32:29.419]                   }
[15:32:29.419]                 })
[15:32:29.419]                 withCallingHandlers({
[15:32:29.419]                   {
[15:32:29.419]                     do.call(function(...) {
[15:32:29.419]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:29.419]                       if (!identical(...future.globals.maxSize.org, 
[15:32:29.419]                         ...future.globals.maxSize)) {
[15:32:29.419]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:29.419]                         on.exit(options(oopts), add = TRUE)
[15:32:29.419]                       }
[15:32:29.419]                       {
[15:32:29.419]                         lapply(seq_along(...future.elements_ii), 
[15:32:29.419]                           FUN = function(jj) {
[15:32:29.419]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:29.419]                             ...future.FUN(...future.X_jj, ...)
[15:32:29.419]                           })
[15:32:29.419]                       }
[15:32:29.419]                     }, args = future.call.arguments)
[15:32:29.419]                   }
[15:32:29.419]                 }, immediateCondition = function(cond) {
[15:32:29.419]                   sendCondition <- ...future.makeSendCondition()
[15:32:29.419]                   sendCondition(cond)
[15:32:29.419]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:29.419]                   {
[15:32:29.419]                     inherits <- base::inherits
[15:32:29.419]                     invokeRestart <- base::invokeRestart
[15:32:29.419]                     is.null <- base::is.null
[15:32:29.419]                     muffled <- FALSE
[15:32:29.419]                     if (inherits(cond, "message")) {
[15:32:29.419]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:29.419]                       if (muffled) 
[15:32:29.419]                         invokeRestart("muffleMessage")
[15:32:29.419]                     }
[15:32:29.419]                     else if (inherits(cond, "warning")) {
[15:32:29.419]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:29.419]                       if (muffled) 
[15:32:29.419]                         invokeRestart("muffleWarning")
[15:32:29.419]                     }
[15:32:29.419]                     else if (inherits(cond, "condition")) {
[15:32:29.419]                       if (!is.null(pattern)) {
[15:32:29.419]                         computeRestarts <- base::computeRestarts
[15:32:29.419]                         grepl <- base::grepl
[15:32:29.419]                         restarts <- computeRestarts(cond)
[15:32:29.419]                         for (restart in restarts) {
[15:32:29.419]                           name <- restart$name
[15:32:29.419]                           if (is.null(name)) 
[15:32:29.419]                             next
[15:32:29.419]                           if (!grepl(pattern, name)) 
[15:32:29.419]                             next
[15:32:29.419]                           invokeRestart(restart)
[15:32:29.419]                           muffled <- TRUE
[15:32:29.419]                           break
[15:32:29.419]                         }
[15:32:29.419]                       }
[15:32:29.419]                     }
[15:32:29.419]                     invisible(muffled)
[15:32:29.419]                   }
[15:32:29.419]                   muffleCondition(cond)
[15:32:29.419]                 })
[15:32:29.419]             }))
[15:32:29.419]             future::FutureResult(value = ...future.value$value, 
[15:32:29.419]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:29.419]                   ...future.rng), globalenv = if (FALSE) 
[15:32:29.419]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:29.419]                     ...future.globalenv.names))
[15:32:29.419]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:29.419]         }, condition = base::local({
[15:32:29.419]             c <- base::c
[15:32:29.419]             inherits <- base::inherits
[15:32:29.419]             invokeRestart <- base::invokeRestart
[15:32:29.419]             length <- base::length
[15:32:29.419]             list <- base::list
[15:32:29.419]             seq.int <- base::seq.int
[15:32:29.419]             signalCondition <- base::signalCondition
[15:32:29.419]             sys.calls <- base::sys.calls
[15:32:29.419]             `[[` <- base::`[[`
[15:32:29.419]             `+` <- base::`+`
[15:32:29.419]             `<<-` <- base::`<<-`
[15:32:29.419]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:29.419]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:29.419]                   3L)]
[15:32:29.419]             }
[15:32:29.419]             function(cond) {
[15:32:29.419]                 is_error <- inherits(cond, "error")
[15:32:29.419]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:29.419]                   NULL)
[15:32:29.419]                 if (is_error) {
[15:32:29.419]                   sessionInformation <- function() {
[15:32:29.419]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:29.419]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:29.419]                       search = base::search(), system = base::Sys.info())
[15:32:29.419]                   }
[15:32:29.419]                   ...future.conditions[[length(...future.conditions) + 
[15:32:29.419]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:29.419]                     cond$call), session = sessionInformation(), 
[15:32:29.419]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:29.419]                   signalCondition(cond)
[15:32:29.419]                 }
[15:32:29.419]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:29.419]                 "immediateCondition"))) {
[15:32:29.419]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:29.419]                   ...future.conditions[[length(...future.conditions) + 
[15:32:29.419]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:29.419]                   if (TRUE && !signal) {
[15:32:29.419]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:29.419]                     {
[15:32:29.419]                       inherits <- base::inherits
[15:32:29.419]                       invokeRestart <- base::invokeRestart
[15:32:29.419]                       is.null <- base::is.null
[15:32:29.419]                       muffled <- FALSE
[15:32:29.419]                       if (inherits(cond, "message")) {
[15:32:29.419]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:29.419]                         if (muffled) 
[15:32:29.419]                           invokeRestart("muffleMessage")
[15:32:29.419]                       }
[15:32:29.419]                       else if (inherits(cond, "warning")) {
[15:32:29.419]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:29.419]                         if (muffled) 
[15:32:29.419]                           invokeRestart("muffleWarning")
[15:32:29.419]                       }
[15:32:29.419]                       else if (inherits(cond, "condition")) {
[15:32:29.419]                         if (!is.null(pattern)) {
[15:32:29.419]                           computeRestarts <- base::computeRestarts
[15:32:29.419]                           grepl <- base::grepl
[15:32:29.419]                           restarts <- computeRestarts(cond)
[15:32:29.419]                           for (restart in restarts) {
[15:32:29.419]                             name <- restart$name
[15:32:29.419]                             if (is.null(name)) 
[15:32:29.419]                               next
[15:32:29.419]                             if (!grepl(pattern, name)) 
[15:32:29.419]                               next
[15:32:29.419]                             invokeRestart(restart)
[15:32:29.419]                             muffled <- TRUE
[15:32:29.419]                             break
[15:32:29.419]                           }
[15:32:29.419]                         }
[15:32:29.419]                       }
[15:32:29.419]                       invisible(muffled)
[15:32:29.419]                     }
[15:32:29.419]                     muffleCondition(cond, pattern = "^muffle")
[15:32:29.419]                   }
[15:32:29.419]                 }
[15:32:29.419]                 else {
[15:32:29.419]                   if (TRUE) {
[15:32:29.419]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:29.419]                     {
[15:32:29.419]                       inherits <- base::inherits
[15:32:29.419]                       invokeRestart <- base::invokeRestart
[15:32:29.419]                       is.null <- base::is.null
[15:32:29.419]                       muffled <- FALSE
[15:32:29.419]                       if (inherits(cond, "message")) {
[15:32:29.419]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:29.419]                         if (muffled) 
[15:32:29.419]                           invokeRestart("muffleMessage")
[15:32:29.419]                       }
[15:32:29.419]                       else if (inherits(cond, "warning")) {
[15:32:29.419]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:29.419]                         if (muffled) 
[15:32:29.419]                           invokeRestart("muffleWarning")
[15:32:29.419]                       }
[15:32:29.419]                       else if (inherits(cond, "condition")) {
[15:32:29.419]                         if (!is.null(pattern)) {
[15:32:29.419]                           computeRestarts <- base::computeRestarts
[15:32:29.419]                           grepl <- base::grepl
[15:32:29.419]                           restarts <- computeRestarts(cond)
[15:32:29.419]                           for (restart in restarts) {
[15:32:29.419]                             name <- restart$name
[15:32:29.419]                             if (is.null(name)) 
[15:32:29.419]                               next
[15:32:29.419]                             if (!grepl(pattern, name)) 
[15:32:29.419]                               next
[15:32:29.419]                             invokeRestart(restart)
[15:32:29.419]                             muffled <- TRUE
[15:32:29.419]                             break
[15:32:29.419]                           }
[15:32:29.419]                         }
[15:32:29.419]                       }
[15:32:29.419]                       invisible(muffled)
[15:32:29.419]                     }
[15:32:29.419]                     muffleCondition(cond, pattern = "^muffle")
[15:32:29.419]                   }
[15:32:29.419]                 }
[15:32:29.419]             }
[15:32:29.419]         }))
[15:32:29.419]     }, error = function(ex) {
[15:32:29.419]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:29.419]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:29.419]                 ...future.rng), started = ...future.startTime, 
[15:32:29.419]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:29.419]             version = "1.8"), class = "FutureResult")
[15:32:29.419]     }, finally = {
[15:32:29.419]         if (!identical(...future.workdir, getwd())) 
[15:32:29.419]             setwd(...future.workdir)
[15:32:29.419]         {
[15:32:29.419]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:29.419]                 ...future.oldOptions$nwarnings <- NULL
[15:32:29.419]             }
[15:32:29.419]             base::options(...future.oldOptions)
[15:32:29.419]             if (.Platform$OS.type == "windows") {
[15:32:29.419]                 old_names <- names(...future.oldEnvVars)
[15:32:29.419]                 envs <- base::Sys.getenv()
[15:32:29.419]                 names <- names(envs)
[15:32:29.419]                 common <- intersect(names, old_names)
[15:32:29.419]                 added <- setdiff(names, old_names)
[15:32:29.419]                 removed <- setdiff(old_names, names)
[15:32:29.419]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:29.419]                   envs[common]]
[15:32:29.419]                 NAMES <- toupper(changed)
[15:32:29.419]                 args <- list()
[15:32:29.419]                 for (kk in seq_along(NAMES)) {
[15:32:29.419]                   name <- changed[[kk]]
[15:32:29.419]                   NAME <- NAMES[[kk]]
[15:32:29.419]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:29.419]                     next
[15:32:29.419]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:29.419]                 }
[15:32:29.419]                 NAMES <- toupper(added)
[15:32:29.419]                 for (kk in seq_along(NAMES)) {
[15:32:29.419]                   name <- added[[kk]]
[15:32:29.419]                   NAME <- NAMES[[kk]]
[15:32:29.419]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:29.419]                     next
[15:32:29.419]                   args[[name]] <- ""
[15:32:29.419]                 }
[15:32:29.419]                 NAMES <- toupper(removed)
[15:32:29.419]                 for (kk in seq_along(NAMES)) {
[15:32:29.419]                   name <- removed[[kk]]
[15:32:29.419]                   NAME <- NAMES[[kk]]
[15:32:29.419]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:29.419]                     next
[15:32:29.419]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:29.419]                 }
[15:32:29.419]                 if (length(args) > 0) 
[15:32:29.419]                   base::do.call(base::Sys.setenv, args = args)
[15:32:29.419]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:29.419]             }
[15:32:29.419]             else {
[15:32:29.419]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:29.419]             }
[15:32:29.419]             {
[15:32:29.419]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:29.419]                   0L) {
[15:32:29.419]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:29.419]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:29.419]                   base::options(opts)
[15:32:29.419]                 }
[15:32:29.419]                 {
[15:32:29.419]                   {
[15:32:29.419]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:29.419]                     NULL
[15:32:29.419]                   }
[15:32:29.419]                   options(future.plan = NULL)
[15:32:29.419]                   if (is.na(NA_character_)) 
[15:32:29.419]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:29.419]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:29.419]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:29.419]                     .init = FALSE)
[15:32:29.419]                 }
[15:32:29.419]             }
[15:32:29.419]         }
[15:32:29.419]     })
[15:32:29.419]     if (TRUE) {
[15:32:29.419]         base::sink(type = "output", split = FALSE)
[15:32:29.419]         if (TRUE) {
[15:32:29.419]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:29.419]         }
[15:32:29.419]         else {
[15:32:29.419]             ...future.result["stdout"] <- base::list(NULL)
[15:32:29.419]         }
[15:32:29.419]         base::close(...future.stdout)
[15:32:29.419]         ...future.stdout <- NULL
[15:32:29.419]     }
[15:32:29.419]     ...future.result$conditions <- ...future.conditions
[15:32:29.419]     ...future.result$finished <- base::Sys.time()
[15:32:29.419]     ...future.result
[15:32:29.419] }
[15:32:29.426] Exporting 5 global objects (4.62 KiB) to cluster node #1 ...
[15:32:29.427] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ...
[15:32:29.427] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ... DONE
[15:32:29.428] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:29.428] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:29.429] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ...
[15:32:29.429] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ... DONE
[15:32:29.429] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:29.430] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:29.430] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:29.431] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:29.431] Exporting 5 global objects (4.62 KiB) to cluster node #1 ... DONE
[15:32:29.432] MultisessionFuture started
[15:32:29.432] - Launch lazy future ... done
[15:32:29.432] run() for 'MultisessionFuture' ... done
[15:32:29.433] Created future:
[15:32:29.456] receiveMessageFromWorker() for ClusterFuture ...
[15:32:29.457] - Validating connection of MultisessionFuture
[15:32:29.457] - received message: FutureResult
[15:32:29.458] - Received FutureResult
[15:32:29.458] - Erased future from FutureRegistry
[15:32:29.458] result() for ClusterFuture ...
[15:32:29.458] - result already collected: FutureResult
[15:32:29.459] result() for ClusterFuture ... done
[15:32:29.463] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:29.433] MultisessionFuture:
[15:32:29.433] Label: 'future_sapply-1'
[15:32:29.433] Expression:
[15:32:29.433] {
[15:32:29.433]     do.call(function(...) {
[15:32:29.433]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:29.433]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:29.433]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:29.433]             on.exit(options(oopts), add = TRUE)
[15:32:29.433]         }
[15:32:29.433]         {
[15:32:29.433]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:29.433]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:29.433]                 ...future.FUN(...future.X_jj, ...)
[15:32:29.433]             })
[15:32:29.433]         }
[15:32:29.433]     }, args = future.call.arguments)
[15:32:29.433] }
[15:32:29.433] Lazy evaluation: FALSE
[15:32:29.433] Asynchronous evaluation: TRUE
[15:32:29.433] Local evaluation: TRUE
[15:32:29.433] Environment: R_GlobalEnv
[15:32:29.433] Capture standard output: TRUE
[15:32:29.433] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:29.433] Globals: 5 objects totaling 4.67 KiB (function '...future.FUN' of 4.62 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)
[15:32:29.433] Packages: <none>
[15:32:29.433] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:29.433] Resolved: TRUE
[15:32:29.433] Value: <not collected>
[15:32:29.433] Conditions captured: <none>
[15:32:29.433] Early signaling: FALSE
[15:32:29.433] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:29.433] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:29.463] Chunk #1 of 2 ... DONE
[15:32:29.464] Chunk #2 of 2 ...
[15:32:29.464]  - Finding globals in 'X' for chunk #2 ...
[15:32:29.464] getGlobalsAndPackages() ...
[15:32:29.464] Searching for globals...
[15:32:29.465] 
[15:32:29.465] Searching for globals ... DONE
[15:32:29.465] - globals: [0] <none>
[15:32:29.466] getGlobalsAndPackages() ... DONE
[15:32:29.466]    + additional globals found: [n=0] 
[15:32:29.466]    + additional namespaces needed: [n=0] 
[15:32:29.466]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:29.467]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:29.467]  - seeds: <none>
[15:32:29.467]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:29.467] getGlobalsAndPackages() ...
[15:32:29.468] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:29.468] Resolving globals: FALSE
[15:32:29.468] Tweak future expression to call with '...' arguments ...
[15:32:29.468] {
[15:32:29.468]     do.call(function(...) {
[15:32:29.468]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:29.468]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:29.468]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:29.468]             on.exit(options(oopts), add = TRUE)
[15:32:29.468]         }
[15:32:29.468]         {
[15:32:29.468]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:29.468]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:29.468]                 ...future.FUN(...future.X_jj, ...)
[15:32:29.468]             })
[15:32:29.468]         }
[15:32:29.468]     }, args = future.call.arguments)
[15:32:29.468] }
[15:32:29.469] Tweak future expression to call with '...' arguments ... DONE
[15:32:29.470] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:29.470] 
[15:32:29.470] getGlobalsAndPackages() ... DONE
[15:32:29.471] run() for 'Future' ...
[15:32:29.471] - state: 'created'
[15:32:29.471] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:29.488] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:29.489] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:29.489]   - Field: 'node'
[15:32:29.489]   - Field: 'label'
[15:32:29.489]   - Field: 'local'
[15:32:29.490]   - Field: 'owner'
[15:32:29.490]   - Field: 'envir'
[15:32:29.490]   - Field: 'workers'
[15:32:29.490]   - Field: 'packages'
[15:32:29.491]   - Field: 'gc'
[15:32:29.491]   - Field: 'conditions'
[15:32:29.491]   - Field: 'persistent'
[15:32:29.491]   - Field: 'expr'
[15:32:29.492]   - Field: 'uuid'
[15:32:29.492]   - Field: 'seed'
[15:32:29.492]   - Field: 'version'
[15:32:29.493]   - Field: 'result'
[15:32:29.493]   - Field: 'asynchronous'
[15:32:29.493]   - Field: 'calls'
[15:32:29.493]   - Field: 'globals'
[15:32:29.494]   - Field: 'stdout'
[15:32:29.494]   - Field: 'earlySignal'
[15:32:29.494]   - Field: 'lazy'
[15:32:29.494]   - Field: 'state'
[15:32:29.495] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:29.495] - Launch lazy future ...
[15:32:29.495] Packages needed by the future expression (n = 0): <none>
[15:32:29.496] Packages needed by future strategies (n = 0): <none>
[15:32:29.497] {
[15:32:29.497]     {
[15:32:29.497]         {
[15:32:29.497]             ...future.startTime <- base::Sys.time()
[15:32:29.497]             {
[15:32:29.497]                 {
[15:32:29.497]                   {
[15:32:29.497]                     {
[15:32:29.497]                       base::local({
[15:32:29.497]                         has_future <- base::requireNamespace("future", 
[15:32:29.497]                           quietly = TRUE)
[15:32:29.497]                         if (has_future) {
[15:32:29.497]                           ns <- base::getNamespace("future")
[15:32:29.497]                           version <- ns[[".package"]][["version"]]
[15:32:29.497]                           if (is.null(version)) 
[15:32:29.497]                             version <- utils::packageVersion("future")
[15:32:29.497]                         }
[15:32:29.497]                         else {
[15:32:29.497]                           version <- NULL
[15:32:29.497]                         }
[15:32:29.497]                         if (!has_future || version < "1.8.0") {
[15:32:29.497]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:29.497]                             "", base::R.version$version.string), 
[15:32:29.497]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:29.497]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:29.497]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:29.497]                               "release", "version")], collapse = " "), 
[15:32:29.497]                             hostname = base::Sys.info()[["nodename"]])
[15:32:29.497]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:29.497]                             info)
[15:32:29.497]                           info <- base::paste(info, collapse = "; ")
[15:32:29.497]                           if (!has_future) {
[15:32:29.497]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:29.497]                               info)
[15:32:29.497]                           }
[15:32:29.497]                           else {
[15:32:29.497]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:29.497]                               info, version)
[15:32:29.497]                           }
[15:32:29.497]                           base::stop(msg)
[15:32:29.497]                         }
[15:32:29.497]                       })
[15:32:29.497]                     }
[15:32:29.497]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:29.497]                     base::options(mc.cores = 1L)
[15:32:29.497]                   }
[15:32:29.497]                   ...future.strategy.old <- future::plan("list")
[15:32:29.497]                   options(future.plan = NULL)
[15:32:29.497]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:29.497]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:29.497]                 }
[15:32:29.497]                 ...future.workdir <- getwd()
[15:32:29.497]             }
[15:32:29.497]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:29.497]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:29.497]         }
[15:32:29.497]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:29.497]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:29.497]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:29.497]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:29.497]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:29.497]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:29.497]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:29.497]             base::names(...future.oldOptions))
[15:32:29.497]     }
[15:32:29.497]     if (FALSE) {
[15:32:29.497]     }
[15:32:29.497]     else {
[15:32:29.497]         if (TRUE) {
[15:32:29.497]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:29.497]                 open = "w")
[15:32:29.497]         }
[15:32:29.497]         else {
[15:32:29.497]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:29.497]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:29.497]         }
[15:32:29.497]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:29.497]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:29.497]             base::sink(type = "output", split = FALSE)
[15:32:29.497]             base::close(...future.stdout)
[15:32:29.497]         }, add = TRUE)
[15:32:29.497]     }
[15:32:29.497]     ...future.frame <- base::sys.nframe()
[15:32:29.497]     ...future.conditions <- base::list()
[15:32:29.497]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:29.497]     if (FALSE) {
[15:32:29.497]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:29.497]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:29.497]     }
[15:32:29.497]     ...future.result <- base::tryCatch({
[15:32:29.497]         base::withCallingHandlers({
[15:32:29.497]             ...future.value <- base::withVisible(base::local({
[15:32:29.497]                 ...future.makeSendCondition <- base::local({
[15:32:29.497]                   sendCondition <- NULL
[15:32:29.497]                   function(frame = 1L) {
[15:32:29.497]                     if (is.function(sendCondition)) 
[15:32:29.497]                       return(sendCondition)
[15:32:29.497]                     ns <- getNamespace("parallel")
[15:32:29.497]                     if (exists("sendData", mode = "function", 
[15:32:29.497]                       envir = ns)) {
[15:32:29.497]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:29.497]                         envir = ns)
[15:32:29.497]                       envir <- sys.frame(frame)
[15:32:29.497]                       master <- NULL
[15:32:29.497]                       while (!identical(envir, .GlobalEnv) && 
[15:32:29.497]                         !identical(envir, emptyenv())) {
[15:32:29.497]                         if (exists("master", mode = "list", envir = envir, 
[15:32:29.497]                           inherits = FALSE)) {
[15:32:29.497]                           master <- get("master", mode = "list", 
[15:32:29.497]                             envir = envir, inherits = FALSE)
[15:32:29.497]                           if (inherits(master, c("SOCKnode", 
[15:32:29.497]                             "SOCK0node"))) {
[15:32:29.497]                             sendCondition <<- function(cond) {
[15:32:29.497]                               data <- list(type = "VALUE", value = cond, 
[15:32:29.497]                                 success = TRUE)
[15:32:29.497]                               parallel_sendData(master, data)
[15:32:29.497]                             }
[15:32:29.497]                             return(sendCondition)
[15:32:29.497]                           }
[15:32:29.497]                         }
[15:32:29.497]                         frame <- frame + 1L
[15:32:29.497]                         envir <- sys.frame(frame)
[15:32:29.497]                       }
[15:32:29.497]                     }
[15:32:29.497]                     sendCondition <<- function(cond) NULL
[15:32:29.497]                   }
[15:32:29.497]                 })
[15:32:29.497]                 withCallingHandlers({
[15:32:29.497]                   {
[15:32:29.497]                     do.call(function(...) {
[15:32:29.497]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:29.497]                       if (!identical(...future.globals.maxSize.org, 
[15:32:29.497]                         ...future.globals.maxSize)) {
[15:32:29.497]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:29.497]                         on.exit(options(oopts), add = TRUE)
[15:32:29.497]                       }
[15:32:29.497]                       {
[15:32:29.497]                         lapply(seq_along(...future.elements_ii), 
[15:32:29.497]                           FUN = function(jj) {
[15:32:29.497]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:29.497]                             ...future.FUN(...future.X_jj, ...)
[15:32:29.497]                           })
[15:32:29.497]                       }
[15:32:29.497]                     }, args = future.call.arguments)
[15:32:29.497]                   }
[15:32:29.497]                 }, immediateCondition = function(cond) {
[15:32:29.497]                   sendCondition <- ...future.makeSendCondition()
[15:32:29.497]                   sendCondition(cond)
[15:32:29.497]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:29.497]                   {
[15:32:29.497]                     inherits <- base::inherits
[15:32:29.497]                     invokeRestart <- base::invokeRestart
[15:32:29.497]                     is.null <- base::is.null
[15:32:29.497]                     muffled <- FALSE
[15:32:29.497]                     if (inherits(cond, "message")) {
[15:32:29.497]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:29.497]                       if (muffled) 
[15:32:29.497]                         invokeRestart("muffleMessage")
[15:32:29.497]                     }
[15:32:29.497]                     else if (inherits(cond, "warning")) {
[15:32:29.497]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:29.497]                       if (muffled) 
[15:32:29.497]                         invokeRestart("muffleWarning")
[15:32:29.497]                     }
[15:32:29.497]                     else if (inherits(cond, "condition")) {
[15:32:29.497]                       if (!is.null(pattern)) {
[15:32:29.497]                         computeRestarts <- base::computeRestarts
[15:32:29.497]                         grepl <- base::grepl
[15:32:29.497]                         restarts <- computeRestarts(cond)
[15:32:29.497]                         for (restart in restarts) {
[15:32:29.497]                           name <- restart$name
[15:32:29.497]                           if (is.null(name)) 
[15:32:29.497]                             next
[15:32:29.497]                           if (!grepl(pattern, name)) 
[15:32:29.497]                             next
[15:32:29.497]                           invokeRestart(restart)
[15:32:29.497]                           muffled <- TRUE
[15:32:29.497]                           break
[15:32:29.497]                         }
[15:32:29.497]                       }
[15:32:29.497]                     }
[15:32:29.497]                     invisible(muffled)
[15:32:29.497]                   }
[15:32:29.497]                   muffleCondition(cond)
[15:32:29.497]                 })
[15:32:29.497]             }))
[15:32:29.497]             future::FutureResult(value = ...future.value$value, 
[15:32:29.497]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:29.497]                   ...future.rng), globalenv = if (FALSE) 
[15:32:29.497]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:29.497]                     ...future.globalenv.names))
[15:32:29.497]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:29.497]         }, condition = base::local({
[15:32:29.497]             c <- base::c
[15:32:29.497]             inherits <- base::inherits
[15:32:29.497]             invokeRestart <- base::invokeRestart
[15:32:29.497]             length <- base::length
[15:32:29.497]             list <- base::list
[15:32:29.497]             seq.int <- base::seq.int
[15:32:29.497]             signalCondition <- base::signalCondition
[15:32:29.497]             sys.calls <- base::sys.calls
[15:32:29.497]             `[[` <- base::`[[`
[15:32:29.497]             `+` <- base::`+`
[15:32:29.497]             `<<-` <- base::`<<-`
[15:32:29.497]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:29.497]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:29.497]                   3L)]
[15:32:29.497]             }
[15:32:29.497]             function(cond) {
[15:32:29.497]                 is_error <- inherits(cond, "error")
[15:32:29.497]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:29.497]                   NULL)
[15:32:29.497]                 if (is_error) {
[15:32:29.497]                   sessionInformation <- function() {
[15:32:29.497]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:29.497]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:29.497]                       search = base::search(), system = base::Sys.info())
[15:32:29.497]                   }
[15:32:29.497]                   ...future.conditions[[length(...future.conditions) + 
[15:32:29.497]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:29.497]                     cond$call), session = sessionInformation(), 
[15:32:29.497]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:29.497]                   signalCondition(cond)
[15:32:29.497]                 }
[15:32:29.497]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:29.497]                 "immediateCondition"))) {
[15:32:29.497]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:29.497]                   ...future.conditions[[length(...future.conditions) + 
[15:32:29.497]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:29.497]                   if (TRUE && !signal) {
[15:32:29.497]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:29.497]                     {
[15:32:29.497]                       inherits <- base::inherits
[15:32:29.497]                       invokeRestart <- base::invokeRestart
[15:32:29.497]                       is.null <- base::is.null
[15:32:29.497]                       muffled <- FALSE
[15:32:29.497]                       if (inherits(cond, "message")) {
[15:32:29.497]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:29.497]                         if (muffled) 
[15:32:29.497]                           invokeRestart("muffleMessage")
[15:32:29.497]                       }
[15:32:29.497]                       else if (inherits(cond, "warning")) {
[15:32:29.497]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:29.497]                         if (muffled) 
[15:32:29.497]                           invokeRestart("muffleWarning")
[15:32:29.497]                       }
[15:32:29.497]                       else if (inherits(cond, "condition")) {
[15:32:29.497]                         if (!is.null(pattern)) {
[15:32:29.497]                           computeRestarts <- base::computeRestarts
[15:32:29.497]                           grepl <- base::grepl
[15:32:29.497]                           restarts <- computeRestarts(cond)
[15:32:29.497]                           for (restart in restarts) {
[15:32:29.497]                             name <- restart$name
[15:32:29.497]                             if (is.null(name)) 
[15:32:29.497]                               next
[15:32:29.497]                             if (!grepl(pattern, name)) 
[15:32:29.497]                               next
[15:32:29.497]                             invokeRestart(restart)
[15:32:29.497]                             muffled <- TRUE
[15:32:29.497]                             break
[15:32:29.497]                           }
[15:32:29.497]                         }
[15:32:29.497]                       }
[15:32:29.497]                       invisible(muffled)
[15:32:29.497]                     }
[15:32:29.497]                     muffleCondition(cond, pattern = "^muffle")
[15:32:29.497]                   }
[15:32:29.497]                 }
[15:32:29.497]                 else {
[15:32:29.497]                   if (TRUE) {
[15:32:29.497]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:29.497]                     {
[15:32:29.497]                       inherits <- base::inherits
[15:32:29.497]                       invokeRestart <- base::invokeRestart
[15:32:29.497]                       is.null <- base::is.null
[15:32:29.497]                       muffled <- FALSE
[15:32:29.497]                       if (inherits(cond, "message")) {
[15:32:29.497]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:29.497]                         if (muffled) 
[15:32:29.497]                           invokeRestart("muffleMessage")
[15:32:29.497]                       }
[15:32:29.497]                       else if (inherits(cond, "warning")) {
[15:32:29.497]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:29.497]                         if (muffled) 
[15:32:29.497]                           invokeRestart("muffleWarning")
[15:32:29.497]                       }
[15:32:29.497]                       else if (inherits(cond, "condition")) {
[15:32:29.497]                         if (!is.null(pattern)) {
[15:32:29.497]                           computeRestarts <- base::computeRestarts
[15:32:29.497]                           grepl <- base::grepl
[15:32:29.497]                           restarts <- computeRestarts(cond)
[15:32:29.497]                           for (restart in restarts) {
[15:32:29.497]                             name <- restart$name
[15:32:29.497]                             if (is.null(name)) 
[15:32:29.497]                               next
[15:32:29.497]                             if (!grepl(pattern, name)) 
[15:32:29.497]                               next
[15:32:29.497]                             invokeRestart(restart)
[15:32:29.497]                             muffled <- TRUE
[15:32:29.497]                             break
[15:32:29.497]                           }
[15:32:29.497]                         }
[15:32:29.497]                       }
[15:32:29.497]                       invisible(muffled)
[15:32:29.497]                     }
[15:32:29.497]                     muffleCondition(cond, pattern = "^muffle")
[15:32:29.497]                   }
[15:32:29.497]                 }
[15:32:29.497]             }
[15:32:29.497]         }))
[15:32:29.497]     }, error = function(ex) {
[15:32:29.497]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:29.497]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:29.497]                 ...future.rng), started = ...future.startTime, 
[15:32:29.497]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:29.497]             version = "1.8"), class = "FutureResult")
[15:32:29.497]     }, finally = {
[15:32:29.497]         if (!identical(...future.workdir, getwd())) 
[15:32:29.497]             setwd(...future.workdir)
[15:32:29.497]         {
[15:32:29.497]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:29.497]                 ...future.oldOptions$nwarnings <- NULL
[15:32:29.497]             }
[15:32:29.497]             base::options(...future.oldOptions)
[15:32:29.497]             if (.Platform$OS.type == "windows") {
[15:32:29.497]                 old_names <- names(...future.oldEnvVars)
[15:32:29.497]                 envs <- base::Sys.getenv()
[15:32:29.497]                 names <- names(envs)
[15:32:29.497]                 common <- intersect(names, old_names)
[15:32:29.497]                 added <- setdiff(names, old_names)
[15:32:29.497]                 removed <- setdiff(old_names, names)
[15:32:29.497]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:29.497]                   envs[common]]
[15:32:29.497]                 NAMES <- toupper(changed)
[15:32:29.497]                 args <- list()
[15:32:29.497]                 for (kk in seq_along(NAMES)) {
[15:32:29.497]                   name <- changed[[kk]]
[15:32:29.497]                   NAME <- NAMES[[kk]]
[15:32:29.497]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:29.497]                     next
[15:32:29.497]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:29.497]                 }
[15:32:29.497]                 NAMES <- toupper(added)
[15:32:29.497]                 for (kk in seq_along(NAMES)) {
[15:32:29.497]                   name <- added[[kk]]
[15:32:29.497]                   NAME <- NAMES[[kk]]
[15:32:29.497]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:29.497]                     next
[15:32:29.497]                   args[[name]] <- ""
[15:32:29.497]                 }
[15:32:29.497]                 NAMES <- toupper(removed)
[15:32:29.497]                 for (kk in seq_along(NAMES)) {
[15:32:29.497]                   name <- removed[[kk]]
[15:32:29.497]                   NAME <- NAMES[[kk]]
[15:32:29.497]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:29.497]                     next
[15:32:29.497]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:29.497]                 }
[15:32:29.497]                 if (length(args) > 0) 
[15:32:29.497]                   base::do.call(base::Sys.setenv, args = args)
[15:32:29.497]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:29.497]             }
[15:32:29.497]             else {
[15:32:29.497]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:29.497]             }
[15:32:29.497]             {
[15:32:29.497]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:29.497]                   0L) {
[15:32:29.497]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:29.497]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:29.497]                   base::options(opts)
[15:32:29.497]                 }
[15:32:29.497]                 {
[15:32:29.497]                   {
[15:32:29.497]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:29.497]                     NULL
[15:32:29.497]                   }
[15:32:29.497]                   options(future.plan = NULL)
[15:32:29.497]                   if (is.na(NA_character_)) 
[15:32:29.497]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:29.497]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:29.497]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:29.497]                     .init = FALSE)
[15:32:29.497]                 }
[15:32:29.497]             }
[15:32:29.497]         }
[15:32:29.497]     })
[15:32:29.497]     if (TRUE) {
[15:32:29.497]         base::sink(type = "output", split = FALSE)
[15:32:29.497]         if (TRUE) {
[15:32:29.497]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:29.497]         }
[15:32:29.497]         else {
[15:32:29.497]             ...future.result["stdout"] <- base::list(NULL)
[15:32:29.497]         }
[15:32:29.497]         base::close(...future.stdout)
[15:32:29.497]         ...future.stdout <- NULL
[15:32:29.497]     }
[15:32:29.497]     ...future.result$conditions <- ...future.conditions
[15:32:29.497]     ...future.result$finished <- base::Sys.time()
[15:32:29.497]     ...future.result
[15:32:29.497] }
[15:32:29.505] Exporting 5 global objects (4.62 KiB) to cluster node #1 ...
[15:32:29.505] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ...
[15:32:29.506] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ... DONE
[15:32:29.506] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:29.507] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:29.507] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:29.508] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:29.508] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:29.509] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:29.509] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:29.510] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:29.510] Exporting 5 global objects (4.62 KiB) to cluster node #1 ... DONE
[15:32:29.512] MultisessionFuture started
[15:32:29.512] - Launch lazy future ... done
[15:32:29.512] run() for 'MultisessionFuture' ... done
[15:32:29.513] Created future:
[15:32:29.538] receiveMessageFromWorker() for ClusterFuture ...
[15:32:29.538] - Validating connection of MultisessionFuture
[15:32:29.539] - received message: FutureResult
[15:32:29.539] - Received FutureResult
[15:32:29.539] - Erased future from FutureRegistry
[15:32:29.540] result() for ClusterFuture ...
[15:32:29.540] - result already collected: FutureResult
[15:32:29.540] result() for ClusterFuture ... done
[15:32:29.540] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:29.513] MultisessionFuture:
[15:32:29.513] Label: 'future_sapply-2'
[15:32:29.513] Expression:
[15:32:29.513] {
[15:32:29.513]     do.call(function(...) {
[15:32:29.513]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:29.513]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:29.513]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:29.513]             on.exit(options(oopts), add = TRUE)
[15:32:29.513]         }
[15:32:29.513]         {
[15:32:29.513]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:29.513]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:29.513]                 ...future.FUN(...future.X_jj, ...)
[15:32:29.513]             })
[15:32:29.513]         }
[15:32:29.513]     }, args = future.call.arguments)
[15:32:29.513] }
[15:32:29.513] Lazy evaluation: FALSE
[15:32:29.513] Asynchronous evaluation: TRUE
[15:32:29.513] Local evaluation: TRUE
[15:32:29.513] Environment: R_GlobalEnv
[15:32:29.513] Capture standard output: TRUE
[15:32:29.513] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:29.513] Globals: 5 objects totaling 4.73 KiB (function '...future.FUN' of 4.62 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)
[15:32:29.513] Packages: <none>
[15:32:29.513] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:29.513] Resolved: TRUE
[15:32:29.513] Value: <not collected>
[15:32:29.513] Conditions captured: <none>
[15:32:29.513] Early signaling: FALSE
[15:32:29.513] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:29.513] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:29.541] Chunk #2 of 2 ... DONE
[15:32:29.542] Launching 2 futures (chunks) ... DONE
[15:32:29.542] Resolving 2 futures (chunks) ...
[15:32:29.542] resolve() on list ...
[15:32:29.542]  recursive: 0
[15:32:29.543]  length: 2
[15:32:29.543] 
[15:32:29.543] Future #1
[15:32:29.543] result() for ClusterFuture ...
[15:32:29.543] - result already collected: FutureResult
[15:32:29.544] result() for ClusterFuture ... done
[15:32:29.544] result() for ClusterFuture ...
[15:32:29.544] - result already collected: FutureResult
[15:32:29.544] result() for ClusterFuture ... done
[15:32:29.545] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:29.545] - nx: 2
[15:32:29.545] - relay: TRUE
[15:32:29.545] - stdout: TRUE
[15:32:29.546] - signal: TRUE
[15:32:29.546] - resignal: FALSE
[15:32:29.546] - force: TRUE
[15:32:29.546] - relayed: [n=2] FALSE, FALSE
[15:32:29.546] - queued futures: [n=2] FALSE, FALSE
[15:32:29.547]  - until=1
[15:32:29.547]  - relaying element #1
[15:32:29.547] result() for ClusterFuture ...
[15:32:29.547] - result already collected: FutureResult
[15:32:29.548] result() for ClusterFuture ... done
[15:32:29.548] result() for ClusterFuture ...
[15:32:29.548] - result already collected: FutureResult
[15:32:29.548] result() for ClusterFuture ... done
[15:32:29.549] result() for ClusterFuture ...
[15:32:29.549] - result already collected: FutureResult
[15:32:29.549] result() for ClusterFuture ... done
[15:32:29.549] result() for ClusterFuture ...
[15:32:29.550] - result already collected: FutureResult
[15:32:29.550] result() for ClusterFuture ... done
[15:32:29.550] - relayed: [n=2] TRUE, FALSE
[15:32:29.550] - queued futures: [n=2] TRUE, FALSE
[15:32:29.550] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:29.551]  length: 1 (resolved future 1)
[15:32:29.551] Future #2
[15:32:29.551] result() for ClusterFuture ...
[15:32:29.552] - result already collected: FutureResult
[15:32:29.552] result() for ClusterFuture ... done
[15:32:29.552] result() for ClusterFuture ...
[15:32:29.552] - result already collected: FutureResult
[15:32:29.553] result() for ClusterFuture ... done
[15:32:29.553] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:29.553] - nx: 2
[15:32:29.553] - relay: TRUE
[15:32:29.553] - stdout: TRUE
[15:32:29.554] - signal: TRUE
[15:32:29.554] - resignal: FALSE
[15:32:29.554] - force: TRUE
[15:32:29.554] - relayed: [n=2] TRUE, FALSE
[15:32:29.555] - queued futures: [n=2] TRUE, FALSE
[15:32:29.555]  - until=2
[15:32:29.555]  - relaying element #2
[15:32:29.555] result() for ClusterFuture ...
[15:32:29.556] - result already collected: FutureResult
[15:32:29.556] result() for ClusterFuture ... done
[15:32:29.556] result() for ClusterFuture ...
[15:32:29.556] - result already collected: FutureResult
[15:32:29.556] result() for ClusterFuture ... done
[15:32:29.557] result() for ClusterFuture ...
[15:32:29.557] - result already collected: FutureResult
[15:32:29.557] result() for ClusterFuture ... done
[15:32:29.558] result() for ClusterFuture ...
[15:32:29.558] - result already collected: FutureResult
[15:32:29.558] result() for ClusterFuture ... done
[15:32:29.558] - relayed: [n=2] TRUE, TRUE
[15:32:29.558] - queued futures: [n=2] TRUE, TRUE
[15:32:29.559] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:29.559]  length: 0 (resolved future 2)
[15:32:29.559] Relaying remaining futures
[15:32:29.559] signalConditionsASAP(NULL, pos=0) ...
[15:32:29.560] - nx: 2
[15:32:29.560] - relay: TRUE
[15:32:29.560] - stdout: TRUE
[15:32:29.560] - signal: TRUE
[15:32:29.561] - resignal: FALSE
[15:32:29.561] - force: TRUE
[15:32:29.561] - relayed: [n=2] TRUE, TRUE
[15:32:29.561] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:29.562] - relayed: [n=2] TRUE, TRUE
[15:32:29.562] - queued futures: [n=2] TRUE, TRUE
[15:32:29.562] signalConditionsASAP(NULL, pos=0) ... done
[15:32:29.562] resolve() on list ... DONE
[15:32:29.563] result() for ClusterFuture ...
[15:32:29.563] - result already collected: FutureResult
[15:32:29.563] result() for ClusterFuture ... done
[15:32:29.563] result() for ClusterFuture ...
[15:32:29.564] - result already collected: FutureResult
[15:32:29.564] result() for ClusterFuture ... done
[15:32:29.564] result() for ClusterFuture ...
[15:32:29.564] - result already collected: FutureResult
[15:32:29.565] result() for ClusterFuture ... done
[15:32:29.565] result() for ClusterFuture ...
[15:32:29.565] - result already collected: FutureResult
[15:32:29.565] result() for ClusterFuture ... done
[15:32:29.566]  - Number of value chunks collected: 2
[15:32:29.566] Resolving 2 futures (chunks) ... DONE
[15:32:29.566] Reducing values from 2 chunks ...
[15:32:29.567]  - Number of values collected after concatenation: 3
[15:32:29.567]  - Number of values expected: 3
[15:32:29.567] Reducing values from 2 chunks ... DONE
[15:32:29.567] future_lapply() ... DONE
List of 2
 $ y0:List of 3
  ..$ a: num [1:3, 1:5] 2 2 2 4 4 4 6 6 6 8 ...
  ..$ b: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
  ..$ c: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
 $ y1:List of 3
  ..$ a: num [1:3, 1:5] 2 2 2 4 4 4 6 6 6 8 ...
  ..$ b: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
  ..$ c: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
List of 2
 $ y0:List of 3
  ..$ a: num [1:3, 1:5] 2 2 2 4 4 4 6 6 6 8 ...
  ..$ b: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
  ..$ c: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
 $ y2:List of 3
  ..$ a: num [1:3, 1:5] 2 2 2 4 4 4 6 6 6 8 ...
  ..$ b: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
  ..$ c: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
[15:32:29.579] future_lapply() ...
[15:32:29.584] Number of chunks: 2
[15:32:29.584] getGlobalsAndPackagesXApply() ...
[15:32:29.585]  - future.globals: TRUE
[15:32:29.585] getGlobalsAndPackages() ...
[15:32:29.585] Searching for globals...
[15:32:29.587] - globals found: [1] 'FUN'
[15:32:29.588] Searching for globals ... DONE
[15:32:29.588] Resolving globals: FALSE
[15:32:29.589] The total size of the 1 globals is 848 bytes (848 bytes)
[15:32:29.589] The total size of the 1 globals exported for future expression ('FUN()') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:32:29.590] - globals: [1] 'FUN'
[15:32:29.590] 
[15:32:29.590] getGlobalsAndPackages() ... DONE
[15:32:29.590]  - globals found/used: [n=1] 'FUN'
[15:32:29.591]  - needed namespaces: [n=0] 
[15:32:29.591] Finding globals ... DONE
[15:32:29.591]  - use_args: TRUE
[15:32:29.591]  - Getting '...' globals ...
[15:32:29.592] resolve() on list ...
[15:32:29.592]  recursive: 0
[15:32:29.593]  length: 1
[15:32:29.593]  elements: '...'
[15:32:29.593]  length: 0 (resolved future 1)
[15:32:29.594] resolve() on list ... DONE
[15:32:29.594]    - '...' content: [n=0] 
[15:32:29.594] List of 1
[15:32:29.594]  $ ...: list()
[15:32:29.594]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:29.594]  - attr(*, "where")=List of 1
[15:32:29.594]   ..$ ...:<environment: 0x00000276e5a96768> 
[15:32:29.594]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:29.594]  - attr(*, "resolved")= logi TRUE
[15:32:29.594]  - attr(*, "total_size")= num NA
[15:32:29.599]  - Getting '...' globals ... DONE
[15:32:29.600] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:29.600] List of 2
[15:32:29.600]  $ ...future.FUN:function (x)  
[15:32:29.600]  $ ...          : list()
[15:32:29.600]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:29.600]  - attr(*, "where")=List of 2
[15:32:29.600]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:29.600]   ..$ ...          :<environment: 0x00000276e5a96768> 
[15:32:29.600]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:29.600]  - attr(*, "resolved")= logi FALSE
[15:32:29.600]  - attr(*, "total_size")= num 848
[15:32:29.605] Packages to be attached in all futures: [n=0] 
[15:32:29.605] getGlobalsAndPackagesXApply() ... DONE
[15:32:29.606] Number of futures (= number of chunks): 2
[15:32:29.606] Launching 2 futures (chunks) ...
[15:32:29.606] Chunk #1 of 2 ...
[15:32:29.607]  - Finding globals in 'X' for chunk #1 ...
[15:32:29.607] getGlobalsAndPackages() ...
[15:32:29.607] Searching for globals...
[15:32:29.608] 
[15:32:29.608] Searching for globals ... DONE
[15:32:29.608] - globals: [0] <none>
[15:32:29.609] getGlobalsAndPackages() ... DONE
[15:32:29.609]    + additional globals found: [n=0] 
[15:32:29.609]    + additional namespaces needed: [n=0] 
[15:32:29.609]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:29.610]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:29.610]  - seeds: <none>
[15:32:29.610]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:29.611] getGlobalsAndPackages() ...
[15:32:29.611] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:29.611] Resolving globals: FALSE
[15:32:29.611] Tweak future expression to call with '...' arguments ...
[15:32:29.612] {
[15:32:29.612]     do.call(function(...) {
[15:32:29.612]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:29.612]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:29.612]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:29.612]             on.exit(options(oopts), add = TRUE)
[15:32:29.612]         }
[15:32:29.612]         {
[15:32:29.612]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:29.612]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:29.612]                 ...future.FUN(...future.X_jj, ...)
[15:32:29.612]             })
[15:32:29.612]         }
[15:32:29.612]     }, args = future.call.arguments)
[15:32:29.612] }
[15:32:29.613] Tweak future expression to call with '...' arguments ... DONE
[15:32:29.613] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:29.614] 
[15:32:29.614] getGlobalsAndPackages() ... DONE
[15:32:29.615] run() for 'Future' ...
[15:32:29.615] - state: 'created'
[15:32:29.615] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:29.631] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:29.632] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:29.632]   - Field: 'node'
[15:32:29.633]   - Field: 'label'
[15:32:29.633]   - Field: 'local'
[15:32:29.633]   - Field: 'owner'
[15:32:29.633]   - Field: 'envir'
[15:32:29.634]   - Field: 'workers'
[15:32:29.634]   - Field: 'packages'
[15:32:29.634]   - Field: 'gc'
[15:32:29.635]   - Field: 'conditions'
[15:32:29.635]   - Field: 'persistent'
[15:32:29.635]   - Field: 'expr'
[15:32:29.635]   - Field: 'uuid'
[15:32:29.636]   - Field: 'seed'
[15:32:29.636]   - Field: 'version'
[15:32:29.636]   - Field: 'result'
[15:32:29.637]   - Field: 'asynchronous'
[15:32:29.637]   - Field: 'calls'
[15:32:29.637]   - Field: 'globals'
[15:32:29.638]   - Field: 'stdout'
[15:32:29.638]   - Field: 'earlySignal'
[15:32:29.638]   - Field: 'lazy'
[15:32:29.638]   - Field: 'state'
[15:32:29.639] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:29.639] - Launch lazy future ...
[15:32:29.640] Packages needed by the future expression (n = 0): <none>
[15:32:29.640] Packages needed by future strategies (n = 0): <none>
[15:32:29.641] {
[15:32:29.641]     {
[15:32:29.641]         {
[15:32:29.641]             ...future.startTime <- base::Sys.time()
[15:32:29.641]             {
[15:32:29.641]                 {
[15:32:29.641]                   {
[15:32:29.641]                     {
[15:32:29.641]                       base::local({
[15:32:29.641]                         has_future <- base::requireNamespace("future", 
[15:32:29.641]                           quietly = TRUE)
[15:32:29.641]                         if (has_future) {
[15:32:29.641]                           ns <- base::getNamespace("future")
[15:32:29.641]                           version <- ns[[".package"]][["version"]]
[15:32:29.641]                           if (is.null(version)) 
[15:32:29.641]                             version <- utils::packageVersion("future")
[15:32:29.641]                         }
[15:32:29.641]                         else {
[15:32:29.641]                           version <- NULL
[15:32:29.641]                         }
[15:32:29.641]                         if (!has_future || version < "1.8.0") {
[15:32:29.641]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:29.641]                             "", base::R.version$version.string), 
[15:32:29.641]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:29.641]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:29.641]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:29.641]                               "release", "version")], collapse = " "), 
[15:32:29.641]                             hostname = base::Sys.info()[["nodename"]])
[15:32:29.641]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:29.641]                             info)
[15:32:29.641]                           info <- base::paste(info, collapse = "; ")
[15:32:29.641]                           if (!has_future) {
[15:32:29.641]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:29.641]                               info)
[15:32:29.641]                           }
[15:32:29.641]                           else {
[15:32:29.641]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:29.641]                               info, version)
[15:32:29.641]                           }
[15:32:29.641]                           base::stop(msg)
[15:32:29.641]                         }
[15:32:29.641]                       })
[15:32:29.641]                     }
[15:32:29.641]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:29.641]                     base::options(mc.cores = 1L)
[15:32:29.641]                   }
[15:32:29.641]                   ...future.strategy.old <- future::plan("list")
[15:32:29.641]                   options(future.plan = NULL)
[15:32:29.641]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:29.641]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:29.641]                 }
[15:32:29.641]                 ...future.workdir <- getwd()
[15:32:29.641]             }
[15:32:29.641]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:29.641]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:29.641]         }
[15:32:29.641]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:29.641]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:29.641]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:29.641]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:29.641]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:29.641]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:29.641]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:29.641]             base::names(...future.oldOptions))
[15:32:29.641]     }
[15:32:29.641]     if (FALSE) {
[15:32:29.641]     }
[15:32:29.641]     else {
[15:32:29.641]         if (TRUE) {
[15:32:29.641]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:29.641]                 open = "w")
[15:32:29.641]         }
[15:32:29.641]         else {
[15:32:29.641]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:29.641]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:29.641]         }
[15:32:29.641]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:29.641]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:29.641]             base::sink(type = "output", split = FALSE)
[15:32:29.641]             base::close(...future.stdout)
[15:32:29.641]         }, add = TRUE)
[15:32:29.641]     }
[15:32:29.641]     ...future.frame <- base::sys.nframe()
[15:32:29.641]     ...future.conditions <- base::list()
[15:32:29.641]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:29.641]     if (FALSE) {
[15:32:29.641]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:29.641]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:29.641]     }
[15:32:29.641]     ...future.result <- base::tryCatch({
[15:32:29.641]         base::withCallingHandlers({
[15:32:29.641]             ...future.value <- base::withVisible(base::local({
[15:32:29.641]                 ...future.makeSendCondition <- base::local({
[15:32:29.641]                   sendCondition <- NULL
[15:32:29.641]                   function(frame = 1L) {
[15:32:29.641]                     if (is.function(sendCondition)) 
[15:32:29.641]                       return(sendCondition)
[15:32:29.641]                     ns <- getNamespace("parallel")
[15:32:29.641]                     if (exists("sendData", mode = "function", 
[15:32:29.641]                       envir = ns)) {
[15:32:29.641]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:29.641]                         envir = ns)
[15:32:29.641]                       envir <- sys.frame(frame)
[15:32:29.641]                       master <- NULL
[15:32:29.641]                       while (!identical(envir, .GlobalEnv) && 
[15:32:29.641]                         !identical(envir, emptyenv())) {
[15:32:29.641]                         if (exists("master", mode = "list", envir = envir, 
[15:32:29.641]                           inherits = FALSE)) {
[15:32:29.641]                           master <- get("master", mode = "list", 
[15:32:29.641]                             envir = envir, inherits = FALSE)
[15:32:29.641]                           if (inherits(master, c("SOCKnode", 
[15:32:29.641]                             "SOCK0node"))) {
[15:32:29.641]                             sendCondition <<- function(cond) {
[15:32:29.641]                               data <- list(type = "VALUE", value = cond, 
[15:32:29.641]                                 success = TRUE)
[15:32:29.641]                               parallel_sendData(master, data)
[15:32:29.641]                             }
[15:32:29.641]                             return(sendCondition)
[15:32:29.641]                           }
[15:32:29.641]                         }
[15:32:29.641]                         frame <- frame + 1L
[15:32:29.641]                         envir <- sys.frame(frame)
[15:32:29.641]                       }
[15:32:29.641]                     }
[15:32:29.641]                     sendCondition <<- function(cond) NULL
[15:32:29.641]                   }
[15:32:29.641]                 })
[15:32:29.641]                 withCallingHandlers({
[15:32:29.641]                   {
[15:32:29.641]                     do.call(function(...) {
[15:32:29.641]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:29.641]                       if (!identical(...future.globals.maxSize.org, 
[15:32:29.641]                         ...future.globals.maxSize)) {
[15:32:29.641]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:29.641]                         on.exit(options(oopts), add = TRUE)
[15:32:29.641]                       }
[15:32:29.641]                       {
[15:32:29.641]                         lapply(seq_along(...future.elements_ii), 
[15:32:29.641]                           FUN = function(jj) {
[15:32:29.641]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:29.641]                             ...future.FUN(...future.X_jj, ...)
[15:32:29.641]                           })
[15:32:29.641]                       }
[15:32:29.641]                     }, args = future.call.arguments)
[15:32:29.641]                   }
[15:32:29.641]                 }, immediateCondition = function(cond) {
[15:32:29.641]                   sendCondition <- ...future.makeSendCondition()
[15:32:29.641]                   sendCondition(cond)
[15:32:29.641]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:29.641]                   {
[15:32:29.641]                     inherits <- base::inherits
[15:32:29.641]                     invokeRestart <- base::invokeRestart
[15:32:29.641]                     is.null <- base::is.null
[15:32:29.641]                     muffled <- FALSE
[15:32:29.641]                     if (inherits(cond, "message")) {
[15:32:29.641]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:29.641]                       if (muffled) 
[15:32:29.641]                         invokeRestart("muffleMessage")
[15:32:29.641]                     }
[15:32:29.641]                     else if (inherits(cond, "warning")) {
[15:32:29.641]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:29.641]                       if (muffled) 
[15:32:29.641]                         invokeRestart("muffleWarning")
[15:32:29.641]                     }
[15:32:29.641]                     else if (inherits(cond, "condition")) {
[15:32:29.641]                       if (!is.null(pattern)) {
[15:32:29.641]                         computeRestarts <- base::computeRestarts
[15:32:29.641]                         grepl <- base::grepl
[15:32:29.641]                         restarts <- computeRestarts(cond)
[15:32:29.641]                         for (restart in restarts) {
[15:32:29.641]                           name <- restart$name
[15:32:29.641]                           if (is.null(name)) 
[15:32:29.641]                             next
[15:32:29.641]                           if (!grepl(pattern, name)) 
[15:32:29.641]                             next
[15:32:29.641]                           invokeRestart(restart)
[15:32:29.641]                           muffled <- TRUE
[15:32:29.641]                           break
[15:32:29.641]                         }
[15:32:29.641]                       }
[15:32:29.641]                     }
[15:32:29.641]                     invisible(muffled)
[15:32:29.641]                   }
[15:32:29.641]                   muffleCondition(cond)
[15:32:29.641]                 })
[15:32:29.641]             }))
[15:32:29.641]             future::FutureResult(value = ...future.value$value, 
[15:32:29.641]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:29.641]                   ...future.rng), globalenv = if (FALSE) 
[15:32:29.641]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:29.641]                     ...future.globalenv.names))
[15:32:29.641]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:29.641]         }, condition = base::local({
[15:32:29.641]             c <- base::c
[15:32:29.641]             inherits <- base::inherits
[15:32:29.641]             invokeRestart <- base::invokeRestart
[15:32:29.641]             length <- base::length
[15:32:29.641]             list <- base::list
[15:32:29.641]             seq.int <- base::seq.int
[15:32:29.641]             signalCondition <- base::signalCondition
[15:32:29.641]             sys.calls <- base::sys.calls
[15:32:29.641]             `[[` <- base::`[[`
[15:32:29.641]             `+` <- base::`+`
[15:32:29.641]             `<<-` <- base::`<<-`
[15:32:29.641]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:29.641]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:29.641]                   3L)]
[15:32:29.641]             }
[15:32:29.641]             function(cond) {
[15:32:29.641]                 is_error <- inherits(cond, "error")
[15:32:29.641]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:29.641]                   NULL)
[15:32:29.641]                 if (is_error) {
[15:32:29.641]                   sessionInformation <- function() {
[15:32:29.641]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:29.641]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:29.641]                       search = base::search(), system = base::Sys.info())
[15:32:29.641]                   }
[15:32:29.641]                   ...future.conditions[[length(...future.conditions) + 
[15:32:29.641]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:29.641]                     cond$call), session = sessionInformation(), 
[15:32:29.641]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:29.641]                   signalCondition(cond)
[15:32:29.641]                 }
[15:32:29.641]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:29.641]                 "immediateCondition"))) {
[15:32:29.641]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:29.641]                   ...future.conditions[[length(...future.conditions) + 
[15:32:29.641]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:29.641]                   if (TRUE && !signal) {
[15:32:29.641]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:29.641]                     {
[15:32:29.641]                       inherits <- base::inherits
[15:32:29.641]                       invokeRestart <- base::invokeRestart
[15:32:29.641]                       is.null <- base::is.null
[15:32:29.641]                       muffled <- FALSE
[15:32:29.641]                       if (inherits(cond, "message")) {
[15:32:29.641]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:29.641]                         if (muffled) 
[15:32:29.641]                           invokeRestart("muffleMessage")
[15:32:29.641]                       }
[15:32:29.641]                       else if (inherits(cond, "warning")) {
[15:32:29.641]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:29.641]                         if (muffled) 
[15:32:29.641]                           invokeRestart("muffleWarning")
[15:32:29.641]                       }
[15:32:29.641]                       else if (inherits(cond, "condition")) {
[15:32:29.641]                         if (!is.null(pattern)) {
[15:32:29.641]                           computeRestarts <- base::computeRestarts
[15:32:29.641]                           grepl <- base::grepl
[15:32:29.641]                           restarts <- computeRestarts(cond)
[15:32:29.641]                           for (restart in restarts) {
[15:32:29.641]                             name <- restart$name
[15:32:29.641]                             if (is.null(name)) 
[15:32:29.641]                               next
[15:32:29.641]                             if (!grepl(pattern, name)) 
[15:32:29.641]                               next
[15:32:29.641]                             invokeRestart(restart)
[15:32:29.641]                             muffled <- TRUE
[15:32:29.641]                             break
[15:32:29.641]                           }
[15:32:29.641]                         }
[15:32:29.641]                       }
[15:32:29.641]                       invisible(muffled)
[15:32:29.641]                     }
[15:32:29.641]                     muffleCondition(cond, pattern = "^muffle")
[15:32:29.641]                   }
[15:32:29.641]                 }
[15:32:29.641]                 else {
[15:32:29.641]                   if (TRUE) {
[15:32:29.641]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:29.641]                     {
[15:32:29.641]                       inherits <- base::inherits
[15:32:29.641]                       invokeRestart <- base::invokeRestart
[15:32:29.641]                       is.null <- base::is.null
[15:32:29.641]                       muffled <- FALSE
[15:32:29.641]                       if (inherits(cond, "message")) {
[15:32:29.641]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:29.641]                         if (muffled) 
[15:32:29.641]                           invokeRestart("muffleMessage")
[15:32:29.641]                       }
[15:32:29.641]                       else if (inherits(cond, "warning")) {
[15:32:29.641]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:29.641]                         if (muffled) 
[15:32:29.641]                           invokeRestart("muffleWarning")
[15:32:29.641]                       }
[15:32:29.641]                       else if (inherits(cond, "condition")) {
[15:32:29.641]                         if (!is.null(pattern)) {
[15:32:29.641]                           computeRestarts <- base::computeRestarts
[15:32:29.641]                           grepl <- base::grepl
[15:32:29.641]                           restarts <- computeRestarts(cond)
[15:32:29.641]                           for (restart in restarts) {
[15:32:29.641]                             name <- restart$name
[15:32:29.641]                             if (is.null(name)) 
[15:32:29.641]                               next
[15:32:29.641]                             if (!grepl(pattern, name)) 
[15:32:29.641]                               next
[15:32:29.641]                             invokeRestart(restart)
[15:32:29.641]                             muffled <- TRUE
[15:32:29.641]                             break
[15:32:29.641]                           }
[15:32:29.641]                         }
[15:32:29.641]                       }
[15:32:29.641]                       invisible(muffled)
[15:32:29.641]                     }
[15:32:29.641]                     muffleCondition(cond, pattern = "^muffle")
[15:32:29.641]                   }
[15:32:29.641]                 }
[15:32:29.641]             }
[15:32:29.641]         }))
[15:32:29.641]     }, error = function(ex) {
[15:32:29.641]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:29.641]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:29.641]                 ...future.rng), started = ...future.startTime, 
[15:32:29.641]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:29.641]             version = "1.8"), class = "FutureResult")
[15:32:29.641]     }, finally = {
[15:32:29.641]         if (!identical(...future.workdir, getwd())) 
[15:32:29.641]             setwd(...future.workdir)
[15:32:29.641]         {
[15:32:29.641]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:29.641]                 ...future.oldOptions$nwarnings <- NULL
[15:32:29.641]             }
[15:32:29.641]             base::options(...future.oldOptions)
[15:32:29.641]             if (.Platform$OS.type == "windows") {
[15:32:29.641]                 old_names <- names(...future.oldEnvVars)
[15:32:29.641]                 envs <- base::Sys.getenv()
[15:32:29.641]                 names <- names(envs)
[15:32:29.641]                 common <- intersect(names, old_names)
[15:32:29.641]                 added <- setdiff(names, old_names)
[15:32:29.641]                 removed <- setdiff(old_names, names)
[15:32:29.641]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:29.641]                   envs[common]]
[15:32:29.641]                 NAMES <- toupper(changed)
[15:32:29.641]                 args <- list()
[15:32:29.641]                 for (kk in seq_along(NAMES)) {
[15:32:29.641]                   name <- changed[[kk]]
[15:32:29.641]                   NAME <- NAMES[[kk]]
[15:32:29.641]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:29.641]                     next
[15:32:29.641]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:29.641]                 }
[15:32:29.641]                 NAMES <- toupper(added)
[15:32:29.641]                 for (kk in seq_along(NAMES)) {
[15:32:29.641]                   name <- added[[kk]]
[15:32:29.641]                   NAME <- NAMES[[kk]]
[15:32:29.641]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:29.641]                     next
[15:32:29.641]                   args[[name]] <- ""
[15:32:29.641]                 }
[15:32:29.641]                 NAMES <- toupper(removed)
[15:32:29.641]                 for (kk in seq_along(NAMES)) {
[15:32:29.641]                   name <- removed[[kk]]
[15:32:29.641]                   NAME <- NAMES[[kk]]
[15:32:29.641]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:29.641]                     next
[15:32:29.641]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:29.641]                 }
[15:32:29.641]                 if (length(args) > 0) 
[15:32:29.641]                   base::do.call(base::Sys.setenv, args = args)
[15:32:29.641]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:29.641]             }
[15:32:29.641]             else {
[15:32:29.641]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:29.641]             }
[15:32:29.641]             {
[15:32:29.641]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:29.641]                   0L) {
[15:32:29.641]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:29.641]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:29.641]                   base::options(opts)
[15:32:29.641]                 }
[15:32:29.641]                 {
[15:32:29.641]                   {
[15:32:29.641]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:29.641]                     NULL
[15:32:29.641]                   }
[15:32:29.641]                   options(future.plan = NULL)
[15:32:29.641]                   if (is.na(NA_character_)) 
[15:32:29.641]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:29.641]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:29.641]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:29.641]                     .init = FALSE)
[15:32:29.641]                 }
[15:32:29.641]             }
[15:32:29.641]         }
[15:32:29.641]     })
[15:32:29.641]     if (TRUE) {
[15:32:29.641]         base::sink(type = "output", split = FALSE)
[15:32:29.641]         if (TRUE) {
[15:32:29.641]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:29.641]         }
[15:32:29.641]         else {
[15:32:29.641]             ...future.result["stdout"] <- base::list(NULL)
[15:32:29.641]         }
[15:32:29.641]         base::close(...future.stdout)
[15:32:29.641]         ...future.stdout <- NULL
[15:32:29.641]     }
[15:32:29.641]     ...future.result$conditions <- ...future.conditions
[15:32:29.641]     ...future.result$finished <- base::Sys.time()
[15:32:29.641]     ...future.result
[15:32:29.641] }
[15:32:29.649] Exporting 5 global objects (848 bytes) to cluster node #1 ...
[15:32:29.649] Exporting '...future.FUN' (848 bytes) to cluster node #1 ...
[15:32:29.650] Exporting '...future.FUN' (848 bytes) to cluster node #1 ... DONE
[15:32:29.651] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:29.652] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:29.652] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ...
[15:32:29.653] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ... DONE
[15:32:29.653] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:29.654] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:29.655] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:29.655] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:29.656] Exporting 5 global objects (848 bytes) to cluster node #1 ... DONE
[15:32:29.657] MultisessionFuture started
[15:32:29.657] - Launch lazy future ... done
[15:32:29.657] run() for 'MultisessionFuture' ... done
[15:32:29.658] Created future:
[15:32:29.686] receiveMessageFromWorker() for ClusterFuture ...
[15:32:29.687] - Validating connection of MultisessionFuture
[15:32:29.687] - received message: FutureResult
[15:32:29.688] - Received FutureResult
[15:32:29.688] - Erased future from FutureRegistry
[15:32:29.688] result() for ClusterFuture ...
[15:32:29.688] - result already collected: FutureResult
[15:32:29.689] result() for ClusterFuture ... done
[15:32:29.689] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:29.658] MultisessionFuture:
[15:32:29.658] Label: 'future_sapply-1'
[15:32:29.658] Expression:
[15:32:29.658] {
[15:32:29.658]     do.call(function(...) {
[15:32:29.658]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:29.658]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:29.658]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:29.658]             on.exit(options(oopts), add = TRUE)
[15:32:29.658]         }
[15:32:29.658]         {
[15:32:29.658]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:29.658]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:29.658]                 ...future.FUN(...future.X_jj, ...)
[15:32:29.658]             })
[15:32:29.658]         }
[15:32:29.658]     }, args = future.call.arguments)
[15:32:29.658] }
[15:32:29.658] Lazy evaluation: FALSE
[15:32:29.658] Asynchronous evaluation: TRUE
[15:32:29.658] Local evaluation: TRUE
[15:32:29.658] Environment: R_GlobalEnv
[15:32:29.658] Capture standard output: TRUE
[15:32:29.658] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:29.658] Globals: 5 objects totaling 904 bytes (function '...future.FUN' of 848 bytes, 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)
[15:32:29.658] Packages: <none>
[15:32:29.658] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:29.658] Resolved: TRUE
[15:32:29.658] Value: <not collected>
[15:32:29.658] Conditions captured: <none>
[15:32:29.658] Early signaling: FALSE
[15:32:29.658] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:29.658] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:29.690] Chunk #1 of 2 ... DONE
[15:32:29.690] Chunk #2 of 2 ...
[15:32:29.690]  - Finding globals in 'X' for chunk #2 ...
[15:32:29.691] getGlobalsAndPackages() ...
[15:32:29.691] Searching for globals...
[15:32:29.691] 
[15:32:29.692] Searching for globals ... DONE
[15:32:29.692] - globals: [0] <none>
[15:32:29.692] getGlobalsAndPackages() ... DONE
[15:32:29.692]    + additional globals found: [n=0] 
[15:32:29.693]    + additional namespaces needed: [n=0] 
[15:32:29.693]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:29.693]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:29.693]  - seeds: <none>
[15:32:29.694]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:29.694] getGlobalsAndPackages() ...
[15:32:29.694] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:29.694] Resolving globals: FALSE
[15:32:29.695] Tweak future expression to call with '...' arguments ...
[15:32:29.695] {
[15:32:29.695]     do.call(function(...) {
[15:32:29.695]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:29.695]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:29.695]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:29.695]             on.exit(options(oopts), add = TRUE)
[15:32:29.695]         }
[15:32:29.695]         {
[15:32:29.695]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:29.695]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:29.695]                 ...future.FUN(...future.X_jj, ...)
[15:32:29.695]             })
[15:32:29.695]         }
[15:32:29.695]     }, args = future.call.arguments)
[15:32:29.695] }
[15:32:29.696] Tweak future expression to call with '...' arguments ... DONE
[15:32:29.696] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:29.697] 
[15:32:29.697] getGlobalsAndPackages() ... DONE
[15:32:29.697] run() for 'Future' ...
[15:32:29.698] - state: 'created'
[15:32:29.698] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:29.714] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:29.714] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:29.715]   - Field: 'node'
[15:32:29.715]   - Field: 'label'
[15:32:29.715]   - Field: 'local'
[15:32:29.715]   - Field: 'owner'
[15:32:29.716]   - Field: 'envir'
[15:32:29.716]   - Field: 'workers'
[15:32:29.716]   - Field: 'packages'
[15:32:29.716]   - Field: 'gc'
[15:32:29.717]   - Field: 'conditions'
[15:32:29.717]   - Field: 'persistent'
[15:32:29.717]   - Field: 'expr'
[15:32:29.717]   - Field: 'uuid'
[15:32:29.718]   - Field: 'seed'
[15:32:29.718]   - Field: 'version'
[15:32:29.718]   - Field: 'result'
[15:32:29.718]   - Field: 'asynchronous'
[15:32:29.721]   - Field: 'calls'
[15:32:29.722]   - Field: 'globals'
[15:32:29.722]   - Field: 'stdout'
[15:32:29.722]   - Field: 'earlySignal'
[15:32:29.722]   - Field: 'lazy'
[15:32:29.722]   - Field: 'state'
[15:32:29.722] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:29.722] - Launch lazy future ...
[15:32:29.723] Packages needed by the future expression (n = 0): <none>
[15:32:29.723] Packages needed by future strategies (n = 0): <none>
[15:32:29.724] {
[15:32:29.724]     {
[15:32:29.724]         {
[15:32:29.724]             ...future.startTime <- base::Sys.time()
[15:32:29.724]             {
[15:32:29.724]                 {
[15:32:29.724]                   {
[15:32:29.724]                     {
[15:32:29.724]                       base::local({
[15:32:29.724]                         has_future <- base::requireNamespace("future", 
[15:32:29.724]                           quietly = TRUE)
[15:32:29.724]                         if (has_future) {
[15:32:29.724]                           ns <- base::getNamespace("future")
[15:32:29.724]                           version <- ns[[".package"]][["version"]]
[15:32:29.724]                           if (is.null(version)) 
[15:32:29.724]                             version <- utils::packageVersion("future")
[15:32:29.724]                         }
[15:32:29.724]                         else {
[15:32:29.724]                           version <- NULL
[15:32:29.724]                         }
[15:32:29.724]                         if (!has_future || version < "1.8.0") {
[15:32:29.724]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:29.724]                             "", base::R.version$version.string), 
[15:32:29.724]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:29.724]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:29.724]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:29.724]                               "release", "version")], collapse = " "), 
[15:32:29.724]                             hostname = base::Sys.info()[["nodename"]])
[15:32:29.724]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:29.724]                             info)
[15:32:29.724]                           info <- base::paste(info, collapse = "; ")
[15:32:29.724]                           if (!has_future) {
[15:32:29.724]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:29.724]                               info)
[15:32:29.724]                           }
[15:32:29.724]                           else {
[15:32:29.724]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:29.724]                               info, version)
[15:32:29.724]                           }
[15:32:29.724]                           base::stop(msg)
[15:32:29.724]                         }
[15:32:29.724]                       })
[15:32:29.724]                     }
[15:32:29.724]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:29.724]                     base::options(mc.cores = 1L)
[15:32:29.724]                   }
[15:32:29.724]                   ...future.strategy.old <- future::plan("list")
[15:32:29.724]                   options(future.plan = NULL)
[15:32:29.724]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:29.724]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:29.724]                 }
[15:32:29.724]                 ...future.workdir <- getwd()
[15:32:29.724]             }
[15:32:29.724]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:29.724]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:29.724]         }
[15:32:29.724]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:29.724]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:29.724]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:29.724]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:29.724]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:29.724]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:29.724]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:29.724]             base::names(...future.oldOptions))
[15:32:29.724]     }
[15:32:29.724]     if (FALSE) {
[15:32:29.724]     }
[15:32:29.724]     else {
[15:32:29.724]         if (TRUE) {
[15:32:29.724]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:29.724]                 open = "w")
[15:32:29.724]         }
[15:32:29.724]         else {
[15:32:29.724]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:29.724]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:29.724]         }
[15:32:29.724]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:29.724]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:29.724]             base::sink(type = "output", split = FALSE)
[15:32:29.724]             base::close(...future.stdout)
[15:32:29.724]         }, add = TRUE)
[15:32:29.724]     }
[15:32:29.724]     ...future.frame <- base::sys.nframe()
[15:32:29.724]     ...future.conditions <- base::list()
[15:32:29.724]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:29.724]     if (FALSE) {
[15:32:29.724]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:29.724]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:29.724]     }
[15:32:29.724]     ...future.result <- base::tryCatch({
[15:32:29.724]         base::withCallingHandlers({
[15:32:29.724]             ...future.value <- base::withVisible(base::local({
[15:32:29.724]                 ...future.makeSendCondition <- base::local({
[15:32:29.724]                   sendCondition <- NULL
[15:32:29.724]                   function(frame = 1L) {
[15:32:29.724]                     if (is.function(sendCondition)) 
[15:32:29.724]                       return(sendCondition)
[15:32:29.724]                     ns <- getNamespace("parallel")
[15:32:29.724]                     if (exists("sendData", mode = "function", 
[15:32:29.724]                       envir = ns)) {
[15:32:29.724]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:29.724]                         envir = ns)
[15:32:29.724]                       envir <- sys.frame(frame)
[15:32:29.724]                       master <- NULL
[15:32:29.724]                       while (!identical(envir, .GlobalEnv) && 
[15:32:29.724]                         !identical(envir, emptyenv())) {
[15:32:29.724]                         if (exists("master", mode = "list", envir = envir, 
[15:32:29.724]                           inherits = FALSE)) {
[15:32:29.724]                           master <- get("master", mode = "list", 
[15:32:29.724]                             envir = envir, inherits = FALSE)
[15:32:29.724]                           if (inherits(master, c("SOCKnode", 
[15:32:29.724]                             "SOCK0node"))) {
[15:32:29.724]                             sendCondition <<- function(cond) {
[15:32:29.724]                               data <- list(type = "VALUE", value = cond, 
[15:32:29.724]                                 success = TRUE)
[15:32:29.724]                               parallel_sendData(master, data)
[15:32:29.724]                             }
[15:32:29.724]                             return(sendCondition)
[15:32:29.724]                           }
[15:32:29.724]                         }
[15:32:29.724]                         frame <- frame + 1L
[15:32:29.724]                         envir <- sys.frame(frame)
[15:32:29.724]                       }
[15:32:29.724]                     }
[15:32:29.724]                     sendCondition <<- function(cond) NULL
[15:32:29.724]                   }
[15:32:29.724]                 })
[15:32:29.724]                 withCallingHandlers({
[15:32:29.724]                   {
[15:32:29.724]                     do.call(function(...) {
[15:32:29.724]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:29.724]                       if (!identical(...future.globals.maxSize.org, 
[15:32:29.724]                         ...future.globals.maxSize)) {
[15:32:29.724]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:29.724]                         on.exit(options(oopts), add = TRUE)
[15:32:29.724]                       }
[15:32:29.724]                       {
[15:32:29.724]                         lapply(seq_along(...future.elements_ii), 
[15:32:29.724]                           FUN = function(jj) {
[15:32:29.724]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:29.724]                             ...future.FUN(...future.X_jj, ...)
[15:32:29.724]                           })
[15:32:29.724]                       }
[15:32:29.724]                     }, args = future.call.arguments)
[15:32:29.724]                   }
[15:32:29.724]                 }, immediateCondition = function(cond) {
[15:32:29.724]                   sendCondition <- ...future.makeSendCondition()
[15:32:29.724]                   sendCondition(cond)
[15:32:29.724]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:29.724]                   {
[15:32:29.724]                     inherits <- base::inherits
[15:32:29.724]                     invokeRestart <- base::invokeRestart
[15:32:29.724]                     is.null <- base::is.null
[15:32:29.724]                     muffled <- FALSE
[15:32:29.724]                     if (inherits(cond, "message")) {
[15:32:29.724]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:29.724]                       if (muffled) 
[15:32:29.724]                         invokeRestart("muffleMessage")
[15:32:29.724]                     }
[15:32:29.724]                     else if (inherits(cond, "warning")) {
[15:32:29.724]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:29.724]                       if (muffled) 
[15:32:29.724]                         invokeRestart("muffleWarning")
[15:32:29.724]                     }
[15:32:29.724]                     else if (inherits(cond, "condition")) {
[15:32:29.724]                       if (!is.null(pattern)) {
[15:32:29.724]                         computeRestarts <- base::computeRestarts
[15:32:29.724]                         grepl <- base::grepl
[15:32:29.724]                         restarts <- computeRestarts(cond)
[15:32:29.724]                         for (restart in restarts) {
[15:32:29.724]                           name <- restart$name
[15:32:29.724]                           if (is.null(name)) 
[15:32:29.724]                             next
[15:32:29.724]                           if (!grepl(pattern, name)) 
[15:32:29.724]                             next
[15:32:29.724]                           invokeRestart(restart)
[15:32:29.724]                           muffled <- TRUE
[15:32:29.724]                           break
[15:32:29.724]                         }
[15:32:29.724]                       }
[15:32:29.724]                     }
[15:32:29.724]                     invisible(muffled)
[15:32:29.724]                   }
[15:32:29.724]                   muffleCondition(cond)
[15:32:29.724]                 })
[15:32:29.724]             }))
[15:32:29.724]             future::FutureResult(value = ...future.value$value, 
[15:32:29.724]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:29.724]                   ...future.rng), globalenv = if (FALSE) 
[15:32:29.724]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:29.724]                     ...future.globalenv.names))
[15:32:29.724]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:29.724]         }, condition = base::local({
[15:32:29.724]             c <- base::c
[15:32:29.724]             inherits <- base::inherits
[15:32:29.724]             invokeRestart <- base::invokeRestart
[15:32:29.724]             length <- base::length
[15:32:29.724]             list <- base::list
[15:32:29.724]             seq.int <- base::seq.int
[15:32:29.724]             signalCondition <- base::signalCondition
[15:32:29.724]             sys.calls <- base::sys.calls
[15:32:29.724]             `[[` <- base::`[[`
[15:32:29.724]             `+` <- base::`+`
[15:32:29.724]             `<<-` <- base::`<<-`
[15:32:29.724]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:29.724]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:29.724]                   3L)]
[15:32:29.724]             }
[15:32:29.724]             function(cond) {
[15:32:29.724]                 is_error <- inherits(cond, "error")
[15:32:29.724]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:29.724]                   NULL)
[15:32:29.724]                 if (is_error) {
[15:32:29.724]                   sessionInformation <- function() {
[15:32:29.724]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:29.724]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:29.724]                       search = base::search(), system = base::Sys.info())
[15:32:29.724]                   }
[15:32:29.724]                   ...future.conditions[[length(...future.conditions) + 
[15:32:29.724]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:29.724]                     cond$call), session = sessionInformation(), 
[15:32:29.724]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:29.724]                   signalCondition(cond)
[15:32:29.724]                 }
[15:32:29.724]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:29.724]                 "immediateCondition"))) {
[15:32:29.724]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:29.724]                   ...future.conditions[[length(...future.conditions) + 
[15:32:29.724]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:29.724]                   if (TRUE && !signal) {
[15:32:29.724]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:29.724]                     {
[15:32:29.724]                       inherits <- base::inherits
[15:32:29.724]                       invokeRestart <- base::invokeRestart
[15:32:29.724]                       is.null <- base::is.null
[15:32:29.724]                       muffled <- FALSE
[15:32:29.724]                       if (inherits(cond, "message")) {
[15:32:29.724]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:29.724]                         if (muffled) 
[15:32:29.724]                           invokeRestart("muffleMessage")
[15:32:29.724]                       }
[15:32:29.724]                       else if (inherits(cond, "warning")) {
[15:32:29.724]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:29.724]                         if (muffled) 
[15:32:29.724]                           invokeRestart("muffleWarning")
[15:32:29.724]                       }
[15:32:29.724]                       else if (inherits(cond, "condition")) {
[15:32:29.724]                         if (!is.null(pattern)) {
[15:32:29.724]                           computeRestarts <- base::computeRestarts
[15:32:29.724]                           grepl <- base::grepl
[15:32:29.724]                           restarts <- computeRestarts(cond)
[15:32:29.724]                           for (restart in restarts) {
[15:32:29.724]                             name <- restart$name
[15:32:29.724]                             if (is.null(name)) 
[15:32:29.724]                               next
[15:32:29.724]                             if (!grepl(pattern, name)) 
[15:32:29.724]                               next
[15:32:29.724]                             invokeRestart(restart)
[15:32:29.724]                             muffled <- TRUE
[15:32:29.724]                             break
[15:32:29.724]                           }
[15:32:29.724]                         }
[15:32:29.724]                       }
[15:32:29.724]                       invisible(muffled)
[15:32:29.724]                     }
[15:32:29.724]                     muffleCondition(cond, pattern = "^muffle")
[15:32:29.724]                   }
[15:32:29.724]                 }
[15:32:29.724]                 else {
[15:32:29.724]                   if (TRUE) {
[15:32:29.724]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:29.724]                     {
[15:32:29.724]                       inherits <- base::inherits
[15:32:29.724]                       invokeRestart <- base::invokeRestart
[15:32:29.724]                       is.null <- base::is.null
[15:32:29.724]                       muffled <- FALSE
[15:32:29.724]                       if (inherits(cond, "message")) {
[15:32:29.724]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:29.724]                         if (muffled) 
[15:32:29.724]                           invokeRestart("muffleMessage")
[15:32:29.724]                       }
[15:32:29.724]                       else if (inherits(cond, "warning")) {
[15:32:29.724]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:29.724]                         if (muffled) 
[15:32:29.724]                           invokeRestart("muffleWarning")
[15:32:29.724]                       }
[15:32:29.724]                       else if (inherits(cond, "condition")) {
[15:32:29.724]                         if (!is.null(pattern)) {
[15:32:29.724]                           computeRestarts <- base::computeRestarts
[15:32:29.724]                           grepl <- base::grepl
[15:32:29.724]                           restarts <- computeRestarts(cond)
[15:32:29.724]                           for (restart in restarts) {
[15:32:29.724]                             name <- restart$name
[15:32:29.724]                             if (is.null(name)) 
[15:32:29.724]                               next
[15:32:29.724]                             if (!grepl(pattern, name)) 
[15:32:29.724]                               next
[15:32:29.724]                             invokeRestart(restart)
[15:32:29.724]                             muffled <- TRUE
[15:32:29.724]                             break
[15:32:29.724]                           }
[15:32:29.724]                         }
[15:32:29.724]                       }
[15:32:29.724]                       invisible(muffled)
[15:32:29.724]                     }
[15:32:29.724]                     muffleCondition(cond, pattern = "^muffle")
[15:32:29.724]                   }
[15:32:29.724]                 }
[15:32:29.724]             }
[15:32:29.724]         }))
[15:32:29.724]     }, error = function(ex) {
[15:32:29.724]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:29.724]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:29.724]                 ...future.rng), started = ...future.startTime, 
[15:32:29.724]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:29.724]             version = "1.8"), class = "FutureResult")
[15:32:29.724]     }, finally = {
[15:32:29.724]         if (!identical(...future.workdir, getwd())) 
[15:32:29.724]             setwd(...future.workdir)
[15:32:29.724]         {
[15:32:29.724]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:29.724]                 ...future.oldOptions$nwarnings <- NULL
[15:32:29.724]             }
[15:32:29.724]             base::options(...future.oldOptions)
[15:32:29.724]             if (.Platform$OS.type == "windows") {
[15:32:29.724]                 old_names <- names(...future.oldEnvVars)
[15:32:29.724]                 envs <- base::Sys.getenv()
[15:32:29.724]                 names <- names(envs)
[15:32:29.724]                 common <- intersect(names, old_names)
[15:32:29.724]                 added <- setdiff(names, old_names)
[15:32:29.724]                 removed <- setdiff(old_names, names)
[15:32:29.724]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:29.724]                   envs[common]]
[15:32:29.724]                 NAMES <- toupper(changed)
[15:32:29.724]                 args <- list()
[15:32:29.724]                 for (kk in seq_along(NAMES)) {
[15:32:29.724]                   name <- changed[[kk]]
[15:32:29.724]                   NAME <- NAMES[[kk]]
[15:32:29.724]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:29.724]                     next
[15:32:29.724]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:29.724]                 }
[15:32:29.724]                 NAMES <- toupper(added)
[15:32:29.724]                 for (kk in seq_along(NAMES)) {
[15:32:29.724]                   name <- added[[kk]]
[15:32:29.724]                   NAME <- NAMES[[kk]]
[15:32:29.724]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:29.724]                     next
[15:32:29.724]                   args[[name]] <- ""
[15:32:29.724]                 }
[15:32:29.724]                 NAMES <- toupper(removed)
[15:32:29.724]                 for (kk in seq_along(NAMES)) {
[15:32:29.724]                   name <- removed[[kk]]
[15:32:29.724]                   NAME <- NAMES[[kk]]
[15:32:29.724]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:29.724]                     next
[15:32:29.724]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:29.724]                 }
[15:32:29.724]                 if (length(args) > 0) 
[15:32:29.724]                   base::do.call(base::Sys.setenv, args = args)
[15:32:29.724]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:29.724]             }
[15:32:29.724]             else {
[15:32:29.724]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:29.724]             }
[15:32:29.724]             {
[15:32:29.724]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:29.724]                   0L) {
[15:32:29.724]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:29.724]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:29.724]                   base::options(opts)
[15:32:29.724]                 }
[15:32:29.724]                 {
[15:32:29.724]                   {
[15:32:29.724]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:29.724]                     NULL
[15:32:29.724]                   }
[15:32:29.724]                   options(future.plan = NULL)
[15:32:29.724]                   if (is.na(NA_character_)) 
[15:32:29.724]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:29.724]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:29.724]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:29.724]                     .init = FALSE)
[15:32:29.724]                 }
[15:32:29.724]             }
[15:32:29.724]         }
[15:32:29.724]     })
[15:32:29.724]     if (TRUE) {
[15:32:29.724]         base::sink(type = "output", split = FALSE)
[15:32:29.724]         if (TRUE) {
[15:32:29.724]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:29.724]         }
[15:32:29.724]         else {
[15:32:29.724]             ...future.result["stdout"] <- base::list(NULL)
[15:32:29.724]         }
[15:32:29.724]         base::close(...future.stdout)
[15:32:29.724]         ...future.stdout <- NULL
[15:32:29.724]     }
[15:32:29.724]     ...future.result$conditions <- ...future.conditions
[15:32:29.724]     ...future.result$finished <- base::Sys.time()
[15:32:29.724]     ...future.result
[15:32:29.724] }
[15:32:29.731] Exporting 5 global objects (848 bytes) to cluster node #1 ...
[15:32:29.732] Exporting '...future.FUN' (848 bytes) to cluster node #1 ...
[15:32:29.733] Exporting '...future.FUN' (848 bytes) to cluster node #1 ... DONE
[15:32:29.733] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:29.734] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:29.734] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:29.735] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:29.735] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:29.736] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:29.736] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:29.736] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:29.737] Exporting 5 global objects (848 bytes) to cluster node #1 ... DONE
[15:32:29.737] MultisessionFuture started
[15:32:29.738] - Launch lazy future ... done
[15:32:29.738] run() for 'MultisessionFuture' ... done
[15:32:29.738] Created future:
[15:32:29.763] receiveMessageFromWorker() for ClusterFuture ...
[15:32:29.763] - Validating connection of MultisessionFuture
[15:32:29.764] - received message: FutureResult
[15:32:29.764] - Received FutureResult
[15:32:29.764] - Erased future from FutureRegistry
[15:32:29.765] result() for ClusterFuture ...
[15:32:29.765] - result already collected: FutureResult
[15:32:29.765] result() for ClusterFuture ... done
[15:32:29.765] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:29.738] MultisessionFuture:
[15:32:29.738] Label: 'future_sapply-2'
[15:32:29.738] Expression:
[15:32:29.738] {
[15:32:29.738]     do.call(function(...) {
[15:32:29.738]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:29.738]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:29.738]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:29.738]             on.exit(options(oopts), add = TRUE)
[15:32:29.738]         }
[15:32:29.738]         {
[15:32:29.738]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:29.738]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:29.738]                 ...future.FUN(...future.X_jj, ...)
[15:32:29.738]             })
[15:32:29.738]         }
[15:32:29.738]     }, args = future.call.arguments)
[15:32:29.738] }
[15:32:29.738] Lazy evaluation: FALSE
[15:32:29.738] Asynchronous evaluation: TRUE
[15:32:29.738] Local evaluation: TRUE
[15:32:29.738] Environment: R_GlobalEnv
[15:32:29.738] Capture standard output: TRUE
[15:32:29.738] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:29.738] Globals: 5 objects totaling 960 bytes (function '...future.FUN' of 848 bytes, 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)
[15:32:29.738] Packages: <none>
[15:32:29.738] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:29.738] Resolved: TRUE
[15:32:29.738] Value: <not collected>
[15:32:29.738] Conditions captured: <none>
[15:32:29.738] Early signaling: FALSE
[15:32:29.738] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:29.738] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:29.766] Chunk #2 of 2 ... DONE
[15:32:29.766] Launching 2 futures (chunks) ... DONE
[15:32:29.766] Resolving 2 futures (chunks) ...
[15:32:29.767] resolve() on list ...
[15:32:29.767]  recursive: 0
[15:32:29.767]  length: 2
[15:32:29.767] 
[15:32:29.768] Future #1
[15:32:29.768] result() for ClusterFuture ...
[15:32:29.768] - result already collected: FutureResult
[15:32:29.768] result() for ClusterFuture ... done
[15:32:29.769] result() for ClusterFuture ...
[15:32:29.769] - result already collected: FutureResult
[15:32:29.769] result() for ClusterFuture ... done
[15:32:29.769] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:29.770] - nx: 2
[15:32:29.770] - relay: TRUE
[15:32:29.770] - stdout: TRUE
[15:32:29.770] - signal: TRUE
[15:32:29.770] - resignal: FALSE
[15:32:29.771] - force: TRUE
[15:32:29.771] - relayed: [n=2] FALSE, FALSE
[15:32:29.771] - queued futures: [n=2] FALSE, FALSE
[15:32:29.771]  - until=1
[15:32:29.772]  - relaying element #1
[15:32:29.772] result() for ClusterFuture ...
[15:32:29.772] - result already collected: FutureResult
[15:32:29.772] result() for ClusterFuture ... done
[15:32:29.773] result() for ClusterFuture ...
[15:32:29.773] - result already collected: FutureResult
[15:32:29.773] result() for ClusterFuture ... done
[15:32:29.773] result() for ClusterFuture ...
[15:32:29.774] - result already collected: FutureResult
[15:32:29.774] result() for ClusterFuture ... done
[15:32:29.774] result() for ClusterFuture ...
[15:32:29.774] - result already collected: FutureResult
[15:32:29.774] result() for ClusterFuture ... done
[15:32:29.775] - relayed: [n=2] TRUE, FALSE
[15:32:29.775] - queued futures: [n=2] TRUE, FALSE
[15:32:29.775] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:29.775]  length: 1 (resolved future 1)
[15:32:29.776] Future #2
[15:32:29.776] result() for ClusterFuture ...
[15:32:29.776] - result already collected: FutureResult
[15:32:29.776] result() for ClusterFuture ... done
[15:32:29.777] result() for ClusterFuture ...
[15:32:29.777] - result already collected: FutureResult
[15:32:29.777] result() for ClusterFuture ... done
[15:32:29.777] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:29.778] - nx: 2
[15:32:29.778] - relay: TRUE
[15:32:29.778] - stdout: TRUE
[15:32:29.778] - signal: TRUE
[15:32:29.778] - resignal: FALSE
[15:32:29.779] - force: TRUE
[15:32:29.779] - relayed: [n=2] TRUE, FALSE
[15:32:29.779] - queued futures: [n=2] TRUE, FALSE
[15:32:29.779]  - until=2
[15:32:29.780]  - relaying element #2
[15:32:29.780] result() for ClusterFuture ...
[15:32:29.780] - result already collected: FutureResult
[15:32:29.780] result() for ClusterFuture ... done
[15:32:29.780] result() for ClusterFuture ...
[15:32:29.781] - result already collected: FutureResult
[15:32:29.781] result() for ClusterFuture ... done
[15:32:29.781] result() for ClusterFuture ...
[15:32:29.781] - result already collected: FutureResult
[15:32:29.782] result() for ClusterFuture ... done
[15:32:29.782] result() for ClusterFuture ...
[15:32:29.782] - result already collected: FutureResult
[15:32:29.782] result() for ClusterFuture ... done
[15:32:29.783] - relayed: [n=2] TRUE, TRUE
[15:32:29.783] - queued futures: [n=2] TRUE, TRUE
[15:32:29.783] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:29.783]  length: 0 (resolved future 2)
[15:32:29.784] Relaying remaining futures
[15:32:29.784] signalConditionsASAP(NULL, pos=0) ...
[15:32:29.784] - nx: 2
[15:32:29.784] - relay: TRUE
[15:32:29.784] - stdout: TRUE
[15:32:29.785] - signal: TRUE
[15:32:29.785] - resignal: FALSE
[15:32:29.785] - force: TRUE
[15:32:29.785] - relayed: [n=2] TRUE, TRUE
[15:32:29.785] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:29.786] - relayed: [n=2] TRUE, TRUE
[15:32:29.786] - queued futures: [n=2] TRUE, TRUE
[15:32:29.786] signalConditionsASAP(NULL, pos=0) ... done
[15:32:29.787] resolve() on list ... DONE
[15:32:29.787] result() for ClusterFuture ...
[15:32:29.787] - result already collected: FutureResult
[15:32:29.787] result() for ClusterFuture ... done
[15:32:29.787] result() for ClusterFuture ...
[15:32:29.788] - result already collected: FutureResult
[15:32:29.788] result() for ClusterFuture ... done
[15:32:29.788] result() for ClusterFuture ...
[15:32:29.788] - result already collected: FutureResult
[15:32:29.789] result() for ClusterFuture ... done
[15:32:29.789] result() for ClusterFuture ...
[15:32:29.789] - result already collected: FutureResult
[15:32:29.789] result() for ClusterFuture ... done
[15:32:29.790]  - Number of value chunks collected: 2
[15:32:29.790] Resolving 2 futures (chunks) ... DONE
[15:32:29.790] Reducing values from 2 chunks ...
[15:32:29.790]  - Number of values collected after concatenation: 3
[15:32:29.791]  - Number of values expected: 3
[15:32:29.791] Reducing values from 2 chunks ... DONE
[15:32:29.791] future_lapply() ... DONE
List of 2
 $ y0: Named num [1:3] 1 2 3
  ..- attr(*, "names")= chr [1:3] "a" "b" "c"
 $ y1: Named num [1:3] 1 2 3
  ..- attr(*, "names")= chr [1:3] "a" "b" "c"
[15:32:29.794] future_lapply() ...
[15:32:29.798] Number of chunks: 2
[15:32:29.799] getGlobalsAndPackagesXApply() ...
[15:32:29.799]  - future.globals: TRUE
[15:32:29.799] getGlobalsAndPackages() ...
[15:32:29.799] Searching for globals...
[15:32:29.801] - globals found: [2] 'FUN', 'UseMethod'
[15:32:29.801] Searching for globals ... DONE
[15:32:29.802] Resolving globals: FALSE
[15:32:29.802] The total size of the 1 globals is 1.22 KiB (1248 bytes)
[15:32:29.803] The total size of the 1 globals exported for future expression ('FUN()') is 1.22 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.22 KiB of class 'function')
[15:32:29.803] - globals: [1] 'FUN'
[15:32:29.804] 
[15:32:29.804] getGlobalsAndPackages() ... DONE
[15:32:29.804]  - globals found/used: [n=1] 'FUN'
[15:32:29.804]  - needed namespaces: [n=0] 
[15:32:29.804] Finding globals ... DONE
[15:32:29.805]  - use_args: TRUE
[15:32:29.805]  - Getting '...' globals ...
[15:32:29.806] resolve() on list ...
[15:32:29.806]  recursive: 0
[15:32:29.806]  length: 1
[15:32:29.806]  elements: '...'
[15:32:29.807]  length: 0 (resolved future 1)
[15:32:29.807] resolve() on list ... DONE
[15:32:29.807]    - '...' content: [n=0] 
[15:32:29.807] List of 1
[15:32:29.807]  $ ...: list()
[15:32:29.807]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:29.807]  - attr(*, "where")=List of 1
[15:32:29.807]   ..$ ...:<environment: 0x00000276e07b0538> 
[15:32:29.807]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:29.807]  - attr(*, "resolved")= logi TRUE
[15:32:29.807]  - attr(*, "total_size")= num NA
[15:32:29.811]  - Getting '...' globals ... DONE
[15:32:29.812] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:29.812] List of 2
[15:32:29.812]  $ ...future.FUN:function (x, ...)  
[15:32:29.812]  $ ...          : list()
[15:32:29.812]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:29.812]  - attr(*, "where")=List of 2
[15:32:29.812]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:29.812]   ..$ ...          :<environment: 0x00000276e07b0538> 
[15:32:29.812]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:29.812]  - attr(*, "resolved")= logi FALSE
[15:32:29.812]  - attr(*, "total_size")= num 1248
[15:32:29.816] Packages to be attached in all futures: [n=0] 
[15:32:29.817] getGlobalsAndPackagesXApply() ... DONE
[15:32:29.817] Number of futures (= number of chunks): 2
[15:32:29.817] Launching 2 futures (chunks) ...
[15:32:29.818] Chunk #1 of 2 ...
[15:32:29.818]  - Finding globals in 'X' for chunk #1 ...
[15:32:29.818] getGlobalsAndPackages() ...
[15:32:29.818] Searching for globals...
[15:32:29.819] 
[15:32:29.819] Searching for globals ... DONE
[15:32:29.819] - globals: [0] <none>
[15:32:29.819] getGlobalsAndPackages() ... DONE
[15:32:29.820]    + additional globals found: [n=0] 
[15:32:29.820]    + additional namespaces needed: [n=0] 
[15:32:29.820]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:29.820]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:29.821]  - seeds: <none>
[15:32:29.821]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:29.821] getGlobalsAndPackages() ...
[15:32:29.821] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:29.822] Resolving globals: FALSE
[15:32:29.822] Tweak future expression to call with '...' arguments ...
[15:32:29.822] {
[15:32:29.822]     do.call(function(...) {
[15:32:29.822]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:29.822]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:29.822]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:29.822]             on.exit(options(oopts), add = TRUE)
[15:32:29.822]         }
[15:32:29.822]         {
[15:32:29.822]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:29.822]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:29.822]                 ...future.FUN(...future.X_jj, ...)
[15:32:29.822]             })
[15:32:29.822]         }
[15:32:29.822]     }, args = future.call.arguments)
[15:32:29.822] }
[15:32:29.823] Tweak future expression to call with '...' arguments ... DONE
[15:32:29.823] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:29.824] 
[15:32:29.824] getGlobalsAndPackages() ... DONE
[15:32:29.824] run() for 'Future' ...
[15:32:29.825] - state: 'created'
[15:32:29.825] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:29.842] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:29.843] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:29.843]   - Field: 'node'
[15:32:29.843]   - Field: 'label'
[15:32:29.843]   - Field: 'local'
[15:32:29.844]   - Field: 'owner'
[15:32:29.844]   - Field: 'envir'
[15:32:29.844]   - Field: 'workers'
[15:32:29.844]   - Field: 'packages'
[15:32:29.845]   - Field: 'gc'
[15:32:29.845]   - Field: 'conditions'
[15:32:29.845]   - Field: 'persistent'
[15:32:29.845]   - Field: 'expr'
[15:32:29.846]   - Field: 'uuid'
[15:32:29.846]   - Field: 'seed'
[15:32:29.846]   - Field: 'version'
[15:32:29.846]   - Field: 'result'
[15:32:29.847]   - Field: 'asynchronous'
[15:32:29.847]   - Field: 'calls'
[15:32:29.847]   - Field: 'globals'
[15:32:29.848]   - Field: 'stdout'
[15:32:29.848]   - Field: 'earlySignal'
[15:32:29.848]   - Field: 'lazy'
[15:32:29.848]   - Field: 'state'
[15:32:29.849] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:29.849] - Launch lazy future ...
[15:32:29.849] Packages needed by the future expression (n = 0): <none>
[15:32:29.850] Packages needed by future strategies (n = 0): <none>
[15:32:29.850] {
[15:32:29.850]     {
[15:32:29.850]         {
[15:32:29.850]             ...future.startTime <- base::Sys.time()
[15:32:29.850]             {
[15:32:29.850]                 {
[15:32:29.850]                   {
[15:32:29.850]                     {
[15:32:29.850]                       base::local({
[15:32:29.850]                         has_future <- base::requireNamespace("future", 
[15:32:29.850]                           quietly = TRUE)
[15:32:29.850]                         if (has_future) {
[15:32:29.850]                           ns <- base::getNamespace("future")
[15:32:29.850]                           version <- ns[[".package"]][["version"]]
[15:32:29.850]                           if (is.null(version)) 
[15:32:29.850]                             version <- utils::packageVersion("future")
[15:32:29.850]                         }
[15:32:29.850]                         else {
[15:32:29.850]                           version <- NULL
[15:32:29.850]                         }
[15:32:29.850]                         if (!has_future || version < "1.8.0") {
[15:32:29.850]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:29.850]                             "", base::R.version$version.string), 
[15:32:29.850]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:29.850]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:29.850]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:29.850]                               "release", "version")], collapse = " "), 
[15:32:29.850]                             hostname = base::Sys.info()[["nodename"]])
[15:32:29.850]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:29.850]                             info)
[15:32:29.850]                           info <- base::paste(info, collapse = "; ")
[15:32:29.850]                           if (!has_future) {
[15:32:29.850]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:29.850]                               info)
[15:32:29.850]                           }
[15:32:29.850]                           else {
[15:32:29.850]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:29.850]                               info, version)
[15:32:29.850]                           }
[15:32:29.850]                           base::stop(msg)
[15:32:29.850]                         }
[15:32:29.850]                       })
[15:32:29.850]                     }
[15:32:29.850]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:29.850]                     base::options(mc.cores = 1L)
[15:32:29.850]                   }
[15:32:29.850]                   ...future.strategy.old <- future::plan("list")
[15:32:29.850]                   options(future.plan = NULL)
[15:32:29.850]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:29.850]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:29.850]                 }
[15:32:29.850]                 ...future.workdir <- getwd()
[15:32:29.850]             }
[15:32:29.850]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:29.850]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:29.850]         }
[15:32:29.850]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:29.850]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:29.850]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:29.850]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:29.850]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:29.850]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:29.850]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:29.850]             base::names(...future.oldOptions))
[15:32:29.850]     }
[15:32:29.850]     if (FALSE) {
[15:32:29.850]     }
[15:32:29.850]     else {
[15:32:29.850]         if (TRUE) {
[15:32:29.850]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:29.850]                 open = "w")
[15:32:29.850]         }
[15:32:29.850]         else {
[15:32:29.850]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:29.850]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:29.850]         }
[15:32:29.850]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:29.850]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:29.850]             base::sink(type = "output", split = FALSE)
[15:32:29.850]             base::close(...future.stdout)
[15:32:29.850]         }, add = TRUE)
[15:32:29.850]     }
[15:32:29.850]     ...future.frame <- base::sys.nframe()
[15:32:29.850]     ...future.conditions <- base::list()
[15:32:29.850]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:29.850]     if (FALSE) {
[15:32:29.850]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:29.850]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:29.850]     }
[15:32:29.850]     ...future.result <- base::tryCatch({
[15:32:29.850]         base::withCallingHandlers({
[15:32:29.850]             ...future.value <- base::withVisible(base::local({
[15:32:29.850]                 ...future.makeSendCondition <- base::local({
[15:32:29.850]                   sendCondition <- NULL
[15:32:29.850]                   function(frame = 1L) {
[15:32:29.850]                     if (is.function(sendCondition)) 
[15:32:29.850]                       return(sendCondition)
[15:32:29.850]                     ns <- getNamespace("parallel")
[15:32:29.850]                     if (exists("sendData", mode = "function", 
[15:32:29.850]                       envir = ns)) {
[15:32:29.850]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:29.850]                         envir = ns)
[15:32:29.850]                       envir <- sys.frame(frame)
[15:32:29.850]                       master <- NULL
[15:32:29.850]                       while (!identical(envir, .GlobalEnv) && 
[15:32:29.850]                         !identical(envir, emptyenv())) {
[15:32:29.850]                         if (exists("master", mode = "list", envir = envir, 
[15:32:29.850]                           inherits = FALSE)) {
[15:32:29.850]                           master <- get("master", mode = "list", 
[15:32:29.850]                             envir = envir, inherits = FALSE)
[15:32:29.850]                           if (inherits(master, c("SOCKnode", 
[15:32:29.850]                             "SOCK0node"))) {
[15:32:29.850]                             sendCondition <<- function(cond) {
[15:32:29.850]                               data <- list(type = "VALUE", value = cond, 
[15:32:29.850]                                 success = TRUE)
[15:32:29.850]                               parallel_sendData(master, data)
[15:32:29.850]                             }
[15:32:29.850]                             return(sendCondition)
[15:32:29.850]                           }
[15:32:29.850]                         }
[15:32:29.850]                         frame <- frame + 1L
[15:32:29.850]                         envir <- sys.frame(frame)
[15:32:29.850]                       }
[15:32:29.850]                     }
[15:32:29.850]                     sendCondition <<- function(cond) NULL
[15:32:29.850]                   }
[15:32:29.850]                 })
[15:32:29.850]                 withCallingHandlers({
[15:32:29.850]                   {
[15:32:29.850]                     do.call(function(...) {
[15:32:29.850]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:29.850]                       if (!identical(...future.globals.maxSize.org, 
[15:32:29.850]                         ...future.globals.maxSize)) {
[15:32:29.850]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:29.850]                         on.exit(options(oopts), add = TRUE)
[15:32:29.850]                       }
[15:32:29.850]                       {
[15:32:29.850]                         lapply(seq_along(...future.elements_ii), 
[15:32:29.850]                           FUN = function(jj) {
[15:32:29.850]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:29.850]                             ...future.FUN(...future.X_jj, ...)
[15:32:29.850]                           })
[15:32:29.850]                       }
[15:32:29.850]                     }, args = future.call.arguments)
[15:32:29.850]                   }
[15:32:29.850]                 }, immediateCondition = function(cond) {
[15:32:29.850]                   sendCondition <- ...future.makeSendCondition()
[15:32:29.850]                   sendCondition(cond)
[15:32:29.850]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:29.850]                   {
[15:32:29.850]                     inherits <- base::inherits
[15:32:29.850]                     invokeRestart <- base::invokeRestart
[15:32:29.850]                     is.null <- base::is.null
[15:32:29.850]                     muffled <- FALSE
[15:32:29.850]                     if (inherits(cond, "message")) {
[15:32:29.850]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:29.850]                       if (muffled) 
[15:32:29.850]                         invokeRestart("muffleMessage")
[15:32:29.850]                     }
[15:32:29.850]                     else if (inherits(cond, "warning")) {
[15:32:29.850]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:29.850]                       if (muffled) 
[15:32:29.850]                         invokeRestart("muffleWarning")
[15:32:29.850]                     }
[15:32:29.850]                     else if (inherits(cond, "condition")) {
[15:32:29.850]                       if (!is.null(pattern)) {
[15:32:29.850]                         computeRestarts <- base::computeRestarts
[15:32:29.850]                         grepl <- base::grepl
[15:32:29.850]                         restarts <- computeRestarts(cond)
[15:32:29.850]                         for (restart in restarts) {
[15:32:29.850]                           name <- restart$name
[15:32:29.850]                           if (is.null(name)) 
[15:32:29.850]                             next
[15:32:29.850]                           if (!grepl(pattern, name)) 
[15:32:29.850]                             next
[15:32:29.850]                           invokeRestart(restart)
[15:32:29.850]                           muffled <- TRUE
[15:32:29.850]                           break
[15:32:29.850]                         }
[15:32:29.850]                       }
[15:32:29.850]                     }
[15:32:29.850]                     invisible(muffled)
[15:32:29.850]                   }
[15:32:29.850]                   muffleCondition(cond)
[15:32:29.850]                 })
[15:32:29.850]             }))
[15:32:29.850]             future::FutureResult(value = ...future.value$value, 
[15:32:29.850]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:29.850]                   ...future.rng), globalenv = if (FALSE) 
[15:32:29.850]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:29.850]                     ...future.globalenv.names))
[15:32:29.850]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:29.850]         }, condition = base::local({
[15:32:29.850]             c <- base::c
[15:32:29.850]             inherits <- base::inherits
[15:32:29.850]             invokeRestart <- base::invokeRestart
[15:32:29.850]             length <- base::length
[15:32:29.850]             list <- base::list
[15:32:29.850]             seq.int <- base::seq.int
[15:32:29.850]             signalCondition <- base::signalCondition
[15:32:29.850]             sys.calls <- base::sys.calls
[15:32:29.850]             `[[` <- base::`[[`
[15:32:29.850]             `+` <- base::`+`
[15:32:29.850]             `<<-` <- base::`<<-`
[15:32:29.850]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:29.850]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:29.850]                   3L)]
[15:32:29.850]             }
[15:32:29.850]             function(cond) {
[15:32:29.850]                 is_error <- inherits(cond, "error")
[15:32:29.850]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:29.850]                   NULL)
[15:32:29.850]                 if (is_error) {
[15:32:29.850]                   sessionInformation <- function() {
[15:32:29.850]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:29.850]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:29.850]                       search = base::search(), system = base::Sys.info())
[15:32:29.850]                   }
[15:32:29.850]                   ...future.conditions[[length(...future.conditions) + 
[15:32:29.850]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:29.850]                     cond$call), session = sessionInformation(), 
[15:32:29.850]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:29.850]                   signalCondition(cond)
[15:32:29.850]                 }
[15:32:29.850]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:29.850]                 "immediateCondition"))) {
[15:32:29.850]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:29.850]                   ...future.conditions[[length(...future.conditions) + 
[15:32:29.850]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:29.850]                   if (TRUE && !signal) {
[15:32:29.850]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:29.850]                     {
[15:32:29.850]                       inherits <- base::inherits
[15:32:29.850]                       invokeRestart <- base::invokeRestart
[15:32:29.850]                       is.null <- base::is.null
[15:32:29.850]                       muffled <- FALSE
[15:32:29.850]                       if (inherits(cond, "message")) {
[15:32:29.850]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:29.850]                         if (muffled) 
[15:32:29.850]                           invokeRestart("muffleMessage")
[15:32:29.850]                       }
[15:32:29.850]                       else if (inherits(cond, "warning")) {
[15:32:29.850]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:29.850]                         if (muffled) 
[15:32:29.850]                           invokeRestart("muffleWarning")
[15:32:29.850]                       }
[15:32:29.850]                       else if (inherits(cond, "condition")) {
[15:32:29.850]                         if (!is.null(pattern)) {
[15:32:29.850]                           computeRestarts <- base::computeRestarts
[15:32:29.850]                           grepl <- base::grepl
[15:32:29.850]                           restarts <- computeRestarts(cond)
[15:32:29.850]                           for (restart in restarts) {
[15:32:29.850]                             name <- restart$name
[15:32:29.850]                             if (is.null(name)) 
[15:32:29.850]                               next
[15:32:29.850]                             if (!grepl(pattern, name)) 
[15:32:29.850]                               next
[15:32:29.850]                             invokeRestart(restart)
[15:32:29.850]                             muffled <- TRUE
[15:32:29.850]                             break
[15:32:29.850]                           }
[15:32:29.850]                         }
[15:32:29.850]                       }
[15:32:29.850]                       invisible(muffled)
[15:32:29.850]                     }
[15:32:29.850]                     muffleCondition(cond, pattern = "^muffle")
[15:32:29.850]                   }
[15:32:29.850]                 }
[15:32:29.850]                 else {
[15:32:29.850]                   if (TRUE) {
[15:32:29.850]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:29.850]                     {
[15:32:29.850]                       inherits <- base::inherits
[15:32:29.850]                       invokeRestart <- base::invokeRestart
[15:32:29.850]                       is.null <- base::is.null
[15:32:29.850]                       muffled <- FALSE
[15:32:29.850]                       if (inherits(cond, "message")) {
[15:32:29.850]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:29.850]                         if (muffled) 
[15:32:29.850]                           invokeRestart("muffleMessage")
[15:32:29.850]                       }
[15:32:29.850]                       else if (inherits(cond, "warning")) {
[15:32:29.850]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:29.850]                         if (muffled) 
[15:32:29.850]                           invokeRestart("muffleWarning")
[15:32:29.850]                       }
[15:32:29.850]                       else if (inherits(cond, "condition")) {
[15:32:29.850]                         if (!is.null(pattern)) {
[15:32:29.850]                           computeRestarts <- base::computeRestarts
[15:32:29.850]                           grepl <- base::grepl
[15:32:29.850]                           restarts <- computeRestarts(cond)
[15:32:29.850]                           for (restart in restarts) {
[15:32:29.850]                             name <- restart$name
[15:32:29.850]                             if (is.null(name)) 
[15:32:29.850]                               next
[15:32:29.850]                             if (!grepl(pattern, name)) 
[15:32:29.850]                               next
[15:32:29.850]                             invokeRestart(restart)
[15:32:29.850]                             muffled <- TRUE
[15:32:29.850]                             break
[15:32:29.850]                           }
[15:32:29.850]                         }
[15:32:29.850]                       }
[15:32:29.850]                       invisible(muffled)
[15:32:29.850]                     }
[15:32:29.850]                     muffleCondition(cond, pattern = "^muffle")
[15:32:29.850]                   }
[15:32:29.850]                 }
[15:32:29.850]             }
[15:32:29.850]         }))
[15:32:29.850]     }, error = function(ex) {
[15:32:29.850]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:29.850]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:29.850]                 ...future.rng), started = ...future.startTime, 
[15:32:29.850]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:29.850]             version = "1.8"), class = "FutureResult")
[15:32:29.850]     }, finally = {
[15:32:29.850]         if (!identical(...future.workdir, getwd())) 
[15:32:29.850]             setwd(...future.workdir)
[15:32:29.850]         {
[15:32:29.850]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:29.850]                 ...future.oldOptions$nwarnings <- NULL
[15:32:29.850]             }
[15:32:29.850]             base::options(...future.oldOptions)
[15:32:29.850]             if (.Platform$OS.type == "windows") {
[15:32:29.850]                 old_names <- names(...future.oldEnvVars)
[15:32:29.850]                 envs <- base::Sys.getenv()
[15:32:29.850]                 names <- names(envs)
[15:32:29.850]                 common <- intersect(names, old_names)
[15:32:29.850]                 added <- setdiff(names, old_names)
[15:32:29.850]                 removed <- setdiff(old_names, names)
[15:32:29.850]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:29.850]                   envs[common]]
[15:32:29.850]                 NAMES <- toupper(changed)
[15:32:29.850]                 args <- list()
[15:32:29.850]                 for (kk in seq_along(NAMES)) {
[15:32:29.850]                   name <- changed[[kk]]
[15:32:29.850]                   NAME <- NAMES[[kk]]
[15:32:29.850]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:29.850]                     next
[15:32:29.850]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:29.850]                 }
[15:32:29.850]                 NAMES <- toupper(added)
[15:32:29.850]                 for (kk in seq_along(NAMES)) {
[15:32:29.850]                   name <- added[[kk]]
[15:32:29.850]                   NAME <- NAMES[[kk]]
[15:32:29.850]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:29.850]                     next
[15:32:29.850]                   args[[name]] <- ""
[15:32:29.850]                 }
[15:32:29.850]                 NAMES <- toupper(removed)
[15:32:29.850]                 for (kk in seq_along(NAMES)) {
[15:32:29.850]                   name <- removed[[kk]]
[15:32:29.850]                   NAME <- NAMES[[kk]]
[15:32:29.850]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:29.850]                     next
[15:32:29.850]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:29.850]                 }
[15:32:29.850]                 if (length(args) > 0) 
[15:32:29.850]                   base::do.call(base::Sys.setenv, args = args)
[15:32:29.850]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:29.850]             }
[15:32:29.850]             else {
[15:32:29.850]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:29.850]             }
[15:32:29.850]             {
[15:32:29.850]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:29.850]                   0L) {
[15:32:29.850]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:29.850]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:29.850]                   base::options(opts)
[15:32:29.850]                 }
[15:32:29.850]                 {
[15:32:29.850]                   {
[15:32:29.850]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:29.850]                     NULL
[15:32:29.850]                   }
[15:32:29.850]                   options(future.plan = NULL)
[15:32:29.850]                   if (is.na(NA_character_)) 
[15:32:29.850]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:29.850]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:29.850]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:29.850]                     .init = FALSE)
[15:32:29.850]                 }
[15:32:29.850]             }
[15:32:29.850]         }
[15:32:29.850]     })
[15:32:29.850]     if (TRUE) {
[15:32:29.850]         base::sink(type = "output", split = FALSE)
[15:32:29.850]         if (TRUE) {
[15:32:29.850]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:29.850]         }
[15:32:29.850]         else {
[15:32:29.850]             ...future.result["stdout"] <- base::list(NULL)
[15:32:29.850]         }
[15:32:29.850]         base::close(...future.stdout)
[15:32:29.850]         ...future.stdout <- NULL
[15:32:29.850]     }
[15:32:29.850]     ...future.result$conditions <- ...future.conditions
[15:32:29.850]     ...future.result$finished <- base::Sys.time()
[15:32:29.850]     ...future.result
[15:32:29.850] }
[15:32:29.858] Exporting 5 global objects (1.22 KiB) to cluster node #1 ...
[15:32:29.858] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ...
[15:32:29.858] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ... DONE
[15:32:29.859] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:29.859] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:29.859] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ...
[15:32:29.860] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ... DONE
[15:32:29.860] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:29.861] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:29.861] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:29.861] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:29.862] Exporting 5 global objects (1.22 KiB) to cluster node #1 ... DONE
[15:32:29.862] MultisessionFuture started
[15:32:29.862] - Launch lazy future ... done
[15:32:29.863] run() for 'MultisessionFuture' ... done
[15:32:29.863] Created future:
[15:32:29.879] receiveMessageFromWorker() for ClusterFuture ...
[15:32:29.879] - Validating connection of MultisessionFuture
[15:32:29.879] - received message: FutureResult
[15:32:29.880] - Received FutureResult
[15:32:29.880] - Erased future from FutureRegistry
[15:32:29.880] result() for ClusterFuture ...
[15:32:29.880] - result already collected: FutureResult
[15:32:29.880] result() for ClusterFuture ... done
[15:32:29.881] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:29.863] MultisessionFuture:
[15:32:29.863] Label: 'future_sapply-1'
[15:32:29.863] Expression:
[15:32:29.863] {
[15:32:29.863]     do.call(function(...) {
[15:32:29.863]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:29.863]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:29.863]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:29.863]             on.exit(options(oopts), add = TRUE)
[15:32:29.863]         }
[15:32:29.863]         {
[15:32:29.863]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:29.863]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:29.863]                 ...future.FUN(...future.X_jj, ...)
[15:32:29.863]             })
[15:32:29.863]         }
[15:32:29.863]     }, args = future.call.arguments)
[15:32:29.863] }
[15:32:29.863] Lazy evaluation: FALSE
[15:32:29.863] Asynchronous evaluation: TRUE
[15:32:29.863] Local evaluation: TRUE
[15:32:29.863] Environment: R_GlobalEnv
[15:32:29.863] Capture standard output: TRUE
[15:32:29.863] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:29.863] Globals: 5 objects totaling 1.27 KiB (function '...future.FUN' of 1.22 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)
[15:32:29.863] Packages: <none>
[15:32:29.863] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:29.863] Resolved: TRUE
[15:32:29.863] Value: <not collected>
[15:32:29.863] Conditions captured: <none>
[15:32:29.863] Early signaling: FALSE
[15:32:29.863] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:29.863] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:29.881] Chunk #1 of 2 ... DONE
[15:32:29.881] Chunk #2 of 2 ...
[15:32:29.882]  - Finding globals in 'X' for chunk #2 ...
[15:32:29.882] getGlobalsAndPackages() ...
[15:32:29.882] Searching for globals...
[15:32:29.882] 
[15:32:29.883] Searching for globals ... DONE
[15:32:29.883] - globals: [0] <none>
[15:32:29.883] getGlobalsAndPackages() ... DONE
[15:32:29.883]    + additional globals found: [n=0] 
[15:32:29.883]    + additional namespaces needed: [n=0] 
[15:32:29.883]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:29.884]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:29.884]  - seeds: <none>
[15:32:29.884]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:29.884] getGlobalsAndPackages() ...
[15:32:29.884] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:29.885] Resolving globals: FALSE
[15:32:29.885] Tweak future expression to call with '...' arguments ...
[15:32:29.885] {
[15:32:29.885]     do.call(function(...) {
[15:32:29.885]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:29.885]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:29.885]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:29.885]             on.exit(options(oopts), add = TRUE)
[15:32:29.885]         }
[15:32:29.885]         {
[15:32:29.885]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:29.885]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:29.885]                 ...future.FUN(...future.X_jj, ...)
[15:32:29.885]             })
[15:32:29.885]         }
[15:32:29.885]     }, args = future.call.arguments)
[15:32:29.885] }
[15:32:29.885] Tweak future expression to call with '...' arguments ... DONE
[15:32:29.886] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:29.886] 
[15:32:29.886] getGlobalsAndPackages() ... DONE
[15:32:29.887] run() for 'Future' ...
[15:32:29.887] - state: 'created'
[15:32:29.887] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:29.903] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:29.903] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:29.903]   - Field: 'node'
[15:32:29.903]   - Field: 'label'
[15:32:29.904]   - Field: 'local'
[15:32:29.904]   - Field: 'owner'
[15:32:29.904]   - Field: 'envir'
[15:32:29.904]   - Field: 'workers'
[15:32:29.904]   - Field: 'packages'
[15:32:29.905]   - Field: 'gc'
[15:32:29.905]   - Field: 'conditions'
[15:32:29.905]   - Field: 'persistent'
[15:32:29.905]   - Field: 'expr'
[15:32:29.905]   - Field: 'uuid'
[15:32:29.906]   - Field: 'seed'
[15:32:29.906]   - Field: 'version'
[15:32:29.907]   - Field: 'result'
[15:32:29.907]   - Field: 'asynchronous'
[15:32:29.907]   - Field: 'calls'
[15:32:29.908]   - Field: 'globals'
[15:32:29.908]   - Field: 'stdout'
[15:32:29.908]   - Field: 'earlySignal'
[15:32:29.909]   - Field: 'lazy'
[15:32:29.909]   - Field: 'state'
[15:32:29.909] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:29.910] - Launch lazy future ...
[15:32:29.910] Packages needed by the future expression (n = 0): <none>
[15:32:29.911] Packages needed by future strategies (n = 0): <none>
[15:32:29.912] {
[15:32:29.912]     {
[15:32:29.912]         {
[15:32:29.912]             ...future.startTime <- base::Sys.time()
[15:32:29.912]             {
[15:32:29.912]                 {
[15:32:29.912]                   {
[15:32:29.912]                     {
[15:32:29.912]                       base::local({
[15:32:29.912]                         has_future <- base::requireNamespace("future", 
[15:32:29.912]                           quietly = TRUE)
[15:32:29.912]                         if (has_future) {
[15:32:29.912]                           ns <- base::getNamespace("future")
[15:32:29.912]                           version <- ns[[".package"]][["version"]]
[15:32:29.912]                           if (is.null(version)) 
[15:32:29.912]                             version <- utils::packageVersion("future")
[15:32:29.912]                         }
[15:32:29.912]                         else {
[15:32:29.912]                           version <- NULL
[15:32:29.912]                         }
[15:32:29.912]                         if (!has_future || version < "1.8.0") {
[15:32:29.912]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:29.912]                             "", base::R.version$version.string), 
[15:32:29.912]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:29.912]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:29.912]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:29.912]                               "release", "version")], collapse = " "), 
[15:32:29.912]                             hostname = base::Sys.info()[["nodename"]])
[15:32:29.912]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:29.912]                             info)
[15:32:29.912]                           info <- base::paste(info, collapse = "; ")
[15:32:29.912]                           if (!has_future) {
[15:32:29.912]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:29.912]                               info)
[15:32:29.912]                           }
[15:32:29.912]                           else {
[15:32:29.912]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:29.912]                               info, version)
[15:32:29.912]                           }
[15:32:29.912]                           base::stop(msg)
[15:32:29.912]                         }
[15:32:29.912]                       })
[15:32:29.912]                     }
[15:32:29.912]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:29.912]                     base::options(mc.cores = 1L)
[15:32:29.912]                   }
[15:32:29.912]                   ...future.strategy.old <- future::plan("list")
[15:32:29.912]                   options(future.plan = NULL)
[15:32:29.912]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:29.912]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:29.912]                 }
[15:32:29.912]                 ...future.workdir <- getwd()
[15:32:29.912]             }
[15:32:29.912]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:29.912]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:29.912]         }
[15:32:29.912]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:29.912]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:29.912]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:29.912]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:29.912]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:29.912]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:29.912]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:29.912]             base::names(...future.oldOptions))
[15:32:29.912]     }
[15:32:29.912]     if (FALSE) {
[15:32:29.912]     }
[15:32:29.912]     else {
[15:32:29.912]         if (TRUE) {
[15:32:29.912]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:29.912]                 open = "w")
[15:32:29.912]         }
[15:32:29.912]         else {
[15:32:29.912]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:29.912]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:29.912]         }
[15:32:29.912]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:29.912]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:29.912]             base::sink(type = "output", split = FALSE)
[15:32:29.912]             base::close(...future.stdout)
[15:32:29.912]         }, add = TRUE)
[15:32:29.912]     }
[15:32:29.912]     ...future.frame <- base::sys.nframe()
[15:32:29.912]     ...future.conditions <- base::list()
[15:32:29.912]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:29.912]     if (FALSE) {
[15:32:29.912]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:29.912]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:29.912]     }
[15:32:29.912]     ...future.result <- base::tryCatch({
[15:32:29.912]         base::withCallingHandlers({
[15:32:29.912]             ...future.value <- base::withVisible(base::local({
[15:32:29.912]                 ...future.makeSendCondition <- base::local({
[15:32:29.912]                   sendCondition <- NULL
[15:32:29.912]                   function(frame = 1L) {
[15:32:29.912]                     if (is.function(sendCondition)) 
[15:32:29.912]                       return(sendCondition)
[15:32:29.912]                     ns <- getNamespace("parallel")
[15:32:29.912]                     if (exists("sendData", mode = "function", 
[15:32:29.912]                       envir = ns)) {
[15:32:29.912]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:29.912]                         envir = ns)
[15:32:29.912]                       envir <- sys.frame(frame)
[15:32:29.912]                       master <- NULL
[15:32:29.912]                       while (!identical(envir, .GlobalEnv) && 
[15:32:29.912]                         !identical(envir, emptyenv())) {
[15:32:29.912]                         if (exists("master", mode = "list", envir = envir, 
[15:32:29.912]                           inherits = FALSE)) {
[15:32:29.912]                           master <- get("master", mode = "list", 
[15:32:29.912]                             envir = envir, inherits = FALSE)
[15:32:29.912]                           if (inherits(master, c("SOCKnode", 
[15:32:29.912]                             "SOCK0node"))) {
[15:32:29.912]                             sendCondition <<- function(cond) {
[15:32:29.912]                               data <- list(type = "VALUE", value = cond, 
[15:32:29.912]                                 success = TRUE)
[15:32:29.912]                               parallel_sendData(master, data)
[15:32:29.912]                             }
[15:32:29.912]                             return(sendCondition)
[15:32:29.912]                           }
[15:32:29.912]                         }
[15:32:29.912]                         frame <- frame + 1L
[15:32:29.912]                         envir <- sys.frame(frame)
[15:32:29.912]                       }
[15:32:29.912]                     }
[15:32:29.912]                     sendCondition <<- function(cond) NULL
[15:32:29.912]                   }
[15:32:29.912]                 })
[15:32:29.912]                 withCallingHandlers({
[15:32:29.912]                   {
[15:32:29.912]                     do.call(function(...) {
[15:32:29.912]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:29.912]                       if (!identical(...future.globals.maxSize.org, 
[15:32:29.912]                         ...future.globals.maxSize)) {
[15:32:29.912]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:29.912]                         on.exit(options(oopts), add = TRUE)
[15:32:29.912]                       }
[15:32:29.912]                       {
[15:32:29.912]                         lapply(seq_along(...future.elements_ii), 
[15:32:29.912]                           FUN = function(jj) {
[15:32:29.912]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:29.912]                             ...future.FUN(...future.X_jj, ...)
[15:32:29.912]                           })
[15:32:29.912]                       }
[15:32:29.912]                     }, args = future.call.arguments)
[15:32:29.912]                   }
[15:32:29.912]                 }, immediateCondition = function(cond) {
[15:32:29.912]                   sendCondition <- ...future.makeSendCondition()
[15:32:29.912]                   sendCondition(cond)
[15:32:29.912]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:29.912]                   {
[15:32:29.912]                     inherits <- base::inherits
[15:32:29.912]                     invokeRestart <- base::invokeRestart
[15:32:29.912]                     is.null <- base::is.null
[15:32:29.912]                     muffled <- FALSE
[15:32:29.912]                     if (inherits(cond, "message")) {
[15:32:29.912]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:29.912]                       if (muffled) 
[15:32:29.912]                         invokeRestart("muffleMessage")
[15:32:29.912]                     }
[15:32:29.912]                     else if (inherits(cond, "warning")) {
[15:32:29.912]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:29.912]                       if (muffled) 
[15:32:29.912]                         invokeRestart("muffleWarning")
[15:32:29.912]                     }
[15:32:29.912]                     else if (inherits(cond, "condition")) {
[15:32:29.912]                       if (!is.null(pattern)) {
[15:32:29.912]                         computeRestarts <- base::computeRestarts
[15:32:29.912]                         grepl <- base::grepl
[15:32:29.912]                         restarts <- computeRestarts(cond)
[15:32:29.912]                         for (restart in restarts) {
[15:32:29.912]                           name <- restart$name
[15:32:29.912]                           if (is.null(name)) 
[15:32:29.912]                             next
[15:32:29.912]                           if (!grepl(pattern, name)) 
[15:32:29.912]                             next
[15:32:29.912]                           invokeRestart(restart)
[15:32:29.912]                           muffled <- TRUE
[15:32:29.912]                           break
[15:32:29.912]                         }
[15:32:29.912]                       }
[15:32:29.912]                     }
[15:32:29.912]                     invisible(muffled)
[15:32:29.912]                   }
[15:32:29.912]                   muffleCondition(cond)
[15:32:29.912]                 })
[15:32:29.912]             }))
[15:32:29.912]             future::FutureResult(value = ...future.value$value, 
[15:32:29.912]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:29.912]                   ...future.rng), globalenv = if (FALSE) 
[15:32:29.912]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:29.912]                     ...future.globalenv.names))
[15:32:29.912]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:29.912]         }, condition = base::local({
[15:32:29.912]             c <- base::c
[15:32:29.912]             inherits <- base::inherits
[15:32:29.912]             invokeRestart <- base::invokeRestart
[15:32:29.912]             length <- base::length
[15:32:29.912]             list <- base::list
[15:32:29.912]             seq.int <- base::seq.int
[15:32:29.912]             signalCondition <- base::signalCondition
[15:32:29.912]             sys.calls <- base::sys.calls
[15:32:29.912]             `[[` <- base::`[[`
[15:32:29.912]             `+` <- base::`+`
[15:32:29.912]             `<<-` <- base::`<<-`
[15:32:29.912]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:29.912]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:29.912]                   3L)]
[15:32:29.912]             }
[15:32:29.912]             function(cond) {
[15:32:29.912]                 is_error <- inherits(cond, "error")
[15:32:29.912]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:29.912]                   NULL)
[15:32:29.912]                 if (is_error) {
[15:32:29.912]                   sessionInformation <- function() {
[15:32:29.912]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:29.912]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:29.912]                       search = base::search(), system = base::Sys.info())
[15:32:29.912]                   }
[15:32:29.912]                   ...future.conditions[[length(...future.conditions) + 
[15:32:29.912]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:29.912]                     cond$call), session = sessionInformation(), 
[15:32:29.912]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:29.912]                   signalCondition(cond)
[15:32:29.912]                 }
[15:32:29.912]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:29.912]                 "immediateCondition"))) {
[15:32:29.912]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:29.912]                   ...future.conditions[[length(...future.conditions) + 
[15:32:29.912]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:29.912]                   if (TRUE && !signal) {
[15:32:29.912]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:29.912]                     {
[15:32:29.912]                       inherits <- base::inherits
[15:32:29.912]                       invokeRestart <- base::invokeRestart
[15:32:29.912]                       is.null <- base::is.null
[15:32:29.912]                       muffled <- FALSE
[15:32:29.912]                       if (inherits(cond, "message")) {
[15:32:29.912]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:29.912]                         if (muffled) 
[15:32:29.912]                           invokeRestart("muffleMessage")
[15:32:29.912]                       }
[15:32:29.912]                       else if (inherits(cond, "warning")) {
[15:32:29.912]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:29.912]                         if (muffled) 
[15:32:29.912]                           invokeRestart("muffleWarning")
[15:32:29.912]                       }
[15:32:29.912]                       else if (inherits(cond, "condition")) {
[15:32:29.912]                         if (!is.null(pattern)) {
[15:32:29.912]                           computeRestarts <- base::computeRestarts
[15:32:29.912]                           grepl <- base::grepl
[15:32:29.912]                           restarts <- computeRestarts(cond)
[15:32:29.912]                           for (restart in restarts) {
[15:32:29.912]                             name <- restart$name
[15:32:29.912]                             if (is.null(name)) 
[15:32:29.912]                               next
[15:32:29.912]                             if (!grepl(pattern, name)) 
[15:32:29.912]                               next
[15:32:29.912]                             invokeRestart(restart)
[15:32:29.912]                             muffled <- TRUE
[15:32:29.912]                             break
[15:32:29.912]                           }
[15:32:29.912]                         }
[15:32:29.912]                       }
[15:32:29.912]                       invisible(muffled)
[15:32:29.912]                     }
[15:32:29.912]                     muffleCondition(cond, pattern = "^muffle")
[15:32:29.912]                   }
[15:32:29.912]                 }
[15:32:29.912]                 else {
[15:32:29.912]                   if (TRUE) {
[15:32:29.912]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:29.912]                     {
[15:32:29.912]                       inherits <- base::inherits
[15:32:29.912]                       invokeRestart <- base::invokeRestart
[15:32:29.912]                       is.null <- base::is.null
[15:32:29.912]                       muffled <- FALSE
[15:32:29.912]                       if (inherits(cond, "message")) {
[15:32:29.912]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:29.912]                         if (muffled) 
[15:32:29.912]                           invokeRestart("muffleMessage")
[15:32:29.912]                       }
[15:32:29.912]                       else if (inherits(cond, "warning")) {
[15:32:29.912]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:29.912]                         if (muffled) 
[15:32:29.912]                           invokeRestart("muffleWarning")
[15:32:29.912]                       }
[15:32:29.912]                       else if (inherits(cond, "condition")) {
[15:32:29.912]                         if (!is.null(pattern)) {
[15:32:29.912]                           computeRestarts <- base::computeRestarts
[15:32:29.912]                           grepl <- base::grepl
[15:32:29.912]                           restarts <- computeRestarts(cond)
[15:32:29.912]                           for (restart in restarts) {
[15:32:29.912]                             name <- restart$name
[15:32:29.912]                             if (is.null(name)) 
[15:32:29.912]                               next
[15:32:29.912]                             if (!grepl(pattern, name)) 
[15:32:29.912]                               next
[15:32:29.912]                             invokeRestart(restart)
[15:32:29.912]                             muffled <- TRUE
[15:32:29.912]                             break
[15:32:29.912]                           }
[15:32:29.912]                         }
[15:32:29.912]                       }
[15:32:29.912]                       invisible(muffled)
[15:32:29.912]                     }
[15:32:29.912]                     muffleCondition(cond, pattern = "^muffle")
[15:32:29.912]                   }
[15:32:29.912]                 }
[15:32:29.912]             }
[15:32:29.912]         }))
[15:32:29.912]     }, error = function(ex) {
[15:32:29.912]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:29.912]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:29.912]                 ...future.rng), started = ...future.startTime, 
[15:32:29.912]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:29.912]             version = "1.8"), class = "FutureResult")
[15:32:29.912]     }, finally = {
[15:32:29.912]         if (!identical(...future.workdir, getwd())) 
[15:32:29.912]             setwd(...future.workdir)
[15:32:29.912]         {
[15:32:29.912]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:29.912]                 ...future.oldOptions$nwarnings <- NULL
[15:32:29.912]             }
[15:32:29.912]             base::options(...future.oldOptions)
[15:32:29.912]             if (.Platform$OS.type == "windows") {
[15:32:29.912]                 old_names <- names(...future.oldEnvVars)
[15:32:29.912]                 envs <- base::Sys.getenv()
[15:32:29.912]                 names <- names(envs)
[15:32:29.912]                 common <- intersect(names, old_names)
[15:32:29.912]                 added <- setdiff(names, old_names)
[15:32:29.912]                 removed <- setdiff(old_names, names)
[15:32:29.912]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:29.912]                   envs[common]]
[15:32:29.912]                 NAMES <- toupper(changed)
[15:32:29.912]                 args <- list()
[15:32:29.912]                 for (kk in seq_along(NAMES)) {
[15:32:29.912]                   name <- changed[[kk]]
[15:32:29.912]                   NAME <- NAMES[[kk]]
[15:32:29.912]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:29.912]                     next
[15:32:29.912]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:29.912]                 }
[15:32:29.912]                 NAMES <- toupper(added)
[15:32:29.912]                 for (kk in seq_along(NAMES)) {
[15:32:29.912]                   name <- added[[kk]]
[15:32:29.912]                   NAME <- NAMES[[kk]]
[15:32:29.912]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:29.912]                     next
[15:32:29.912]                   args[[name]] <- ""
[15:32:29.912]                 }
[15:32:29.912]                 NAMES <- toupper(removed)
[15:32:29.912]                 for (kk in seq_along(NAMES)) {
[15:32:29.912]                   name <- removed[[kk]]
[15:32:29.912]                   NAME <- NAMES[[kk]]
[15:32:29.912]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:29.912]                     next
[15:32:29.912]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:29.912]                 }
[15:32:29.912]                 if (length(args) > 0) 
[15:32:29.912]                   base::do.call(base::Sys.setenv, args = args)
[15:32:29.912]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:29.912]             }
[15:32:29.912]             else {
[15:32:29.912]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:29.912]             }
[15:32:29.912]             {
[15:32:29.912]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:29.912]                   0L) {
[15:32:29.912]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:29.912]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:29.912]                   base::options(opts)
[15:32:29.912]                 }
[15:32:29.912]                 {
[15:32:29.912]                   {
[15:32:29.912]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:29.912]                     NULL
[15:32:29.912]                   }
[15:32:29.912]                   options(future.plan = NULL)
[15:32:29.912]                   if (is.na(NA_character_)) 
[15:32:29.912]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:29.912]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:29.912]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:29.912]                     .init = FALSE)
[15:32:29.912]                 }
[15:32:29.912]             }
[15:32:29.912]         }
[15:32:29.912]     })
[15:32:29.912]     if (TRUE) {
[15:32:29.912]         base::sink(type = "output", split = FALSE)
[15:32:29.912]         if (TRUE) {
[15:32:29.912]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:29.912]         }
[15:32:29.912]         else {
[15:32:29.912]             ...future.result["stdout"] <- base::list(NULL)
[15:32:29.912]         }
[15:32:29.912]         base::close(...future.stdout)
[15:32:29.912]         ...future.stdout <- NULL
[15:32:29.912]     }
[15:32:29.912]     ...future.result$conditions <- ...future.conditions
[15:32:29.912]     ...future.result$finished <- base::Sys.time()
[15:32:29.912]     ...future.result
[15:32:29.912] }
[15:32:29.922] Exporting 5 global objects (1.22 KiB) to cluster node #1 ...
[15:32:29.923] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ...
[15:32:29.924] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ... DONE
[15:32:29.924] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:29.925] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:29.925] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:29.926] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:29.926] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:29.927] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:29.927] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:29.928] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:29.928] Exporting 5 global objects (1.22 KiB) to cluster node #1 ... DONE
[15:32:29.929] MultisessionFuture started
[15:32:29.929] - Launch lazy future ... done
[15:32:29.929] run() for 'MultisessionFuture' ... done
[15:32:29.930] Created future:
[15:32:29.986] receiveMessageFromWorker() for ClusterFuture ...
[15:32:29.986] - Validating connection of MultisessionFuture
[15:32:29.987] - received message: FutureResult
[15:32:29.987] - Received FutureResult
[15:32:29.988] - Erased future from FutureRegistry
[15:32:29.988] result() for ClusterFuture ...
[15:32:29.988] - result already collected: FutureResult
[15:32:29.988] result() for ClusterFuture ... done
[15:32:29.989] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:29.930] MultisessionFuture:
[15:32:29.930] Label: 'future_sapply-2'
[15:32:29.930] Expression:
[15:32:29.930] {
[15:32:29.930]     do.call(function(...) {
[15:32:29.930]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:29.930]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:29.930]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:29.930]             on.exit(options(oopts), add = TRUE)
[15:32:29.930]         }
[15:32:29.930]         {
[15:32:29.930]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:29.930]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:29.930]                 ...future.FUN(...future.X_jj, ...)
[15:32:29.930]             })
[15:32:29.930]         }
[15:32:29.930]     }, args = future.call.arguments)
[15:32:29.930] }
[15:32:29.930] Lazy evaluation: FALSE
[15:32:29.930] Asynchronous evaluation: TRUE
[15:32:29.930] Local evaluation: TRUE
[15:32:29.930] Environment: R_GlobalEnv
[15:32:29.930] Capture standard output: TRUE
[15:32:29.930] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:29.930] Globals: 5 objects totaling 1.33 KiB (function '...future.FUN' of 1.22 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)
[15:32:29.930] Packages: <none>
[15:32:29.930] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:29.930] Resolved: TRUE
[15:32:29.930] Value: <not collected>
[15:32:29.930] Conditions captured: <none>
[15:32:29.930] Early signaling: FALSE
[15:32:29.930] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:29.930] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:29.990] Chunk #2 of 2 ... DONE
[15:32:29.990] Launching 2 futures (chunks) ... DONE
[15:32:29.990] Resolving 2 futures (chunks) ...
[15:32:29.991] resolve() on list ...
[15:32:29.991]  recursive: 0
[15:32:29.991]  length: 2
[15:32:29.992] 
[15:32:29.992] Future #1
[15:32:29.992] result() for ClusterFuture ...
[15:32:29.993] - result already collected: FutureResult
[15:32:29.993] result() for ClusterFuture ... done
[15:32:29.993] result() for ClusterFuture ...
[15:32:29.994] - result already collected: FutureResult
[15:32:29.994] result() for ClusterFuture ... done
[15:32:29.994] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:29.994] - nx: 2
[15:32:29.995] - relay: TRUE
[15:32:29.995] - stdout: TRUE
[15:32:29.995] - signal: TRUE
[15:32:29.996] - resignal: FALSE
[15:32:29.996] - force: TRUE
[15:32:29.996] - relayed: [n=2] FALSE, FALSE
[15:32:29.996] - queued futures: [n=2] FALSE, FALSE
[15:32:29.997]  - until=1
[15:32:29.997]  - relaying element #1
[15:32:29.997] result() for ClusterFuture ...
[15:32:29.998] - result already collected: FutureResult
[15:32:29.998] result() for ClusterFuture ... done
[15:32:29.998] result() for ClusterFuture ...
[15:32:29.999] - result already collected: FutureResult
[15:32:29.999] result() for ClusterFuture ... done
[15:32:29.999] result() for ClusterFuture ...
[15:32:30.000] - result already collected: FutureResult
[15:32:30.000] result() for ClusterFuture ... done
[15:32:30.000] result() for ClusterFuture ...
[15:32:30.000] - result already collected: FutureResult
[15:32:30.001] result() for ClusterFuture ... done
[15:32:30.001] - relayed: [n=2] TRUE, FALSE
[15:32:30.001] - queued futures: [n=2] TRUE, FALSE
[15:32:30.002] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:30.002]  length: 1 (resolved future 1)
[15:32:30.002] Future #2
[15:32:30.003] result() for ClusterFuture ...
[15:32:30.003] - result already collected: FutureResult
[15:32:30.003] result() for ClusterFuture ... done
[15:32:30.004] result() for ClusterFuture ...
[15:32:30.004] - result already collected: FutureResult
[15:32:30.004] result() for ClusterFuture ... done
[15:32:30.005] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:30.005] - nx: 2
[15:32:30.005] - relay: TRUE
[15:32:30.005] - stdout: TRUE
[15:32:30.006] - signal: TRUE
[15:32:30.006] - resignal: FALSE
[15:32:30.006] - force: TRUE
[15:32:30.007] - relayed: [n=2] TRUE, FALSE
[15:32:30.007] - queued futures: [n=2] TRUE, FALSE
[15:32:30.007]  - until=2
[15:32:30.012]  - relaying element #2
[15:32:30.012] result() for ClusterFuture ...
[15:32:30.013] - result already collected: FutureResult
[15:32:30.013] result() for ClusterFuture ... done
[15:32:30.013] result() for ClusterFuture ...
[15:32:30.014] - result already collected: FutureResult
[15:32:30.014] result() for ClusterFuture ... done
[15:32:30.014] result() for ClusterFuture ...
[15:32:30.015] - result already collected: FutureResult
[15:32:30.015] result() for ClusterFuture ... done
[15:32:30.015] result() for ClusterFuture ...
[15:32:30.016] - result already collected: FutureResult
[15:32:30.016] result() for ClusterFuture ... done
[15:32:30.016] - relayed: [n=2] TRUE, TRUE
[15:32:30.016] - queued futures: [n=2] TRUE, TRUE
[15:32:30.017] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:30.017]  length: 0 (resolved future 2)
[15:32:30.017] Relaying remaining futures
[15:32:30.017] signalConditionsASAP(NULL, pos=0) ...
[15:32:30.018] - nx: 2
[15:32:30.018] - relay: TRUE
[15:32:30.018] - stdout: TRUE
[15:32:30.018] - signal: TRUE
[15:32:30.018] - resignal: FALSE
[15:32:30.018] - force: TRUE
[15:32:30.019] - relayed: [n=2] TRUE, TRUE
[15:32:30.019] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:30.019] - relayed: [n=2] TRUE, TRUE
[15:32:30.019] - queued futures: [n=2] TRUE, TRUE
[15:32:30.019] signalConditionsASAP(NULL, pos=0) ... done
[15:32:30.020] resolve() on list ... DONE
[15:32:30.020] result() for ClusterFuture ...
[15:32:30.020] - result already collected: FutureResult
[15:32:30.020] result() for ClusterFuture ... done
[15:32:30.020] result() for ClusterFuture ...
[15:32:30.020] - result already collected: FutureResult
[15:32:30.020] result() for ClusterFuture ... done
[15:32:30.021] result() for ClusterFuture ...
[15:32:30.021] - result already collected: FutureResult
[15:32:30.021] result() for ClusterFuture ... done
[15:32:30.021] result() for ClusterFuture ...
[15:32:30.021] - result already collected: FutureResult
[15:32:30.022] result() for ClusterFuture ... done
[15:32:30.022]  - Number of value chunks collected: 2
[15:32:30.022] Resolving 2 futures (chunks) ... DONE
[15:32:30.022] Reducing values from 2 chunks ...
[15:32:30.022]  - Number of values collected after concatenation: 3
[15:32:30.022]  - Number of values expected: 3
[15:32:30.023] Reducing values from 2 chunks ... DONE
[15:32:30.023] future_lapply() ... DONE
List of 2
 $ y0: Named num [1:3] 1 2 3
  ..- attr(*, "names")= chr [1:3] "a" "b" "c"
 $ y1: Named num [1:3] 1 2 3
  ..- attr(*, "names")= chr [1:3] "a" "b" "c"
[15:32:30.025] future_lapply() ...
[15:32:30.030] Number of chunks: 2
[15:32:30.030] getGlobalsAndPackagesXApply() ...
[15:32:30.030]  - future.globals: TRUE
[15:32:30.031] getGlobalsAndPackages() ...
[15:32:30.031] Searching for globals...
[15:32:30.033] - globals found: [5] 'FUN', '*', ':', 'outer', 'rep'
[15:32:30.033] Searching for globals ... DONE
[15:32:30.033] Resolving globals: FALSE
[15:32:30.034] The total size of the 1 globals is 4.62 KiB (4728 bytes)
[15:32:30.034] The total size of the 1 globals exported for future expression ('FUN()') is 4.62 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.62 KiB of class 'function')
[15:32:30.034] - globals: [1] 'FUN'
[15:32:30.035] 
[15:32:30.035] getGlobalsAndPackages() ... DONE
[15:32:30.035]  - globals found/used: [n=1] 'FUN'
[15:32:30.035]  - needed namespaces: [n=0] 
[15:32:30.035] Finding globals ... DONE
[15:32:30.036]  - use_args: TRUE
[15:32:30.036]  - Getting '...' globals ...
[15:32:30.036] resolve() on list ...
[15:32:30.036]  recursive: 0
[15:32:30.037]  length: 1
[15:32:30.037]  elements: '...'
[15:32:30.037]  length: 0 (resolved future 1)
[15:32:30.037] resolve() on list ... DONE
[15:32:30.037]    - '...' content: [n=0] 
[15:32:30.038] List of 1
[15:32:30.038]  $ ...: list()
[15:32:30.038]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:30.038]  - attr(*, "where")=List of 1
[15:32:30.038]   ..$ ...:<environment: 0x00000276e287cc68> 
[15:32:30.038]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:30.038]  - attr(*, "resolved")= logi TRUE
[15:32:30.038]  - attr(*, "total_size")= num NA
[15:32:30.041]  - Getting '...' globals ... DONE
[15:32:30.041] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:30.041] List of 2
[15:32:30.041]  $ ...future.FUN:function (x, y = 2 * 1:5)  
[15:32:30.041]  $ ...          : list()
[15:32:30.041]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:30.041]  - attr(*, "where")=List of 2
[15:32:30.041]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:30.041]   ..$ ...          :<environment: 0x00000276e287cc68> 
[15:32:30.041]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:30.041]  - attr(*, "resolved")= logi FALSE
[15:32:30.041]  - attr(*, "total_size")= num 4728
[15:32:30.045] Packages to be attached in all futures: [n=0] 
[15:32:30.045] getGlobalsAndPackagesXApply() ... DONE
[15:32:30.045] Number of futures (= number of chunks): 2
[15:32:30.046] Launching 2 futures (chunks) ...
[15:32:30.046] Chunk #1 of 2 ...
[15:32:30.046]  - Finding globals in 'X' for chunk #1 ...
[15:32:30.046] getGlobalsAndPackages() ...
[15:32:30.046] Searching for globals...
[15:32:30.047] 
[15:32:30.047] Searching for globals ... DONE
[15:32:30.047] - globals: [0] <none>
[15:32:30.047] getGlobalsAndPackages() ... DONE
[15:32:30.047]    + additional globals found: [n=0] 
[15:32:30.048]    + additional namespaces needed: [n=0] 
[15:32:30.048]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:30.048]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:30.048]  - seeds: <none>
[15:32:30.048]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:30.048] getGlobalsAndPackages() ...
[15:32:30.049] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:30.049] Resolving globals: FALSE
[15:32:30.049] Tweak future expression to call with '...' arguments ...
[15:32:30.049] {
[15:32:30.049]     do.call(function(...) {
[15:32:30.049]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:30.049]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:30.049]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:30.049]             on.exit(options(oopts), add = TRUE)
[15:32:30.049]         }
[15:32:30.049]         {
[15:32:30.049]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:30.049]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:30.049]                 ...future.FUN(...future.X_jj, ...)
[15:32:30.049]             })
[15:32:30.049]         }
[15:32:30.049]     }, args = future.call.arguments)
[15:32:30.049] }
[15:32:30.050] Tweak future expression to call with '...' arguments ... DONE
[15:32:30.050] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:30.050] 
[15:32:30.051] getGlobalsAndPackages() ... DONE
[15:32:30.051] run() for 'Future' ...
[15:32:30.051] - state: 'created'
[15:32:30.052] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:30.068] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:30.068] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:30.069]   - Field: 'node'
[15:32:30.069]   - Field: 'label'
[15:32:30.069]   - Field: 'local'
[15:32:30.069]   - Field: 'owner'
[15:32:30.069]   - Field: 'envir'
[15:32:30.070]   - Field: 'workers'
[15:32:30.070]   - Field: 'packages'
[15:32:30.070]   - Field: 'gc'
[15:32:30.071]   - Field: 'conditions'
[15:32:30.071]   - Field: 'persistent'
[15:32:30.071]   - Field: 'expr'
[15:32:30.072]   - Field: 'uuid'
[15:32:30.072]   - Field: 'seed'
[15:32:30.072]   - Field: 'version'
[15:32:30.073]   - Field: 'result'
[15:32:30.073]   - Field: 'asynchronous'
[15:32:30.073]   - Field: 'calls'
[15:32:30.074]   - Field: 'globals'
[15:32:30.074]   - Field: 'stdout'
[15:32:30.074]   - Field: 'earlySignal'
[15:32:30.075]   - Field: 'lazy'
[15:32:30.075]   - Field: 'state'
[15:32:30.075] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:30.076] - Launch lazy future ...
[15:32:30.076] Packages needed by the future expression (n = 0): <none>
[15:32:30.077] Packages needed by future strategies (n = 0): <none>
[15:32:30.078] {
[15:32:30.078]     {
[15:32:30.078]         {
[15:32:30.078]             ...future.startTime <- base::Sys.time()
[15:32:30.078]             {
[15:32:30.078]                 {
[15:32:30.078]                   {
[15:32:30.078]                     {
[15:32:30.078]                       base::local({
[15:32:30.078]                         has_future <- base::requireNamespace("future", 
[15:32:30.078]                           quietly = TRUE)
[15:32:30.078]                         if (has_future) {
[15:32:30.078]                           ns <- base::getNamespace("future")
[15:32:30.078]                           version <- ns[[".package"]][["version"]]
[15:32:30.078]                           if (is.null(version)) 
[15:32:30.078]                             version <- utils::packageVersion("future")
[15:32:30.078]                         }
[15:32:30.078]                         else {
[15:32:30.078]                           version <- NULL
[15:32:30.078]                         }
[15:32:30.078]                         if (!has_future || version < "1.8.0") {
[15:32:30.078]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:30.078]                             "", base::R.version$version.string), 
[15:32:30.078]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:30.078]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:30.078]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:30.078]                               "release", "version")], collapse = " "), 
[15:32:30.078]                             hostname = base::Sys.info()[["nodename"]])
[15:32:30.078]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:30.078]                             info)
[15:32:30.078]                           info <- base::paste(info, collapse = "; ")
[15:32:30.078]                           if (!has_future) {
[15:32:30.078]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:30.078]                               info)
[15:32:30.078]                           }
[15:32:30.078]                           else {
[15:32:30.078]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:30.078]                               info, version)
[15:32:30.078]                           }
[15:32:30.078]                           base::stop(msg)
[15:32:30.078]                         }
[15:32:30.078]                       })
[15:32:30.078]                     }
[15:32:30.078]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:30.078]                     base::options(mc.cores = 1L)
[15:32:30.078]                   }
[15:32:30.078]                   ...future.strategy.old <- future::plan("list")
[15:32:30.078]                   options(future.plan = NULL)
[15:32:30.078]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:30.078]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:30.078]                 }
[15:32:30.078]                 ...future.workdir <- getwd()
[15:32:30.078]             }
[15:32:30.078]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:30.078]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:30.078]         }
[15:32:30.078]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:30.078]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:30.078]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:30.078]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:30.078]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:30.078]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:30.078]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:30.078]             base::names(...future.oldOptions))
[15:32:30.078]     }
[15:32:30.078]     if (FALSE) {
[15:32:30.078]     }
[15:32:30.078]     else {
[15:32:30.078]         if (TRUE) {
[15:32:30.078]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:30.078]                 open = "w")
[15:32:30.078]         }
[15:32:30.078]         else {
[15:32:30.078]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:30.078]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:30.078]         }
[15:32:30.078]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:30.078]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:30.078]             base::sink(type = "output", split = FALSE)
[15:32:30.078]             base::close(...future.stdout)
[15:32:30.078]         }, add = TRUE)
[15:32:30.078]     }
[15:32:30.078]     ...future.frame <- base::sys.nframe()
[15:32:30.078]     ...future.conditions <- base::list()
[15:32:30.078]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:30.078]     if (FALSE) {
[15:32:30.078]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:30.078]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:30.078]     }
[15:32:30.078]     ...future.result <- base::tryCatch({
[15:32:30.078]         base::withCallingHandlers({
[15:32:30.078]             ...future.value <- base::withVisible(base::local({
[15:32:30.078]                 ...future.makeSendCondition <- base::local({
[15:32:30.078]                   sendCondition <- NULL
[15:32:30.078]                   function(frame = 1L) {
[15:32:30.078]                     if (is.function(sendCondition)) 
[15:32:30.078]                       return(sendCondition)
[15:32:30.078]                     ns <- getNamespace("parallel")
[15:32:30.078]                     if (exists("sendData", mode = "function", 
[15:32:30.078]                       envir = ns)) {
[15:32:30.078]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:30.078]                         envir = ns)
[15:32:30.078]                       envir <- sys.frame(frame)
[15:32:30.078]                       master <- NULL
[15:32:30.078]                       while (!identical(envir, .GlobalEnv) && 
[15:32:30.078]                         !identical(envir, emptyenv())) {
[15:32:30.078]                         if (exists("master", mode = "list", envir = envir, 
[15:32:30.078]                           inherits = FALSE)) {
[15:32:30.078]                           master <- get("master", mode = "list", 
[15:32:30.078]                             envir = envir, inherits = FALSE)
[15:32:30.078]                           if (inherits(master, c("SOCKnode", 
[15:32:30.078]                             "SOCK0node"))) {
[15:32:30.078]                             sendCondition <<- function(cond) {
[15:32:30.078]                               data <- list(type = "VALUE", value = cond, 
[15:32:30.078]                                 success = TRUE)
[15:32:30.078]                               parallel_sendData(master, data)
[15:32:30.078]                             }
[15:32:30.078]                             return(sendCondition)
[15:32:30.078]                           }
[15:32:30.078]                         }
[15:32:30.078]                         frame <- frame + 1L
[15:32:30.078]                         envir <- sys.frame(frame)
[15:32:30.078]                       }
[15:32:30.078]                     }
[15:32:30.078]                     sendCondition <<- function(cond) NULL
[15:32:30.078]                   }
[15:32:30.078]                 })
[15:32:30.078]                 withCallingHandlers({
[15:32:30.078]                   {
[15:32:30.078]                     do.call(function(...) {
[15:32:30.078]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:30.078]                       if (!identical(...future.globals.maxSize.org, 
[15:32:30.078]                         ...future.globals.maxSize)) {
[15:32:30.078]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:30.078]                         on.exit(options(oopts), add = TRUE)
[15:32:30.078]                       }
[15:32:30.078]                       {
[15:32:30.078]                         lapply(seq_along(...future.elements_ii), 
[15:32:30.078]                           FUN = function(jj) {
[15:32:30.078]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:30.078]                             ...future.FUN(...future.X_jj, ...)
[15:32:30.078]                           })
[15:32:30.078]                       }
[15:32:30.078]                     }, args = future.call.arguments)
[15:32:30.078]                   }
[15:32:30.078]                 }, immediateCondition = function(cond) {
[15:32:30.078]                   sendCondition <- ...future.makeSendCondition()
[15:32:30.078]                   sendCondition(cond)
[15:32:30.078]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:30.078]                   {
[15:32:30.078]                     inherits <- base::inherits
[15:32:30.078]                     invokeRestart <- base::invokeRestart
[15:32:30.078]                     is.null <- base::is.null
[15:32:30.078]                     muffled <- FALSE
[15:32:30.078]                     if (inherits(cond, "message")) {
[15:32:30.078]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:30.078]                       if (muffled) 
[15:32:30.078]                         invokeRestart("muffleMessage")
[15:32:30.078]                     }
[15:32:30.078]                     else if (inherits(cond, "warning")) {
[15:32:30.078]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:30.078]                       if (muffled) 
[15:32:30.078]                         invokeRestart("muffleWarning")
[15:32:30.078]                     }
[15:32:30.078]                     else if (inherits(cond, "condition")) {
[15:32:30.078]                       if (!is.null(pattern)) {
[15:32:30.078]                         computeRestarts <- base::computeRestarts
[15:32:30.078]                         grepl <- base::grepl
[15:32:30.078]                         restarts <- computeRestarts(cond)
[15:32:30.078]                         for (restart in restarts) {
[15:32:30.078]                           name <- restart$name
[15:32:30.078]                           if (is.null(name)) 
[15:32:30.078]                             next
[15:32:30.078]                           if (!grepl(pattern, name)) 
[15:32:30.078]                             next
[15:32:30.078]                           invokeRestart(restart)
[15:32:30.078]                           muffled <- TRUE
[15:32:30.078]                           break
[15:32:30.078]                         }
[15:32:30.078]                       }
[15:32:30.078]                     }
[15:32:30.078]                     invisible(muffled)
[15:32:30.078]                   }
[15:32:30.078]                   muffleCondition(cond)
[15:32:30.078]                 })
[15:32:30.078]             }))
[15:32:30.078]             future::FutureResult(value = ...future.value$value, 
[15:32:30.078]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:30.078]                   ...future.rng), globalenv = if (FALSE) 
[15:32:30.078]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:30.078]                     ...future.globalenv.names))
[15:32:30.078]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:30.078]         }, condition = base::local({
[15:32:30.078]             c <- base::c
[15:32:30.078]             inherits <- base::inherits
[15:32:30.078]             invokeRestart <- base::invokeRestart
[15:32:30.078]             length <- base::length
[15:32:30.078]             list <- base::list
[15:32:30.078]             seq.int <- base::seq.int
[15:32:30.078]             signalCondition <- base::signalCondition
[15:32:30.078]             sys.calls <- base::sys.calls
[15:32:30.078]             `[[` <- base::`[[`
[15:32:30.078]             `+` <- base::`+`
[15:32:30.078]             `<<-` <- base::`<<-`
[15:32:30.078]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:30.078]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:30.078]                   3L)]
[15:32:30.078]             }
[15:32:30.078]             function(cond) {
[15:32:30.078]                 is_error <- inherits(cond, "error")
[15:32:30.078]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:30.078]                   NULL)
[15:32:30.078]                 if (is_error) {
[15:32:30.078]                   sessionInformation <- function() {
[15:32:30.078]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:30.078]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:30.078]                       search = base::search(), system = base::Sys.info())
[15:32:30.078]                   }
[15:32:30.078]                   ...future.conditions[[length(...future.conditions) + 
[15:32:30.078]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:30.078]                     cond$call), session = sessionInformation(), 
[15:32:30.078]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:30.078]                   signalCondition(cond)
[15:32:30.078]                 }
[15:32:30.078]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:30.078]                 "immediateCondition"))) {
[15:32:30.078]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:30.078]                   ...future.conditions[[length(...future.conditions) + 
[15:32:30.078]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:30.078]                   if (TRUE && !signal) {
[15:32:30.078]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:30.078]                     {
[15:32:30.078]                       inherits <- base::inherits
[15:32:30.078]                       invokeRestart <- base::invokeRestart
[15:32:30.078]                       is.null <- base::is.null
[15:32:30.078]                       muffled <- FALSE
[15:32:30.078]                       if (inherits(cond, "message")) {
[15:32:30.078]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:30.078]                         if (muffled) 
[15:32:30.078]                           invokeRestart("muffleMessage")
[15:32:30.078]                       }
[15:32:30.078]                       else if (inherits(cond, "warning")) {
[15:32:30.078]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:30.078]                         if (muffled) 
[15:32:30.078]                           invokeRestart("muffleWarning")
[15:32:30.078]                       }
[15:32:30.078]                       else if (inherits(cond, "condition")) {
[15:32:30.078]                         if (!is.null(pattern)) {
[15:32:30.078]                           computeRestarts <- base::computeRestarts
[15:32:30.078]                           grepl <- base::grepl
[15:32:30.078]                           restarts <- computeRestarts(cond)
[15:32:30.078]                           for (restart in restarts) {
[15:32:30.078]                             name <- restart$name
[15:32:30.078]                             if (is.null(name)) 
[15:32:30.078]                               next
[15:32:30.078]                             if (!grepl(pattern, name)) 
[15:32:30.078]                               next
[15:32:30.078]                             invokeRestart(restart)
[15:32:30.078]                             muffled <- TRUE
[15:32:30.078]                             break
[15:32:30.078]                           }
[15:32:30.078]                         }
[15:32:30.078]                       }
[15:32:30.078]                       invisible(muffled)
[15:32:30.078]                     }
[15:32:30.078]                     muffleCondition(cond, pattern = "^muffle")
[15:32:30.078]                   }
[15:32:30.078]                 }
[15:32:30.078]                 else {
[15:32:30.078]                   if (TRUE) {
[15:32:30.078]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:30.078]                     {
[15:32:30.078]                       inherits <- base::inherits
[15:32:30.078]                       invokeRestart <- base::invokeRestart
[15:32:30.078]                       is.null <- base::is.null
[15:32:30.078]                       muffled <- FALSE
[15:32:30.078]                       if (inherits(cond, "message")) {
[15:32:30.078]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:30.078]                         if (muffled) 
[15:32:30.078]                           invokeRestart("muffleMessage")
[15:32:30.078]                       }
[15:32:30.078]                       else if (inherits(cond, "warning")) {
[15:32:30.078]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:30.078]                         if (muffled) 
[15:32:30.078]                           invokeRestart("muffleWarning")
[15:32:30.078]                       }
[15:32:30.078]                       else if (inherits(cond, "condition")) {
[15:32:30.078]                         if (!is.null(pattern)) {
[15:32:30.078]                           computeRestarts <- base::computeRestarts
[15:32:30.078]                           grepl <- base::grepl
[15:32:30.078]                           restarts <- computeRestarts(cond)
[15:32:30.078]                           for (restart in restarts) {
[15:32:30.078]                             name <- restart$name
[15:32:30.078]                             if (is.null(name)) 
[15:32:30.078]                               next
[15:32:30.078]                             if (!grepl(pattern, name)) 
[15:32:30.078]                               next
[15:32:30.078]                             invokeRestart(restart)
[15:32:30.078]                             muffled <- TRUE
[15:32:30.078]                             break
[15:32:30.078]                           }
[15:32:30.078]                         }
[15:32:30.078]                       }
[15:32:30.078]                       invisible(muffled)
[15:32:30.078]                     }
[15:32:30.078]                     muffleCondition(cond, pattern = "^muffle")
[15:32:30.078]                   }
[15:32:30.078]                 }
[15:32:30.078]             }
[15:32:30.078]         }))
[15:32:30.078]     }, error = function(ex) {
[15:32:30.078]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:30.078]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:30.078]                 ...future.rng), started = ...future.startTime, 
[15:32:30.078]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:30.078]             version = "1.8"), class = "FutureResult")
[15:32:30.078]     }, finally = {
[15:32:30.078]         if (!identical(...future.workdir, getwd())) 
[15:32:30.078]             setwd(...future.workdir)
[15:32:30.078]         {
[15:32:30.078]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:30.078]                 ...future.oldOptions$nwarnings <- NULL
[15:32:30.078]             }
[15:32:30.078]             base::options(...future.oldOptions)
[15:32:30.078]             if (.Platform$OS.type == "windows") {
[15:32:30.078]                 old_names <- names(...future.oldEnvVars)
[15:32:30.078]                 envs <- base::Sys.getenv()
[15:32:30.078]                 names <- names(envs)
[15:32:30.078]                 common <- intersect(names, old_names)
[15:32:30.078]                 added <- setdiff(names, old_names)
[15:32:30.078]                 removed <- setdiff(old_names, names)
[15:32:30.078]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:30.078]                   envs[common]]
[15:32:30.078]                 NAMES <- toupper(changed)
[15:32:30.078]                 args <- list()
[15:32:30.078]                 for (kk in seq_along(NAMES)) {
[15:32:30.078]                   name <- changed[[kk]]
[15:32:30.078]                   NAME <- NAMES[[kk]]
[15:32:30.078]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:30.078]                     next
[15:32:30.078]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:30.078]                 }
[15:32:30.078]                 NAMES <- toupper(added)
[15:32:30.078]                 for (kk in seq_along(NAMES)) {
[15:32:30.078]                   name <- added[[kk]]
[15:32:30.078]                   NAME <- NAMES[[kk]]
[15:32:30.078]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:30.078]                     next
[15:32:30.078]                   args[[name]] <- ""
[15:32:30.078]                 }
[15:32:30.078]                 NAMES <- toupper(removed)
[15:32:30.078]                 for (kk in seq_along(NAMES)) {
[15:32:30.078]                   name <- removed[[kk]]
[15:32:30.078]                   NAME <- NAMES[[kk]]
[15:32:30.078]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:30.078]                     next
[15:32:30.078]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:30.078]                 }
[15:32:30.078]                 if (length(args) > 0) 
[15:32:30.078]                   base::do.call(base::Sys.setenv, args = args)
[15:32:30.078]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:30.078]             }
[15:32:30.078]             else {
[15:32:30.078]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:30.078]             }
[15:32:30.078]             {
[15:32:30.078]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:30.078]                   0L) {
[15:32:30.078]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:30.078]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:30.078]                   base::options(opts)
[15:32:30.078]                 }
[15:32:30.078]                 {
[15:32:30.078]                   {
[15:32:30.078]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:30.078]                     NULL
[15:32:30.078]                   }
[15:32:30.078]                   options(future.plan = NULL)
[15:32:30.078]                   if (is.na(NA_character_)) 
[15:32:30.078]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:30.078]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:30.078]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:30.078]                     .init = FALSE)
[15:32:30.078]                 }
[15:32:30.078]             }
[15:32:30.078]         }
[15:32:30.078]     })
[15:32:30.078]     if (TRUE) {
[15:32:30.078]         base::sink(type = "output", split = FALSE)
[15:32:30.078]         if (TRUE) {
[15:32:30.078]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:30.078]         }
[15:32:30.078]         else {
[15:32:30.078]             ...future.result["stdout"] <- base::list(NULL)
[15:32:30.078]         }
[15:32:30.078]         base::close(...future.stdout)
[15:32:30.078]         ...future.stdout <- NULL
[15:32:30.078]     }
[15:32:30.078]     ...future.result$conditions <- ...future.conditions
[15:32:30.078]     ...future.result$finished <- base::Sys.time()
[15:32:30.078]     ...future.result
[15:32:30.078] }
[15:32:30.087] Exporting 5 global objects (4.62 KiB) to cluster node #1 ...
[15:32:30.088] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ...
[15:32:30.089] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ... DONE
[15:32:30.089] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:30.090] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:30.090] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ...
[15:32:30.091] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ... DONE
[15:32:30.092] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:30.092] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:30.092] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:30.093] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:30.093] Exporting 5 global objects (4.62 KiB) to cluster node #1 ... DONE
[15:32:30.094] MultisessionFuture started
[15:32:30.095] - Launch lazy future ... done
[15:32:30.095] run() for 'MultisessionFuture' ... done
[15:32:30.095] Created future:
[15:32:30.123] receiveMessageFromWorker() for ClusterFuture ...
[15:32:30.124] - Validating connection of MultisessionFuture
[15:32:30.124] - received message: FutureResult
[15:32:30.125] - Received FutureResult
[15:32:30.125] - Erased future from FutureRegistry
[15:32:30.125] result() for ClusterFuture ...
[15:32:30.126] - result already collected: FutureResult
[15:32:30.126] result() for ClusterFuture ... done
[15:32:30.126] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:30.096] MultisessionFuture:
[15:32:30.096] Label: 'future_sapply-1'
[15:32:30.096] Expression:
[15:32:30.096] {
[15:32:30.096]     do.call(function(...) {
[15:32:30.096]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:30.096]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:30.096]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:30.096]             on.exit(options(oopts), add = TRUE)
[15:32:30.096]         }
[15:32:30.096]         {
[15:32:30.096]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:30.096]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:30.096]                 ...future.FUN(...future.X_jj, ...)
[15:32:30.096]             })
[15:32:30.096]         }
[15:32:30.096]     }, args = future.call.arguments)
[15:32:30.096] }
[15:32:30.096] Lazy evaluation: FALSE
[15:32:30.096] Asynchronous evaluation: TRUE
[15:32:30.096] Local evaluation: TRUE
[15:32:30.096] Environment: R_GlobalEnv
[15:32:30.096] Capture standard output: TRUE
[15:32:30.096] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:30.096] Globals: 5 objects totaling 4.67 KiB (function '...future.FUN' of 4.62 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)
[15:32:30.096] Packages: <none>
[15:32:30.096] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:30.096] Resolved: TRUE
[15:32:30.096] Value: <not collected>
[15:32:30.096] Conditions captured: <none>
[15:32:30.096] Early signaling: FALSE
[15:32:30.096] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:30.096] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:30.127] Chunk #1 of 2 ... DONE
[15:32:30.127] Chunk #2 of 2 ...
[15:32:30.128]  - Finding globals in 'X' for chunk #2 ...
[15:32:30.128] getGlobalsAndPackages() ...
[15:32:30.128] Searching for globals...
[15:32:30.129] 
[15:32:30.129] Searching for globals ... DONE
[15:32:30.130] - globals: [0] <none>
[15:32:30.130] getGlobalsAndPackages() ... DONE
[15:32:30.130]    + additional globals found: [n=0] 
[15:32:30.130]    + additional namespaces needed: [n=0] 
[15:32:30.131]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:30.131]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:30.131]  - seeds: <none>
[15:32:30.131]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:30.132] getGlobalsAndPackages() ...
[15:32:30.132] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:30.132] Resolving globals: FALSE
[15:32:30.133] Tweak future expression to call with '...' arguments ...
[15:32:30.133] {
[15:32:30.133]     do.call(function(...) {
[15:32:30.133]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:30.133]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:30.133]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:30.133]             on.exit(options(oopts), add = TRUE)
[15:32:30.133]         }
[15:32:30.133]         {
[15:32:30.133]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:30.133]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:30.133]                 ...future.FUN(...future.X_jj, ...)
[15:32:30.133]             })
[15:32:30.133]         }
[15:32:30.133]     }, args = future.call.arguments)
[15:32:30.133] }
[15:32:30.134] Tweak future expression to call with '...' arguments ... DONE
[15:32:30.135] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:30.135] 
[15:32:30.135] getGlobalsAndPackages() ... DONE
[15:32:30.136] run() for 'Future' ...
[15:32:30.136] - state: 'created'
[15:32:30.136] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:30.156] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:30.156] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:30.157]   - Field: 'node'
[15:32:30.157]   - Field: 'label'
[15:32:30.158]   - Field: 'local'
[15:32:30.158]   - Field: 'owner'
[15:32:30.158]   - Field: 'envir'
[15:32:30.159]   - Field: 'workers'
[15:32:30.159]   - Field: 'packages'
[15:32:30.160]   - Field: 'gc'
[15:32:30.160]   - Field: 'conditions'
[15:32:30.160]   - Field: 'persistent'
[15:32:30.161]   - Field: 'expr'
[15:32:30.161]   - Field: 'uuid'
[15:32:30.161]   - Field: 'seed'
[15:32:30.162]   - Field: 'version'
[15:32:30.162]   - Field: 'result'
[15:32:30.163]   - Field: 'asynchronous'
[15:32:30.163]   - Field: 'calls'
[15:32:30.163]   - Field: 'globals'
[15:32:30.164]   - Field: 'stdout'
[15:32:30.164]   - Field: 'earlySignal'
[15:32:30.165]   - Field: 'lazy'
[15:32:30.165]   - Field: 'state'
[15:32:30.165] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:30.166] - Launch lazy future ...
[15:32:30.167] Packages needed by the future expression (n = 0): <none>
[15:32:30.167] Packages needed by future strategies (n = 0): <none>
[15:32:30.168] {
[15:32:30.168]     {
[15:32:30.168]         {
[15:32:30.168]             ...future.startTime <- base::Sys.time()
[15:32:30.168]             {
[15:32:30.168]                 {
[15:32:30.168]                   {
[15:32:30.168]                     {
[15:32:30.168]                       base::local({
[15:32:30.168]                         has_future <- base::requireNamespace("future", 
[15:32:30.168]                           quietly = TRUE)
[15:32:30.168]                         if (has_future) {
[15:32:30.168]                           ns <- base::getNamespace("future")
[15:32:30.168]                           version <- ns[[".package"]][["version"]]
[15:32:30.168]                           if (is.null(version)) 
[15:32:30.168]                             version <- utils::packageVersion("future")
[15:32:30.168]                         }
[15:32:30.168]                         else {
[15:32:30.168]                           version <- NULL
[15:32:30.168]                         }
[15:32:30.168]                         if (!has_future || version < "1.8.0") {
[15:32:30.168]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:30.168]                             "", base::R.version$version.string), 
[15:32:30.168]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:30.168]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:30.168]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:30.168]                               "release", "version")], collapse = " "), 
[15:32:30.168]                             hostname = base::Sys.info()[["nodename"]])
[15:32:30.168]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:30.168]                             info)
[15:32:30.168]                           info <- base::paste(info, collapse = "; ")
[15:32:30.168]                           if (!has_future) {
[15:32:30.168]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:30.168]                               info)
[15:32:30.168]                           }
[15:32:30.168]                           else {
[15:32:30.168]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:30.168]                               info, version)
[15:32:30.168]                           }
[15:32:30.168]                           base::stop(msg)
[15:32:30.168]                         }
[15:32:30.168]                       })
[15:32:30.168]                     }
[15:32:30.168]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:30.168]                     base::options(mc.cores = 1L)
[15:32:30.168]                   }
[15:32:30.168]                   ...future.strategy.old <- future::plan("list")
[15:32:30.168]                   options(future.plan = NULL)
[15:32:30.168]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:30.168]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:30.168]                 }
[15:32:30.168]                 ...future.workdir <- getwd()
[15:32:30.168]             }
[15:32:30.168]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:30.168]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:30.168]         }
[15:32:30.168]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:30.168]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:30.168]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:30.168]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:30.168]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:30.168]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:30.168]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:30.168]             base::names(...future.oldOptions))
[15:32:30.168]     }
[15:32:30.168]     if (FALSE) {
[15:32:30.168]     }
[15:32:30.168]     else {
[15:32:30.168]         if (TRUE) {
[15:32:30.168]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:30.168]                 open = "w")
[15:32:30.168]         }
[15:32:30.168]         else {
[15:32:30.168]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:30.168]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:30.168]         }
[15:32:30.168]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:30.168]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:30.168]             base::sink(type = "output", split = FALSE)
[15:32:30.168]             base::close(...future.stdout)
[15:32:30.168]         }, add = TRUE)
[15:32:30.168]     }
[15:32:30.168]     ...future.frame <- base::sys.nframe()
[15:32:30.168]     ...future.conditions <- base::list()
[15:32:30.168]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:30.168]     if (FALSE) {
[15:32:30.168]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:30.168]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:30.168]     }
[15:32:30.168]     ...future.result <- base::tryCatch({
[15:32:30.168]         base::withCallingHandlers({
[15:32:30.168]             ...future.value <- base::withVisible(base::local({
[15:32:30.168]                 ...future.makeSendCondition <- base::local({
[15:32:30.168]                   sendCondition <- NULL
[15:32:30.168]                   function(frame = 1L) {
[15:32:30.168]                     if (is.function(sendCondition)) 
[15:32:30.168]                       return(sendCondition)
[15:32:30.168]                     ns <- getNamespace("parallel")
[15:32:30.168]                     if (exists("sendData", mode = "function", 
[15:32:30.168]                       envir = ns)) {
[15:32:30.168]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:30.168]                         envir = ns)
[15:32:30.168]                       envir <- sys.frame(frame)
[15:32:30.168]                       master <- NULL
[15:32:30.168]                       while (!identical(envir, .GlobalEnv) && 
[15:32:30.168]                         !identical(envir, emptyenv())) {
[15:32:30.168]                         if (exists("master", mode = "list", envir = envir, 
[15:32:30.168]                           inherits = FALSE)) {
[15:32:30.168]                           master <- get("master", mode = "list", 
[15:32:30.168]                             envir = envir, inherits = FALSE)
[15:32:30.168]                           if (inherits(master, c("SOCKnode", 
[15:32:30.168]                             "SOCK0node"))) {
[15:32:30.168]                             sendCondition <<- function(cond) {
[15:32:30.168]                               data <- list(type = "VALUE", value = cond, 
[15:32:30.168]                                 success = TRUE)
[15:32:30.168]                               parallel_sendData(master, data)
[15:32:30.168]                             }
[15:32:30.168]                             return(sendCondition)
[15:32:30.168]                           }
[15:32:30.168]                         }
[15:32:30.168]                         frame <- frame + 1L
[15:32:30.168]                         envir <- sys.frame(frame)
[15:32:30.168]                       }
[15:32:30.168]                     }
[15:32:30.168]                     sendCondition <<- function(cond) NULL
[15:32:30.168]                   }
[15:32:30.168]                 })
[15:32:30.168]                 withCallingHandlers({
[15:32:30.168]                   {
[15:32:30.168]                     do.call(function(...) {
[15:32:30.168]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:30.168]                       if (!identical(...future.globals.maxSize.org, 
[15:32:30.168]                         ...future.globals.maxSize)) {
[15:32:30.168]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:30.168]                         on.exit(options(oopts), add = TRUE)
[15:32:30.168]                       }
[15:32:30.168]                       {
[15:32:30.168]                         lapply(seq_along(...future.elements_ii), 
[15:32:30.168]                           FUN = function(jj) {
[15:32:30.168]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:30.168]                             ...future.FUN(...future.X_jj, ...)
[15:32:30.168]                           })
[15:32:30.168]                       }
[15:32:30.168]                     }, args = future.call.arguments)
[15:32:30.168]                   }
[15:32:30.168]                 }, immediateCondition = function(cond) {
[15:32:30.168]                   sendCondition <- ...future.makeSendCondition()
[15:32:30.168]                   sendCondition(cond)
[15:32:30.168]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:30.168]                   {
[15:32:30.168]                     inherits <- base::inherits
[15:32:30.168]                     invokeRestart <- base::invokeRestart
[15:32:30.168]                     is.null <- base::is.null
[15:32:30.168]                     muffled <- FALSE
[15:32:30.168]                     if (inherits(cond, "message")) {
[15:32:30.168]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:30.168]                       if (muffled) 
[15:32:30.168]                         invokeRestart("muffleMessage")
[15:32:30.168]                     }
[15:32:30.168]                     else if (inherits(cond, "warning")) {
[15:32:30.168]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:30.168]                       if (muffled) 
[15:32:30.168]                         invokeRestart("muffleWarning")
[15:32:30.168]                     }
[15:32:30.168]                     else if (inherits(cond, "condition")) {
[15:32:30.168]                       if (!is.null(pattern)) {
[15:32:30.168]                         computeRestarts <- base::computeRestarts
[15:32:30.168]                         grepl <- base::grepl
[15:32:30.168]                         restarts <- computeRestarts(cond)
[15:32:30.168]                         for (restart in restarts) {
[15:32:30.168]                           name <- restart$name
[15:32:30.168]                           if (is.null(name)) 
[15:32:30.168]                             next
[15:32:30.168]                           if (!grepl(pattern, name)) 
[15:32:30.168]                             next
[15:32:30.168]                           invokeRestart(restart)
[15:32:30.168]                           muffled <- TRUE
[15:32:30.168]                           break
[15:32:30.168]                         }
[15:32:30.168]                       }
[15:32:30.168]                     }
[15:32:30.168]                     invisible(muffled)
[15:32:30.168]                   }
[15:32:30.168]                   muffleCondition(cond)
[15:32:30.168]                 })
[15:32:30.168]             }))
[15:32:30.168]             future::FutureResult(value = ...future.value$value, 
[15:32:30.168]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:30.168]                   ...future.rng), globalenv = if (FALSE) 
[15:32:30.168]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:30.168]                     ...future.globalenv.names))
[15:32:30.168]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:30.168]         }, condition = base::local({
[15:32:30.168]             c <- base::c
[15:32:30.168]             inherits <- base::inherits
[15:32:30.168]             invokeRestart <- base::invokeRestart
[15:32:30.168]             length <- base::length
[15:32:30.168]             list <- base::list
[15:32:30.168]             seq.int <- base::seq.int
[15:32:30.168]             signalCondition <- base::signalCondition
[15:32:30.168]             sys.calls <- base::sys.calls
[15:32:30.168]             `[[` <- base::`[[`
[15:32:30.168]             `+` <- base::`+`
[15:32:30.168]             `<<-` <- base::`<<-`
[15:32:30.168]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:30.168]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:30.168]                   3L)]
[15:32:30.168]             }
[15:32:30.168]             function(cond) {
[15:32:30.168]                 is_error <- inherits(cond, "error")
[15:32:30.168]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:30.168]                   NULL)
[15:32:30.168]                 if (is_error) {
[15:32:30.168]                   sessionInformation <- function() {
[15:32:30.168]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:30.168]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:30.168]                       search = base::search(), system = base::Sys.info())
[15:32:30.168]                   }
[15:32:30.168]                   ...future.conditions[[length(...future.conditions) + 
[15:32:30.168]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:30.168]                     cond$call), session = sessionInformation(), 
[15:32:30.168]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:30.168]                   signalCondition(cond)
[15:32:30.168]                 }
[15:32:30.168]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:30.168]                 "immediateCondition"))) {
[15:32:30.168]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:30.168]                   ...future.conditions[[length(...future.conditions) + 
[15:32:30.168]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:30.168]                   if (TRUE && !signal) {
[15:32:30.168]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:30.168]                     {
[15:32:30.168]                       inherits <- base::inherits
[15:32:30.168]                       invokeRestart <- base::invokeRestart
[15:32:30.168]                       is.null <- base::is.null
[15:32:30.168]                       muffled <- FALSE
[15:32:30.168]                       if (inherits(cond, "message")) {
[15:32:30.168]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:30.168]                         if (muffled) 
[15:32:30.168]                           invokeRestart("muffleMessage")
[15:32:30.168]                       }
[15:32:30.168]                       else if (inherits(cond, "warning")) {
[15:32:30.168]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:30.168]                         if (muffled) 
[15:32:30.168]                           invokeRestart("muffleWarning")
[15:32:30.168]                       }
[15:32:30.168]                       else if (inherits(cond, "condition")) {
[15:32:30.168]                         if (!is.null(pattern)) {
[15:32:30.168]                           computeRestarts <- base::computeRestarts
[15:32:30.168]                           grepl <- base::grepl
[15:32:30.168]                           restarts <- computeRestarts(cond)
[15:32:30.168]                           for (restart in restarts) {
[15:32:30.168]                             name <- restart$name
[15:32:30.168]                             if (is.null(name)) 
[15:32:30.168]                               next
[15:32:30.168]                             if (!grepl(pattern, name)) 
[15:32:30.168]                               next
[15:32:30.168]                             invokeRestart(restart)
[15:32:30.168]                             muffled <- TRUE
[15:32:30.168]                             break
[15:32:30.168]                           }
[15:32:30.168]                         }
[15:32:30.168]                       }
[15:32:30.168]                       invisible(muffled)
[15:32:30.168]                     }
[15:32:30.168]                     muffleCondition(cond, pattern = "^muffle")
[15:32:30.168]                   }
[15:32:30.168]                 }
[15:32:30.168]                 else {
[15:32:30.168]                   if (TRUE) {
[15:32:30.168]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:30.168]                     {
[15:32:30.168]                       inherits <- base::inherits
[15:32:30.168]                       invokeRestart <- base::invokeRestart
[15:32:30.168]                       is.null <- base::is.null
[15:32:30.168]                       muffled <- FALSE
[15:32:30.168]                       if (inherits(cond, "message")) {
[15:32:30.168]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:30.168]                         if (muffled) 
[15:32:30.168]                           invokeRestart("muffleMessage")
[15:32:30.168]                       }
[15:32:30.168]                       else if (inherits(cond, "warning")) {
[15:32:30.168]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:30.168]                         if (muffled) 
[15:32:30.168]                           invokeRestart("muffleWarning")
[15:32:30.168]                       }
[15:32:30.168]                       else if (inherits(cond, "condition")) {
[15:32:30.168]                         if (!is.null(pattern)) {
[15:32:30.168]                           computeRestarts <- base::computeRestarts
[15:32:30.168]                           grepl <- base::grepl
[15:32:30.168]                           restarts <- computeRestarts(cond)
[15:32:30.168]                           for (restart in restarts) {
[15:32:30.168]                             name <- restart$name
[15:32:30.168]                             if (is.null(name)) 
[15:32:30.168]                               next
[15:32:30.168]                             if (!grepl(pattern, name)) 
[15:32:30.168]                               next
[15:32:30.168]                             invokeRestart(restart)
[15:32:30.168]                             muffled <- TRUE
[15:32:30.168]                             break
[15:32:30.168]                           }
[15:32:30.168]                         }
[15:32:30.168]                       }
[15:32:30.168]                       invisible(muffled)
[15:32:30.168]                     }
[15:32:30.168]                     muffleCondition(cond, pattern = "^muffle")
[15:32:30.168]                   }
[15:32:30.168]                 }
[15:32:30.168]             }
[15:32:30.168]         }))
[15:32:30.168]     }, error = function(ex) {
[15:32:30.168]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:30.168]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:30.168]                 ...future.rng), started = ...future.startTime, 
[15:32:30.168]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:30.168]             version = "1.8"), class = "FutureResult")
[15:32:30.168]     }, finally = {
[15:32:30.168]         if (!identical(...future.workdir, getwd())) 
[15:32:30.168]             setwd(...future.workdir)
[15:32:30.168]         {
[15:32:30.168]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:30.168]                 ...future.oldOptions$nwarnings <- NULL
[15:32:30.168]             }
[15:32:30.168]             base::options(...future.oldOptions)
[15:32:30.168]             if (.Platform$OS.type == "windows") {
[15:32:30.168]                 old_names <- names(...future.oldEnvVars)
[15:32:30.168]                 envs <- base::Sys.getenv()
[15:32:30.168]                 names <- names(envs)
[15:32:30.168]                 common <- intersect(names, old_names)
[15:32:30.168]                 added <- setdiff(names, old_names)
[15:32:30.168]                 removed <- setdiff(old_names, names)
[15:32:30.168]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:30.168]                   envs[common]]
[15:32:30.168]                 NAMES <- toupper(changed)
[15:32:30.168]                 args <- list()
[15:32:30.168]                 for (kk in seq_along(NAMES)) {
[15:32:30.168]                   name <- changed[[kk]]
[15:32:30.168]                   NAME <- NAMES[[kk]]
[15:32:30.168]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:30.168]                     next
[15:32:30.168]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:30.168]                 }
[15:32:30.168]                 NAMES <- toupper(added)
[15:32:30.168]                 for (kk in seq_along(NAMES)) {
[15:32:30.168]                   name <- added[[kk]]
[15:32:30.168]                   NAME <- NAMES[[kk]]
[15:32:30.168]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:30.168]                     next
[15:32:30.168]                   args[[name]] <- ""
[15:32:30.168]                 }
[15:32:30.168]                 NAMES <- toupper(removed)
[15:32:30.168]                 for (kk in seq_along(NAMES)) {
[15:32:30.168]                   name <- removed[[kk]]
[15:32:30.168]                   NAME <- NAMES[[kk]]
[15:32:30.168]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:30.168]                     next
[15:32:30.168]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:30.168]                 }
[15:32:30.168]                 if (length(args) > 0) 
[15:32:30.168]                   base::do.call(base::Sys.setenv, args = args)
[15:32:30.168]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:30.168]             }
[15:32:30.168]             else {
[15:32:30.168]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:30.168]             }
[15:32:30.168]             {
[15:32:30.168]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:30.168]                   0L) {
[15:32:30.168]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:30.168]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:30.168]                   base::options(opts)
[15:32:30.168]                 }
[15:32:30.168]                 {
[15:32:30.168]                   {
[15:32:30.168]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:30.168]                     NULL
[15:32:30.168]                   }
[15:32:30.168]                   options(future.plan = NULL)
[15:32:30.168]                   if (is.na(NA_character_)) 
[15:32:30.168]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:30.168]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:30.168]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:30.168]                     .init = FALSE)
[15:32:30.168]                 }
[15:32:30.168]             }
[15:32:30.168]         }
[15:32:30.168]     })
[15:32:30.168]     if (TRUE) {
[15:32:30.168]         base::sink(type = "output", split = FALSE)
[15:32:30.168]         if (TRUE) {
[15:32:30.168]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:30.168]         }
[15:32:30.168]         else {
[15:32:30.168]             ...future.result["stdout"] <- base::list(NULL)
[15:32:30.168]         }
[15:32:30.168]         base::close(...future.stdout)
[15:32:30.168]         ...future.stdout <- NULL
[15:32:30.168]     }
[15:32:30.168]     ...future.result$conditions <- ...future.conditions
[15:32:30.168]     ...future.result$finished <- base::Sys.time()
[15:32:30.168]     ...future.result
[15:32:30.168] }
[15:32:30.180] Exporting 5 global objects (4.62 KiB) to cluster node #1 ...
[15:32:30.181] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ...
[15:32:30.182] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ... DONE
[15:32:30.182] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:30.184] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:30.184] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:30.185] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:30.185] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:30.186] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:30.187] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:30.188] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:30.188] Exporting 5 global objects (4.62 KiB) to cluster node #1 ... DONE
[15:32:30.189] MultisessionFuture started
[15:32:30.190] - Launch lazy future ... done
[15:32:30.190] run() for 'MultisessionFuture' ... done
[15:32:30.191] Created future:
[15:32:30.214] receiveMessageFromWorker() for ClusterFuture ...
[15:32:30.215] - Validating connection of MultisessionFuture
[15:32:30.215] - received message: FutureResult
[15:32:30.216] - Received FutureResult
[15:32:30.216] - Erased future from FutureRegistry
[15:32:30.216] result() for ClusterFuture ...
[15:32:30.217] - result already collected: FutureResult
[15:32:30.217] result() for ClusterFuture ... done
[15:32:30.217] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:30.191] MultisessionFuture:
[15:32:30.191] Label: 'future_sapply-2'
[15:32:30.191] Expression:
[15:32:30.191] {
[15:32:30.191]     do.call(function(...) {
[15:32:30.191]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:30.191]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:30.191]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:30.191]             on.exit(options(oopts), add = TRUE)
[15:32:30.191]         }
[15:32:30.191]         {
[15:32:30.191]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:30.191]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:30.191]                 ...future.FUN(...future.X_jj, ...)
[15:32:30.191]             })
[15:32:30.191]         }
[15:32:30.191]     }, args = future.call.arguments)
[15:32:30.191] }
[15:32:30.191] Lazy evaluation: FALSE
[15:32:30.191] Asynchronous evaluation: TRUE
[15:32:30.191] Local evaluation: TRUE
[15:32:30.191] Environment: R_GlobalEnv
[15:32:30.191] Capture standard output: TRUE
[15:32:30.191] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:30.191] Globals: 5 objects totaling 4.73 KiB (function '...future.FUN' of 4.62 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)
[15:32:30.191] Packages: <none>
[15:32:30.191] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:30.191] Resolved: TRUE
[15:32:30.191] Value: <not collected>
[15:32:30.191] Conditions captured: <none>
[15:32:30.191] Early signaling: FALSE
[15:32:30.191] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:30.191] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:30.218] Chunk #2 of 2 ... DONE
[15:32:30.218] Launching 2 futures (chunks) ... DONE
[15:32:30.219] Resolving 2 futures (chunks) ...
[15:32:30.219] resolve() on list ...
[15:32:30.219]  recursive: 0
[15:32:30.220]  length: 2
[15:32:30.220] 
[15:32:30.220] Future #1
[15:32:30.220] result() for ClusterFuture ...
[15:32:30.221] - result already collected: FutureResult
[15:32:30.221] result() for ClusterFuture ... done
[15:32:30.221] result() for ClusterFuture ...
[15:32:30.222] - result already collected: FutureResult
[15:32:30.222] result() for ClusterFuture ... done
[15:32:30.222] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:30.223] - nx: 2
[15:32:30.223] - relay: TRUE
[15:32:30.223] - stdout: TRUE
[15:32:30.223] - signal: TRUE
[15:32:30.224] - resignal: FALSE
[15:32:30.224] - force: TRUE
[15:32:30.224] - relayed: [n=2] FALSE, FALSE
[15:32:30.224] - queued futures: [n=2] FALSE, FALSE
[15:32:30.225]  - until=1
[15:32:30.225]  - relaying element #1
[15:32:30.225] result() for ClusterFuture ...
[15:32:30.226] - result already collected: FutureResult
[15:32:30.226] result() for ClusterFuture ... done
[15:32:30.226] result() for ClusterFuture ...
[15:32:30.227] - result already collected: FutureResult
[15:32:30.227] result() for ClusterFuture ... done
[15:32:30.227] result() for ClusterFuture ...
[15:32:30.228] - result already collected: FutureResult
[15:32:30.228] result() for ClusterFuture ... done
[15:32:30.228] result() for ClusterFuture ...
[15:32:30.228] - result already collected: FutureResult
[15:32:30.229] result() for ClusterFuture ... done
[15:32:30.229] - relayed: [n=2] TRUE, FALSE
[15:32:30.229] - queued futures: [n=2] TRUE, FALSE
[15:32:30.229] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:30.230]  length: 1 (resolved future 1)
[15:32:30.230] Future #2
[15:32:30.230] result() for ClusterFuture ...
[15:32:30.231] - result already collected: FutureResult
[15:32:30.231] result() for ClusterFuture ... done
[15:32:30.231] result() for ClusterFuture ...
[15:32:30.232] - result already collected: FutureResult
[15:32:30.232] result() for ClusterFuture ... done
[15:32:30.232] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:30.233] - nx: 2
[15:32:30.233] - relay: TRUE
[15:32:30.233] - stdout: TRUE
[15:32:30.233] - signal: TRUE
[15:32:30.234] - resignal: FALSE
[15:32:30.234] - force: TRUE
[15:32:30.234] - relayed: [n=2] TRUE, FALSE
[15:32:30.234] - queued futures: [n=2] TRUE, FALSE
[15:32:30.235]  - until=2
[15:32:30.235]  - relaying element #2
[15:32:30.235] result() for ClusterFuture ...
[15:32:30.236] - result already collected: FutureResult
[15:32:30.236] result() for ClusterFuture ... done
[15:32:30.236] result() for ClusterFuture ...
[15:32:30.236] - result already collected: FutureResult
[15:32:30.237] result() for ClusterFuture ... done
[15:32:30.237] result() for ClusterFuture ...
[15:32:30.237] - result already collected: FutureResult
[15:32:30.238] result() for ClusterFuture ... done
[15:32:30.238] result() for ClusterFuture ...
[15:32:30.238] - result already collected: FutureResult
[15:32:30.239] result() for ClusterFuture ... done
[15:32:30.239] - relayed: [n=2] TRUE, TRUE
[15:32:30.239] - queued futures: [n=2] TRUE, TRUE
[15:32:30.239] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:30.240]  length: 0 (resolved future 2)
[15:32:30.240] Relaying remaining futures
[15:32:30.240] signalConditionsASAP(NULL, pos=0) ...
[15:32:30.241] - nx: 2
[15:32:30.241] - relay: TRUE
[15:32:30.241] - stdout: TRUE
[15:32:30.241] - signal: TRUE
[15:32:30.242] - resignal: FALSE
[15:32:30.242] - force: TRUE
[15:32:30.242] - relayed: [n=2] TRUE, TRUE
[15:32:30.242] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:30.243] - relayed: [n=2] TRUE, TRUE
[15:32:30.243] - queued futures: [n=2] TRUE, TRUE
[15:32:30.244] signalConditionsASAP(NULL, pos=0) ... done
[15:32:30.244] resolve() on list ... DONE
[15:32:30.244] result() for ClusterFuture ...
[15:32:30.244] - result already collected: FutureResult
[15:32:30.245] result() for ClusterFuture ... done
[15:32:30.245] result() for ClusterFuture ...
[15:32:30.245] - result already collected: FutureResult
[15:32:30.246] result() for ClusterFuture ... done
[15:32:30.246] result() for ClusterFuture ...
[15:32:30.246] - result already collected: FutureResult
[15:32:30.247] result() for ClusterFuture ... done
[15:32:30.247] result() for ClusterFuture ...
[15:32:30.247] - result already collected: FutureResult
[15:32:30.247] result() for ClusterFuture ... done
[15:32:30.248]  - Number of value chunks collected: 2
[15:32:30.248] Resolving 2 futures (chunks) ... DONE
[15:32:30.248] Reducing values from 2 chunks ...
[15:32:30.249]  - Number of values collected after concatenation: 3
[15:32:30.249]  - Number of values expected: 3
[15:32:30.249] Reducing values from 2 chunks ... DONE
[15:32:30.250] future_lapply() ... DONE
List of 2
 $ y0: num [1:15, 1:3] 2 2 2 4 4 4 6 6 6 8 ...
  ..- attr(*, "dimnames")=List of 2
  .. ..$ : NULL
  .. ..$ : chr [1:3] "a" "b" "c"
 $ y1: num [1:15, 1:3] 2 2 2 4 4 4 6 6 6 8 ...
  ..- attr(*, "dimnames")=List of 2
  .. ..$ : NULL
  .. ..$ : chr [1:3] "a" "b" "c"
[15:32:30.255] future_lapply() ...
[15:32:30.260] Number of chunks: 2
[15:32:30.260] getGlobalsAndPackagesXApply() ...
[15:32:30.260]  - future.globals: TRUE
[15:32:30.261] getGlobalsAndPackages() ...
[15:32:30.261] Searching for globals...
[15:32:30.263] - globals found: [1] 'FUN'
[15:32:30.263] Searching for globals ... DONE
[15:32:30.264] Resolving globals: FALSE
[15:32:30.268] The total size of the 1 globals is 848 bytes (848 bytes)
[15:32:30.269] The total size of the 1 globals exported for future expression ('FUN()') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:32:30.269] - globals: [1] 'FUN'
[15:32:30.270] 
[15:32:30.270] getGlobalsAndPackages() ... DONE
[15:32:30.270]  - globals found/used: [n=1] 'FUN'
[15:32:30.270]  - needed namespaces: [n=0] 
[15:32:30.271] Finding globals ... DONE
[15:32:30.271]  - use_args: TRUE
[15:32:30.271]  - Getting '...' globals ...
[15:32:30.272] resolve() on list ...
[15:32:30.272]  recursive: 0
[15:32:30.272]  length: 1
[15:32:30.273]  elements: '...'
[15:32:30.273]  length: 0 (resolved future 1)
[15:32:30.273] resolve() on list ... DONE
[15:32:30.273]    - '...' content: [n=0] 
[15:32:30.274] List of 1
[15:32:30.274]  $ ...: list()
[15:32:30.274]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:30.274]  - attr(*, "where")=List of 1
[15:32:30.274]   ..$ ...:<environment: 0x00000276e4318a40> 
[15:32:30.274]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:30.274]  - attr(*, "resolved")= logi TRUE
[15:32:30.274]  - attr(*, "total_size")= num NA
[15:32:30.279]  - Getting '...' globals ... DONE
[15:32:30.279] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:30.279] List of 2
[15:32:30.279]  $ ...future.FUN:function (x)  
[15:32:30.279]  $ ...          : list()
[15:32:30.279]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:30.279]  - attr(*, "where")=List of 2
[15:32:30.279]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:30.279]   ..$ ...          :<environment: 0x00000276e4318a40> 
[15:32:30.279]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:30.279]  - attr(*, "resolved")= logi FALSE
[15:32:30.279]  - attr(*, "total_size")= num 848
[15:32:30.284] Packages to be attached in all futures: [n=0] 
[15:32:30.285] getGlobalsAndPackagesXApply() ... DONE
[15:32:30.285] Number of futures (= number of chunks): 2
[15:32:30.285] Launching 2 futures (chunks) ...
[15:32:30.286] Chunk #1 of 2 ...
[15:32:30.286]  - Finding globals in 'X' for chunk #1 ...
[15:32:30.286] getGlobalsAndPackages() ...
[15:32:30.286] Searching for globals...
[15:32:30.287] 
[15:32:30.287] Searching for globals ... DONE
[15:32:30.287] - globals: [0] <none>
[15:32:30.288] getGlobalsAndPackages() ... DONE
[15:32:30.288]    + additional globals found: [n=0] 
[15:32:30.288]    + additional namespaces needed: [n=0] 
[15:32:30.288]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:30.289]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:30.289]  - seeds: <none>
[15:32:30.289]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:30.289] getGlobalsAndPackages() ...
[15:32:30.290] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:30.290] Resolving globals: FALSE
[15:32:30.290] Tweak future expression to call with '...' arguments ...
[15:32:30.291] {
[15:32:30.291]     do.call(function(...) {
[15:32:30.291]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:30.291]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:30.291]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:30.291]             on.exit(options(oopts), add = TRUE)
[15:32:30.291]         }
[15:32:30.291]         {
[15:32:30.291]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:30.291]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:30.291]                 ...future.FUN(...future.X_jj, ...)
[15:32:30.291]             })
[15:32:30.291]         }
[15:32:30.291]     }, args = future.call.arguments)
[15:32:30.291] }
[15:32:30.291] Tweak future expression to call with '...' arguments ... DONE
[15:32:30.292] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:30.292] 
[15:32:30.293] getGlobalsAndPackages() ... DONE
[15:32:30.293] run() for 'Future' ...
[15:32:30.293] - state: 'created'
[15:32:30.294] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:30.312] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:30.313] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:30.313]   - Field: 'node'
[15:32:30.313]   - Field: 'label'
[15:32:30.314]   - Field: 'local'
[15:32:30.314]   - Field: 'owner'
[15:32:30.314]   - Field: 'envir'
[15:32:30.314]   - Field: 'workers'
[15:32:30.315]   - Field: 'packages'
[15:32:30.315]   - Field: 'gc'
[15:32:30.315]   - Field: 'conditions'
[15:32:30.315]   - Field: 'persistent'
[15:32:30.316]   - Field: 'expr'
[15:32:30.316]   - Field: 'uuid'
[15:32:30.316]   - Field: 'seed'
[15:32:30.317]   - Field: 'version'
[15:32:30.317]   - Field: 'result'
[15:32:30.317]   - Field: 'asynchronous'
[15:32:30.317]   - Field: 'calls'
[15:32:30.318]   - Field: 'globals'
[15:32:30.318]   - Field: 'stdout'
[15:32:30.318]   - Field: 'earlySignal'
[15:32:30.318]   - Field: 'lazy'
[15:32:30.319]   - Field: 'state'
[15:32:30.319] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:30.319] - Launch lazy future ...
[15:32:30.320] Packages needed by the future expression (n = 0): <none>
[15:32:30.320] Packages needed by future strategies (n = 0): <none>
[15:32:30.321] {
[15:32:30.321]     {
[15:32:30.321]         {
[15:32:30.321]             ...future.startTime <- base::Sys.time()
[15:32:30.321]             {
[15:32:30.321]                 {
[15:32:30.321]                   {
[15:32:30.321]                     {
[15:32:30.321]                       base::local({
[15:32:30.321]                         has_future <- base::requireNamespace("future", 
[15:32:30.321]                           quietly = TRUE)
[15:32:30.321]                         if (has_future) {
[15:32:30.321]                           ns <- base::getNamespace("future")
[15:32:30.321]                           version <- ns[[".package"]][["version"]]
[15:32:30.321]                           if (is.null(version)) 
[15:32:30.321]                             version <- utils::packageVersion("future")
[15:32:30.321]                         }
[15:32:30.321]                         else {
[15:32:30.321]                           version <- NULL
[15:32:30.321]                         }
[15:32:30.321]                         if (!has_future || version < "1.8.0") {
[15:32:30.321]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:30.321]                             "", base::R.version$version.string), 
[15:32:30.321]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:30.321]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:30.321]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:30.321]                               "release", "version")], collapse = " "), 
[15:32:30.321]                             hostname = base::Sys.info()[["nodename"]])
[15:32:30.321]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:30.321]                             info)
[15:32:30.321]                           info <- base::paste(info, collapse = "; ")
[15:32:30.321]                           if (!has_future) {
[15:32:30.321]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:30.321]                               info)
[15:32:30.321]                           }
[15:32:30.321]                           else {
[15:32:30.321]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:30.321]                               info, version)
[15:32:30.321]                           }
[15:32:30.321]                           base::stop(msg)
[15:32:30.321]                         }
[15:32:30.321]                       })
[15:32:30.321]                     }
[15:32:30.321]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:30.321]                     base::options(mc.cores = 1L)
[15:32:30.321]                   }
[15:32:30.321]                   ...future.strategy.old <- future::plan("list")
[15:32:30.321]                   options(future.plan = NULL)
[15:32:30.321]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:30.321]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:30.321]                 }
[15:32:30.321]                 ...future.workdir <- getwd()
[15:32:30.321]             }
[15:32:30.321]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:30.321]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:30.321]         }
[15:32:30.321]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:30.321]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:30.321]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:30.321]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:30.321]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:30.321]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:30.321]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:30.321]             base::names(...future.oldOptions))
[15:32:30.321]     }
[15:32:30.321]     if (FALSE) {
[15:32:30.321]     }
[15:32:30.321]     else {
[15:32:30.321]         if (TRUE) {
[15:32:30.321]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:30.321]                 open = "w")
[15:32:30.321]         }
[15:32:30.321]         else {
[15:32:30.321]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:30.321]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:30.321]         }
[15:32:30.321]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:30.321]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:30.321]             base::sink(type = "output", split = FALSE)
[15:32:30.321]             base::close(...future.stdout)
[15:32:30.321]         }, add = TRUE)
[15:32:30.321]     }
[15:32:30.321]     ...future.frame <- base::sys.nframe()
[15:32:30.321]     ...future.conditions <- base::list()
[15:32:30.321]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:30.321]     if (FALSE) {
[15:32:30.321]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:30.321]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:30.321]     }
[15:32:30.321]     ...future.result <- base::tryCatch({
[15:32:30.321]         base::withCallingHandlers({
[15:32:30.321]             ...future.value <- base::withVisible(base::local({
[15:32:30.321]                 ...future.makeSendCondition <- base::local({
[15:32:30.321]                   sendCondition <- NULL
[15:32:30.321]                   function(frame = 1L) {
[15:32:30.321]                     if (is.function(sendCondition)) 
[15:32:30.321]                       return(sendCondition)
[15:32:30.321]                     ns <- getNamespace("parallel")
[15:32:30.321]                     if (exists("sendData", mode = "function", 
[15:32:30.321]                       envir = ns)) {
[15:32:30.321]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:30.321]                         envir = ns)
[15:32:30.321]                       envir <- sys.frame(frame)
[15:32:30.321]                       master <- NULL
[15:32:30.321]                       while (!identical(envir, .GlobalEnv) && 
[15:32:30.321]                         !identical(envir, emptyenv())) {
[15:32:30.321]                         if (exists("master", mode = "list", envir = envir, 
[15:32:30.321]                           inherits = FALSE)) {
[15:32:30.321]                           master <- get("master", mode = "list", 
[15:32:30.321]                             envir = envir, inherits = FALSE)
[15:32:30.321]                           if (inherits(master, c("SOCKnode", 
[15:32:30.321]                             "SOCK0node"))) {
[15:32:30.321]                             sendCondition <<- function(cond) {
[15:32:30.321]                               data <- list(type = "VALUE", value = cond, 
[15:32:30.321]                                 success = TRUE)
[15:32:30.321]                               parallel_sendData(master, data)
[15:32:30.321]                             }
[15:32:30.321]                             return(sendCondition)
[15:32:30.321]                           }
[15:32:30.321]                         }
[15:32:30.321]                         frame <- frame + 1L
[15:32:30.321]                         envir <- sys.frame(frame)
[15:32:30.321]                       }
[15:32:30.321]                     }
[15:32:30.321]                     sendCondition <<- function(cond) NULL
[15:32:30.321]                   }
[15:32:30.321]                 })
[15:32:30.321]                 withCallingHandlers({
[15:32:30.321]                   {
[15:32:30.321]                     do.call(function(...) {
[15:32:30.321]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:30.321]                       if (!identical(...future.globals.maxSize.org, 
[15:32:30.321]                         ...future.globals.maxSize)) {
[15:32:30.321]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:30.321]                         on.exit(options(oopts), add = TRUE)
[15:32:30.321]                       }
[15:32:30.321]                       {
[15:32:30.321]                         lapply(seq_along(...future.elements_ii), 
[15:32:30.321]                           FUN = function(jj) {
[15:32:30.321]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:30.321]                             ...future.FUN(...future.X_jj, ...)
[15:32:30.321]                           })
[15:32:30.321]                       }
[15:32:30.321]                     }, args = future.call.arguments)
[15:32:30.321]                   }
[15:32:30.321]                 }, immediateCondition = function(cond) {
[15:32:30.321]                   sendCondition <- ...future.makeSendCondition()
[15:32:30.321]                   sendCondition(cond)
[15:32:30.321]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:30.321]                   {
[15:32:30.321]                     inherits <- base::inherits
[15:32:30.321]                     invokeRestart <- base::invokeRestart
[15:32:30.321]                     is.null <- base::is.null
[15:32:30.321]                     muffled <- FALSE
[15:32:30.321]                     if (inherits(cond, "message")) {
[15:32:30.321]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:30.321]                       if (muffled) 
[15:32:30.321]                         invokeRestart("muffleMessage")
[15:32:30.321]                     }
[15:32:30.321]                     else if (inherits(cond, "warning")) {
[15:32:30.321]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:30.321]                       if (muffled) 
[15:32:30.321]                         invokeRestart("muffleWarning")
[15:32:30.321]                     }
[15:32:30.321]                     else if (inherits(cond, "condition")) {
[15:32:30.321]                       if (!is.null(pattern)) {
[15:32:30.321]                         computeRestarts <- base::computeRestarts
[15:32:30.321]                         grepl <- base::grepl
[15:32:30.321]                         restarts <- computeRestarts(cond)
[15:32:30.321]                         for (restart in restarts) {
[15:32:30.321]                           name <- restart$name
[15:32:30.321]                           if (is.null(name)) 
[15:32:30.321]                             next
[15:32:30.321]                           if (!grepl(pattern, name)) 
[15:32:30.321]                             next
[15:32:30.321]                           invokeRestart(restart)
[15:32:30.321]                           muffled <- TRUE
[15:32:30.321]                           break
[15:32:30.321]                         }
[15:32:30.321]                       }
[15:32:30.321]                     }
[15:32:30.321]                     invisible(muffled)
[15:32:30.321]                   }
[15:32:30.321]                   muffleCondition(cond)
[15:32:30.321]                 })
[15:32:30.321]             }))
[15:32:30.321]             future::FutureResult(value = ...future.value$value, 
[15:32:30.321]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:30.321]                   ...future.rng), globalenv = if (FALSE) 
[15:32:30.321]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:30.321]                     ...future.globalenv.names))
[15:32:30.321]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:30.321]         }, condition = base::local({
[15:32:30.321]             c <- base::c
[15:32:30.321]             inherits <- base::inherits
[15:32:30.321]             invokeRestart <- base::invokeRestart
[15:32:30.321]             length <- base::length
[15:32:30.321]             list <- base::list
[15:32:30.321]             seq.int <- base::seq.int
[15:32:30.321]             signalCondition <- base::signalCondition
[15:32:30.321]             sys.calls <- base::sys.calls
[15:32:30.321]             `[[` <- base::`[[`
[15:32:30.321]             `+` <- base::`+`
[15:32:30.321]             `<<-` <- base::`<<-`
[15:32:30.321]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:30.321]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:30.321]                   3L)]
[15:32:30.321]             }
[15:32:30.321]             function(cond) {
[15:32:30.321]                 is_error <- inherits(cond, "error")
[15:32:30.321]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:30.321]                   NULL)
[15:32:30.321]                 if (is_error) {
[15:32:30.321]                   sessionInformation <- function() {
[15:32:30.321]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:30.321]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:30.321]                       search = base::search(), system = base::Sys.info())
[15:32:30.321]                   }
[15:32:30.321]                   ...future.conditions[[length(...future.conditions) + 
[15:32:30.321]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:30.321]                     cond$call), session = sessionInformation(), 
[15:32:30.321]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:30.321]                   signalCondition(cond)
[15:32:30.321]                 }
[15:32:30.321]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:30.321]                 "immediateCondition"))) {
[15:32:30.321]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:30.321]                   ...future.conditions[[length(...future.conditions) + 
[15:32:30.321]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:30.321]                   if (TRUE && !signal) {
[15:32:30.321]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:30.321]                     {
[15:32:30.321]                       inherits <- base::inherits
[15:32:30.321]                       invokeRestart <- base::invokeRestart
[15:32:30.321]                       is.null <- base::is.null
[15:32:30.321]                       muffled <- FALSE
[15:32:30.321]                       if (inherits(cond, "message")) {
[15:32:30.321]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:30.321]                         if (muffled) 
[15:32:30.321]                           invokeRestart("muffleMessage")
[15:32:30.321]                       }
[15:32:30.321]                       else if (inherits(cond, "warning")) {
[15:32:30.321]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:30.321]                         if (muffled) 
[15:32:30.321]                           invokeRestart("muffleWarning")
[15:32:30.321]                       }
[15:32:30.321]                       else if (inherits(cond, "condition")) {
[15:32:30.321]                         if (!is.null(pattern)) {
[15:32:30.321]                           computeRestarts <- base::computeRestarts
[15:32:30.321]                           grepl <- base::grepl
[15:32:30.321]                           restarts <- computeRestarts(cond)
[15:32:30.321]                           for (restart in restarts) {
[15:32:30.321]                             name <- restart$name
[15:32:30.321]                             if (is.null(name)) 
[15:32:30.321]                               next
[15:32:30.321]                             if (!grepl(pattern, name)) 
[15:32:30.321]                               next
[15:32:30.321]                             invokeRestart(restart)
[15:32:30.321]                             muffled <- TRUE
[15:32:30.321]                             break
[15:32:30.321]                           }
[15:32:30.321]                         }
[15:32:30.321]                       }
[15:32:30.321]                       invisible(muffled)
[15:32:30.321]                     }
[15:32:30.321]                     muffleCondition(cond, pattern = "^muffle")
[15:32:30.321]                   }
[15:32:30.321]                 }
[15:32:30.321]                 else {
[15:32:30.321]                   if (TRUE) {
[15:32:30.321]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:30.321]                     {
[15:32:30.321]                       inherits <- base::inherits
[15:32:30.321]                       invokeRestart <- base::invokeRestart
[15:32:30.321]                       is.null <- base::is.null
[15:32:30.321]                       muffled <- FALSE
[15:32:30.321]                       if (inherits(cond, "message")) {
[15:32:30.321]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:30.321]                         if (muffled) 
[15:32:30.321]                           invokeRestart("muffleMessage")
[15:32:30.321]                       }
[15:32:30.321]                       else if (inherits(cond, "warning")) {
[15:32:30.321]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:30.321]                         if (muffled) 
[15:32:30.321]                           invokeRestart("muffleWarning")
[15:32:30.321]                       }
[15:32:30.321]                       else if (inherits(cond, "condition")) {
[15:32:30.321]                         if (!is.null(pattern)) {
[15:32:30.321]                           computeRestarts <- base::computeRestarts
[15:32:30.321]                           grepl <- base::grepl
[15:32:30.321]                           restarts <- computeRestarts(cond)
[15:32:30.321]                           for (restart in restarts) {
[15:32:30.321]                             name <- restart$name
[15:32:30.321]                             if (is.null(name)) 
[15:32:30.321]                               next
[15:32:30.321]                             if (!grepl(pattern, name)) 
[15:32:30.321]                               next
[15:32:30.321]                             invokeRestart(restart)
[15:32:30.321]                             muffled <- TRUE
[15:32:30.321]                             break
[15:32:30.321]                           }
[15:32:30.321]                         }
[15:32:30.321]                       }
[15:32:30.321]                       invisible(muffled)
[15:32:30.321]                     }
[15:32:30.321]                     muffleCondition(cond, pattern = "^muffle")
[15:32:30.321]                   }
[15:32:30.321]                 }
[15:32:30.321]             }
[15:32:30.321]         }))
[15:32:30.321]     }, error = function(ex) {
[15:32:30.321]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:30.321]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:30.321]                 ...future.rng), started = ...future.startTime, 
[15:32:30.321]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:30.321]             version = "1.8"), class = "FutureResult")
[15:32:30.321]     }, finally = {
[15:32:30.321]         if (!identical(...future.workdir, getwd())) 
[15:32:30.321]             setwd(...future.workdir)
[15:32:30.321]         {
[15:32:30.321]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:30.321]                 ...future.oldOptions$nwarnings <- NULL
[15:32:30.321]             }
[15:32:30.321]             base::options(...future.oldOptions)
[15:32:30.321]             if (.Platform$OS.type == "windows") {
[15:32:30.321]                 old_names <- names(...future.oldEnvVars)
[15:32:30.321]                 envs <- base::Sys.getenv()
[15:32:30.321]                 names <- names(envs)
[15:32:30.321]                 common <- intersect(names, old_names)
[15:32:30.321]                 added <- setdiff(names, old_names)
[15:32:30.321]                 removed <- setdiff(old_names, names)
[15:32:30.321]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:30.321]                   envs[common]]
[15:32:30.321]                 NAMES <- toupper(changed)
[15:32:30.321]                 args <- list()
[15:32:30.321]                 for (kk in seq_along(NAMES)) {
[15:32:30.321]                   name <- changed[[kk]]
[15:32:30.321]                   NAME <- NAMES[[kk]]
[15:32:30.321]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:30.321]                     next
[15:32:30.321]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:30.321]                 }
[15:32:30.321]                 NAMES <- toupper(added)
[15:32:30.321]                 for (kk in seq_along(NAMES)) {
[15:32:30.321]                   name <- added[[kk]]
[15:32:30.321]                   NAME <- NAMES[[kk]]
[15:32:30.321]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:30.321]                     next
[15:32:30.321]                   args[[name]] <- ""
[15:32:30.321]                 }
[15:32:30.321]                 NAMES <- toupper(removed)
[15:32:30.321]                 for (kk in seq_along(NAMES)) {
[15:32:30.321]                   name <- removed[[kk]]
[15:32:30.321]                   NAME <- NAMES[[kk]]
[15:32:30.321]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:30.321]                     next
[15:32:30.321]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:30.321]                 }
[15:32:30.321]                 if (length(args) > 0) 
[15:32:30.321]                   base::do.call(base::Sys.setenv, args = args)
[15:32:30.321]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:30.321]             }
[15:32:30.321]             else {
[15:32:30.321]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:30.321]             }
[15:32:30.321]             {
[15:32:30.321]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:30.321]                   0L) {
[15:32:30.321]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:30.321]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:30.321]                   base::options(opts)
[15:32:30.321]                 }
[15:32:30.321]                 {
[15:32:30.321]                   {
[15:32:30.321]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:30.321]                     NULL
[15:32:30.321]                   }
[15:32:30.321]                   options(future.plan = NULL)
[15:32:30.321]                   if (is.na(NA_character_)) 
[15:32:30.321]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:30.321]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:30.321]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:30.321]                     .init = FALSE)
[15:32:30.321]                 }
[15:32:30.321]             }
[15:32:30.321]         }
[15:32:30.321]     })
[15:32:30.321]     if (TRUE) {
[15:32:30.321]         base::sink(type = "output", split = FALSE)
[15:32:30.321]         if (TRUE) {
[15:32:30.321]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:30.321]         }
[15:32:30.321]         else {
[15:32:30.321]             ...future.result["stdout"] <- base::list(NULL)
[15:32:30.321]         }
[15:32:30.321]         base::close(...future.stdout)
[15:32:30.321]         ...future.stdout <- NULL
[15:32:30.321]     }
[15:32:30.321]     ...future.result$conditions <- ...future.conditions
[15:32:30.321]     ...future.result$finished <- base::Sys.time()
[15:32:30.321]     ...future.result
[15:32:30.321] }
[15:32:30.330] Exporting 5 global objects (848 bytes) to cluster node #1 ...
[15:32:30.330] Exporting '...future.FUN' (848 bytes) to cluster node #1 ...
[15:32:30.331] Exporting '...future.FUN' (848 bytes) to cluster node #1 ... DONE
[15:32:30.332] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:30.332] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:30.333] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ...
[15:32:30.333] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ... DONE
[15:32:30.334] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:30.334] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:30.335] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:30.335] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:30.335] Exporting 5 global objects (848 bytes) to cluster node #1 ... DONE
[15:32:30.336] MultisessionFuture started
[15:32:30.337] - Launch lazy future ... done
[15:32:30.337] run() for 'MultisessionFuture' ... done
[15:32:30.338] Created future:
[15:32:30.367] receiveMessageFromWorker() for ClusterFuture ...
[15:32:30.368] - Validating connection of MultisessionFuture
[15:32:30.368] - received message: FutureResult
[15:32:30.369] - Received FutureResult
[15:32:30.369] - Erased future from FutureRegistry
[15:32:30.369] result() for ClusterFuture ...
[15:32:30.370] - result already collected: FutureResult
[15:32:30.370] result() for ClusterFuture ... done
[15:32:30.370] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:30.338] MultisessionFuture:
[15:32:30.338] Label: 'future_sapply-1'
[15:32:30.338] Expression:
[15:32:30.338] {
[15:32:30.338]     do.call(function(...) {
[15:32:30.338]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:30.338]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:30.338]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:30.338]             on.exit(options(oopts), add = TRUE)
[15:32:30.338]         }
[15:32:30.338]         {
[15:32:30.338]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:30.338]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:30.338]                 ...future.FUN(...future.X_jj, ...)
[15:32:30.338]             })
[15:32:30.338]         }
[15:32:30.338]     }, args = future.call.arguments)
[15:32:30.338] }
[15:32:30.338] Lazy evaluation: FALSE
[15:32:30.338] Asynchronous evaluation: TRUE
[15:32:30.338] Local evaluation: TRUE
[15:32:30.338] Environment: R_GlobalEnv
[15:32:30.338] Capture standard output: TRUE
[15:32:30.338] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:30.338] Globals: 5 objects totaling 904 bytes (function '...future.FUN' of 848 bytes, 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)
[15:32:30.338] Packages: <none>
[15:32:30.338] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:30.338] Resolved: TRUE
[15:32:30.338] Value: <not collected>
[15:32:30.338] Conditions captured: <none>
[15:32:30.338] Early signaling: FALSE
[15:32:30.338] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:30.338] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:30.371] Chunk #1 of 2 ... DONE
[15:32:30.371] Chunk #2 of 2 ...
[15:32:30.372]  - Finding globals in 'X' for chunk #2 ...
[15:32:30.372] getGlobalsAndPackages() ...
[15:32:30.372] Searching for globals...
[15:32:30.373] 
[15:32:30.373] Searching for globals ... DONE
[15:32:30.374] - globals: [0] <none>
[15:32:30.374] getGlobalsAndPackages() ... DONE
[15:32:30.374]    + additional globals found: [n=0] 
[15:32:30.374]    + additional namespaces needed: [n=0] 
[15:32:30.375]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:30.375]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:30.375]  - seeds: <none>
[15:32:30.376]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:30.376] getGlobalsAndPackages() ...
[15:32:30.376] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:30.377] Resolving globals: FALSE
[15:32:30.377] Tweak future expression to call with '...' arguments ...
[15:32:30.377] {
[15:32:30.377]     do.call(function(...) {
[15:32:30.377]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:30.377]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:30.377]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:30.377]             on.exit(options(oopts), add = TRUE)
[15:32:30.377]         }
[15:32:30.377]         {
[15:32:30.377]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:30.377]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:30.377]                 ...future.FUN(...future.X_jj, ...)
[15:32:30.377]             })
[15:32:30.377]         }
[15:32:30.377]     }, args = future.call.arguments)
[15:32:30.377] }
[15:32:30.378] Tweak future expression to call with '...' arguments ... DONE
[15:32:30.379] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:30.379] 
[15:32:30.380] getGlobalsAndPackages() ... DONE
[15:32:30.380] run() for 'Future' ...
[15:32:30.381] - state: 'created'
[15:32:30.381] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:30.401] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:30.401] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:30.401]   - Field: 'node'
[15:32:30.402]   - Field: 'label'
[15:32:30.402]   - Field: 'local'
[15:32:30.402]   - Field: 'owner'
[15:32:30.402]   - Field: 'envir'
[15:32:30.403]   - Field: 'workers'
[15:32:30.403]   - Field: 'packages'
[15:32:30.403]   - Field: 'gc'
[15:32:30.403]   - Field: 'conditions'
[15:32:30.403]   - Field: 'persistent'
[15:32:30.404]   - Field: 'expr'
[15:32:30.404]   - Field: 'uuid'
[15:32:30.404]   - Field: 'seed'
[15:32:30.404]   - Field: 'version'
[15:32:30.405]   - Field: 'result'
[15:32:30.405]   - Field: 'asynchronous'
[15:32:30.405]   - Field: 'calls'
[15:32:30.405]   - Field: 'globals'
[15:32:30.406]   - Field: 'stdout'
[15:32:30.406]   - Field: 'earlySignal'
[15:32:30.406]   - Field: 'lazy'
[15:32:30.406]   - Field: 'state'
[15:32:30.407] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:30.407] - Launch lazy future ...
[15:32:30.407] Packages needed by the future expression (n = 0): <none>
[15:32:30.408] Packages needed by future strategies (n = 0): <none>
[15:32:30.408] {
[15:32:30.408]     {
[15:32:30.408]         {
[15:32:30.408]             ...future.startTime <- base::Sys.time()
[15:32:30.408]             {
[15:32:30.408]                 {
[15:32:30.408]                   {
[15:32:30.408]                     {
[15:32:30.408]                       base::local({
[15:32:30.408]                         has_future <- base::requireNamespace("future", 
[15:32:30.408]                           quietly = TRUE)
[15:32:30.408]                         if (has_future) {
[15:32:30.408]                           ns <- base::getNamespace("future")
[15:32:30.408]                           version <- ns[[".package"]][["version"]]
[15:32:30.408]                           if (is.null(version)) 
[15:32:30.408]                             version <- utils::packageVersion("future")
[15:32:30.408]                         }
[15:32:30.408]                         else {
[15:32:30.408]                           version <- NULL
[15:32:30.408]                         }
[15:32:30.408]                         if (!has_future || version < "1.8.0") {
[15:32:30.408]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:30.408]                             "", base::R.version$version.string), 
[15:32:30.408]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:30.408]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:30.408]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:30.408]                               "release", "version")], collapse = " "), 
[15:32:30.408]                             hostname = base::Sys.info()[["nodename"]])
[15:32:30.408]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:30.408]                             info)
[15:32:30.408]                           info <- base::paste(info, collapse = "; ")
[15:32:30.408]                           if (!has_future) {
[15:32:30.408]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:30.408]                               info)
[15:32:30.408]                           }
[15:32:30.408]                           else {
[15:32:30.408]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:30.408]                               info, version)
[15:32:30.408]                           }
[15:32:30.408]                           base::stop(msg)
[15:32:30.408]                         }
[15:32:30.408]                       })
[15:32:30.408]                     }
[15:32:30.408]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:30.408]                     base::options(mc.cores = 1L)
[15:32:30.408]                   }
[15:32:30.408]                   ...future.strategy.old <- future::plan("list")
[15:32:30.408]                   options(future.plan = NULL)
[15:32:30.408]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:30.408]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:30.408]                 }
[15:32:30.408]                 ...future.workdir <- getwd()
[15:32:30.408]             }
[15:32:30.408]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:30.408]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:30.408]         }
[15:32:30.408]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:30.408]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:30.408]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:30.408]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:30.408]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:30.408]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:30.408]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:30.408]             base::names(...future.oldOptions))
[15:32:30.408]     }
[15:32:30.408]     if (FALSE) {
[15:32:30.408]     }
[15:32:30.408]     else {
[15:32:30.408]         if (TRUE) {
[15:32:30.408]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:30.408]                 open = "w")
[15:32:30.408]         }
[15:32:30.408]         else {
[15:32:30.408]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:30.408]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:30.408]         }
[15:32:30.408]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:30.408]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:30.408]             base::sink(type = "output", split = FALSE)
[15:32:30.408]             base::close(...future.stdout)
[15:32:30.408]         }, add = TRUE)
[15:32:30.408]     }
[15:32:30.408]     ...future.frame <- base::sys.nframe()
[15:32:30.408]     ...future.conditions <- base::list()
[15:32:30.408]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:30.408]     if (FALSE) {
[15:32:30.408]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:30.408]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:30.408]     }
[15:32:30.408]     ...future.result <- base::tryCatch({
[15:32:30.408]         base::withCallingHandlers({
[15:32:30.408]             ...future.value <- base::withVisible(base::local({
[15:32:30.408]                 ...future.makeSendCondition <- base::local({
[15:32:30.408]                   sendCondition <- NULL
[15:32:30.408]                   function(frame = 1L) {
[15:32:30.408]                     if (is.function(sendCondition)) 
[15:32:30.408]                       return(sendCondition)
[15:32:30.408]                     ns <- getNamespace("parallel")
[15:32:30.408]                     if (exists("sendData", mode = "function", 
[15:32:30.408]                       envir = ns)) {
[15:32:30.408]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:30.408]                         envir = ns)
[15:32:30.408]                       envir <- sys.frame(frame)
[15:32:30.408]                       master <- NULL
[15:32:30.408]                       while (!identical(envir, .GlobalEnv) && 
[15:32:30.408]                         !identical(envir, emptyenv())) {
[15:32:30.408]                         if (exists("master", mode = "list", envir = envir, 
[15:32:30.408]                           inherits = FALSE)) {
[15:32:30.408]                           master <- get("master", mode = "list", 
[15:32:30.408]                             envir = envir, inherits = FALSE)
[15:32:30.408]                           if (inherits(master, c("SOCKnode", 
[15:32:30.408]                             "SOCK0node"))) {
[15:32:30.408]                             sendCondition <<- function(cond) {
[15:32:30.408]                               data <- list(type = "VALUE", value = cond, 
[15:32:30.408]                                 success = TRUE)
[15:32:30.408]                               parallel_sendData(master, data)
[15:32:30.408]                             }
[15:32:30.408]                             return(sendCondition)
[15:32:30.408]                           }
[15:32:30.408]                         }
[15:32:30.408]                         frame <- frame + 1L
[15:32:30.408]                         envir <- sys.frame(frame)
[15:32:30.408]                       }
[15:32:30.408]                     }
[15:32:30.408]                     sendCondition <<- function(cond) NULL
[15:32:30.408]                   }
[15:32:30.408]                 })
[15:32:30.408]                 withCallingHandlers({
[15:32:30.408]                   {
[15:32:30.408]                     do.call(function(...) {
[15:32:30.408]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:30.408]                       if (!identical(...future.globals.maxSize.org, 
[15:32:30.408]                         ...future.globals.maxSize)) {
[15:32:30.408]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:30.408]                         on.exit(options(oopts), add = TRUE)
[15:32:30.408]                       }
[15:32:30.408]                       {
[15:32:30.408]                         lapply(seq_along(...future.elements_ii), 
[15:32:30.408]                           FUN = function(jj) {
[15:32:30.408]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:30.408]                             ...future.FUN(...future.X_jj, ...)
[15:32:30.408]                           })
[15:32:30.408]                       }
[15:32:30.408]                     }, args = future.call.arguments)
[15:32:30.408]                   }
[15:32:30.408]                 }, immediateCondition = function(cond) {
[15:32:30.408]                   sendCondition <- ...future.makeSendCondition()
[15:32:30.408]                   sendCondition(cond)
[15:32:30.408]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:30.408]                   {
[15:32:30.408]                     inherits <- base::inherits
[15:32:30.408]                     invokeRestart <- base::invokeRestart
[15:32:30.408]                     is.null <- base::is.null
[15:32:30.408]                     muffled <- FALSE
[15:32:30.408]                     if (inherits(cond, "message")) {
[15:32:30.408]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:30.408]                       if (muffled) 
[15:32:30.408]                         invokeRestart("muffleMessage")
[15:32:30.408]                     }
[15:32:30.408]                     else if (inherits(cond, "warning")) {
[15:32:30.408]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:30.408]                       if (muffled) 
[15:32:30.408]                         invokeRestart("muffleWarning")
[15:32:30.408]                     }
[15:32:30.408]                     else if (inherits(cond, "condition")) {
[15:32:30.408]                       if (!is.null(pattern)) {
[15:32:30.408]                         computeRestarts <- base::computeRestarts
[15:32:30.408]                         grepl <- base::grepl
[15:32:30.408]                         restarts <- computeRestarts(cond)
[15:32:30.408]                         for (restart in restarts) {
[15:32:30.408]                           name <- restart$name
[15:32:30.408]                           if (is.null(name)) 
[15:32:30.408]                             next
[15:32:30.408]                           if (!grepl(pattern, name)) 
[15:32:30.408]                             next
[15:32:30.408]                           invokeRestart(restart)
[15:32:30.408]                           muffled <- TRUE
[15:32:30.408]                           break
[15:32:30.408]                         }
[15:32:30.408]                       }
[15:32:30.408]                     }
[15:32:30.408]                     invisible(muffled)
[15:32:30.408]                   }
[15:32:30.408]                   muffleCondition(cond)
[15:32:30.408]                 })
[15:32:30.408]             }))
[15:32:30.408]             future::FutureResult(value = ...future.value$value, 
[15:32:30.408]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:30.408]                   ...future.rng), globalenv = if (FALSE) 
[15:32:30.408]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:30.408]                     ...future.globalenv.names))
[15:32:30.408]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:30.408]         }, condition = base::local({
[15:32:30.408]             c <- base::c
[15:32:30.408]             inherits <- base::inherits
[15:32:30.408]             invokeRestart <- base::invokeRestart
[15:32:30.408]             length <- base::length
[15:32:30.408]             list <- base::list
[15:32:30.408]             seq.int <- base::seq.int
[15:32:30.408]             signalCondition <- base::signalCondition
[15:32:30.408]             sys.calls <- base::sys.calls
[15:32:30.408]             `[[` <- base::`[[`
[15:32:30.408]             `+` <- base::`+`
[15:32:30.408]             `<<-` <- base::`<<-`
[15:32:30.408]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:30.408]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:30.408]                   3L)]
[15:32:30.408]             }
[15:32:30.408]             function(cond) {
[15:32:30.408]                 is_error <- inherits(cond, "error")
[15:32:30.408]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:30.408]                   NULL)
[15:32:30.408]                 if (is_error) {
[15:32:30.408]                   sessionInformation <- function() {
[15:32:30.408]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:30.408]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:30.408]                       search = base::search(), system = base::Sys.info())
[15:32:30.408]                   }
[15:32:30.408]                   ...future.conditions[[length(...future.conditions) + 
[15:32:30.408]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:30.408]                     cond$call), session = sessionInformation(), 
[15:32:30.408]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:30.408]                   signalCondition(cond)
[15:32:30.408]                 }
[15:32:30.408]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:30.408]                 "immediateCondition"))) {
[15:32:30.408]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:30.408]                   ...future.conditions[[length(...future.conditions) + 
[15:32:30.408]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:30.408]                   if (TRUE && !signal) {
[15:32:30.408]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:30.408]                     {
[15:32:30.408]                       inherits <- base::inherits
[15:32:30.408]                       invokeRestart <- base::invokeRestart
[15:32:30.408]                       is.null <- base::is.null
[15:32:30.408]                       muffled <- FALSE
[15:32:30.408]                       if (inherits(cond, "message")) {
[15:32:30.408]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:30.408]                         if (muffled) 
[15:32:30.408]                           invokeRestart("muffleMessage")
[15:32:30.408]                       }
[15:32:30.408]                       else if (inherits(cond, "warning")) {
[15:32:30.408]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:30.408]                         if (muffled) 
[15:32:30.408]                           invokeRestart("muffleWarning")
[15:32:30.408]                       }
[15:32:30.408]                       else if (inherits(cond, "condition")) {
[15:32:30.408]                         if (!is.null(pattern)) {
[15:32:30.408]                           computeRestarts <- base::computeRestarts
[15:32:30.408]                           grepl <- base::grepl
[15:32:30.408]                           restarts <- computeRestarts(cond)
[15:32:30.408]                           for (restart in restarts) {
[15:32:30.408]                             name <- restart$name
[15:32:30.408]                             if (is.null(name)) 
[15:32:30.408]                               next
[15:32:30.408]                             if (!grepl(pattern, name)) 
[15:32:30.408]                               next
[15:32:30.408]                             invokeRestart(restart)
[15:32:30.408]                             muffled <- TRUE
[15:32:30.408]                             break
[15:32:30.408]                           }
[15:32:30.408]                         }
[15:32:30.408]                       }
[15:32:30.408]                       invisible(muffled)
[15:32:30.408]                     }
[15:32:30.408]                     muffleCondition(cond, pattern = "^muffle")
[15:32:30.408]                   }
[15:32:30.408]                 }
[15:32:30.408]                 else {
[15:32:30.408]                   if (TRUE) {
[15:32:30.408]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:30.408]                     {
[15:32:30.408]                       inherits <- base::inherits
[15:32:30.408]                       invokeRestart <- base::invokeRestart
[15:32:30.408]                       is.null <- base::is.null
[15:32:30.408]                       muffled <- FALSE
[15:32:30.408]                       if (inherits(cond, "message")) {
[15:32:30.408]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:30.408]                         if (muffled) 
[15:32:30.408]                           invokeRestart("muffleMessage")
[15:32:30.408]                       }
[15:32:30.408]                       else if (inherits(cond, "warning")) {
[15:32:30.408]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:30.408]                         if (muffled) 
[15:32:30.408]                           invokeRestart("muffleWarning")
[15:32:30.408]                       }
[15:32:30.408]                       else if (inherits(cond, "condition")) {
[15:32:30.408]                         if (!is.null(pattern)) {
[15:32:30.408]                           computeRestarts <- base::computeRestarts
[15:32:30.408]                           grepl <- base::grepl
[15:32:30.408]                           restarts <- computeRestarts(cond)
[15:32:30.408]                           for (restart in restarts) {
[15:32:30.408]                             name <- restart$name
[15:32:30.408]                             if (is.null(name)) 
[15:32:30.408]                               next
[15:32:30.408]                             if (!grepl(pattern, name)) 
[15:32:30.408]                               next
[15:32:30.408]                             invokeRestart(restart)
[15:32:30.408]                             muffled <- TRUE
[15:32:30.408]                             break
[15:32:30.408]                           }
[15:32:30.408]                         }
[15:32:30.408]                       }
[15:32:30.408]                       invisible(muffled)
[15:32:30.408]                     }
[15:32:30.408]                     muffleCondition(cond, pattern = "^muffle")
[15:32:30.408]                   }
[15:32:30.408]                 }
[15:32:30.408]             }
[15:32:30.408]         }))
[15:32:30.408]     }, error = function(ex) {
[15:32:30.408]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:30.408]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:30.408]                 ...future.rng), started = ...future.startTime, 
[15:32:30.408]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:30.408]             version = "1.8"), class = "FutureResult")
[15:32:30.408]     }, finally = {
[15:32:30.408]         if (!identical(...future.workdir, getwd())) 
[15:32:30.408]             setwd(...future.workdir)
[15:32:30.408]         {
[15:32:30.408]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:30.408]                 ...future.oldOptions$nwarnings <- NULL
[15:32:30.408]             }
[15:32:30.408]             base::options(...future.oldOptions)
[15:32:30.408]             if (.Platform$OS.type == "windows") {
[15:32:30.408]                 old_names <- names(...future.oldEnvVars)
[15:32:30.408]                 envs <- base::Sys.getenv()
[15:32:30.408]                 names <- names(envs)
[15:32:30.408]                 common <- intersect(names, old_names)
[15:32:30.408]                 added <- setdiff(names, old_names)
[15:32:30.408]                 removed <- setdiff(old_names, names)
[15:32:30.408]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:30.408]                   envs[common]]
[15:32:30.408]                 NAMES <- toupper(changed)
[15:32:30.408]                 args <- list()
[15:32:30.408]                 for (kk in seq_along(NAMES)) {
[15:32:30.408]                   name <- changed[[kk]]
[15:32:30.408]                   NAME <- NAMES[[kk]]
[15:32:30.408]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:30.408]                     next
[15:32:30.408]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:30.408]                 }
[15:32:30.408]                 NAMES <- toupper(added)
[15:32:30.408]                 for (kk in seq_along(NAMES)) {
[15:32:30.408]                   name <- added[[kk]]
[15:32:30.408]                   NAME <- NAMES[[kk]]
[15:32:30.408]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:30.408]                     next
[15:32:30.408]                   args[[name]] <- ""
[15:32:30.408]                 }
[15:32:30.408]                 NAMES <- toupper(removed)
[15:32:30.408]                 for (kk in seq_along(NAMES)) {
[15:32:30.408]                   name <- removed[[kk]]
[15:32:30.408]                   NAME <- NAMES[[kk]]
[15:32:30.408]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:30.408]                     next
[15:32:30.408]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:30.408]                 }
[15:32:30.408]                 if (length(args) > 0) 
[15:32:30.408]                   base::do.call(base::Sys.setenv, args = args)
[15:32:30.408]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:30.408]             }
[15:32:30.408]             else {
[15:32:30.408]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:30.408]             }
[15:32:30.408]             {
[15:32:30.408]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:30.408]                   0L) {
[15:32:30.408]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:30.408]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:30.408]                   base::options(opts)
[15:32:30.408]                 }
[15:32:30.408]                 {
[15:32:30.408]                   {
[15:32:30.408]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:30.408]                     NULL
[15:32:30.408]                   }
[15:32:30.408]                   options(future.plan = NULL)
[15:32:30.408]                   if (is.na(NA_character_)) 
[15:32:30.408]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:30.408]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:30.408]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:30.408]                     .init = FALSE)
[15:32:30.408]                 }
[15:32:30.408]             }
[15:32:30.408]         }
[15:32:30.408]     })
[15:32:30.408]     if (TRUE) {
[15:32:30.408]         base::sink(type = "output", split = FALSE)
[15:32:30.408]         if (TRUE) {
[15:32:30.408]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:30.408]         }
[15:32:30.408]         else {
[15:32:30.408]             ...future.result["stdout"] <- base::list(NULL)
[15:32:30.408]         }
[15:32:30.408]         base::close(...future.stdout)
[15:32:30.408]         ...future.stdout <- NULL
[15:32:30.408]     }
[15:32:30.408]     ...future.result$conditions <- ...future.conditions
[15:32:30.408]     ...future.result$finished <- base::Sys.time()
[15:32:30.408]     ...future.result
[15:32:30.408] }
[15:32:30.416] Exporting 5 global objects (848 bytes) to cluster node #1 ...
[15:32:30.416] Exporting '...future.FUN' (848 bytes) to cluster node #1 ...
[15:32:30.417] Exporting '...future.FUN' (848 bytes) to cluster node #1 ... DONE
[15:32:30.417] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:30.418] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:30.418] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:30.419] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:30.420] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:30.420] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:30.421] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:30.421] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:30.422] Exporting 5 global objects (848 bytes) to cluster node #1 ... DONE
[15:32:30.423] MultisessionFuture started
[15:32:30.423] - Launch lazy future ... done
[15:32:30.424] run() for 'MultisessionFuture' ... done
[15:32:30.424] Created future:
[15:32:30.455] receiveMessageFromWorker() for ClusterFuture ...
[15:32:30.456] - Validating connection of MultisessionFuture
[15:32:30.456] - received message: FutureResult
[15:32:30.457] - Received FutureResult
[15:32:30.457] - Erased future from FutureRegistry
[15:32:30.457] result() for ClusterFuture ...
[15:32:30.457] - result already collected: FutureResult
[15:32:30.458] result() for ClusterFuture ... done
[15:32:30.458] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:30.425] MultisessionFuture:
[15:32:30.425] Label: 'future_sapply-2'
[15:32:30.425] Expression:
[15:32:30.425] {
[15:32:30.425]     do.call(function(...) {
[15:32:30.425]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:30.425]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:30.425]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:30.425]             on.exit(options(oopts), add = TRUE)
[15:32:30.425]         }
[15:32:30.425]         {
[15:32:30.425]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:30.425]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:30.425]                 ...future.FUN(...future.X_jj, ...)
[15:32:30.425]             })
[15:32:30.425]         }
[15:32:30.425]     }, args = future.call.arguments)
[15:32:30.425] }
[15:32:30.425] Lazy evaluation: FALSE
[15:32:30.425] Asynchronous evaluation: TRUE
[15:32:30.425] Local evaluation: TRUE
[15:32:30.425] Environment: R_GlobalEnv
[15:32:30.425] Capture standard output: TRUE
[15:32:30.425] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:30.425] Globals: 5 objects totaling 960 bytes (function '...future.FUN' of 848 bytes, 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)
[15:32:30.425] Packages: <none>
[15:32:30.425] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:30.425] Resolved: TRUE
[15:32:30.425] Value: <not collected>
[15:32:30.425] Conditions captured: <none>
[15:32:30.425] Early signaling: FALSE
[15:32:30.425] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:30.425] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:30.459] Chunk #2 of 2 ... DONE
[15:32:30.459] Launching 2 futures (chunks) ... DONE
[15:32:30.459] Resolving 2 futures (chunks) ...
[15:32:30.459] resolve() on list ...
[15:32:30.460]  recursive: 0
[15:32:30.460]  length: 2
[15:32:30.460] 
[15:32:30.461] Future #1
[15:32:30.461] result() for ClusterFuture ...
[15:32:30.461] - result already collected: FutureResult
[15:32:30.461] result() for ClusterFuture ... done
[15:32:30.462] result() for ClusterFuture ...
[15:32:30.462] - result already collected: FutureResult
[15:32:30.462] result() for ClusterFuture ... done
[15:32:30.462] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:30.463] - nx: 2
[15:32:30.463] - relay: TRUE
[15:32:30.463] - stdout: TRUE
[15:32:30.463] - signal: TRUE
[15:32:30.464] - resignal: FALSE
[15:32:30.464] - force: TRUE
[15:32:30.464] - relayed: [n=2] FALSE, FALSE
[15:32:30.464] - queued futures: [n=2] FALSE, FALSE
[15:32:30.465]  - until=1
[15:32:30.465]  - relaying element #1
[15:32:30.465] result() for ClusterFuture ...
[15:32:30.465] - result already collected: FutureResult
[15:32:30.466] result() for ClusterFuture ... done
[15:32:30.466] result() for ClusterFuture ...
[15:32:30.466] - result already collected: FutureResult
[15:32:30.466] result() for ClusterFuture ... done
[15:32:30.467] result() for ClusterFuture ...
[15:32:30.467] - result already collected: FutureResult
[15:32:30.467] result() for ClusterFuture ... done
[15:32:30.468] result() for ClusterFuture ...
[15:32:30.468] - result already collected: FutureResult
[15:32:30.468] result() for ClusterFuture ... done
[15:32:30.468] - relayed: [n=2] TRUE, FALSE
[15:32:30.469] - queued futures: [n=2] TRUE, FALSE
[15:32:30.469] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:30.469]  length: 1 (resolved future 1)
[15:32:30.469] Future #2
[15:32:30.470] result() for ClusterFuture ...
[15:32:30.470] - result already collected: FutureResult
[15:32:30.470] result() for ClusterFuture ... done
[15:32:30.471] result() for ClusterFuture ...
[15:32:30.471] - result already collected: FutureResult
[15:32:30.471] result() for ClusterFuture ... done
[15:32:30.471] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:30.472] - nx: 2
[15:32:30.472] - relay: TRUE
[15:32:30.472] - stdout: TRUE
[15:32:30.472] - signal: TRUE
[15:32:30.473] - resignal: FALSE
[15:32:30.473] - force: TRUE
[15:32:30.473] - relayed: [n=2] TRUE, FALSE
[15:32:30.473] - queued futures: [n=2] TRUE, FALSE
[15:32:30.474]  - until=2
[15:32:30.474]  - relaying element #2
[15:32:30.474] result() for ClusterFuture ...
[15:32:30.474] - result already collected: FutureResult
[15:32:30.475] result() for ClusterFuture ... done
[15:32:30.475] result() for ClusterFuture ...
[15:32:30.475] - result already collected: FutureResult
[15:32:30.475] result() for ClusterFuture ... done
[15:32:30.476] result() for ClusterFuture ...
[15:32:30.476] - result already collected: FutureResult
[15:32:30.476] result() for ClusterFuture ... done
[15:32:30.477] result() for ClusterFuture ...
[15:32:30.477] - result already collected: FutureResult
[15:32:30.477] result() for ClusterFuture ... done
[15:32:30.477] - relayed: [n=2] TRUE, TRUE
[15:32:30.478] - queued futures: [n=2] TRUE, TRUE
[15:32:30.478] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:30.478]  length: 0 (resolved future 2)
[15:32:30.478] Relaying remaining futures
[15:32:30.479] signalConditionsASAP(NULL, pos=0) ...
[15:32:30.479] - nx: 2
[15:32:30.479] - relay: TRUE
[15:32:30.479] - stdout: TRUE
[15:32:30.480] - signal: TRUE
[15:32:30.480] - resignal: FALSE
[15:32:30.480] - force: TRUE
[15:32:30.480] - relayed: [n=2] TRUE, TRUE
[15:32:30.481] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:30.481] - relayed: [n=2] TRUE, TRUE
[15:32:30.481] - queued futures: [n=2] TRUE, TRUE
[15:32:30.482] signalConditionsASAP(NULL, pos=0) ... done
[15:32:30.482] resolve() on list ... DONE
[15:32:30.482] result() for ClusterFuture ...
[15:32:30.482] - result already collected: FutureResult
[15:32:30.483] result() for ClusterFuture ... done
[15:32:30.483] result() for ClusterFuture ...
[15:32:30.483] - result already collected: FutureResult
[15:32:30.483] result() for ClusterFuture ... done
[15:32:30.484] result() for ClusterFuture ...
[15:32:30.484] - result already collected: FutureResult
[15:32:30.484] result() for ClusterFuture ... done
[15:32:30.485] result() for ClusterFuture ...
[15:32:30.485] - result already collected: FutureResult
[15:32:30.485] result() for ClusterFuture ... done
[15:32:30.485]  - Number of value chunks collected: 2
[15:32:30.486] Resolving 2 futures (chunks) ... DONE
[15:32:30.486] Reducing values from 2 chunks ...
[15:32:30.486]  - Number of values collected after concatenation: 3
[15:32:30.486]  - Number of values expected: 3
[15:32:30.487] Reducing values from 2 chunks ... DONE
[15:32:30.487] future_lapply() ... DONE
List of 2
 $ y0: Named num [1:3] 1 2 3
  ..- attr(*, "names")= chr [1:3] "a" "b" "c"
 $ y1: Named num [1:3] 1 2 3
  ..- attr(*, "names")= chr [1:3] "a" "b" "c"
[15:32:30.490] future_lapply() ...
[15:32:30.495] Number of chunks: 2
[15:32:30.495] getGlobalsAndPackagesXApply() ...
[15:32:30.496]  - future.globals: TRUE
[15:32:30.496] getGlobalsAndPackages() ...
[15:32:30.496] Searching for globals...
[15:32:30.498] - globals found: [2] 'FUN', 'UseMethod'
[15:32:30.499] Searching for globals ... DONE
[15:32:30.499] Resolving globals: FALSE
[15:32:30.500] The total size of the 1 globals is 1.22 KiB (1248 bytes)
[15:32:30.500] The total size of the 1 globals exported for future expression ('FUN()') is 1.22 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.22 KiB of class 'function')
[15:32:30.501] - globals: [1] 'FUN'
[15:32:30.501] 
[15:32:30.501] getGlobalsAndPackages() ... DONE
[15:32:30.501]  - globals found/used: [n=1] 'FUN'
[15:32:30.502]  - needed namespaces: [n=0] 
[15:32:30.502] Finding globals ... DONE
[15:32:30.502]  - use_args: TRUE
[15:32:30.502]  - Getting '...' globals ...
[15:32:30.503] resolve() on list ...
[15:32:30.503]  recursive: 0
[15:32:30.504]  length: 1
[15:32:30.504]  elements: '...'
[15:32:30.504]  length: 0 (resolved future 1)
[15:32:30.505] resolve() on list ... DONE
[15:32:30.505]    - '...' content: [n=0] 
[15:32:30.505] List of 1
[15:32:30.505]  $ ...: list()
[15:32:30.505]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:30.505]  - attr(*, "where")=List of 1
[15:32:30.505]   ..$ ...:<environment: 0x00000276e4cc0208> 
[15:32:30.505]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:30.505]  - attr(*, "resolved")= logi TRUE
[15:32:30.505]  - attr(*, "total_size")= num NA
[15:32:30.510]  - Getting '...' globals ... DONE
[15:32:30.511] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:30.511] List of 2
[15:32:30.511]  $ ...future.FUN:function (x, ...)  
[15:32:30.511]  $ ...          : list()
[15:32:30.511]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:30.511]  - attr(*, "where")=List of 2
[15:32:30.511]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:30.511]   ..$ ...          :<environment: 0x00000276e4cc0208> 
[15:32:30.511]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:30.511]  - attr(*, "resolved")= logi FALSE
[15:32:30.511]  - attr(*, "total_size")= num 1248
[15:32:30.516] Packages to be attached in all futures: [n=0] 
[15:32:30.517] getGlobalsAndPackagesXApply() ... DONE
[15:32:30.517] Number of futures (= number of chunks): 2
[15:32:30.517] Launching 2 futures (chunks) ...
[15:32:30.518] Chunk #1 of 2 ...
[15:32:30.518]  - Finding globals in 'X' for chunk #1 ...
[15:32:30.518] getGlobalsAndPackages() ...
[15:32:30.519] Searching for globals...
[15:32:30.519] 
[15:32:30.519] Searching for globals ... DONE
[15:32:30.520] - globals: [0] <none>
[15:32:30.520] getGlobalsAndPackages() ... DONE
[15:32:30.520]    + additional globals found: [n=0] 
[15:32:30.520]    + additional namespaces needed: [n=0] 
[15:32:30.521]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:30.521]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:30.521]  - seeds: <none>
[15:32:30.522]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:30.522] getGlobalsAndPackages() ...
[15:32:30.522] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:30.522] Resolving globals: FALSE
[15:32:30.523] Tweak future expression to call with '...' arguments ...
[15:32:30.523] {
[15:32:30.523]     do.call(function(...) {
[15:32:30.523]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:30.523]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:30.523]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:30.523]             on.exit(options(oopts), add = TRUE)
[15:32:30.523]         }
[15:32:30.523]         {
[15:32:30.523]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:30.523]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:30.523]                 ...future.FUN(...future.X_jj, ...)
[15:32:30.523]             })
[15:32:30.523]         }
[15:32:30.523]     }, args = future.call.arguments)
[15:32:30.523] }
[15:32:30.524] Tweak future expression to call with '...' arguments ... DONE
[15:32:30.525] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:30.525] 
[15:32:30.525] getGlobalsAndPackages() ... DONE
[15:32:30.530] run() for 'Future' ...
[15:32:30.530] - state: 'created'
[15:32:30.531] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:30.549] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:30.550] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:30.550]   - Field: 'node'
[15:32:30.550]   - Field: 'label'
[15:32:30.551]   - Field: 'local'
[15:32:30.551]   - Field: 'owner'
[15:32:30.551]   - Field: 'envir'
[15:32:30.551]   - Field: 'workers'
[15:32:30.552]   - Field: 'packages'
[15:32:30.552]   - Field: 'gc'
[15:32:30.552]   - Field: 'conditions'
[15:32:30.553]   - Field: 'persistent'
[15:32:30.553]   - Field: 'expr'
[15:32:30.553]   - Field: 'uuid'
[15:32:30.554]   - Field: 'seed'
[15:32:30.554]   - Field: 'version'
[15:32:30.554]   - Field: 'result'
[15:32:30.555]   - Field: 'asynchronous'
[15:32:30.555]   - Field: 'calls'
[15:32:30.555]   - Field: 'globals'
[15:32:30.555]   - Field: 'stdout'
[15:32:30.556]   - Field: 'earlySignal'
[15:32:30.556]   - Field: 'lazy'
[15:32:30.556]   - Field: 'state'
[15:32:30.557] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:30.557] - Launch lazy future ...
[15:32:30.558] Packages needed by the future expression (n = 0): <none>
[15:32:30.558] Packages needed by future strategies (n = 0): <none>
[15:32:30.559] {
[15:32:30.559]     {
[15:32:30.559]         {
[15:32:30.559]             ...future.startTime <- base::Sys.time()
[15:32:30.559]             {
[15:32:30.559]                 {
[15:32:30.559]                   {
[15:32:30.559]                     {
[15:32:30.559]                       base::local({
[15:32:30.559]                         has_future <- base::requireNamespace("future", 
[15:32:30.559]                           quietly = TRUE)
[15:32:30.559]                         if (has_future) {
[15:32:30.559]                           ns <- base::getNamespace("future")
[15:32:30.559]                           version <- ns[[".package"]][["version"]]
[15:32:30.559]                           if (is.null(version)) 
[15:32:30.559]                             version <- utils::packageVersion("future")
[15:32:30.559]                         }
[15:32:30.559]                         else {
[15:32:30.559]                           version <- NULL
[15:32:30.559]                         }
[15:32:30.559]                         if (!has_future || version < "1.8.0") {
[15:32:30.559]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:30.559]                             "", base::R.version$version.string), 
[15:32:30.559]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:30.559]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:30.559]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:30.559]                               "release", "version")], collapse = " "), 
[15:32:30.559]                             hostname = base::Sys.info()[["nodename"]])
[15:32:30.559]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:30.559]                             info)
[15:32:30.559]                           info <- base::paste(info, collapse = "; ")
[15:32:30.559]                           if (!has_future) {
[15:32:30.559]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:30.559]                               info)
[15:32:30.559]                           }
[15:32:30.559]                           else {
[15:32:30.559]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:30.559]                               info, version)
[15:32:30.559]                           }
[15:32:30.559]                           base::stop(msg)
[15:32:30.559]                         }
[15:32:30.559]                       })
[15:32:30.559]                     }
[15:32:30.559]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:30.559]                     base::options(mc.cores = 1L)
[15:32:30.559]                   }
[15:32:30.559]                   ...future.strategy.old <- future::plan("list")
[15:32:30.559]                   options(future.plan = NULL)
[15:32:30.559]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:30.559]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:30.559]                 }
[15:32:30.559]                 ...future.workdir <- getwd()
[15:32:30.559]             }
[15:32:30.559]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:30.559]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:30.559]         }
[15:32:30.559]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:30.559]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:30.559]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:30.559]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:30.559]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:30.559]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:30.559]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:30.559]             base::names(...future.oldOptions))
[15:32:30.559]     }
[15:32:30.559]     if (FALSE) {
[15:32:30.559]     }
[15:32:30.559]     else {
[15:32:30.559]         if (TRUE) {
[15:32:30.559]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:30.559]                 open = "w")
[15:32:30.559]         }
[15:32:30.559]         else {
[15:32:30.559]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:30.559]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:30.559]         }
[15:32:30.559]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:30.559]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:30.559]             base::sink(type = "output", split = FALSE)
[15:32:30.559]             base::close(...future.stdout)
[15:32:30.559]         }, add = TRUE)
[15:32:30.559]     }
[15:32:30.559]     ...future.frame <- base::sys.nframe()
[15:32:30.559]     ...future.conditions <- base::list()
[15:32:30.559]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:30.559]     if (FALSE) {
[15:32:30.559]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:30.559]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:30.559]     }
[15:32:30.559]     ...future.result <- base::tryCatch({
[15:32:30.559]         base::withCallingHandlers({
[15:32:30.559]             ...future.value <- base::withVisible(base::local({
[15:32:30.559]                 ...future.makeSendCondition <- base::local({
[15:32:30.559]                   sendCondition <- NULL
[15:32:30.559]                   function(frame = 1L) {
[15:32:30.559]                     if (is.function(sendCondition)) 
[15:32:30.559]                       return(sendCondition)
[15:32:30.559]                     ns <- getNamespace("parallel")
[15:32:30.559]                     if (exists("sendData", mode = "function", 
[15:32:30.559]                       envir = ns)) {
[15:32:30.559]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:30.559]                         envir = ns)
[15:32:30.559]                       envir <- sys.frame(frame)
[15:32:30.559]                       master <- NULL
[15:32:30.559]                       while (!identical(envir, .GlobalEnv) && 
[15:32:30.559]                         !identical(envir, emptyenv())) {
[15:32:30.559]                         if (exists("master", mode = "list", envir = envir, 
[15:32:30.559]                           inherits = FALSE)) {
[15:32:30.559]                           master <- get("master", mode = "list", 
[15:32:30.559]                             envir = envir, inherits = FALSE)
[15:32:30.559]                           if (inherits(master, c("SOCKnode", 
[15:32:30.559]                             "SOCK0node"))) {
[15:32:30.559]                             sendCondition <<- function(cond) {
[15:32:30.559]                               data <- list(type = "VALUE", value = cond, 
[15:32:30.559]                                 success = TRUE)
[15:32:30.559]                               parallel_sendData(master, data)
[15:32:30.559]                             }
[15:32:30.559]                             return(sendCondition)
[15:32:30.559]                           }
[15:32:30.559]                         }
[15:32:30.559]                         frame <- frame + 1L
[15:32:30.559]                         envir <- sys.frame(frame)
[15:32:30.559]                       }
[15:32:30.559]                     }
[15:32:30.559]                     sendCondition <<- function(cond) NULL
[15:32:30.559]                   }
[15:32:30.559]                 })
[15:32:30.559]                 withCallingHandlers({
[15:32:30.559]                   {
[15:32:30.559]                     do.call(function(...) {
[15:32:30.559]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:30.559]                       if (!identical(...future.globals.maxSize.org, 
[15:32:30.559]                         ...future.globals.maxSize)) {
[15:32:30.559]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:30.559]                         on.exit(options(oopts), add = TRUE)
[15:32:30.559]                       }
[15:32:30.559]                       {
[15:32:30.559]                         lapply(seq_along(...future.elements_ii), 
[15:32:30.559]                           FUN = function(jj) {
[15:32:30.559]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:30.559]                             ...future.FUN(...future.X_jj, ...)
[15:32:30.559]                           })
[15:32:30.559]                       }
[15:32:30.559]                     }, args = future.call.arguments)
[15:32:30.559]                   }
[15:32:30.559]                 }, immediateCondition = function(cond) {
[15:32:30.559]                   sendCondition <- ...future.makeSendCondition()
[15:32:30.559]                   sendCondition(cond)
[15:32:30.559]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:30.559]                   {
[15:32:30.559]                     inherits <- base::inherits
[15:32:30.559]                     invokeRestart <- base::invokeRestart
[15:32:30.559]                     is.null <- base::is.null
[15:32:30.559]                     muffled <- FALSE
[15:32:30.559]                     if (inherits(cond, "message")) {
[15:32:30.559]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:30.559]                       if (muffled) 
[15:32:30.559]                         invokeRestart("muffleMessage")
[15:32:30.559]                     }
[15:32:30.559]                     else if (inherits(cond, "warning")) {
[15:32:30.559]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:30.559]                       if (muffled) 
[15:32:30.559]                         invokeRestart("muffleWarning")
[15:32:30.559]                     }
[15:32:30.559]                     else if (inherits(cond, "condition")) {
[15:32:30.559]                       if (!is.null(pattern)) {
[15:32:30.559]                         computeRestarts <- base::computeRestarts
[15:32:30.559]                         grepl <- base::grepl
[15:32:30.559]                         restarts <- computeRestarts(cond)
[15:32:30.559]                         for (restart in restarts) {
[15:32:30.559]                           name <- restart$name
[15:32:30.559]                           if (is.null(name)) 
[15:32:30.559]                             next
[15:32:30.559]                           if (!grepl(pattern, name)) 
[15:32:30.559]                             next
[15:32:30.559]                           invokeRestart(restart)
[15:32:30.559]                           muffled <- TRUE
[15:32:30.559]                           break
[15:32:30.559]                         }
[15:32:30.559]                       }
[15:32:30.559]                     }
[15:32:30.559]                     invisible(muffled)
[15:32:30.559]                   }
[15:32:30.559]                   muffleCondition(cond)
[15:32:30.559]                 })
[15:32:30.559]             }))
[15:32:30.559]             future::FutureResult(value = ...future.value$value, 
[15:32:30.559]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:30.559]                   ...future.rng), globalenv = if (FALSE) 
[15:32:30.559]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:30.559]                     ...future.globalenv.names))
[15:32:30.559]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:30.559]         }, condition = base::local({
[15:32:30.559]             c <- base::c
[15:32:30.559]             inherits <- base::inherits
[15:32:30.559]             invokeRestart <- base::invokeRestart
[15:32:30.559]             length <- base::length
[15:32:30.559]             list <- base::list
[15:32:30.559]             seq.int <- base::seq.int
[15:32:30.559]             signalCondition <- base::signalCondition
[15:32:30.559]             sys.calls <- base::sys.calls
[15:32:30.559]             `[[` <- base::`[[`
[15:32:30.559]             `+` <- base::`+`
[15:32:30.559]             `<<-` <- base::`<<-`
[15:32:30.559]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:30.559]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:30.559]                   3L)]
[15:32:30.559]             }
[15:32:30.559]             function(cond) {
[15:32:30.559]                 is_error <- inherits(cond, "error")
[15:32:30.559]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:30.559]                   NULL)
[15:32:30.559]                 if (is_error) {
[15:32:30.559]                   sessionInformation <- function() {
[15:32:30.559]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:30.559]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:30.559]                       search = base::search(), system = base::Sys.info())
[15:32:30.559]                   }
[15:32:30.559]                   ...future.conditions[[length(...future.conditions) + 
[15:32:30.559]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:30.559]                     cond$call), session = sessionInformation(), 
[15:32:30.559]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:30.559]                   signalCondition(cond)
[15:32:30.559]                 }
[15:32:30.559]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:30.559]                 "immediateCondition"))) {
[15:32:30.559]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:30.559]                   ...future.conditions[[length(...future.conditions) + 
[15:32:30.559]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:30.559]                   if (TRUE && !signal) {
[15:32:30.559]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:30.559]                     {
[15:32:30.559]                       inherits <- base::inherits
[15:32:30.559]                       invokeRestart <- base::invokeRestart
[15:32:30.559]                       is.null <- base::is.null
[15:32:30.559]                       muffled <- FALSE
[15:32:30.559]                       if (inherits(cond, "message")) {
[15:32:30.559]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:30.559]                         if (muffled) 
[15:32:30.559]                           invokeRestart("muffleMessage")
[15:32:30.559]                       }
[15:32:30.559]                       else if (inherits(cond, "warning")) {
[15:32:30.559]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:30.559]                         if (muffled) 
[15:32:30.559]                           invokeRestart("muffleWarning")
[15:32:30.559]                       }
[15:32:30.559]                       else if (inherits(cond, "condition")) {
[15:32:30.559]                         if (!is.null(pattern)) {
[15:32:30.559]                           computeRestarts <- base::computeRestarts
[15:32:30.559]                           grepl <- base::grepl
[15:32:30.559]                           restarts <- computeRestarts(cond)
[15:32:30.559]                           for (restart in restarts) {
[15:32:30.559]                             name <- restart$name
[15:32:30.559]                             if (is.null(name)) 
[15:32:30.559]                               next
[15:32:30.559]                             if (!grepl(pattern, name)) 
[15:32:30.559]                               next
[15:32:30.559]                             invokeRestart(restart)
[15:32:30.559]                             muffled <- TRUE
[15:32:30.559]                             break
[15:32:30.559]                           }
[15:32:30.559]                         }
[15:32:30.559]                       }
[15:32:30.559]                       invisible(muffled)
[15:32:30.559]                     }
[15:32:30.559]                     muffleCondition(cond, pattern = "^muffle")
[15:32:30.559]                   }
[15:32:30.559]                 }
[15:32:30.559]                 else {
[15:32:30.559]                   if (TRUE) {
[15:32:30.559]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:30.559]                     {
[15:32:30.559]                       inherits <- base::inherits
[15:32:30.559]                       invokeRestart <- base::invokeRestart
[15:32:30.559]                       is.null <- base::is.null
[15:32:30.559]                       muffled <- FALSE
[15:32:30.559]                       if (inherits(cond, "message")) {
[15:32:30.559]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:30.559]                         if (muffled) 
[15:32:30.559]                           invokeRestart("muffleMessage")
[15:32:30.559]                       }
[15:32:30.559]                       else if (inherits(cond, "warning")) {
[15:32:30.559]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:30.559]                         if (muffled) 
[15:32:30.559]                           invokeRestart("muffleWarning")
[15:32:30.559]                       }
[15:32:30.559]                       else if (inherits(cond, "condition")) {
[15:32:30.559]                         if (!is.null(pattern)) {
[15:32:30.559]                           computeRestarts <- base::computeRestarts
[15:32:30.559]                           grepl <- base::grepl
[15:32:30.559]                           restarts <- computeRestarts(cond)
[15:32:30.559]                           for (restart in restarts) {
[15:32:30.559]                             name <- restart$name
[15:32:30.559]                             if (is.null(name)) 
[15:32:30.559]                               next
[15:32:30.559]                             if (!grepl(pattern, name)) 
[15:32:30.559]                               next
[15:32:30.559]                             invokeRestart(restart)
[15:32:30.559]                             muffled <- TRUE
[15:32:30.559]                             break
[15:32:30.559]                           }
[15:32:30.559]                         }
[15:32:30.559]                       }
[15:32:30.559]                       invisible(muffled)
[15:32:30.559]                     }
[15:32:30.559]                     muffleCondition(cond, pattern = "^muffle")
[15:32:30.559]                   }
[15:32:30.559]                 }
[15:32:30.559]             }
[15:32:30.559]         }))
[15:32:30.559]     }, error = function(ex) {
[15:32:30.559]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:30.559]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:30.559]                 ...future.rng), started = ...future.startTime, 
[15:32:30.559]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:30.559]             version = "1.8"), class = "FutureResult")
[15:32:30.559]     }, finally = {
[15:32:30.559]         if (!identical(...future.workdir, getwd())) 
[15:32:30.559]             setwd(...future.workdir)
[15:32:30.559]         {
[15:32:30.559]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:30.559]                 ...future.oldOptions$nwarnings <- NULL
[15:32:30.559]             }
[15:32:30.559]             base::options(...future.oldOptions)
[15:32:30.559]             if (.Platform$OS.type == "windows") {
[15:32:30.559]                 old_names <- names(...future.oldEnvVars)
[15:32:30.559]                 envs <- base::Sys.getenv()
[15:32:30.559]                 names <- names(envs)
[15:32:30.559]                 common <- intersect(names, old_names)
[15:32:30.559]                 added <- setdiff(names, old_names)
[15:32:30.559]                 removed <- setdiff(old_names, names)
[15:32:30.559]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:30.559]                   envs[common]]
[15:32:30.559]                 NAMES <- toupper(changed)
[15:32:30.559]                 args <- list()
[15:32:30.559]                 for (kk in seq_along(NAMES)) {
[15:32:30.559]                   name <- changed[[kk]]
[15:32:30.559]                   NAME <- NAMES[[kk]]
[15:32:30.559]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:30.559]                     next
[15:32:30.559]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:30.559]                 }
[15:32:30.559]                 NAMES <- toupper(added)
[15:32:30.559]                 for (kk in seq_along(NAMES)) {
[15:32:30.559]                   name <- added[[kk]]
[15:32:30.559]                   NAME <- NAMES[[kk]]
[15:32:30.559]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:30.559]                     next
[15:32:30.559]                   args[[name]] <- ""
[15:32:30.559]                 }
[15:32:30.559]                 NAMES <- toupper(removed)
[15:32:30.559]                 for (kk in seq_along(NAMES)) {
[15:32:30.559]                   name <- removed[[kk]]
[15:32:30.559]                   NAME <- NAMES[[kk]]
[15:32:30.559]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:30.559]                     next
[15:32:30.559]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:30.559]                 }
[15:32:30.559]                 if (length(args) > 0) 
[15:32:30.559]                   base::do.call(base::Sys.setenv, args = args)
[15:32:30.559]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:30.559]             }
[15:32:30.559]             else {
[15:32:30.559]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:30.559]             }
[15:32:30.559]             {
[15:32:30.559]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:30.559]                   0L) {
[15:32:30.559]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:30.559]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:30.559]                   base::options(opts)
[15:32:30.559]                 }
[15:32:30.559]                 {
[15:32:30.559]                   {
[15:32:30.559]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:30.559]                     NULL
[15:32:30.559]                   }
[15:32:30.559]                   options(future.plan = NULL)
[15:32:30.559]                   if (is.na(NA_character_)) 
[15:32:30.559]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:30.559]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:30.559]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:30.559]                     .init = FALSE)
[15:32:30.559]                 }
[15:32:30.559]             }
[15:32:30.559]         }
[15:32:30.559]     })
[15:32:30.559]     if (TRUE) {
[15:32:30.559]         base::sink(type = "output", split = FALSE)
[15:32:30.559]         if (TRUE) {
[15:32:30.559]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:30.559]         }
[15:32:30.559]         else {
[15:32:30.559]             ...future.result["stdout"] <- base::list(NULL)
[15:32:30.559]         }
[15:32:30.559]         base::close(...future.stdout)
[15:32:30.559]         ...future.stdout <- NULL
[15:32:30.559]     }
[15:32:30.559]     ...future.result$conditions <- ...future.conditions
[15:32:30.559]     ...future.result$finished <- base::Sys.time()
[15:32:30.559]     ...future.result
[15:32:30.559] }
[15:32:30.568] Exporting 5 global objects (1.22 KiB) to cluster node #1 ...
[15:32:30.568] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ...
[15:32:30.569] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ... DONE
[15:32:30.569] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:30.570] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:30.570] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ...
[15:32:30.571] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ... DONE
[15:32:30.571] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:30.571] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:30.571] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:30.572] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:30.572] Exporting 5 global objects (1.22 KiB) to cluster node #1 ... DONE
[15:32:30.573] MultisessionFuture started
[15:32:30.573] - Launch lazy future ... done
[15:32:30.573] run() for 'MultisessionFuture' ... done
[15:32:30.573] Created future:
[15:32:30.596] receiveMessageFromWorker() for ClusterFuture ...
[15:32:30.596] - Validating connection of MultisessionFuture
[15:32:30.597] - received message: FutureResult
[15:32:30.597] - Received FutureResult
[15:32:30.597] - Erased future from FutureRegistry
[15:32:30.597] result() for ClusterFuture ...
[15:32:30.598] - result already collected: FutureResult
[15:32:30.598] result() for ClusterFuture ... done
[15:32:30.598] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:30.573] MultisessionFuture:
[15:32:30.573] Label: 'future_sapply-1'
[15:32:30.573] Expression:
[15:32:30.573] {
[15:32:30.573]     do.call(function(...) {
[15:32:30.573]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:30.573]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:30.573]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:30.573]             on.exit(options(oopts), add = TRUE)
[15:32:30.573]         }
[15:32:30.573]         {
[15:32:30.573]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:30.573]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:30.573]                 ...future.FUN(...future.X_jj, ...)
[15:32:30.573]             })
[15:32:30.573]         }
[15:32:30.573]     }, args = future.call.arguments)
[15:32:30.573] }
[15:32:30.573] Lazy evaluation: FALSE
[15:32:30.573] Asynchronous evaluation: TRUE
[15:32:30.573] Local evaluation: TRUE
[15:32:30.573] Environment: R_GlobalEnv
[15:32:30.573] Capture standard output: TRUE
[15:32:30.573] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:30.573] Globals: 5 objects totaling 1.27 KiB (function '...future.FUN' of 1.22 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)
[15:32:30.573] Packages: <none>
[15:32:30.573] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:30.573] Resolved: TRUE
[15:32:30.573] Value: <not collected>
[15:32:30.573] Conditions captured: <none>
[15:32:30.573] Early signaling: FALSE
[15:32:30.573] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:30.573] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:30.599] Chunk #1 of 2 ... DONE
[15:32:30.599] Chunk #2 of 2 ...
[15:32:30.599]  - Finding globals in 'X' for chunk #2 ...
[15:32:30.599] getGlobalsAndPackages() ...
[15:32:30.599] Searching for globals...
[15:32:30.600] 
[15:32:30.600] Searching for globals ... DONE
[15:32:30.600] - globals: [0] <none>
[15:32:30.600] getGlobalsAndPackages() ... DONE
[15:32:30.600]    + additional globals found: [n=0] 
[15:32:30.601]    + additional namespaces needed: [n=0] 
[15:32:30.601]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:30.601]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:30.601]  - seeds: <none>
[15:32:30.601]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:30.601] getGlobalsAndPackages() ...
[15:32:30.602] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:30.602] Resolving globals: FALSE
[15:32:30.602] Tweak future expression to call with '...' arguments ...
[15:32:30.602] {
[15:32:30.602]     do.call(function(...) {
[15:32:30.602]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:30.602]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:30.602]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:30.602]             on.exit(options(oopts), add = TRUE)
[15:32:30.602]         }
[15:32:30.602]         {
[15:32:30.602]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:30.602]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:30.602]                 ...future.FUN(...future.X_jj, ...)
[15:32:30.602]             })
[15:32:30.602]         }
[15:32:30.602]     }, args = future.call.arguments)
[15:32:30.602] }
[15:32:30.603] Tweak future expression to call with '...' arguments ... DONE
[15:32:30.603] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:30.604] 
[15:32:30.604] getGlobalsAndPackages() ... DONE
[15:32:30.604] run() for 'Future' ...
[15:32:30.604] - state: 'created'
[15:32:30.605] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:30.620] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:30.620] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:30.620]   - Field: 'node'
[15:32:30.621]   - Field: 'label'
[15:32:30.621]   - Field: 'local'
[15:32:30.621]   - Field: 'owner'
[15:32:30.621]   - Field: 'envir'
[15:32:30.621]   - Field: 'workers'
[15:32:30.622]   - Field: 'packages'
[15:32:30.622]   - Field: 'gc'
[15:32:30.622]   - Field: 'conditions'
[15:32:30.622]   - Field: 'persistent'
[15:32:30.622]   - Field: 'expr'
[15:32:30.622]   - Field: 'uuid'
[15:32:30.623]   - Field: 'seed'
[15:32:30.623]   - Field: 'version'
[15:32:30.623]   - Field: 'result'
[15:32:30.623]   - Field: 'asynchronous'
[15:32:30.623]   - Field: 'calls'
[15:32:30.624]   - Field: 'globals'
[15:32:30.624]   - Field: 'stdout'
[15:32:30.624]   - Field: 'earlySignal'
[15:32:30.624]   - Field: 'lazy'
[15:32:30.624]   - Field: 'state'
[15:32:30.625] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:30.625] - Launch lazy future ...
[15:32:30.625] Packages needed by the future expression (n = 0): <none>
[15:32:30.625] Packages needed by future strategies (n = 0): <none>
[15:32:30.626] {
[15:32:30.626]     {
[15:32:30.626]         {
[15:32:30.626]             ...future.startTime <- base::Sys.time()
[15:32:30.626]             {
[15:32:30.626]                 {
[15:32:30.626]                   {
[15:32:30.626]                     {
[15:32:30.626]                       base::local({
[15:32:30.626]                         has_future <- base::requireNamespace("future", 
[15:32:30.626]                           quietly = TRUE)
[15:32:30.626]                         if (has_future) {
[15:32:30.626]                           ns <- base::getNamespace("future")
[15:32:30.626]                           version <- ns[[".package"]][["version"]]
[15:32:30.626]                           if (is.null(version)) 
[15:32:30.626]                             version <- utils::packageVersion("future")
[15:32:30.626]                         }
[15:32:30.626]                         else {
[15:32:30.626]                           version <- NULL
[15:32:30.626]                         }
[15:32:30.626]                         if (!has_future || version < "1.8.0") {
[15:32:30.626]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:30.626]                             "", base::R.version$version.string), 
[15:32:30.626]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:30.626]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:30.626]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:30.626]                               "release", "version")], collapse = " "), 
[15:32:30.626]                             hostname = base::Sys.info()[["nodename"]])
[15:32:30.626]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:30.626]                             info)
[15:32:30.626]                           info <- base::paste(info, collapse = "; ")
[15:32:30.626]                           if (!has_future) {
[15:32:30.626]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:30.626]                               info)
[15:32:30.626]                           }
[15:32:30.626]                           else {
[15:32:30.626]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:30.626]                               info, version)
[15:32:30.626]                           }
[15:32:30.626]                           base::stop(msg)
[15:32:30.626]                         }
[15:32:30.626]                       })
[15:32:30.626]                     }
[15:32:30.626]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:30.626]                     base::options(mc.cores = 1L)
[15:32:30.626]                   }
[15:32:30.626]                   ...future.strategy.old <- future::plan("list")
[15:32:30.626]                   options(future.plan = NULL)
[15:32:30.626]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:30.626]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:30.626]                 }
[15:32:30.626]                 ...future.workdir <- getwd()
[15:32:30.626]             }
[15:32:30.626]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:30.626]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:30.626]         }
[15:32:30.626]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:30.626]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:30.626]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:30.626]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:30.626]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:30.626]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:30.626]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:30.626]             base::names(...future.oldOptions))
[15:32:30.626]     }
[15:32:30.626]     if (FALSE) {
[15:32:30.626]     }
[15:32:30.626]     else {
[15:32:30.626]         if (TRUE) {
[15:32:30.626]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:30.626]                 open = "w")
[15:32:30.626]         }
[15:32:30.626]         else {
[15:32:30.626]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:30.626]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:30.626]         }
[15:32:30.626]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:30.626]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:30.626]             base::sink(type = "output", split = FALSE)
[15:32:30.626]             base::close(...future.stdout)
[15:32:30.626]         }, add = TRUE)
[15:32:30.626]     }
[15:32:30.626]     ...future.frame <- base::sys.nframe()
[15:32:30.626]     ...future.conditions <- base::list()
[15:32:30.626]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:30.626]     if (FALSE) {
[15:32:30.626]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:30.626]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:30.626]     }
[15:32:30.626]     ...future.result <- base::tryCatch({
[15:32:30.626]         base::withCallingHandlers({
[15:32:30.626]             ...future.value <- base::withVisible(base::local({
[15:32:30.626]                 ...future.makeSendCondition <- base::local({
[15:32:30.626]                   sendCondition <- NULL
[15:32:30.626]                   function(frame = 1L) {
[15:32:30.626]                     if (is.function(sendCondition)) 
[15:32:30.626]                       return(sendCondition)
[15:32:30.626]                     ns <- getNamespace("parallel")
[15:32:30.626]                     if (exists("sendData", mode = "function", 
[15:32:30.626]                       envir = ns)) {
[15:32:30.626]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:30.626]                         envir = ns)
[15:32:30.626]                       envir <- sys.frame(frame)
[15:32:30.626]                       master <- NULL
[15:32:30.626]                       while (!identical(envir, .GlobalEnv) && 
[15:32:30.626]                         !identical(envir, emptyenv())) {
[15:32:30.626]                         if (exists("master", mode = "list", envir = envir, 
[15:32:30.626]                           inherits = FALSE)) {
[15:32:30.626]                           master <- get("master", mode = "list", 
[15:32:30.626]                             envir = envir, inherits = FALSE)
[15:32:30.626]                           if (inherits(master, c("SOCKnode", 
[15:32:30.626]                             "SOCK0node"))) {
[15:32:30.626]                             sendCondition <<- function(cond) {
[15:32:30.626]                               data <- list(type = "VALUE", value = cond, 
[15:32:30.626]                                 success = TRUE)
[15:32:30.626]                               parallel_sendData(master, data)
[15:32:30.626]                             }
[15:32:30.626]                             return(sendCondition)
[15:32:30.626]                           }
[15:32:30.626]                         }
[15:32:30.626]                         frame <- frame + 1L
[15:32:30.626]                         envir <- sys.frame(frame)
[15:32:30.626]                       }
[15:32:30.626]                     }
[15:32:30.626]                     sendCondition <<- function(cond) NULL
[15:32:30.626]                   }
[15:32:30.626]                 })
[15:32:30.626]                 withCallingHandlers({
[15:32:30.626]                   {
[15:32:30.626]                     do.call(function(...) {
[15:32:30.626]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:30.626]                       if (!identical(...future.globals.maxSize.org, 
[15:32:30.626]                         ...future.globals.maxSize)) {
[15:32:30.626]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:30.626]                         on.exit(options(oopts), add = TRUE)
[15:32:30.626]                       }
[15:32:30.626]                       {
[15:32:30.626]                         lapply(seq_along(...future.elements_ii), 
[15:32:30.626]                           FUN = function(jj) {
[15:32:30.626]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:30.626]                             ...future.FUN(...future.X_jj, ...)
[15:32:30.626]                           })
[15:32:30.626]                       }
[15:32:30.626]                     }, args = future.call.arguments)
[15:32:30.626]                   }
[15:32:30.626]                 }, immediateCondition = function(cond) {
[15:32:30.626]                   sendCondition <- ...future.makeSendCondition()
[15:32:30.626]                   sendCondition(cond)
[15:32:30.626]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:30.626]                   {
[15:32:30.626]                     inherits <- base::inherits
[15:32:30.626]                     invokeRestart <- base::invokeRestart
[15:32:30.626]                     is.null <- base::is.null
[15:32:30.626]                     muffled <- FALSE
[15:32:30.626]                     if (inherits(cond, "message")) {
[15:32:30.626]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:30.626]                       if (muffled) 
[15:32:30.626]                         invokeRestart("muffleMessage")
[15:32:30.626]                     }
[15:32:30.626]                     else if (inherits(cond, "warning")) {
[15:32:30.626]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:30.626]                       if (muffled) 
[15:32:30.626]                         invokeRestart("muffleWarning")
[15:32:30.626]                     }
[15:32:30.626]                     else if (inherits(cond, "condition")) {
[15:32:30.626]                       if (!is.null(pattern)) {
[15:32:30.626]                         computeRestarts <- base::computeRestarts
[15:32:30.626]                         grepl <- base::grepl
[15:32:30.626]                         restarts <- computeRestarts(cond)
[15:32:30.626]                         for (restart in restarts) {
[15:32:30.626]                           name <- restart$name
[15:32:30.626]                           if (is.null(name)) 
[15:32:30.626]                             next
[15:32:30.626]                           if (!grepl(pattern, name)) 
[15:32:30.626]                             next
[15:32:30.626]                           invokeRestart(restart)
[15:32:30.626]                           muffled <- TRUE
[15:32:30.626]                           break
[15:32:30.626]                         }
[15:32:30.626]                       }
[15:32:30.626]                     }
[15:32:30.626]                     invisible(muffled)
[15:32:30.626]                   }
[15:32:30.626]                   muffleCondition(cond)
[15:32:30.626]                 })
[15:32:30.626]             }))
[15:32:30.626]             future::FutureResult(value = ...future.value$value, 
[15:32:30.626]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:30.626]                   ...future.rng), globalenv = if (FALSE) 
[15:32:30.626]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:30.626]                     ...future.globalenv.names))
[15:32:30.626]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:30.626]         }, condition = base::local({
[15:32:30.626]             c <- base::c
[15:32:30.626]             inherits <- base::inherits
[15:32:30.626]             invokeRestart <- base::invokeRestart
[15:32:30.626]             length <- base::length
[15:32:30.626]             list <- base::list
[15:32:30.626]             seq.int <- base::seq.int
[15:32:30.626]             signalCondition <- base::signalCondition
[15:32:30.626]             sys.calls <- base::sys.calls
[15:32:30.626]             `[[` <- base::`[[`
[15:32:30.626]             `+` <- base::`+`
[15:32:30.626]             `<<-` <- base::`<<-`
[15:32:30.626]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:30.626]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:30.626]                   3L)]
[15:32:30.626]             }
[15:32:30.626]             function(cond) {
[15:32:30.626]                 is_error <- inherits(cond, "error")
[15:32:30.626]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:30.626]                   NULL)
[15:32:30.626]                 if (is_error) {
[15:32:30.626]                   sessionInformation <- function() {
[15:32:30.626]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:30.626]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:30.626]                       search = base::search(), system = base::Sys.info())
[15:32:30.626]                   }
[15:32:30.626]                   ...future.conditions[[length(...future.conditions) + 
[15:32:30.626]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:30.626]                     cond$call), session = sessionInformation(), 
[15:32:30.626]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:30.626]                   signalCondition(cond)
[15:32:30.626]                 }
[15:32:30.626]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:30.626]                 "immediateCondition"))) {
[15:32:30.626]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:30.626]                   ...future.conditions[[length(...future.conditions) + 
[15:32:30.626]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:30.626]                   if (TRUE && !signal) {
[15:32:30.626]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:30.626]                     {
[15:32:30.626]                       inherits <- base::inherits
[15:32:30.626]                       invokeRestart <- base::invokeRestart
[15:32:30.626]                       is.null <- base::is.null
[15:32:30.626]                       muffled <- FALSE
[15:32:30.626]                       if (inherits(cond, "message")) {
[15:32:30.626]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:30.626]                         if (muffled) 
[15:32:30.626]                           invokeRestart("muffleMessage")
[15:32:30.626]                       }
[15:32:30.626]                       else if (inherits(cond, "warning")) {
[15:32:30.626]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:30.626]                         if (muffled) 
[15:32:30.626]                           invokeRestart("muffleWarning")
[15:32:30.626]                       }
[15:32:30.626]                       else if (inherits(cond, "condition")) {
[15:32:30.626]                         if (!is.null(pattern)) {
[15:32:30.626]                           computeRestarts <- base::computeRestarts
[15:32:30.626]                           grepl <- base::grepl
[15:32:30.626]                           restarts <- computeRestarts(cond)
[15:32:30.626]                           for (restart in restarts) {
[15:32:30.626]                             name <- restart$name
[15:32:30.626]                             if (is.null(name)) 
[15:32:30.626]                               next
[15:32:30.626]                             if (!grepl(pattern, name)) 
[15:32:30.626]                               next
[15:32:30.626]                             invokeRestart(restart)
[15:32:30.626]                             muffled <- TRUE
[15:32:30.626]                             break
[15:32:30.626]                           }
[15:32:30.626]                         }
[15:32:30.626]                       }
[15:32:30.626]                       invisible(muffled)
[15:32:30.626]                     }
[15:32:30.626]                     muffleCondition(cond, pattern = "^muffle")
[15:32:30.626]                   }
[15:32:30.626]                 }
[15:32:30.626]                 else {
[15:32:30.626]                   if (TRUE) {
[15:32:30.626]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:30.626]                     {
[15:32:30.626]                       inherits <- base::inherits
[15:32:30.626]                       invokeRestart <- base::invokeRestart
[15:32:30.626]                       is.null <- base::is.null
[15:32:30.626]                       muffled <- FALSE
[15:32:30.626]                       if (inherits(cond, "message")) {
[15:32:30.626]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:30.626]                         if (muffled) 
[15:32:30.626]                           invokeRestart("muffleMessage")
[15:32:30.626]                       }
[15:32:30.626]                       else if (inherits(cond, "warning")) {
[15:32:30.626]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:30.626]                         if (muffled) 
[15:32:30.626]                           invokeRestart("muffleWarning")
[15:32:30.626]                       }
[15:32:30.626]                       else if (inherits(cond, "condition")) {
[15:32:30.626]                         if (!is.null(pattern)) {
[15:32:30.626]                           computeRestarts <- base::computeRestarts
[15:32:30.626]                           grepl <- base::grepl
[15:32:30.626]                           restarts <- computeRestarts(cond)
[15:32:30.626]                           for (restart in restarts) {
[15:32:30.626]                             name <- restart$name
[15:32:30.626]                             if (is.null(name)) 
[15:32:30.626]                               next
[15:32:30.626]                             if (!grepl(pattern, name)) 
[15:32:30.626]                               next
[15:32:30.626]                             invokeRestart(restart)
[15:32:30.626]                             muffled <- TRUE
[15:32:30.626]                             break
[15:32:30.626]                           }
[15:32:30.626]                         }
[15:32:30.626]                       }
[15:32:30.626]                       invisible(muffled)
[15:32:30.626]                     }
[15:32:30.626]                     muffleCondition(cond, pattern = "^muffle")
[15:32:30.626]                   }
[15:32:30.626]                 }
[15:32:30.626]             }
[15:32:30.626]         }))
[15:32:30.626]     }, error = function(ex) {
[15:32:30.626]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:30.626]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:30.626]                 ...future.rng), started = ...future.startTime, 
[15:32:30.626]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:30.626]             version = "1.8"), class = "FutureResult")
[15:32:30.626]     }, finally = {
[15:32:30.626]         if (!identical(...future.workdir, getwd())) 
[15:32:30.626]             setwd(...future.workdir)
[15:32:30.626]         {
[15:32:30.626]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:30.626]                 ...future.oldOptions$nwarnings <- NULL
[15:32:30.626]             }
[15:32:30.626]             base::options(...future.oldOptions)
[15:32:30.626]             if (.Platform$OS.type == "windows") {
[15:32:30.626]                 old_names <- names(...future.oldEnvVars)
[15:32:30.626]                 envs <- base::Sys.getenv()
[15:32:30.626]                 names <- names(envs)
[15:32:30.626]                 common <- intersect(names, old_names)
[15:32:30.626]                 added <- setdiff(names, old_names)
[15:32:30.626]                 removed <- setdiff(old_names, names)
[15:32:30.626]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:30.626]                   envs[common]]
[15:32:30.626]                 NAMES <- toupper(changed)
[15:32:30.626]                 args <- list()
[15:32:30.626]                 for (kk in seq_along(NAMES)) {
[15:32:30.626]                   name <- changed[[kk]]
[15:32:30.626]                   NAME <- NAMES[[kk]]
[15:32:30.626]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:30.626]                     next
[15:32:30.626]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:30.626]                 }
[15:32:30.626]                 NAMES <- toupper(added)
[15:32:30.626]                 for (kk in seq_along(NAMES)) {
[15:32:30.626]                   name <- added[[kk]]
[15:32:30.626]                   NAME <- NAMES[[kk]]
[15:32:30.626]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:30.626]                     next
[15:32:30.626]                   args[[name]] <- ""
[15:32:30.626]                 }
[15:32:30.626]                 NAMES <- toupper(removed)
[15:32:30.626]                 for (kk in seq_along(NAMES)) {
[15:32:30.626]                   name <- removed[[kk]]
[15:32:30.626]                   NAME <- NAMES[[kk]]
[15:32:30.626]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:30.626]                     next
[15:32:30.626]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:30.626]                 }
[15:32:30.626]                 if (length(args) > 0) 
[15:32:30.626]                   base::do.call(base::Sys.setenv, args = args)
[15:32:30.626]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:30.626]             }
[15:32:30.626]             else {
[15:32:30.626]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:30.626]             }
[15:32:30.626]             {
[15:32:30.626]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:30.626]                   0L) {
[15:32:30.626]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:30.626]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:30.626]                   base::options(opts)
[15:32:30.626]                 }
[15:32:30.626]                 {
[15:32:30.626]                   {
[15:32:30.626]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:30.626]                     NULL
[15:32:30.626]                   }
[15:32:30.626]                   options(future.plan = NULL)
[15:32:30.626]                   if (is.na(NA_character_)) 
[15:32:30.626]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:30.626]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:30.626]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:30.626]                     .init = FALSE)
[15:32:30.626]                 }
[15:32:30.626]             }
[15:32:30.626]         }
[15:32:30.626]     })
[15:32:30.626]     if (TRUE) {
[15:32:30.626]         base::sink(type = "output", split = FALSE)
[15:32:30.626]         if (TRUE) {
[15:32:30.626]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:30.626]         }
[15:32:30.626]         else {
[15:32:30.626]             ...future.result["stdout"] <- base::list(NULL)
[15:32:30.626]         }
[15:32:30.626]         base::close(...future.stdout)
[15:32:30.626]         ...future.stdout <- NULL
[15:32:30.626]     }
[15:32:30.626]     ...future.result$conditions <- ...future.conditions
[15:32:30.626]     ...future.result$finished <- base::Sys.time()
[15:32:30.626]     ...future.result
[15:32:30.626] }
[15:32:30.632] Exporting 5 global objects (1.22 KiB) to cluster node #1 ...
[15:32:30.632] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ...
[15:32:30.632] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ... DONE
[15:32:30.633] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:30.633] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:30.633] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:30.634] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:30.634] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:30.635] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:30.635] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:30.636] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:30.636] Exporting 5 global objects (1.22 KiB) to cluster node #1 ... DONE
[15:32:30.638] MultisessionFuture started
[15:32:30.638] - Launch lazy future ... done
[15:32:30.638] run() for 'MultisessionFuture' ... done
[15:32:30.638] Created future:
[15:32:30.664] receiveMessageFromWorker() for ClusterFuture ...
[15:32:30.664] - Validating connection of MultisessionFuture
[15:32:30.665] - received message: FutureResult
[15:32:30.665] - Received FutureResult
[15:32:30.665] - Erased future from FutureRegistry
[15:32:30.665] result() for ClusterFuture ...
[15:32:30.666] - result already collected: FutureResult
[15:32:30.666] result() for ClusterFuture ... done
[15:32:30.666] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:30.639] MultisessionFuture:
[15:32:30.639] Label: 'future_sapply-2'
[15:32:30.639] Expression:
[15:32:30.639] {
[15:32:30.639]     do.call(function(...) {
[15:32:30.639]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:30.639]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:30.639]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:30.639]             on.exit(options(oopts), add = TRUE)
[15:32:30.639]         }
[15:32:30.639]         {
[15:32:30.639]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:30.639]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:30.639]                 ...future.FUN(...future.X_jj, ...)
[15:32:30.639]             })
[15:32:30.639]         }
[15:32:30.639]     }, args = future.call.arguments)
[15:32:30.639] }
[15:32:30.639] Lazy evaluation: FALSE
[15:32:30.639] Asynchronous evaluation: TRUE
[15:32:30.639] Local evaluation: TRUE
[15:32:30.639] Environment: R_GlobalEnv
[15:32:30.639] Capture standard output: TRUE
[15:32:30.639] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:30.639] Globals: 5 objects totaling 1.33 KiB (function '...future.FUN' of 1.22 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)
[15:32:30.639] Packages: <none>
[15:32:30.639] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:30.639] Resolved: TRUE
[15:32:30.639] Value: <not collected>
[15:32:30.639] Conditions captured: <none>
[15:32:30.639] Early signaling: FALSE
[15:32:30.639] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:30.639] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:30.667] Chunk #2 of 2 ... DONE
[15:32:30.667] Launching 2 futures (chunks) ... DONE
[15:32:30.667] Resolving 2 futures (chunks) ...
[15:32:30.667] resolve() on list ...
[15:32:30.667]  recursive: 0
[15:32:30.668]  length: 2
[15:32:30.668] 
[15:32:30.668] Future #1
[15:32:30.669] result() for ClusterFuture ...
[15:32:30.669] - result already collected: FutureResult
[15:32:30.669] result() for ClusterFuture ... done
[15:32:30.669] result() for ClusterFuture ...
[15:32:30.669] - result already collected: FutureResult
[15:32:30.670] result() for ClusterFuture ... done
[15:32:30.670] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:30.670] - nx: 2
[15:32:30.670] - relay: TRUE
[15:32:30.671] - stdout: TRUE
[15:32:30.671] - signal: TRUE
[15:32:30.671] - resignal: FALSE
[15:32:30.671] - force: TRUE
[15:32:30.671] - relayed: [n=2] FALSE, FALSE
[15:32:30.672] - queued futures: [n=2] FALSE, FALSE
[15:32:30.672]  - until=1
[15:32:30.672]  - relaying element #1
[15:32:30.672] result() for ClusterFuture ...
[15:32:30.672] - result already collected: FutureResult
[15:32:30.673] result() for ClusterFuture ... done
[15:32:30.673] result() for ClusterFuture ...
[15:32:30.673] - result already collected: FutureResult
[15:32:30.673] result() for ClusterFuture ... done
[15:32:30.674] result() for ClusterFuture ...
[15:32:30.674] - result already collected: FutureResult
[15:32:30.674] result() for ClusterFuture ... done
[15:32:30.674] result() for ClusterFuture ...
[15:32:30.674] - result already collected: FutureResult
[15:32:30.675] result() for ClusterFuture ... done
[15:32:30.675] - relayed: [n=2] TRUE, FALSE
[15:32:30.675] - queued futures: [n=2] TRUE, FALSE
[15:32:30.675] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:30.675]  length: 1 (resolved future 1)
[15:32:30.676] Future #2
[15:32:30.676] result() for ClusterFuture ...
[15:32:30.676] - result already collected: FutureResult
[15:32:30.676] result() for ClusterFuture ... done
[15:32:30.676] result() for ClusterFuture ...
[15:32:30.677] - result already collected: FutureResult
[15:32:30.677] result() for ClusterFuture ... done
[15:32:30.677] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:30.678] - nx: 2
[15:32:30.678] - relay: TRUE
[15:32:30.678] - stdout: TRUE
[15:32:30.678] - signal: TRUE
[15:32:30.678] - resignal: FALSE
[15:32:30.678] - force: TRUE
[15:32:30.679] - relayed: [n=2] TRUE, FALSE
[15:32:30.679] - queued futures: [n=2] TRUE, FALSE
[15:32:30.679]  - until=2
[15:32:30.679]  - relaying element #2
[15:32:30.679] result() for ClusterFuture ...
[15:32:30.680] - result already collected: FutureResult
[15:32:30.680] result() for ClusterFuture ... done
[15:32:30.680] result() for ClusterFuture ...
[15:32:30.680] - result already collected: FutureResult
[15:32:30.680] result() for ClusterFuture ... done
[15:32:30.681] result() for ClusterFuture ...
[15:32:30.681] - result already collected: FutureResult
[15:32:30.681] result() for ClusterFuture ... done
[15:32:30.682] result() for ClusterFuture ...
[15:32:30.682] - result already collected: FutureResult
[15:32:30.682] result() for ClusterFuture ... done
[15:32:30.682] - relayed: [n=2] TRUE, TRUE
[15:32:30.682] - queued futures: [n=2] TRUE, TRUE
[15:32:30.683] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:30.683]  length: 0 (resolved future 2)
[15:32:30.683] Relaying remaining futures
[15:32:30.683] signalConditionsASAP(NULL, pos=0) ...
[15:32:30.683] - nx: 2
[15:32:30.684] - relay: TRUE
[15:32:30.684] - stdout: TRUE
[15:32:30.684] - signal: TRUE
[15:32:30.684] - resignal: FALSE
[15:32:30.684] - force: TRUE
[15:32:30.685] - relayed: [n=2] TRUE, TRUE
[15:32:30.685] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:30.685] - relayed: [n=2] TRUE, TRUE
[15:32:30.685] - queued futures: [n=2] TRUE, TRUE
[15:32:30.686] signalConditionsASAP(NULL, pos=0) ... done
[15:32:30.686] resolve() on list ... DONE
[15:32:30.686] result() for ClusterFuture ...
[15:32:30.686] - result already collected: FutureResult
[15:32:30.686] result() for ClusterFuture ... done
[15:32:30.687] result() for ClusterFuture ...
[15:32:30.687] - result already collected: FutureResult
[15:32:30.687] result() for ClusterFuture ... done
[15:32:30.688] result() for ClusterFuture ...
[15:32:30.688] - result already collected: FutureResult
[15:32:30.688] result() for ClusterFuture ... done
[15:32:30.689] result() for ClusterFuture ...
[15:32:30.689] - result already collected: FutureResult
[15:32:30.689] result() for ClusterFuture ... done
[15:32:30.690]  - Number of value chunks collected: 2
[15:32:30.690] Resolving 2 futures (chunks) ... DONE
[15:32:30.690] Reducing values from 2 chunks ...
[15:32:30.691]  - Number of values collected after concatenation: 3
[15:32:30.691]  - Number of values expected: 3
[15:32:30.691] Reducing values from 2 chunks ... DONE
[15:32:30.692] future_lapply() ... DONE
List of 2
 $ y0: Named num [1:3] 1 2 3
  ..- attr(*, "names")= chr [1:3] "a" "b" "c"
 $ y1: Named num [1:3] 1 2 3
  ..- attr(*, "names")= chr [1:3] "a" "b" "c"
[15:32:30.696] future_lapply() ...
[15:32:30.702] Number of chunks: 2
[15:32:30.703] getGlobalsAndPackagesXApply() ...
[15:32:30.703]  - future.globals: TRUE
[15:32:30.703] getGlobalsAndPackages() ...
[15:32:30.703] Searching for globals...
[15:32:30.707] - globals found: [5] 'FUN', '*', ':', 'outer', 'rep'
[15:32:30.707] Searching for globals ... DONE
[15:32:30.707] Resolving globals: FALSE
[15:32:30.708] The total size of the 1 globals is 4.62 KiB (4728 bytes)
[15:32:30.709] The total size of the 1 globals exported for future expression ('FUN()') is 4.62 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.62 KiB of class 'function')
[15:32:30.709] - globals: [1] 'FUN'
[15:32:30.710] 
[15:32:30.710] getGlobalsAndPackages() ... DONE
[15:32:30.710]  - globals found/used: [n=1] 'FUN'
[15:32:30.710]  - needed namespaces: [n=0] 
[15:32:30.711] Finding globals ... DONE
[15:32:30.711]  - use_args: TRUE
[15:32:30.711]  - Getting '...' globals ...
[15:32:30.712] resolve() on list ...
[15:32:30.712]  recursive: 0
[15:32:30.713]  length: 1
[15:32:30.713]  elements: '...'
[15:32:30.713]  length: 0 (resolved future 1)
[15:32:30.713] resolve() on list ... DONE
[15:32:30.714]    - '...' content: [n=0] 
[15:32:30.714] List of 1
[15:32:30.714]  $ ...: list()
[15:32:30.714]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:30.714]  - attr(*, "where")=List of 1
[15:32:30.714]   ..$ ...:<environment: 0x00000276e5597008> 
[15:32:30.714]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:30.714]  - attr(*, "resolved")= logi TRUE
[15:32:30.714]  - attr(*, "total_size")= num NA
[15:32:30.719]  - Getting '...' globals ... DONE
[15:32:30.720] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:30.720] List of 2
[15:32:30.720]  $ ...future.FUN:function (x, y = 2 * 1:5)  
[15:32:30.720]  $ ...          : list()
[15:32:30.720]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:30.720]  - attr(*, "where")=List of 2
[15:32:30.720]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:30.720]   ..$ ...          :<environment: 0x00000276e5597008> 
[15:32:30.720]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:30.720]  - attr(*, "resolved")= logi FALSE
[15:32:30.720]  - attr(*, "total_size")= num 4728
[15:32:30.726] Packages to be attached in all futures: [n=0] 
[15:32:30.726] getGlobalsAndPackagesXApply() ... DONE
[15:32:30.727] Number of futures (= number of chunks): 2
[15:32:30.727] Launching 2 futures (chunks) ...
[15:32:30.728] Chunk #1 of 2 ...
[15:32:30.728]  - Finding globals in 'X' for chunk #1 ...
[15:32:30.728] getGlobalsAndPackages() ...
[15:32:30.729] Searching for globals...
[15:32:30.729] 
[15:32:30.730] Searching for globals ... DONE
[15:32:30.730] - globals: [0] <none>
[15:32:30.730] getGlobalsAndPackages() ... DONE
[15:32:30.731]    + additional globals found: [n=0] 
[15:32:30.731]    + additional namespaces needed: [n=0] 
[15:32:30.731]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:30.732]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:30.732]  - seeds: <none>
[15:32:30.732]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:30.733] getGlobalsAndPackages() ...
[15:32:30.733] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:30.733] Resolving globals: FALSE
[15:32:30.733] Tweak future expression to call with '...' arguments ...
[15:32:30.734] {
[15:32:30.734]     do.call(function(...) {
[15:32:30.734]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:30.734]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:30.734]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:30.734]             on.exit(options(oopts), add = TRUE)
[15:32:30.734]         }
[15:32:30.734]         {
[15:32:30.734]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:30.734]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:30.734]                 ...future.FUN(...future.X_jj, ...)
[15:32:30.734]             })
[15:32:30.734]         }
[15:32:30.734]     }, args = future.call.arguments)
[15:32:30.734] }
[15:32:30.735] Tweak future expression to call with '...' arguments ... DONE
[15:32:30.736] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:30.736] 
[15:32:30.736] getGlobalsAndPackages() ... DONE
[15:32:30.737] run() for 'Future' ...
[15:32:30.737] - state: 'created'
[15:32:30.738] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:30.759] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:30.760] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:30.760]   - Field: 'node'
[15:32:30.760]   - Field: 'label'
[15:32:30.761]   - Field: 'local'
[15:32:30.761]   - Field: 'owner'
[15:32:30.761]   - Field: 'envir'
[15:32:30.762]   - Field: 'workers'
[15:32:30.762]   - Field: 'packages'
[15:32:30.762]   - Field: 'gc'
[15:32:30.763]   - Field: 'conditions'
[15:32:30.763]   - Field: 'persistent'
[15:32:30.763]   - Field: 'expr'
[15:32:30.763]   - Field: 'uuid'
[15:32:30.764]   - Field: 'seed'
[15:32:30.764]   - Field: 'version'
[15:32:30.764]   - Field: 'result'
[15:32:30.765]   - Field: 'asynchronous'
[15:32:30.765]   - Field: 'calls'
[15:32:30.765]   - Field: 'globals'
[15:32:30.766]   - Field: 'stdout'
[15:32:30.766]   - Field: 'earlySignal'
[15:32:30.766]   - Field: 'lazy'
[15:32:30.766]   - Field: 'state'
[15:32:30.767] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:30.767] - Launch lazy future ...
[15:32:30.768] Packages needed by the future expression (n = 0): <none>
[15:32:30.768] Packages needed by future strategies (n = 0): <none>
[15:32:30.769] {
[15:32:30.769]     {
[15:32:30.769]         {
[15:32:30.769]             ...future.startTime <- base::Sys.time()
[15:32:30.769]             {
[15:32:30.769]                 {
[15:32:30.769]                   {
[15:32:30.769]                     {
[15:32:30.769]                       base::local({
[15:32:30.769]                         has_future <- base::requireNamespace("future", 
[15:32:30.769]                           quietly = TRUE)
[15:32:30.769]                         if (has_future) {
[15:32:30.769]                           ns <- base::getNamespace("future")
[15:32:30.769]                           version <- ns[[".package"]][["version"]]
[15:32:30.769]                           if (is.null(version)) 
[15:32:30.769]                             version <- utils::packageVersion("future")
[15:32:30.769]                         }
[15:32:30.769]                         else {
[15:32:30.769]                           version <- NULL
[15:32:30.769]                         }
[15:32:30.769]                         if (!has_future || version < "1.8.0") {
[15:32:30.769]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:30.769]                             "", base::R.version$version.string), 
[15:32:30.769]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:30.769]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:30.769]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:30.769]                               "release", "version")], collapse = " "), 
[15:32:30.769]                             hostname = base::Sys.info()[["nodename"]])
[15:32:30.769]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:30.769]                             info)
[15:32:30.769]                           info <- base::paste(info, collapse = "; ")
[15:32:30.769]                           if (!has_future) {
[15:32:30.769]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:30.769]                               info)
[15:32:30.769]                           }
[15:32:30.769]                           else {
[15:32:30.769]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:30.769]                               info, version)
[15:32:30.769]                           }
[15:32:30.769]                           base::stop(msg)
[15:32:30.769]                         }
[15:32:30.769]                       })
[15:32:30.769]                     }
[15:32:30.769]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:30.769]                     base::options(mc.cores = 1L)
[15:32:30.769]                   }
[15:32:30.769]                   ...future.strategy.old <- future::plan("list")
[15:32:30.769]                   options(future.plan = NULL)
[15:32:30.769]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:30.769]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:30.769]                 }
[15:32:30.769]                 ...future.workdir <- getwd()
[15:32:30.769]             }
[15:32:30.769]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:30.769]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:30.769]         }
[15:32:30.769]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:30.769]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:30.769]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:30.769]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:30.769]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:30.769]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:30.769]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:30.769]             base::names(...future.oldOptions))
[15:32:30.769]     }
[15:32:30.769]     if (FALSE) {
[15:32:30.769]     }
[15:32:30.769]     else {
[15:32:30.769]         if (TRUE) {
[15:32:30.769]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:30.769]                 open = "w")
[15:32:30.769]         }
[15:32:30.769]         else {
[15:32:30.769]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:30.769]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:30.769]         }
[15:32:30.769]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:30.769]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:30.769]             base::sink(type = "output", split = FALSE)
[15:32:30.769]             base::close(...future.stdout)
[15:32:30.769]         }, add = TRUE)
[15:32:30.769]     }
[15:32:30.769]     ...future.frame <- base::sys.nframe()
[15:32:30.769]     ...future.conditions <- base::list()
[15:32:30.769]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:30.769]     if (FALSE) {
[15:32:30.769]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:30.769]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:30.769]     }
[15:32:30.769]     ...future.result <- base::tryCatch({
[15:32:30.769]         base::withCallingHandlers({
[15:32:30.769]             ...future.value <- base::withVisible(base::local({
[15:32:30.769]                 ...future.makeSendCondition <- base::local({
[15:32:30.769]                   sendCondition <- NULL
[15:32:30.769]                   function(frame = 1L) {
[15:32:30.769]                     if (is.function(sendCondition)) 
[15:32:30.769]                       return(sendCondition)
[15:32:30.769]                     ns <- getNamespace("parallel")
[15:32:30.769]                     if (exists("sendData", mode = "function", 
[15:32:30.769]                       envir = ns)) {
[15:32:30.769]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:30.769]                         envir = ns)
[15:32:30.769]                       envir <- sys.frame(frame)
[15:32:30.769]                       master <- NULL
[15:32:30.769]                       while (!identical(envir, .GlobalEnv) && 
[15:32:30.769]                         !identical(envir, emptyenv())) {
[15:32:30.769]                         if (exists("master", mode = "list", envir = envir, 
[15:32:30.769]                           inherits = FALSE)) {
[15:32:30.769]                           master <- get("master", mode = "list", 
[15:32:30.769]                             envir = envir, inherits = FALSE)
[15:32:30.769]                           if (inherits(master, c("SOCKnode", 
[15:32:30.769]                             "SOCK0node"))) {
[15:32:30.769]                             sendCondition <<- function(cond) {
[15:32:30.769]                               data <- list(type = "VALUE", value = cond, 
[15:32:30.769]                                 success = TRUE)
[15:32:30.769]                               parallel_sendData(master, data)
[15:32:30.769]                             }
[15:32:30.769]                             return(sendCondition)
[15:32:30.769]                           }
[15:32:30.769]                         }
[15:32:30.769]                         frame <- frame + 1L
[15:32:30.769]                         envir <- sys.frame(frame)
[15:32:30.769]                       }
[15:32:30.769]                     }
[15:32:30.769]                     sendCondition <<- function(cond) NULL
[15:32:30.769]                   }
[15:32:30.769]                 })
[15:32:30.769]                 withCallingHandlers({
[15:32:30.769]                   {
[15:32:30.769]                     do.call(function(...) {
[15:32:30.769]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:30.769]                       if (!identical(...future.globals.maxSize.org, 
[15:32:30.769]                         ...future.globals.maxSize)) {
[15:32:30.769]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:30.769]                         on.exit(options(oopts), add = TRUE)
[15:32:30.769]                       }
[15:32:30.769]                       {
[15:32:30.769]                         lapply(seq_along(...future.elements_ii), 
[15:32:30.769]                           FUN = function(jj) {
[15:32:30.769]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:30.769]                             ...future.FUN(...future.X_jj, ...)
[15:32:30.769]                           })
[15:32:30.769]                       }
[15:32:30.769]                     }, args = future.call.arguments)
[15:32:30.769]                   }
[15:32:30.769]                 }, immediateCondition = function(cond) {
[15:32:30.769]                   sendCondition <- ...future.makeSendCondition()
[15:32:30.769]                   sendCondition(cond)
[15:32:30.769]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:30.769]                   {
[15:32:30.769]                     inherits <- base::inherits
[15:32:30.769]                     invokeRestart <- base::invokeRestart
[15:32:30.769]                     is.null <- base::is.null
[15:32:30.769]                     muffled <- FALSE
[15:32:30.769]                     if (inherits(cond, "message")) {
[15:32:30.769]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:30.769]                       if (muffled) 
[15:32:30.769]                         invokeRestart("muffleMessage")
[15:32:30.769]                     }
[15:32:30.769]                     else if (inherits(cond, "warning")) {
[15:32:30.769]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:30.769]                       if (muffled) 
[15:32:30.769]                         invokeRestart("muffleWarning")
[15:32:30.769]                     }
[15:32:30.769]                     else if (inherits(cond, "condition")) {
[15:32:30.769]                       if (!is.null(pattern)) {
[15:32:30.769]                         computeRestarts <- base::computeRestarts
[15:32:30.769]                         grepl <- base::grepl
[15:32:30.769]                         restarts <- computeRestarts(cond)
[15:32:30.769]                         for (restart in restarts) {
[15:32:30.769]                           name <- restart$name
[15:32:30.769]                           if (is.null(name)) 
[15:32:30.769]                             next
[15:32:30.769]                           if (!grepl(pattern, name)) 
[15:32:30.769]                             next
[15:32:30.769]                           invokeRestart(restart)
[15:32:30.769]                           muffled <- TRUE
[15:32:30.769]                           break
[15:32:30.769]                         }
[15:32:30.769]                       }
[15:32:30.769]                     }
[15:32:30.769]                     invisible(muffled)
[15:32:30.769]                   }
[15:32:30.769]                   muffleCondition(cond)
[15:32:30.769]                 })
[15:32:30.769]             }))
[15:32:30.769]             future::FutureResult(value = ...future.value$value, 
[15:32:30.769]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:30.769]                   ...future.rng), globalenv = if (FALSE) 
[15:32:30.769]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:30.769]                     ...future.globalenv.names))
[15:32:30.769]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:30.769]         }, condition = base::local({
[15:32:30.769]             c <- base::c
[15:32:30.769]             inherits <- base::inherits
[15:32:30.769]             invokeRestart <- base::invokeRestart
[15:32:30.769]             length <- base::length
[15:32:30.769]             list <- base::list
[15:32:30.769]             seq.int <- base::seq.int
[15:32:30.769]             signalCondition <- base::signalCondition
[15:32:30.769]             sys.calls <- base::sys.calls
[15:32:30.769]             `[[` <- base::`[[`
[15:32:30.769]             `+` <- base::`+`
[15:32:30.769]             `<<-` <- base::`<<-`
[15:32:30.769]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:30.769]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:30.769]                   3L)]
[15:32:30.769]             }
[15:32:30.769]             function(cond) {
[15:32:30.769]                 is_error <- inherits(cond, "error")
[15:32:30.769]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:30.769]                   NULL)
[15:32:30.769]                 if (is_error) {
[15:32:30.769]                   sessionInformation <- function() {
[15:32:30.769]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:30.769]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:30.769]                       search = base::search(), system = base::Sys.info())
[15:32:30.769]                   }
[15:32:30.769]                   ...future.conditions[[length(...future.conditions) + 
[15:32:30.769]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:30.769]                     cond$call), session = sessionInformation(), 
[15:32:30.769]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:30.769]                   signalCondition(cond)
[15:32:30.769]                 }
[15:32:30.769]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:30.769]                 "immediateCondition"))) {
[15:32:30.769]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:30.769]                   ...future.conditions[[length(...future.conditions) + 
[15:32:30.769]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:30.769]                   if (TRUE && !signal) {
[15:32:30.769]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:30.769]                     {
[15:32:30.769]                       inherits <- base::inherits
[15:32:30.769]                       invokeRestart <- base::invokeRestart
[15:32:30.769]                       is.null <- base::is.null
[15:32:30.769]                       muffled <- FALSE
[15:32:30.769]                       if (inherits(cond, "message")) {
[15:32:30.769]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:30.769]                         if (muffled) 
[15:32:30.769]                           invokeRestart("muffleMessage")
[15:32:30.769]                       }
[15:32:30.769]                       else if (inherits(cond, "warning")) {
[15:32:30.769]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:30.769]                         if (muffled) 
[15:32:30.769]                           invokeRestart("muffleWarning")
[15:32:30.769]                       }
[15:32:30.769]                       else if (inherits(cond, "condition")) {
[15:32:30.769]                         if (!is.null(pattern)) {
[15:32:30.769]                           computeRestarts <- base::computeRestarts
[15:32:30.769]                           grepl <- base::grepl
[15:32:30.769]                           restarts <- computeRestarts(cond)
[15:32:30.769]                           for (restart in restarts) {
[15:32:30.769]                             name <- restart$name
[15:32:30.769]                             if (is.null(name)) 
[15:32:30.769]                               next
[15:32:30.769]                             if (!grepl(pattern, name)) 
[15:32:30.769]                               next
[15:32:30.769]                             invokeRestart(restart)
[15:32:30.769]                             muffled <- TRUE
[15:32:30.769]                             break
[15:32:30.769]                           }
[15:32:30.769]                         }
[15:32:30.769]                       }
[15:32:30.769]                       invisible(muffled)
[15:32:30.769]                     }
[15:32:30.769]                     muffleCondition(cond, pattern = "^muffle")
[15:32:30.769]                   }
[15:32:30.769]                 }
[15:32:30.769]                 else {
[15:32:30.769]                   if (TRUE) {
[15:32:30.769]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:30.769]                     {
[15:32:30.769]                       inherits <- base::inherits
[15:32:30.769]                       invokeRestart <- base::invokeRestart
[15:32:30.769]                       is.null <- base::is.null
[15:32:30.769]                       muffled <- FALSE
[15:32:30.769]                       if (inherits(cond, "message")) {
[15:32:30.769]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:30.769]                         if (muffled) 
[15:32:30.769]                           invokeRestart("muffleMessage")
[15:32:30.769]                       }
[15:32:30.769]                       else if (inherits(cond, "warning")) {
[15:32:30.769]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:30.769]                         if (muffled) 
[15:32:30.769]                           invokeRestart("muffleWarning")
[15:32:30.769]                       }
[15:32:30.769]                       else if (inherits(cond, "condition")) {
[15:32:30.769]                         if (!is.null(pattern)) {
[15:32:30.769]                           computeRestarts <- base::computeRestarts
[15:32:30.769]                           grepl <- base::grepl
[15:32:30.769]                           restarts <- computeRestarts(cond)
[15:32:30.769]                           for (restart in restarts) {
[15:32:30.769]                             name <- restart$name
[15:32:30.769]                             if (is.null(name)) 
[15:32:30.769]                               next
[15:32:30.769]                             if (!grepl(pattern, name)) 
[15:32:30.769]                               next
[15:32:30.769]                             invokeRestart(restart)
[15:32:30.769]                             muffled <- TRUE
[15:32:30.769]                             break
[15:32:30.769]                           }
[15:32:30.769]                         }
[15:32:30.769]                       }
[15:32:30.769]                       invisible(muffled)
[15:32:30.769]                     }
[15:32:30.769]                     muffleCondition(cond, pattern = "^muffle")
[15:32:30.769]                   }
[15:32:30.769]                 }
[15:32:30.769]             }
[15:32:30.769]         }))
[15:32:30.769]     }, error = function(ex) {
[15:32:30.769]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:30.769]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:30.769]                 ...future.rng), started = ...future.startTime, 
[15:32:30.769]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:30.769]             version = "1.8"), class = "FutureResult")
[15:32:30.769]     }, finally = {
[15:32:30.769]         if (!identical(...future.workdir, getwd())) 
[15:32:30.769]             setwd(...future.workdir)
[15:32:30.769]         {
[15:32:30.769]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:30.769]                 ...future.oldOptions$nwarnings <- NULL
[15:32:30.769]             }
[15:32:30.769]             base::options(...future.oldOptions)
[15:32:30.769]             if (.Platform$OS.type == "windows") {
[15:32:30.769]                 old_names <- names(...future.oldEnvVars)
[15:32:30.769]                 envs <- base::Sys.getenv()
[15:32:30.769]                 names <- names(envs)
[15:32:30.769]                 common <- intersect(names, old_names)
[15:32:30.769]                 added <- setdiff(names, old_names)
[15:32:30.769]                 removed <- setdiff(old_names, names)
[15:32:30.769]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:30.769]                   envs[common]]
[15:32:30.769]                 NAMES <- toupper(changed)
[15:32:30.769]                 args <- list()
[15:32:30.769]                 for (kk in seq_along(NAMES)) {
[15:32:30.769]                   name <- changed[[kk]]
[15:32:30.769]                   NAME <- NAMES[[kk]]
[15:32:30.769]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:30.769]                     next
[15:32:30.769]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:30.769]                 }
[15:32:30.769]                 NAMES <- toupper(added)
[15:32:30.769]                 for (kk in seq_along(NAMES)) {
[15:32:30.769]                   name <- added[[kk]]
[15:32:30.769]                   NAME <- NAMES[[kk]]
[15:32:30.769]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:30.769]                     next
[15:32:30.769]                   args[[name]] <- ""
[15:32:30.769]                 }
[15:32:30.769]                 NAMES <- toupper(removed)
[15:32:30.769]                 for (kk in seq_along(NAMES)) {
[15:32:30.769]                   name <- removed[[kk]]
[15:32:30.769]                   NAME <- NAMES[[kk]]
[15:32:30.769]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:30.769]                     next
[15:32:30.769]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:30.769]                 }
[15:32:30.769]                 if (length(args) > 0) 
[15:32:30.769]                   base::do.call(base::Sys.setenv, args = args)
[15:32:30.769]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:30.769]             }
[15:32:30.769]             else {
[15:32:30.769]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:30.769]             }
[15:32:30.769]             {
[15:32:30.769]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:30.769]                   0L) {
[15:32:30.769]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:30.769]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:30.769]                   base::options(opts)
[15:32:30.769]                 }
[15:32:30.769]                 {
[15:32:30.769]                   {
[15:32:30.769]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:30.769]                     NULL
[15:32:30.769]                   }
[15:32:30.769]                   options(future.plan = NULL)
[15:32:30.769]                   if (is.na(NA_character_)) 
[15:32:30.769]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:30.769]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:30.769]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:30.769]                     .init = FALSE)
[15:32:30.769]                 }
[15:32:30.769]             }
[15:32:30.769]         }
[15:32:30.769]     })
[15:32:30.769]     if (TRUE) {
[15:32:30.769]         base::sink(type = "output", split = FALSE)
[15:32:30.769]         if (TRUE) {
[15:32:30.769]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:30.769]         }
[15:32:30.769]         else {
[15:32:30.769]             ...future.result["stdout"] <- base::list(NULL)
[15:32:30.769]         }
[15:32:30.769]         base::close(...future.stdout)
[15:32:30.769]         ...future.stdout <- NULL
[15:32:30.769]     }
[15:32:30.769]     ...future.result$conditions <- ...future.conditions
[15:32:30.769]     ...future.result$finished <- base::Sys.time()
[15:32:30.769]     ...future.result
[15:32:30.769] }
[15:32:30.779] Exporting 5 global objects (4.62 KiB) to cluster node #1 ...
[15:32:30.779] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ...
[15:32:30.780] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ... DONE
[15:32:30.780] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:30.781] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:30.781] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ...
[15:32:30.782] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ... DONE
[15:32:30.782] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:30.783] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:30.783] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:30.784] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:30.784] Exporting 5 global objects (4.62 KiB) to cluster node #1 ... DONE
[15:32:30.785] MultisessionFuture started
[15:32:30.786] - Launch lazy future ... done
[15:32:30.786] run() for 'MultisessionFuture' ... done
[15:32:30.786] Created future:
[15:32:30.810] receiveMessageFromWorker() for ClusterFuture ...
[15:32:30.810] - Validating connection of MultisessionFuture
[15:32:30.815] - received message: FutureResult
[15:32:30.815] - Received FutureResult
[15:32:30.816] - Erased future from FutureRegistry
[15:32:30.816] result() for ClusterFuture ...
[15:32:30.816] - result already collected: FutureResult
[15:32:30.817] result() for ClusterFuture ... done
[15:32:30.817] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:30.786] MultisessionFuture:
[15:32:30.786] Label: 'future_sapply-1'
[15:32:30.786] Expression:
[15:32:30.786] {
[15:32:30.786]     do.call(function(...) {
[15:32:30.786]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:30.786]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:30.786]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:30.786]             on.exit(options(oopts), add = TRUE)
[15:32:30.786]         }
[15:32:30.786]         {
[15:32:30.786]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:30.786]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:30.786]                 ...future.FUN(...future.X_jj, ...)
[15:32:30.786]             })
[15:32:30.786]         }
[15:32:30.786]     }, args = future.call.arguments)
[15:32:30.786] }
[15:32:30.786] Lazy evaluation: FALSE
[15:32:30.786] Asynchronous evaluation: TRUE
[15:32:30.786] Local evaluation: TRUE
[15:32:30.786] Environment: R_GlobalEnv
[15:32:30.786] Capture standard output: TRUE
[15:32:30.786] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:30.786] Globals: 5 objects totaling 4.67 KiB (function '...future.FUN' of 4.62 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)
[15:32:30.786] Packages: <none>
[15:32:30.786] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:30.786] Resolved: TRUE
[15:32:30.786] Value: <not collected>
[15:32:30.786] Conditions captured: <none>
[15:32:30.786] Early signaling: FALSE
[15:32:30.786] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:30.786] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:30.818] Chunk #1 of 2 ... DONE
[15:32:30.818] Chunk #2 of 2 ...
[15:32:30.818]  - Finding globals in 'X' for chunk #2 ...
[15:32:30.818] getGlobalsAndPackages() ...
[15:32:30.819] Searching for globals...
[15:32:30.819] 
[15:32:30.820] Searching for globals ... DONE
[15:32:30.820] - globals: [0] <none>
[15:32:30.820] getGlobalsAndPackages() ... DONE
[15:32:30.820]    + additional globals found: [n=0] 
[15:32:30.821]    + additional namespaces needed: [n=0] 
[15:32:30.821]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:30.821]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:30.821]  - seeds: <none>
[15:32:30.822]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:30.822] getGlobalsAndPackages() ...
[15:32:30.822] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:30.823] Resolving globals: FALSE
[15:32:30.823] Tweak future expression to call with '...' arguments ...
[15:32:30.823] {
[15:32:30.823]     do.call(function(...) {
[15:32:30.823]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:30.823]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:30.823]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:30.823]             on.exit(options(oopts), add = TRUE)
[15:32:30.823]         }
[15:32:30.823]         {
[15:32:30.823]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:30.823]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:30.823]                 ...future.FUN(...future.X_jj, ...)
[15:32:30.823]             })
[15:32:30.823]         }
[15:32:30.823]     }, args = future.call.arguments)
[15:32:30.823] }
[15:32:30.824] Tweak future expression to call with '...' arguments ... DONE
[15:32:30.825] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:30.825] 
[15:32:30.825] getGlobalsAndPackages() ... DONE
[15:32:30.826] run() for 'Future' ...
[15:32:30.826] - state: 'created'
[15:32:30.827] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:30.846] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:30.846] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:30.847]   - Field: 'node'
[15:32:30.847]   - Field: 'label'
[15:32:30.847]   - Field: 'local'
[15:32:30.848]   - Field: 'owner'
[15:32:30.848]   - Field: 'envir'
[15:32:30.848]   - Field: 'workers'
[15:32:30.848]   - Field: 'packages'
[15:32:30.849]   - Field: 'gc'
[15:32:30.849]   - Field: 'conditions'
[15:32:30.849]   - Field: 'persistent'
[15:32:30.850]   - Field: 'expr'
[15:32:30.850]   - Field: 'uuid'
[15:32:30.850]   - Field: 'seed'
[15:32:30.850]   - Field: 'version'
[15:32:30.851]   - Field: 'result'
[15:32:30.851]   - Field: 'asynchronous'
[15:32:30.851]   - Field: 'calls'
[15:32:30.852]   - Field: 'globals'
[15:32:30.852]   - Field: 'stdout'
[15:32:30.852]   - Field: 'earlySignal'
[15:32:30.852]   - Field: 'lazy'
[15:32:30.853]   - Field: 'state'
[15:32:30.853] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:30.853] - Launch lazy future ...
[15:32:30.854] Packages needed by the future expression (n = 0): <none>
[15:32:30.854] Packages needed by future strategies (n = 0): <none>
[15:32:30.855] {
[15:32:30.855]     {
[15:32:30.855]         {
[15:32:30.855]             ...future.startTime <- base::Sys.time()
[15:32:30.855]             {
[15:32:30.855]                 {
[15:32:30.855]                   {
[15:32:30.855]                     {
[15:32:30.855]                       base::local({
[15:32:30.855]                         has_future <- base::requireNamespace("future", 
[15:32:30.855]                           quietly = TRUE)
[15:32:30.855]                         if (has_future) {
[15:32:30.855]                           ns <- base::getNamespace("future")
[15:32:30.855]                           version <- ns[[".package"]][["version"]]
[15:32:30.855]                           if (is.null(version)) 
[15:32:30.855]                             version <- utils::packageVersion("future")
[15:32:30.855]                         }
[15:32:30.855]                         else {
[15:32:30.855]                           version <- NULL
[15:32:30.855]                         }
[15:32:30.855]                         if (!has_future || version < "1.8.0") {
[15:32:30.855]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:30.855]                             "", base::R.version$version.string), 
[15:32:30.855]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:30.855]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:30.855]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:30.855]                               "release", "version")], collapse = " "), 
[15:32:30.855]                             hostname = base::Sys.info()[["nodename"]])
[15:32:30.855]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:30.855]                             info)
[15:32:30.855]                           info <- base::paste(info, collapse = "; ")
[15:32:30.855]                           if (!has_future) {
[15:32:30.855]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:30.855]                               info)
[15:32:30.855]                           }
[15:32:30.855]                           else {
[15:32:30.855]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:30.855]                               info, version)
[15:32:30.855]                           }
[15:32:30.855]                           base::stop(msg)
[15:32:30.855]                         }
[15:32:30.855]                       })
[15:32:30.855]                     }
[15:32:30.855]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:30.855]                     base::options(mc.cores = 1L)
[15:32:30.855]                   }
[15:32:30.855]                   ...future.strategy.old <- future::plan("list")
[15:32:30.855]                   options(future.plan = NULL)
[15:32:30.855]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:30.855]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:30.855]                 }
[15:32:30.855]                 ...future.workdir <- getwd()
[15:32:30.855]             }
[15:32:30.855]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:30.855]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:30.855]         }
[15:32:30.855]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:30.855]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:30.855]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:30.855]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:30.855]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:30.855]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:30.855]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:30.855]             base::names(...future.oldOptions))
[15:32:30.855]     }
[15:32:30.855]     if (FALSE) {
[15:32:30.855]     }
[15:32:30.855]     else {
[15:32:30.855]         if (TRUE) {
[15:32:30.855]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:30.855]                 open = "w")
[15:32:30.855]         }
[15:32:30.855]         else {
[15:32:30.855]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:30.855]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:30.855]         }
[15:32:30.855]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:30.855]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:30.855]             base::sink(type = "output", split = FALSE)
[15:32:30.855]             base::close(...future.stdout)
[15:32:30.855]         }, add = TRUE)
[15:32:30.855]     }
[15:32:30.855]     ...future.frame <- base::sys.nframe()
[15:32:30.855]     ...future.conditions <- base::list()
[15:32:30.855]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:30.855]     if (FALSE) {
[15:32:30.855]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:30.855]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:30.855]     }
[15:32:30.855]     ...future.result <- base::tryCatch({
[15:32:30.855]         base::withCallingHandlers({
[15:32:30.855]             ...future.value <- base::withVisible(base::local({
[15:32:30.855]                 ...future.makeSendCondition <- base::local({
[15:32:30.855]                   sendCondition <- NULL
[15:32:30.855]                   function(frame = 1L) {
[15:32:30.855]                     if (is.function(sendCondition)) 
[15:32:30.855]                       return(sendCondition)
[15:32:30.855]                     ns <- getNamespace("parallel")
[15:32:30.855]                     if (exists("sendData", mode = "function", 
[15:32:30.855]                       envir = ns)) {
[15:32:30.855]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:30.855]                         envir = ns)
[15:32:30.855]                       envir <- sys.frame(frame)
[15:32:30.855]                       master <- NULL
[15:32:30.855]                       while (!identical(envir, .GlobalEnv) && 
[15:32:30.855]                         !identical(envir, emptyenv())) {
[15:32:30.855]                         if (exists("master", mode = "list", envir = envir, 
[15:32:30.855]                           inherits = FALSE)) {
[15:32:30.855]                           master <- get("master", mode = "list", 
[15:32:30.855]                             envir = envir, inherits = FALSE)
[15:32:30.855]                           if (inherits(master, c("SOCKnode", 
[15:32:30.855]                             "SOCK0node"))) {
[15:32:30.855]                             sendCondition <<- function(cond) {
[15:32:30.855]                               data <- list(type = "VALUE", value = cond, 
[15:32:30.855]                                 success = TRUE)
[15:32:30.855]                               parallel_sendData(master, data)
[15:32:30.855]                             }
[15:32:30.855]                             return(sendCondition)
[15:32:30.855]                           }
[15:32:30.855]                         }
[15:32:30.855]                         frame <- frame + 1L
[15:32:30.855]                         envir <- sys.frame(frame)
[15:32:30.855]                       }
[15:32:30.855]                     }
[15:32:30.855]                     sendCondition <<- function(cond) NULL
[15:32:30.855]                   }
[15:32:30.855]                 })
[15:32:30.855]                 withCallingHandlers({
[15:32:30.855]                   {
[15:32:30.855]                     do.call(function(...) {
[15:32:30.855]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:30.855]                       if (!identical(...future.globals.maxSize.org, 
[15:32:30.855]                         ...future.globals.maxSize)) {
[15:32:30.855]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:30.855]                         on.exit(options(oopts), add = TRUE)
[15:32:30.855]                       }
[15:32:30.855]                       {
[15:32:30.855]                         lapply(seq_along(...future.elements_ii), 
[15:32:30.855]                           FUN = function(jj) {
[15:32:30.855]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:30.855]                             ...future.FUN(...future.X_jj, ...)
[15:32:30.855]                           })
[15:32:30.855]                       }
[15:32:30.855]                     }, args = future.call.arguments)
[15:32:30.855]                   }
[15:32:30.855]                 }, immediateCondition = function(cond) {
[15:32:30.855]                   sendCondition <- ...future.makeSendCondition()
[15:32:30.855]                   sendCondition(cond)
[15:32:30.855]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:30.855]                   {
[15:32:30.855]                     inherits <- base::inherits
[15:32:30.855]                     invokeRestart <- base::invokeRestart
[15:32:30.855]                     is.null <- base::is.null
[15:32:30.855]                     muffled <- FALSE
[15:32:30.855]                     if (inherits(cond, "message")) {
[15:32:30.855]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:30.855]                       if (muffled) 
[15:32:30.855]                         invokeRestart("muffleMessage")
[15:32:30.855]                     }
[15:32:30.855]                     else if (inherits(cond, "warning")) {
[15:32:30.855]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:30.855]                       if (muffled) 
[15:32:30.855]                         invokeRestart("muffleWarning")
[15:32:30.855]                     }
[15:32:30.855]                     else if (inherits(cond, "condition")) {
[15:32:30.855]                       if (!is.null(pattern)) {
[15:32:30.855]                         computeRestarts <- base::computeRestarts
[15:32:30.855]                         grepl <- base::grepl
[15:32:30.855]                         restarts <- computeRestarts(cond)
[15:32:30.855]                         for (restart in restarts) {
[15:32:30.855]                           name <- restart$name
[15:32:30.855]                           if (is.null(name)) 
[15:32:30.855]                             next
[15:32:30.855]                           if (!grepl(pattern, name)) 
[15:32:30.855]                             next
[15:32:30.855]                           invokeRestart(restart)
[15:32:30.855]                           muffled <- TRUE
[15:32:30.855]                           break
[15:32:30.855]                         }
[15:32:30.855]                       }
[15:32:30.855]                     }
[15:32:30.855]                     invisible(muffled)
[15:32:30.855]                   }
[15:32:30.855]                   muffleCondition(cond)
[15:32:30.855]                 })
[15:32:30.855]             }))
[15:32:30.855]             future::FutureResult(value = ...future.value$value, 
[15:32:30.855]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:30.855]                   ...future.rng), globalenv = if (FALSE) 
[15:32:30.855]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:30.855]                     ...future.globalenv.names))
[15:32:30.855]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:30.855]         }, condition = base::local({
[15:32:30.855]             c <- base::c
[15:32:30.855]             inherits <- base::inherits
[15:32:30.855]             invokeRestart <- base::invokeRestart
[15:32:30.855]             length <- base::length
[15:32:30.855]             list <- base::list
[15:32:30.855]             seq.int <- base::seq.int
[15:32:30.855]             signalCondition <- base::signalCondition
[15:32:30.855]             sys.calls <- base::sys.calls
[15:32:30.855]             `[[` <- base::`[[`
[15:32:30.855]             `+` <- base::`+`
[15:32:30.855]             `<<-` <- base::`<<-`
[15:32:30.855]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:30.855]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:30.855]                   3L)]
[15:32:30.855]             }
[15:32:30.855]             function(cond) {
[15:32:30.855]                 is_error <- inherits(cond, "error")
[15:32:30.855]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:30.855]                   NULL)
[15:32:30.855]                 if (is_error) {
[15:32:30.855]                   sessionInformation <- function() {
[15:32:30.855]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:30.855]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:30.855]                       search = base::search(), system = base::Sys.info())
[15:32:30.855]                   }
[15:32:30.855]                   ...future.conditions[[length(...future.conditions) + 
[15:32:30.855]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:30.855]                     cond$call), session = sessionInformation(), 
[15:32:30.855]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:30.855]                   signalCondition(cond)
[15:32:30.855]                 }
[15:32:30.855]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:30.855]                 "immediateCondition"))) {
[15:32:30.855]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:30.855]                   ...future.conditions[[length(...future.conditions) + 
[15:32:30.855]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:30.855]                   if (TRUE && !signal) {
[15:32:30.855]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:30.855]                     {
[15:32:30.855]                       inherits <- base::inherits
[15:32:30.855]                       invokeRestart <- base::invokeRestart
[15:32:30.855]                       is.null <- base::is.null
[15:32:30.855]                       muffled <- FALSE
[15:32:30.855]                       if (inherits(cond, "message")) {
[15:32:30.855]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:30.855]                         if (muffled) 
[15:32:30.855]                           invokeRestart("muffleMessage")
[15:32:30.855]                       }
[15:32:30.855]                       else if (inherits(cond, "warning")) {
[15:32:30.855]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:30.855]                         if (muffled) 
[15:32:30.855]                           invokeRestart("muffleWarning")
[15:32:30.855]                       }
[15:32:30.855]                       else if (inherits(cond, "condition")) {
[15:32:30.855]                         if (!is.null(pattern)) {
[15:32:30.855]                           computeRestarts <- base::computeRestarts
[15:32:30.855]                           grepl <- base::grepl
[15:32:30.855]                           restarts <- computeRestarts(cond)
[15:32:30.855]                           for (restart in restarts) {
[15:32:30.855]                             name <- restart$name
[15:32:30.855]                             if (is.null(name)) 
[15:32:30.855]                               next
[15:32:30.855]                             if (!grepl(pattern, name)) 
[15:32:30.855]                               next
[15:32:30.855]                             invokeRestart(restart)
[15:32:30.855]                             muffled <- TRUE
[15:32:30.855]                             break
[15:32:30.855]                           }
[15:32:30.855]                         }
[15:32:30.855]                       }
[15:32:30.855]                       invisible(muffled)
[15:32:30.855]                     }
[15:32:30.855]                     muffleCondition(cond, pattern = "^muffle")
[15:32:30.855]                   }
[15:32:30.855]                 }
[15:32:30.855]                 else {
[15:32:30.855]                   if (TRUE) {
[15:32:30.855]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:30.855]                     {
[15:32:30.855]                       inherits <- base::inherits
[15:32:30.855]                       invokeRestart <- base::invokeRestart
[15:32:30.855]                       is.null <- base::is.null
[15:32:30.855]                       muffled <- FALSE
[15:32:30.855]                       if (inherits(cond, "message")) {
[15:32:30.855]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:30.855]                         if (muffled) 
[15:32:30.855]                           invokeRestart("muffleMessage")
[15:32:30.855]                       }
[15:32:30.855]                       else if (inherits(cond, "warning")) {
[15:32:30.855]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:30.855]                         if (muffled) 
[15:32:30.855]                           invokeRestart("muffleWarning")
[15:32:30.855]                       }
[15:32:30.855]                       else if (inherits(cond, "condition")) {
[15:32:30.855]                         if (!is.null(pattern)) {
[15:32:30.855]                           computeRestarts <- base::computeRestarts
[15:32:30.855]                           grepl <- base::grepl
[15:32:30.855]                           restarts <- computeRestarts(cond)
[15:32:30.855]                           for (restart in restarts) {
[15:32:30.855]                             name <- restart$name
[15:32:30.855]                             if (is.null(name)) 
[15:32:30.855]                               next
[15:32:30.855]                             if (!grepl(pattern, name)) 
[15:32:30.855]                               next
[15:32:30.855]                             invokeRestart(restart)
[15:32:30.855]                             muffled <- TRUE
[15:32:30.855]                             break
[15:32:30.855]                           }
[15:32:30.855]                         }
[15:32:30.855]                       }
[15:32:30.855]                       invisible(muffled)
[15:32:30.855]                     }
[15:32:30.855]                     muffleCondition(cond, pattern = "^muffle")
[15:32:30.855]                   }
[15:32:30.855]                 }
[15:32:30.855]             }
[15:32:30.855]         }))
[15:32:30.855]     }, error = function(ex) {
[15:32:30.855]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:30.855]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:30.855]                 ...future.rng), started = ...future.startTime, 
[15:32:30.855]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:30.855]             version = "1.8"), class = "FutureResult")
[15:32:30.855]     }, finally = {
[15:32:30.855]         if (!identical(...future.workdir, getwd())) 
[15:32:30.855]             setwd(...future.workdir)
[15:32:30.855]         {
[15:32:30.855]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:30.855]                 ...future.oldOptions$nwarnings <- NULL
[15:32:30.855]             }
[15:32:30.855]             base::options(...future.oldOptions)
[15:32:30.855]             if (.Platform$OS.type == "windows") {
[15:32:30.855]                 old_names <- names(...future.oldEnvVars)
[15:32:30.855]                 envs <- base::Sys.getenv()
[15:32:30.855]                 names <- names(envs)
[15:32:30.855]                 common <- intersect(names, old_names)
[15:32:30.855]                 added <- setdiff(names, old_names)
[15:32:30.855]                 removed <- setdiff(old_names, names)
[15:32:30.855]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:30.855]                   envs[common]]
[15:32:30.855]                 NAMES <- toupper(changed)
[15:32:30.855]                 args <- list()
[15:32:30.855]                 for (kk in seq_along(NAMES)) {
[15:32:30.855]                   name <- changed[[kk]]
[15:32:30.855]                   NAME <- NAMES[[kk]]
[15:32:30.855]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:30.855]                     next
[15:32:30.855]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:30.855]                 }
[15:32:30.855]                 NAMES <- toupper(added)
[15:32:30.855]                 for (kk in seq_along(NAMES)) {
[15:32:30.855]                   name <- added[[kk]]
[15:32:30.855]                   NAME <- NAMES[[kk]]
[15:32:30.855]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:30.855]                     next
[15:32:30.855]                   args[[name]] <- ""
[15:32:30.855]                 }
[15:32:30.855]                 NAMES <- toupper(removed)
[15:32:30.855]                 for (kk in seq_along(NAMES)) {
[15:32:30.855]                   name <- removed[[kk]]
[15:32:30.855]                   NAME <- NAMES[[kk]]
[15:32:30.855]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:30.855]                     next
[15:32:30.855]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:30.855]                 }
[15:32:30.855]                 if (length(args) > 0) 
[15:32:30.855]                   base::do.call(base::Sys.setenv, args = args)
[15:32:30.855]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:30.855]             }
[15:32:30.855]             else {
[15:32:30.855]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:30.855]             }
[15:32:30.855]             {
[15:32:30.855]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:30.855]                   0L) {
[15:32:30.855]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:30.855]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:30.855]                   base::options(opts)
[15:32:30.855]                 }
[15:32:30.855]                 {
[15:32:30.855]                   {
[15:32:30.855]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:30.855]                     NULL
[15:32:30.855]                   }
[15:32:30.855]                   options(future.plan = NULL)
[15:32:30.855]                   if (is.na(NA_character_)) 
[15:32:30.855]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:30.855]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:30.855]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:30.855]                     .init = FALSE)
[15:32:30.855]                 }
[15:32:30.855]             }
[15:32:30.855]         }
[15:32:30.855]     })
[15:32:30.855]     if (TRUE) {
[15:32:30.855]         base::sink(type = "output", split = FALSE)
[15:32:30.855]         if (TRUE) {
[15:32:30.855]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:30.855]         }
[15:32:30.855]         else {
[15:32:30.855]             ...future.result["stdout"] <- base::list(NULL)
[15:32:30.855]         }
[15:32:30.855]         base::close(...future.stdout)
[15:32:30.855]         ...future.stdout <- NULL
[15:32:30.855]     }
[15:32:30.855]     ...future.result$conditions <- ...future.conditions
[15:32:30.855]     ...future.result$finished <- base::Sys.time()
[15:32:30.855]     ...future.result
[15:32:30.855] }
[15:32:30.864] Exporting 5 global objects (4.62 KiB) to cluster node #1 ...
[15:32:30.865] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ...
[15:32:30.865] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ... DONE
[15:32:30.866] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:30.867] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:30.867] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:30.868] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:30.868] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:30.868] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:30.869] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:30.869] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:30.869] Exporting 5 global objects (4.62 KiB) to cluster node #1 ... DONE
[15:32:30.870] MultisessionFuture started
[15:32:30.870] - Launch lazy future ... done
[15:32:30.870] run() for 'MultisessionFuture' ... done
[15:32:30.870] Created future:
[15:32:30.897] receiveMessageFromWorker() for ClusterFuture ...
[15:32:30.898] - Validating connection of MultisessionFuture
[15:32:30.898] - received message: FutureResult
[15:32:30.898] - Received FutureResult
[15:32:30.899] - Erased future from FutureRegistry
[15:32:30.899] result() for ClusterFuture ...
[15:32:30.899] - result already collected: FutureResult
[15:32:30.900] result() for ClusterFuture ... done
[15:32:30.900] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:30.871] MultisessionFuture:
[15:32:30.871] Label: 'future_sapply-2'
[15:32:30.871] Expression:
[15:32:30.871] {
[15:32:30.871]     do.call(function(...) {
[15:32:30.871]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:30.871]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:30.871]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:30.871]             on.exit(options(oopts), add = TRUE)
[15:32:30.871]         }
[15:32:30.871]         {
[15:32:30.871]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:30.871]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:30.871]                 ...future.FUN(...future.X_jj, ...)
[15:32:30.871]             })
[15:32:30.871]         }
[15:32:30.871]     }, args = future.call.arguments)
[15:32:30.871] }
[15:32:30.871] Lazy evaluation: FALSE
[15:32:30.871] Asynchronous evaluation: TRUE
[15:32:30.871] Local evaluation: TRUE
[15:32:30.871] Environment: R_GlobalEnv
[15:32:30.871] Capture standard output: TRUE
[15:32:30.871] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:30.871] Globals: 5 objects totaling 4.73 KiB (function '...future.FUN' of 4.62 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)
[15:32:30.871] Packages: <none>
[15:32:30.871] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:30.871] Resolved: TRUE
[15:32:30.871] Value: <not collected>
[15:32:30.871] Conditions captured: <none>
[15:32:30.871] Early signaling: FALSE
[15:32:30.871] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:30.871] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:30.901] Chunk #2 of 2 ... DONE
[15:32:30.901] Launching 2 futures (chunks) ... DONE
[15:32:30.901] Resolving 2 futures (chunks) ...
[15:32:30.902] resolve() on list ...
[15:32:30.902]  recursive: 0
[15:32:30.902]  length: 2
[15:32:30.903] 
[15:32:30.903] Future #1
[15:32:30.903] result() for ClusterFuture ...
[15:32:30.903] - result already collected: FutureResult
[15:32:30.904] result() for ClusterFuture ... done
[15:32:30.904] result() for ClusterFuture ...
[15:32:30.904] - result already collected: FutureResult
[15:32:30.905] result() for ClusterFuture ... done
[15:32:30.905] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:30.905] - nx: 2
[15:32:30.905] - relay: TRUE
[15:32:30.906] - stdout: TRUE
[15:32:30.906] - signal: TRUE
[15:32:30.906] - resignal: FALSE
[15:32:30.906] - force: TRUE
[15:32:30.907] - relayed: [n=2] FALSE, FALSE
[15:32:30.907] - queued futures: [n=2] FALSE, FALSE
[15:32:30.907]  - until=1
[15:32:30.907]  - relaying element #1
[15:32:30.908] result() for ClusterFuture ...
[15:32:30.908] - result already collected: FutureResult
[15:32:30.908] result() for ClusterFuture ... done
[15:32:30.909] result() for ClusterFuture ...
[15:32:30.909] - result already collected: FutureResult
[15:32:30.909] result() for ClusterFuture ... done
[15:32:30.909] result() for ClusterFuture ...
[15:32:30.910] - result already collected: FutureResult
[15:32:30.910] result() for ClusterFuture ... done
[15:32:30.910] result() for ClusterFuture ...
[15:32:30.911] - result already collected: FutureResult
[15:32:30.911] result() for ClusterFuture ... done
[15:32:30.911] - relayed: [n=2] TRUE, FALSE
[15:32:30.911] - queued futures: [n=2] TRUE, FALSE
[15:32:30.912] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:30.912]  length: 1 (resolved future 1)
[15:32:30.912] Future #2
[15:32:30.912] result() for ClusterFuture ...
[15:32:30.913] - result already collected: FutureResult
[15:32:30.913] result() for ClusterFuture ... done
[15:32:30.913] result() for ClusterFuture ...
[15:32:30.914] - result already collected: FutureResult
[15:32:30.914] result() for ClusterFuture ... done
[15:32:30.914] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:30.914] - nx: 2
[15:32:30.915] - relay: TRUE
[15:32:30.915] - stdout: TRUE
[15:32:30.915] - signal: TRUE
[15:32:30.915] - resignal: FALSE
[15:32:30.916] - force: TRUE
[15:32:30.916] - relayed: [n=2] TRUE, FALSE
[15:32:30.916] - queued futures: [n=2] TRUE, FALSE
[15:32:30.916]  - until=2
[15:32:30.917]  - relaying element #2
[15:32:30.917] result() for ClusterFuture ...
[15:32:30.917] - result already collected: FutureResult
[15:32:30.917] result() for ClusterFuture ... done
[15:32:30.918] result() for ClusterFuture ...
[15:32:30.918] - result already collected: FutureResult
[15:32:30.918] result() for ClusterFuture ... done
[15:32:30.918] result() for ClusterFuture ...
[15:32:30.919] - result already collected: FutureResult
[15:32:30.919] result() for ClusterFuture ... done
[15:32:30.919] result() for ClusterFuture ...
[15:32:30.920] - result already collected: FutureResult
[15:32:30.920] result() for ClusterFuture ... done
[15:32:30.920] - relayed: [n=2] TRUE, TRUE
[15:32:30.920] - queued futures: [n=2] TRUE, TRUE
[15:32:30.920] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:30.921]  length: 0 (resolved future 2)
[15:32:30.921] Relaying remaining futures
[15:32:30.921] signalConditionsASAP(NULL, pos=0) ...
[15:32:30.922] - nx: 2
[15:32:30.922] - relay: TRUE
[15:32:30.922] - stdout: TRUE
[15:32:30.922] - signal: TRUE
[15:32:30.923] - resignal: FALSE
[15:32:30.923] - force: TRUE
[15:32:30.923] - relayed: [n=2] TRUE, TRUE
[15:32:30.923] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:30.924] - relayed: [n=2] TRUE, TRUE
[15:32:30.924] - queued futures: [n=2] TRUE, TRUE
[15:32:30.924] signalConditionsASAP(NULL, pos=0) ... done
[15:32:30.924] resolve() on list ... DONE
[15:32:30.925] result() for ClusterFuture ...
[15:32:30.925] - result already collected: FutureResult
[15:32:30.925] result() for ClusterFuture ... done
[15:32:30.925] result() for ClusterFuture ...
[15:32:30.926] - result already collected: FutureResult
[15:32:30.926] result() for ClusterFuture ... done
[15:32:30.926] result() for ClusterFuture ...
[15:32:30.927] - result already collected: FutureResult
[15:32:30.927] result() for ClusterFuture ... done
[15:32:30.927] result() for ClusterFuture ...
[15:32:30.927] - result already collected: FutureResult
[15:32:30.928] result() for ClusterFuture ... done
[15:32:30.928]  - Number of value chunks collected: 2
[15:32:30.928] Resolving 2 futures (chunks) ... DONE
[15:32:30.929] Reducing values from 2 chunks ...
[15:32:30.929]  - Number of values collected after concatenation: 3
[15:32:30.929]  - Number of values expected: 3
[15:32:30.929] Reducing values from 2 chunks ... DONE
[15:32:30.930] future_lapply() ... DONE
List of 2
 $ y0: num [1:3, 1:5, 1:3] 2 2 2 4 4 4 6 6 6 8 ...
  ..- attr(*, "dimnames")=List of 3
  .. ..$ : NULL
  .. ..$ : NULL
  .. ..$ : chr [1:3] "a" "b" "c"
 $ y1: num [1:3, 1:5, 1:3] 2 2 2 4 4 4 6 6 6 8 ...
  ..- attr(*, "dimnames")=List of 3
  .. ..$ : NULL
  .. ..$ : NULL
  .. ..$ : chr [1:3] "a" "b" "c"
[15:32:30.935] future_lapply() ...
[15:32:30.940] Number of chunks: 2
[15:32:30.940] getGlobalsAndPackagesXApply() ...
[15:32:30.940]  - future.globals: TRUE
[15:32:30.941] getGlobalsAndPackages() ...
[15:32:30.941] Searching for globals...
[15:32:30.943] - globals found: [1] 'FUN'
[15:32:30.943] Searching for globals ... DONE
[15:32:30.943] Resolving globals: FALSE
[15:32:30.944] The total size of the 1 globals is 848 bytes (848 bytes)
[15:32:30.945] The total size of the 1 globals exported for future expression ('FUN()') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:32:30.945] - globals: [1] 'FUN'
[15:32:30.945] 
[15:32:30.946] getGlobalsAndPackages() ... DONE
[15:32:30.946]  - globals found/used: [n=1] 'FUN'
[15:32:30.946]  - needed namespaces: [n=0] 
[15:32:30.946] Finding globals ... DONE
[15:32:30.947]  - use_args: TRUE
[15:32:30.947]  - Getting '...' globals ...
[15:32:30.948] resolve() on list ...
[15:32:30.948]  recursive: 0
[15:32:30.948]  length: 1
[15:32:30.948]  elements: '...'
[15:32:30.949]  length: 0 (resolved future 1)
[15:32:30.949] resolve() on list ... DONE
[15:32:30.949]    - '...' content: [n=0] 
[15:32:30.950] List of 1
[15:32:30.950]  $ ...: list()
[15:32:30.950]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:30.950]  - attr(*, "where")=List of 1
[15:32:30.950]   ..$ ...:<environment: 0x00000276e5c97370> 
[15:32:30.950]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:30.950]  - attr(*, "resolved")= logi TRUE
[15:32:30.950]  - attr(*, "total_size")= num NA
[15:32:30.955]  - Getting '...' globals ... DONE
[15:32:30.955] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:30.955] List of 2
[15:32:30.955]  $ ...future.FUN:function (x)  
[15:32:30.955]  $ ...          : list()
[15:32:30.955]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:30.955]  - attr(*, "where")=List of 2
[15:32:30.955]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:30.955]   ..$ ...          :<environment: 0x00000276e5c97370> 
[15:32:30.955]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:30.955]  - attr(*, "resolved")= logi FALSE
[15:32:30.955]  - attr(*, "total_size")= num 848
[15:32:30.960] Packages to be attached in all futures: [n=0] 
[15:32:30.961] getGlobalsAndPackagesXApply() ... DONE
[15:32:30.961] Number of futures (= number of chunks): 2
[15:32:30.962] Launching 2 futures (chunks) ...
[15:32:30.962] Chunk #1 of 2 ...
[15:32:30.962]  - Finding globals in 'X' for chunk #1 ...
[15:32:30.962] getGlobalsAndPackages() ...
[15:32:30.963] Searching for globals...
[15:32:30.963] 
[15:32:30.963] Searching for globals ... DONE
[15:32:30.964] - globals: [0] <none>
[15:32:30.964] getGlobalsAndPackages() ... DONE
[15:32:30.964]    + additional globals found: [n=0] 
[15:32:30.964]    + additional namespaces needed: [n=0] 
[15:32:30.965]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:30.965]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:30.965]  - seeds: <none>
[15:32:30.965]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:30.966] getGlobalsAndPackages() ...
[15:32:30.966] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:30.966] Resolving globals: FALSE
[15:32:30.967] Tweak future expression to call with '...' arguments ...
[15:32:30.967] {
[15:32:30.967]     do.call(function(...) {
[15:32:30.967]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:30.967]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:30.967]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:30.967]             on.exit(options(oopts), add = TRUE)
[15:32:30.967]         }
[15:32:30.967]         {
[15:32:30.967]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:30.967]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:30.967]                 ...future.FUN(...future.X_jj, ...)
[15:32:30.967]             })
[15:32:30.967]         }
[15:32:30.967]     }, args = future.call.arguments)
[15:32:30.967] }
[15:32:30.968] Tweak future expression to call with '...' arguments ... DONE
[15:32:30.969] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:30.969] 
[15:32:30.969] getGlobalsAndPackages() ... DONE
[15:32:30.970] run() for 'Future' ...
[15:32:30.970] - state: 'created'
[15:32:30.970] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:30.988] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:30.989] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:30.989]   - Field: 'node'
[15:32:30.989]   - Field: 'label'
[15:32:30.990]   - Field: 'local'
[15:32:30.990]   - Field: 'owner'
[15:32:30.990]   - Field: 'envir'
[15:32:30.991]   - Field: 'workers'
[15:32:30.991]   - Field: 'packages'
[15:32:30.991]   - Field: 'gc'
[15:32:30.992]   - Field: 'conditions'
[15:32:30.992]   - Field: 'persistent'
[15:32:30.992]   - Field: 'expr'
[15:32:30.992]   - Field: 'uuid'
[15:32:30.993]   - Field: 'seed'
[15:32:30.993]   - Field: 'version'
[15:32:30.993]   - Field: 'result'
[15:32:30.994]   - Field: 'asynchronous'
[15:32:30.994]   - Field: 'calls'
[15:32:30.994]   - Field: 'globals'
[15:32:30.995]   - Field: 'stdout'
[15:32:30.995]   - Field: 'earlySignal'
[15:32:30.995]   - Field: 'lazy'
[15:32:30.996]   - Field: 'state'
[15:32:30.996] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:30.996] - Launch lazy future ...
[15:32:30.997] Packages needed by the future expression (n = 0): <none>
[15:32:30.997] Packages needed by future strategies (n = 0): <none>
[15:32:30.998] {
[15:32:30.998]     {
[15:32:30.998]         {
[15:32:30.998]             ...future.startTime <- base::Sys.time()
[15:32:30.998]             {
[15:32:30.998]                 {
[15:32:30.998]                   {
[15:32:30.998]                     {
[15:32:30.998]                       base::local({
[15:32:30.998]                         has_future <- base::requireNamespace("future", 
[15:32:30.998]                           quietly = TRUE)
[15:32:30.998]                         if (has_future) {
[15:32:30.998]                           ns <- base::getNamespace("future")
[15:32:30.998]                           version <- ns[[".package"]][["version"]]
[15:32:30.998]                           if (is.null(version)) 
[15:32:30.998]                             version <- utils::packageVersion("future")
[15:32:30.998]                         }
[15:32:30.998]                         else {
[15:32:30.998]                           version <- NULL
[15:32:30.998]                         }
[15:32:30.998]                         if (!has_future || version < "1.8.0") {
[15:32:30.998]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:30.998]                             "", base::R.version$version.string), 
[15:32:30.998]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:30.998]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:30.998]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:30.998]                               "release", "version")], collapse = " "), 
[15:32:30.998]                             hostname = base::Sys.info()[["nodename"]])
[15:32:30.998]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:30.998]                             info)
[15:32:30.998]                           info <- base::paste(info, collapse = "; ")
[15:32:30.998]                           if (!has_future) {
[15:32:30.998]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:30.998]                               info)
[15:32:30.998]                           }
[15:32:30.998]                           else {
[15:32:30.998]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:30.998]                               info, version)
[15:32:30.998]                           }
[15:32:30.998]                           base::stop(msg)
[15:32:30.998]                         }
[15:32:30.998]                       })
[15:32:30.998]                     }
[15:32:30.998]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:30.998]                     base::options(mc.cores = 1L)
[15:32:30.998]                   }
[15:32:30.998]                   ...future.strategy.old <- future::plan("list")
[15:32:30.998]                   options(future.plan = NULL)
[15:32:30.998]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:30.998]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:30.998]                 }
[15:32:30.998]                 ...future.workdir <- getwd()
[15:32:30.998]             }
[15:32:30.998]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:30.998]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:30.998]         }
[15:32:30.998]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:30.998]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:30.998]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:30.998]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:30.998]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:30.998]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:30.998]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:30.998]             base::names(...future.oldOptions))
[15:32:30.998]     }
[15:32:30.998]     if (FALSE) {
[15:32:30.998]     }
[15:32:30.998]     else {
[15:32:30.998]         if (TRUE) {
[15:32:30.998]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:30.998]                 open = "w")
[15:32:30.998]         }
[15:32:30.998]         else {
[15:32:30.998]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:30.998]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:30.998]         }
[15:32:30.998]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:30.998]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:30.998]             base::sink(type = "output", split = FALSE)
[15:32:30.998]             base::close(...future.stdout)
[15:32:30.998]         }, add = TRUE)
[15:32:30.998]     }
[15:32:30.998]     ...future.frame <- base::sys.nframe()
[15:32:30.998]     ...future.conditions <- base::list()
[15:32:30.998]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:30.998]     if (FALSE) {
[15:32:30.998]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:30.998]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:30.998]     }
[15:32:30.998]     ...future.result <- base::tryCatch({
[15:32:30.998]         base::withCallingHandlers({
[15:32:30.998]             ...future.value <- base::withVisible(base::local({
[15:32:30.998]                 ...future.makeSendCondition <- base::local({
[15:32:30.998]                   sendCondition <- NULL
[15:32:30.998]                   function(frame = 1L) {
[15:32:30.998]                     if (is.function(sendCondition)) 
[15:32:30.998]                       return(sendCondition)
[15:32:30.998]                     ns <- getNamespace("parallel")
[15:32:30.998]                     if (exists("sendData", mode = "function", 
[15:32:30.998]                       envir = ns)) {
[15:32:30.998]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:30.998]                         envir = ns)
[15:32:30.998]                       envir <- sys.frame(frame)
[15:32:30.998]                       master <- NULL
[15:32:30.998]                       while (!identical(envir, .GlobalEnv) && 
[15:32:30.998]                         !identical(envir, emptyenv())) {
[15:32:30.998]                         if (exists("master", mode = "list", envir = envir, 
[15:32:30.998]                           inherits = FALSE)) {
[15:32:30.998]                           master <- get("master", mode = "list", 
[15:32:30.998]                             envir = envir, inherits = FALSE)
[15:32:30.998]                           if (inherits(master, c("SOCKnode", 
[15:32:30.998]                             "SOCK0node"))) {
[15:32:30.998]                             sendCondition <<- function(cond) {
[15:32:30.998]                               data <- list(type = "VALUE", value = cond, 
[15:32:30.998]                                 success = TRUE)
[15:32:30.998]                               parallel_sendData(master, data)
[15:32:30.998]                             }
[15:32:30.998]                             return(sendCondition)
[15:32:30.998]                           }
[15:32:30.998]                         }
[15:32:30.998]                         frame <- frame + 1L
[15:32:30.998]                         envir <- sys.frame(frame)
[15:32:30.998]                       }
[15:32:30.998]                     }
[15:32:30.998]                     sendCondition <<- function(cond) NULL
[15:32:30.998]                   }
[15:32:30.998]                 })
[15:32:30.998]                 withCallingHandlers({
[15:32:30.998]                   {
[15:32:30.998]                     do.call(function(...) {
[15:32:30.998]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:30.998]                       if (!identical(...future.globals.maxSize.org, 
[15:32:30.998]                         ...future.globals.maxSize)) {
[15:32:30.998]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:30.998]                         on.exit(options(oopts), add = TRUE)
[15:32:30.998]                       }
[15:32:30.998]                       {
[15:32:30.998]                         lapply(seq_along(...future.elements_ii), 
[15:32:30.998]                           FUN = function(jj) {
[15:32:30.998]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:30.998]                             ...future.FUN(...future.X_jj, ...)
[15:32:30.998]                           })
[15:32:30.998]                       }
[15:32:30.998]                     }, args = future.call.arguments)
[15:32:30.998]                   }
[15:32:30.998]                 }, immediateCondition = function(cond) {
[15:32:30.998]                   sendCondition <- ...future.makeSendCondition()
[15:32:30.998]                   sendCondition(cond)
[15:32:30.998]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:30.998]                   {
[15:32:30.998]                     inherits <- base::inherits
[15:32:30.998]                     invokeRestart <- base::invokeRestart
[15:32:30.998]                     is.null <- base::is.null
[15:32:30.998]                     muffled <- FALSE
[15:32:30.998]                     if (inherits(cond, "message")) {
[15:32:30.998]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:30.998]                       if (muffled) 
[15:32:30.998]                         invokeRestart("muffleMessage")
[15:32:30.998]                     }
[15:32:30.998]                     else if (inherits(cond, "warning")) {
[15:32:30.998]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:30.998]                       if (muffled) 
[15:32:30.998]                         invokeRestart("muffleWarning")
[15:32:30.998]                     }
[15:32:30.998]                     else if (inherits(cond, "condition")) {
[15:32:30.998]                       if (!is.null(pattern)) {
[15:32:30.998]                         computeRestarts <- base::computeRestarts
[15:32:30.998]                         grepl <- base::grepl
[15:32:30.998]                         restarts <- computeRestarts(cond)
[15:32:30.998]                         for (restart in restarts) {
[15:32:30.998]                           name <- restart$name
[15:32:30.998]                           if (is.null(name)) 
[15:32:30.998]                             next
[15:32:30.998]                           if (!grepl(pattern, name)) 
[15:32:30.998]                             next
[15:32:30.998]                           invokeRestart(restart)
[15:32:30.998]                           muffled <- TRUE
[15:32:30.998]                           break
[15:32:30.998]                         }
[15:32:30.998]                       }
[15:32:30.998]                     }
[15:32:30.998]                     invisible(muffled)
[15:32:30.998]                   }
[15:32:30.998]                   muffleCondition(cond)
[15:32:30.998]                 })
[15:32:30.998]             }))
[15:32:30.998]             future::FutureResult(value = ...future.value$value, 
[15:32:30.998]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:30.998]                   ...future.rng), globalenv = if (FALSE) 
[15:32:30.998]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:30.998]                     ...future.globalenv.names))
[15:32:30.998]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:30.998]         }, condition = base::local({
[15:32:30.998]             c <- base::c
[15:32:30.998]             inherits <- base::inherits
[15:32:30.998]             invokeRestart <- base::invokeRestart
[15:32:30.998]             length <- base::length
[15:32:30.998]             list <- base::list
[15:32:30.998]             seq.int <- base::seq.int
[15:32:30.998]             signalCondition <- base::signalCondition
[15:32:30.998]             sys.calls <- base::sys.calls
[15:32:30.998]             `[[` <- base::`[[`
[15:32:30.998]             `+` <- base::`+`
[15:32:30.998]             `<<-` <- base::`<<-`
[15:32:30.998]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:30.998]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:30.998]                   3L)]
[15:32:30.998]             }
[15:32:30.998]             function(cond) {
[15:32:30.998]                 is_error <- inherits(cond, "error")
[15:32:30.998]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:30.998]                   NULL)
[15:32:30.998]                 if (is_error) {
[15:32:30.998]                   sessionInformation <- function() {
[15:32:30.998]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:30.998]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:30.998]                       search = base::search(), system = base::Sys.info())
[15:32:30.998]                   }
[15:32:30.998]                   ...future.conditions[[length(...future.conditions) + 
[15:32:30.998]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:30.998]                     cond$call), session = sessionInformation(), 
[15:32:30.998]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:30.998]                   signalCondition(cond)
[15:32:30.998]                 }
[15:32:30.998]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:30.998]                 "immediateCondition"))) {
[15:32:30.998]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:30.998]                   ...future.conditions[[length(...future.conditions) + 
[15:32:30.998]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:30.998]                   if (TRUE && !signal) {
[15:32:30.998]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:30.998]                     {
[15:32:30.998]                       inherits <- base::inherits
[15:32:30.998]                       invokeRestart <- base::invokeRestart
[15:32:30.998]                       is.null <- base::is.null
[15:32:30.998]                       muffled <- FALSE
[15:32:30.998]                       if (inherits(cond, "message")) {
[15:32:30.998]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:30.998]                         if (muffled) 
[15:32:30.998]                           invokeRestart("muffleMessage")
[15:32:30.998]                       }
[15:32:30.998]                       else if (inherits(cond, "warning")) {
[15:32:30.998]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:30.998]                         if (muffled) 
[15:32:30.998]                           invokeRestart("muffleWarning")
[15:32:30.998]                       }
[15:32:30.998]                       else if (inherits(cond, "condition")) {
[15:32:30.998]                         if (!is.null(pattern)) {
[15:32:30.998]                           computeRestarts <- base::computeRestarts
[15:32:30.998]                           grepl <- base::grepl
[15:32:30.998]                           restarts <- computeRestarts(cond)
[15:32:30.998]                           for (restart in restarts) {
[15:32:30.998]                             name <- restart$name
[15:32:30.998]                             if (is.null(name)) 
[15:32:30.998]                               next
[15:32:30.998]                             if (!grepl(pattern, name)) 
[15:32:30.998]                               next
[15:32:30.998]                             invokeRestart(restart)
[15:32:30.998]                             muffled <- TRUE
[15:32:30.998]                             break
[15:32:30.998]                           }
[15:32:30.998]                         }
[15:32:30.998]                       }
[15:32:30.998]                       invisible(muffled)
[15:32:30.998]                     }
[15:32:30.998]                     muffleCondition(cond, pattern = "^muffle")
[15:32:30.998]                   }
[15:32:30.998]                 }
[15:32:30.998]                 else {
[15:32:30.998]                   if (TRUE) {
[15:32:30.998]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:30.998]                     {
[15:32:30.998]                       inherits <- base::inherits
[15:32:30.998]                       invokeRestart <- base::invokeRestart
[15:32:30.998]                       is.null <- base::is.null
[15:32:30.998]                       muffled <- FALSE
[15:32:30.998]                       if (inherits(cond, "message")) {
[15:32:30.998]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:30.998]                         if (muffled) 
[15:32:30.998]                           invokeRestart("muffleMessage")
[15:32:30.998]                       }
[15:32:30.998]                       else if (inherits(cond, "warning")) {
[15:32:30.998]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:30.998]                         if (muffled) 
[15:32:30.998]                           invokeRestart("muffleWarning")
[15:32:30.998]                       }
[15:32:30.998]                       else if (inherits(cond, "condition")) {
[15:32:30.998]                         if (!is.null(pattern)) {
[15:32:30.998]                           computeRestarts <- base::computeRestarts
[15:32:30.998]                           grepl <- base::grepl
[15:32:30.998]                           restarts <- computeRestarts(cond)
[15:32:30.998]                           for (restart in restarts) {
[15:32:30.998]                             name <- restart$name
[15:32:30.998]                             if (is.null(name)) 
[15:32:30.998]                               next
[15:32:30.998]                             if (!grepl(pattern, name)) 
[15:32:30.998]                               next
[15:32:30.998]                             invokeRestart(restart)
[15:32:30.998]                             muffled <- TRUE
[15:32:30.998]                             break
[15:32:30.998]                           }
[15:32:30.998]                         }
[15:32:30.998]                       }
[15:32:30.998]                       invisible(muffled)
[15:32:30.998]                     }
[15:32:30.998]                     muffleCondition(cond, pattern = "^muffle")
[15:32:30.998]                   }
[15:32:30.998]                 }
[15:32:30.998]             }
[15:32:30.998]         }))
[15:32:30.998]     }, error = function(ex) {
[15:32:30.998]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:30.998]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:30.998]                 ...future.rng), started = ...future.startTime, 
[15:32:30.998]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:30.998]             version = "1.8"), class = "FutureResult")
[15:32:30.998]     }, finally = {
[15:32:30.998]         if (!identical(...future.workdir, getwd())) 
[15:32:30.998]             setwd(...future.workdir)
[15:32:30.998]         {
[15:32:30.998]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:30.998]                 ...future.oldOptions$nwarnings <- NULL
[15:32:30.998]             }
[15:32:30.998]             base::options(...future.oldOptions)
[15:32:30.998]             if (.Platform$OS.type == "windows") {
[15:32:30.998]                 old_names <- names(...future.oldEnvVars)
[15:32:30.998]                 envs <- base::Sys.getenv()
[15:32:30.998]                 names <- names(envs)
[15:32:30.998]                 common <- intersect(names, old_names)
[15:32:30.998]                 added <- setdiff(names, old_names)
[15:32:30.998]                 removed <- setdiff(old_names, names)
[15:32:30.998]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:30.998]                   envs[common]]
[15:32:30.998]                 NAMES <- toupper(changed)
[15:32:30.998]                 args <- list()
[15:32:30.998]                 for (kk in seq_along(NAMES)) {
[15:32:30.998]                   name <- changed[[kk]]
[15:32:30.998]                   NAME <- NAMES[[kk]]
[15:32:30.998]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:30.998]                     next
[15:32:30.998]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:30.998]                 }
[15:32:30.998]                 NAMES <- toupper(added)
[15:32:30.998]                 for (kk in seq_along(NAMES)) {
[15:32:30.998]                   name <- added[[kk]]
[15:32:30.998]                   NAME <- NAMES[[kk]]
[15:32:30.998]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:30.998]                     next
[15:32:30.998]                   args[[name]] <- ""
[15:32:30.998]                 }
[15:32:30.998]                 NAMES <- toupper(removed)
[15:32:30.998]                 for (kk in seq_along(NAMES)) {
[15:32:30.998]                   name <- removed[[kk]]
[15:32:30.998]                   NAME <- NAMES[[kk]]
[15:32:30.998]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:30.998]                     next
[15:32:30.998]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:30.998]                 }
[15:32:30.998]                 if (length(args) > 0) 
[15:32:30.998]                   base::do.call(base::Sys.setenv, args = args)
[15:32:30.998]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:30.998]             }
[15:32:30.998]             else {
[15:32:30.998]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:30.998]             }
[15:32:30.998]             {
[15:32:30.998]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:30.998]                   0L) {
[15:32:30.998]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:30.998]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:30.998]                   base::options(opts)
[15:32:30.998]                 }
[15:32:30.998]                 {
[15:32:30.998]                   {
[15:32:30.998]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:30.998]                     NULL
[15:32:30.998]                   }
[15:32:30.998]                   options(future.plan = NULL)
[15:32:30.998]                   if (is.na(NA_character_)) 
[15:32:30.998]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:30.998]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:30.998]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:30.998]                     .init = FALSE)
[15:32:30.998]                 }
[15:32:30.998]             }
[15:32:30.998]         }
[15:32:30.998]     })
[15:32:30.998]     if (TRUE) {
[15:32:30.998]         base::sink(type = "output", split = FALSE)
[15:32:30.998]         if (TRUE) {
[15:32:30.998]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:30.998]         }
[15:32:30.998]         else {
[15:32:30.998]             ...future.result["stdout"] <- base::list(NULL)
[15:32:30.998]         }
[15:32:30.998]         base::close(...future.stdout)
[15:32:30.998]         ...future.stdout <- NULL
[15:32:30.998]     }
[15:32:30.998]     ...future.result$conditions <- ...future.conditions
[15:32:30.998]     ...future.result$finished <- base::Sys.time()
[15:32:30.998]     ...future.result
[15:32:30.998] }
[15:32:31.008] Exporting 5 global objects (848 bytes) to cluster node #1 ...
[15:32:31.008] Exporting '...future.FUN' (848 bytes) to cluster node #1 ...
[15:32:31.009] Exporting '...future.FUN' (848 bytes) to cluster node #1 ... DONE
[15:32:31.009] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:31.010] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:31.010] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ...
[15:32:31.011] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ... DONE
[15:32:31.011] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:31.012] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:31.012] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:31.013] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:31.014] Exporting 5 global objects (848 bytes) to cluster node #1 ... DONE
[15:32:31.015] MultisessionFuture started
[15:32:31.015] - Launch lazy future ... done
[15:32:31.015] run() for 'MultisessionFuture' ... done
[15:32:31.016] Created future:
[15:32:31.041] receiveMessageFromWorker() for ClusterFuture ...
[15:32:31.042] - Validating connection of MultisessionFuture
[15:32:31.042] - received message: FutureResult
[15:32:31.043] - Received FutureResult
[15:32:31.043] - Erased future from FutureRegistry
[15:32:31.043] result() for ClusterFuture ...
[15:32:31.044] - result already collected: FutureResult
[15:32:31.044] result() for ClusterFuture ... done
[15:32:31.044] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:31.016] MultisessionFuture:
[15:32:31.016] Label: 'future_sapply-1'
[15:32:31.016] Expression:
[15:32:31.016] {
[15:32:31.016]     do.call(function(...) {
[15:32:31.016]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:31.016]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:31.016]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:31.016]             on.exit(options(oopts), add = TRUE)
[15:32:31.016]         }
[15:32:31.016]         {
[15:32:31.016]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:31.016]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:31.016]                 ...future.FUN(...future.X_jj, ...)
[15:32:31.016]             })
[15:32:31.016]         }
[15:32:31.016]     }, args = future.call.arguments)
[15:32:31.016] }
[15:32:31.016] Lazy evaluation: FALSE
[15:32:31.016] Asynchronous evaluation: TRUE
[15:32:31.016] Local evaluation: TRUE
[15:32:31.016] Environment: R_GlobalEnv
[15:32:31.016] Capture standard output: TRUE
[15:32:31.016] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:31.016] Globals: 5 objects totaling 0.99 KiB (function '...future.FUN' of 848 bytes, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:31.016] Packages: <none>
[15:32:31.016] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:31.016] Resolved: TRUE
[15:32:31.016] Value: <not collected>
[15:32:31.016] Conditions captured: <none>
[15:32:31.016] Early signaling: FALSE
[15:32:31.016] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:31.016] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:31.045] Chunk #1 of 2 ... DONE
[15:32:31.045] Chunk #2 of 2 ...
[15:32:31.046]  - Finding globals in 'X' for chunk #2 ...
[15:32:31.046] getGlobalsAndPackages() ...
[15:32:31.046] Searching for globals...
[15:32:31.047] 
[15:32:31.047] Searching for globals ... DONE
[15:32:31.047] - globals: [0] <none>
[15:32:31.047] getGlobalsAndPackages() ... DONE
[15:32:31.047]    + additional globals found: [n=0] 
[15:32:31.048]    + additional namespaces needed: [n=0] 
[15:32:31.048]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:31.048]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:31.048]  - seeds: <none>
[15:32:31.048]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:31.049] getGlobalsAndPackages() ...
[15:32:31.049] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:31.049] Resolving globals: FALSE
[15:32:31.049] Tweak future expression to call with '...' arguments ...
[15:32:31.050] {
[15:32:31.050]     do.call(function(...) {
[15:32:31.050]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:31.050]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:31.050]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:31.050]             on.exit(options(oopts), add = TRUE)
[15:32:31.050]         }
[15:32:31.050]         {
[15:32:31.050]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:31.050]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:31.050]                 ...future.FUN(...future.X_jj, ...)
[15:32:31.050]             })
[15:32:31.050]         }
[15:32:31.050]     }, args = future.call.arguments)
[15:32:31.050] }
[15:32:31.050] Tweak future expression to call with '...' arguments ... DONE
[15:32:31.051] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:31.051] 
[15:32:31.052] getGlobalsAndPackages() ... DONE
[15:32:31.052] run() for 'Future' ...
[15:32:31.052] - state: 'created'
[15:32:31.053] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:31.074] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:31.075] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:31.075]   - Field: 'node'
[15:32:31.076]   - Field: 'label'
[15:32:31.076]   - Field: 'local'
[15:32:31.077]   - Field: 'owner'
[15:32:31.077]   - Field: 'envir'
[15:32:31.077]   - Field: 'workers'
[15:32:31.078]   - Field: 'packages'
[15:32:31.078]   - Field: 'gc'
[15:32:31.078]   - Field: 'conditions'
[15:32:31.079]   - Field: 'persistent'
[15:32:31.079]   - Field: 'expr'
[15:32:31.080]   - Field: 'uuid'
[15:32:31.080]   - Field: 'seed'
[15:32:31.080]   - Field: 'version'
[15:32:31.081]   - Field: 'result'
[15:32:31.081]   - Field: 'asynchronous'
[15:32:31.082]   - Field: 'calls'
[15:32:31.082]   - Field: 'globals'
[15:32:31.082]   - Field: 'stdout'
[15:32:31.083]   - Field: 'earlySignal'
[15:32:31.083]   - Field: 'lazy'
[15:32:31.084]   - Field: 'state'
[15:32:31.084] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:31.084] - Launch lazy future ...
[15:32:31.085] Packages needed by the future expression (n = 0): <none>
[15:32:31.090] Packages needed by future strategies (n = 0): <none>
[15:32:31.091] {
[15:32:31.091]     {
[15:32:31.091]         {
[15:32:31.091]             ...future.startTime <- base::Sys.time()
[15:32:31.091]             {
[15:32:31.091]                 {
[15:32:31.091]                   {
[15:32:31.091]                     {
[15:32:31.091]                       base::local({
[15:32:31.091]                         has_future <- base::requireNamespace("future", 
[15:32:31.091]                           quietly = TRUE)
[15:32:31.091]                         if (has_future) {
[15:32:31.091]                           ns <- base::getNamespace("future")
[15:32:31.091]                           version <- ns[[".package"]][["version"]]
[15:32:31.091]                           if (is.null(version)) 
[15:32:31.091]                             version <- utils::packageVersion("future")
[15:32:31.091]                         }
[15:32:31.091]                         else {
[15:32:31.091]                           version <- NULL
[15:32:31.091]                         }
[15:32:31.091]                         if (!has_future || version < "1.8.0") {
[15:32:31.091]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:31.091]                             "", base::R.version$version.string), 
[15:32:31.091]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:31.091]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:31.091]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:31.091]                               "release", "version")], collapse = " "), 
[15:32:31.091]                             hostname = base::Sys.info()[["nodename"]])
[15:32:31.091]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:31.091]                             info)
[15:32:31.091]                           info <- base::paste(info, collapse = "; ")
[15:32:31.091]                           if (!has_future) {
[15:32:31.091]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:31.091]                               info)
[15:32:31.091]                           }
[15:32:31.091]                           else {
[15:32:31.091]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:31.091]                               info, version)
[15:32:31.091]                           }
[15:32:31.091]                           base::stop(msg)
[15:32:31.091]                         }
[15:32:31.091]                       })
[15:32:31.091]                     }
[15:32:31.091]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:31.091]                     base::options(mc.cores = 1L)
[15:32:31.091]                   }
[15:32:31.091]                   ...future.strategy.old <- future::plan("list")
[15:32:31.091]                   options(future.plan = NULL)
[15:32:31.091]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:31.091]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:31.091]                 }
[15:32:31.091]                 ...future.workdir <- getwd()
[15:32:31.091]             }
[15:32:31.091]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:31.091]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:31.091]         }
[15:32:31.091]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:31.091]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:31.091]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:31.091]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:31.091]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:31.091]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:31.091]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:31.091]             base::names(...future.oldOptions))
[15:32:31.091]     }
[15:32:31.091]     if (FALSE) {
[15:32:31.091]     }
[15:32:31.091]     else {
[15:32:31.091]         if (TRUE) {
[15:32:31.091]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:31.091]                 open = "w")
[15:32:31.091]         }
[15:32:31.091]         else {
[15:32:31.091]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:31.091]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:31.091]         }
[15:32:31.091]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:31.091]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:31.091]             base::sink(type = "output", split = FALSE)
[15:32:31.091]             base::close(...future.stdout)
[15:32:31.091]         }, add = TRUE)
[15:32:31.091]     }
[15:32:31.091]     ...future.frame <- base::sys.nframe()
[15:32:31.091]     ...future.conditions <- base::list()
[15:32:31.091]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:31.091]     if (FALSE) {
[15:32:31.091]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:31.091]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:31.091]     }
[15:32:31.091]     ...future.result <- base::tryCatch({
[15:32:31.091]         base::withCallingHandlers({
[15:32:31.091]             ...future.value <- base::withVisible(base::local({
[15:32:31.091]                 ...future.makeSendCondition <- base::local({
[15:32:31.091]                   sendCondition <- NULL
[15:32:31.091]                   function(frame = 1L) {
[15:32:31.091]                     if (is.function(sendCondition)) 
[15:32:31.091]                       return(sendCondition)
[15:32:31.091]                     ns <- getNamespace("parallel")
[15:32:31.091]                     if (exists("sendData", mode = "function", 
[15:32:31.091]                       envir = ns)) {
[15:32:31.091]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:31.091]                         envir = ns)
[15:32:31.091]                       envir <- sys.frame(frame)
[15:32:31.091]                       master <- NULL
[15:32:31.091]                       while (!identical(envir, .GlobalEnv) && 
[15:32:31.091]                         !identical(envir, emptyenv())) {
[15:32:31.091]                         if (exists("master", mode = "list", envir = envir, 
[15:32:31.091]                           inherits = FALSE)) {
[15:32:31.091]                           master <- get("master", mode = "list", 
[15:32:31.091]                             envir = envir, inherits = FALSE)
[15:32:31.091]                           if (inherits(master, c("SOCKnode", 
[15:32:31.091]                             "SOCK0node"))) {
[15:32:31.091]                             sendCondition <<- function(cond) {
[15:32:31.091]                               data <- list(type = "VALUE", value = cond, 
[15:32:31.091]                                 success = TRUE)
[15:32:31.091]                               parallel_sendData(master, data)
[15:32:31.091]                             }
[15:32:31.091]                             return(sendCondition)
[15:32:31.091]                           }
[15:32:31.091]                         }
[15:32:31.091]                         frame <- frame + 1L
[15:32:31.091]                         envir <- sys.frame(frame)
[15:32:31.091]                       }
[15:32:31.091]                     }
[15:32:31.091]                     sendCondition <<- function(cond) NULL
[15:32:31.091]                   }
[15:32:31.091]                 })
[15:32:31.091]                 withCallingHandlers({
[15:32:31.091]                   {
[15:32:31.091]                     do.call(function(...) {
[15:32:31.091]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:31.091]                       if (!identical(...future.globals.maxSize.org, 
[15:32:31.091]                         ...future.globals.maxSize)) {
[15:32:31.091]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:31.091]                         on.exit(options(oopts), add = TRUE)
[15:32:31.091]                       }
[15:32:31.091]                       {
[15:32:31.091]                         lapply(seq_along(...future.elements_ii), 
[15:32:31.091]                           FUN = function(jj) {
[15:32:31.091]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:31.091]                             ...future.FUN(...future.X_jj, ...)
[15:32:31.091]                           })
[15:32:31.091]                       }
[15:32:31.091]                     }, args = future.call.arguments)
[15:32:31.091]                   }
[15:32:31.091]                 }, immediateCondition = function(cond) {
[15:32:31.091]                   sendCondition <- ...future.makeSendCondition()
[15:32:31.091]                   sendCondition(cond)
[15:32:31.091]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:31.091]                   {
[15:32:31.091]                     inherits <- base::inherits
[15:32:31.091]                     invokeRestart <- base::invokeRestart
[15:32:31.091]                     is.null <- base::is.null
[15:32:31.091]                     muffled <- FALSE
[15:32:31.091]                     if (inherits(cond, "message")) {
[15:32:31.091]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:31.091]                       if (muffled) 
[15:32:31.091]                         invokeRestart("muffleMessage")
[15:32:31.091]                     }
[15:32:31.091]                     else if (inherits(cond, "warning")) {
[15:32:31.091]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:31.091]                       if (muffled) 
[15:32:31.091]                         invokeRestart("muffleWarning")
[15:32:31.091]                     }
[15:32:31.091]                     else if (inherits(cond, "condition")) {
[15:32:31.091]                       if (!is.null(pattern)) {
[15:32:31.091]                         computeRestarts <- base::computeRestarts
[15:32:31.091]                         grepl <- base::grepl
[15:32:31.091]                         restarts <- computeRestarts(cond)
[15:32:31.091]                         for (restart in restarts) {
[15:32:31.091]                           name <- restart$name
[15:32:31.091]                           if (is.null(name)) 
[15:32:31.091]                             next
[15:32:31.091]                           if (!grepl(pattern, name)) 
[15:32:31.091]                             next
[15:32:31.091]                           invokeRestart(restart)
[15:32:31.091]                           muffled <- TRUE
[15:32:31.091]                           break
[15:32:31.091]                         }
[15:32:31.091]                       }
[15:32:31.091]                     }
[15:32:31.091]                     invisible(muffled)
[15:32:31.091]                   }
[15:32:31.091]                   muffleCondition(cond)
[15:32:31.091]                 })
[15:32:31.091]             }))
[15:32:31.091]             future::FutureResult(value = ...future.value$value, 
[15:32:31.091]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:31.091]                   ...future.rng), globalenv = if (FALSE) 
[15:32:31.091]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:31.091]                     ...future.globalenv.names))
[15:32:31.091]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:31.091]         }, condition = base::local({
[15:32:31.091]             c <- base::c
[15:32:31.091]             inherits <- base::inherits
[15:32:31.091]             invokeRestart <- base::invokeRestart
[15:32:31.091]             length <- base::length
[15:32:31.091]             list <- base::list
[15:32:31.091]             seq.int <- base::seq.int
[15:32:31.091]             signalCondition <- base::signalCondition
[15:32:31.091]             sys.calls <- base::sys.calls
[15:32:31.091]             `[[` <- base::`[[`
[15:32:31.091]             `+` <- base::`+`
[15:32:31.091]             `<<-` <- base::`<<-`
[15:32:31.091]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:31.091]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:31.091]                   3L)]
[15:32:31.091]             }
[15:32:31.091]             function(cond) {
[15:32:31.091]                 is_error <- inherits(cond, "error")
[15:32:31.091]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:31.091]                   NULL)
[15:32:31.091]                 if (is_error) {
[15:32:31.091]                   sessionInformation <- function() {
[15:32:31.091]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:31.091]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:31.091]                       search = base::search(), system = base::Sys.info())
[15:32:31.091]                   }
[15:32:31.091]                   ...future.conditions[[length(...future.conditions) + 
[15:32:31.091]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:31.091]                     cond$call), session = sessionInformation(), 
[15:32:31.091]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:31.091]                   signalCondition(cond)
[15:32:31.091]                 }
[15:32:31.091]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:31.091]                 "immediateCondition"))) {
[15:32:31.091]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:31.091]                   ...future.conditions[[length(...future.conditions) + 
[15:32:31.091]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:31.091]                   if (TRUE && !signal) {
[15:32:31.091]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:31.091]                     {
[15:32:31.091]                       inherits <- base::inherits
[15:32:31.091]                       invokeRestart <- base::invokeRestart
[15:32:31.091]                       is.null <- base::is.null
[15:32:31.091]                       muffled <- FALSE
[15:32:31.091]                       if (inherits(cond, "message")) {
[15:32:31.091]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:31.091]                         if (muffled) 
[15:32:31.091]                           invokeRestart("muffleMessage")
[15:32:31.091]                       }
[15:32:31.091]                       else if (inherits(cond, "warning")) {
[15:32:31.091]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:31.091]                         if (muffled) 
[15:32:31.091]                           invokeRestart("muffleWarning")
[15:32:31.091]                       }
[15:32:31.091]                       else if (inherits(cond, "condition")) {
[15:32:31.091]                         if (!is.null(pattern)) {
[15:32:31.091]                           computeRestarts <- base::computeRestarts
[15:32:31.091]                           grepl <- base::grepl
[15:32:31.091]                           restarts <- computeRestarts(cond)
[15:32:31.091]                           for (restart in restarts) {
[15:32:31.091]                             name <- restart$name
[15:32:31.091]                             if (is.null(name)) 
[15:32:31.091]                               next
[15:32:31.091]                             if (!grepl(pattern, name)) 
[15:32:31.091]                               next
[15:32:31.091]                             invokeRestart(restart)
[15:32:31.091]                             muffled <- TRUE
[15:32:31.091]                             break
[15:32:31.091]                           }
[15:32:31.091]                         }
[15:32:31.091]                       }
[15:32:31.091]                       invisible(muffled)
[15:32:31.091]                     }
[15:32:31.091]                     muffleCondition(cond, pattern = "^muffle")
[15:32:31.091]                   }
[15:32:31.091]                 }
[15:32:31.091]                 else {
[15:32:31.091]                   if (TRUE) {
[15:32:31.091]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:31.091]                     {
[15:32:31.091]                       inherits <- base::inherits
[15:32:31.091]                       invokeRestart <- base::invokeRestart
[15:32:31.091]                       is.null <- base::is.null
[15:32:31.091]                       muffled <- FALSE
[15:32:31.091]                       if (inherits(cond, "message")) {
[15:32:31.091]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:31.091]                         if (muffled) 
[15:32:31.091]                           invokeRestart("muffleMessage")
[15:32:31.091]                       }
[15:32:31.091]                       else if (inherits(cond, "warning")) {
[15:32:31.091]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:31.091]                         if (muffled) 
[15:32:31.091]                           invokeRestart("muffleWarning")
[15:32:31.091]                       }
[15:32:31.091]                       else if (inherits(cond, "condition")) {
[15:32:31.091]                         if (!is.null(pattern)) {
[15:32:31.091]                           computeRestarts <- base::computeRestarts
[15:32:31.091]                           grepl <- base::grepl
[15:32:31.091]                           restarts <- computeRestarts(cond)
[15:32:31.091]                           for (restart in restarts) {
[15:32:31.091]                             name <- restart$name
[15:32:31.091]                             if (is.null(name)) 
[15:32:31.091]                               next
[15:32:31.091]                             if (!grepl(pattern, name)) 
[15:32:31.091]                               next
[15:32:31.091]                             invokeRestart(restart)
[15:32:31.091]                             muffled <- TRUE
[15:32:31.091]                             break
[15:32:31.091]                           }
[15:32:31.091]                         }
[15:32:31.091]                       }
[15:32:31.091]                       invisible(muffled)
[15:32:31.091]                     }
[15:32:31.091]                     muffleCondition(cond, pattern = "^muffle")
[15:32:31.091]                   }
[15:32:31.091]                 }
[15:32:31.091]             }
[15:32:31.091]         }))
[15:32:31.091]     }, error = function(ex) {
[15:32:31.091]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:31.091]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:31.091]                 ...future.rng), started = ...future.startTime, 
[15:32:31.091]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:31.091]             version = "1.8"), class = "FutureResult")
[15:32:31.091]     }, finally = {
[15:32:31.091]         if (!identical(...future.workdir, getwd())) 
[15:32:31.091]             setwd(...future.workdir)
[15:32:31.091]         {
[15:32:31.091]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:31.091]                 ...future.oldOptions$nwarnings <- NULL
[15:32:31.091]             }
[15:32:31.091]             base::options(...future.oldOptions)
[15:32:31.091]             if (.Platform$OS.type == "windows") {
[15:32:31.091]                 old_names <- names(...future.oldEnvVars)
[15:32:31.091]                 envs <- base::Sys.getenv()
[15:32:31.091]                 names <- names(envs)
[15:32:31.091]                 common <- intersect(names, old_names)
[15:32:31.091]                 added <- setdiff(names, old_names)
[15:32:31.091]                 removed <- setdiff(old_names, names)
[15:32:31.091]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:31.091]                   envs[common]]
[15:32:31.091]                 NAMES <- toupper(changed)
[15:32:31.091]                 args <- list()
[15:32:31.091]                 for (kk in seq_along(NAMES)) {
[15:32:31.091]                   name <- changed[[kk]]
[15:32:31.091]                   NAME <- NAMES[[kk]]
[15:32:31.091]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:31.091]                     next
[15:32:31.091]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:31.091]                 }
[15:32:31.091]                 NAMES <- toupper(added)
[15:32:31.091]                 for (kk in seq_along(NAMES)) {
[15:32:31.091]                   name <- added[[kk]]
[15:32:31.091]                   NAME <- NAMES[[kk]]
[15:32:31.091]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:31.091]                     next
[15:32:31.091]                   args[[name]] <- ""
[15:32:31.091]                 }
[15:32:31.091]                 NAMES <- toupper(removed)
[15:32:31.091]                 for (kk in seq_along(NAMES)) {
[15:32:31.091]                   name <- removed[[kk]]
[15:32:31.091]                   NAME <- NAMES[[kk]]
[15:32:31.091]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:31.091]                     next
[15:32:31.091]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:31.091]                 }
[15:32:31.091]                 if (length(args) > 0) 
[15:32:31.091]                   base::do.call(base::Sys.setenv, args = args)
[15:32:31.091]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:31.091]             }
[15:32:31.091]             else {
[15:32:31.091]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:31.091]             }
[15:32:31.091]             {
[15:32:31.091]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:31.091]                   0L) {
[15:32:31.091]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:31.091]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:31.091]                   base::options(opts)
[15:32:31.091]                 }
[15:32:31.091]                 {
[15:32:31.091]                   {
[15:32:31.091]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:31.091]                     NULL
[15:32:31.091]                   }
[15:32:31.091]                   options(future.plan = NULL)
[15:32:31.091]                   if (is.na(NA_character_)) 
[15:32:31.091]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:31.091]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:31.091]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:31.091]                     .init = FALSE)
[15:32:31.091]                 }
[15:32:31.091]             }
[15:32:31.091]         }
[15:32:31.091]     })
[15:32:31.091]     if (TRUE) {
[15:32:31.091]         base::sink(type = "output", split = FALSE)
[15:32:31.091]         if (TRUE) {
[15:32:31.091]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:31.091]         }
[15:32:31.091]         else {
[15:32:31.091]             ...future.result["stdout"] <- base::list(NULL)
[15:32:31.091]         }
[15:32:31.091]         base::close(...future.stdout)
[15:32:31.091]         ...future.stdout <- NULL
[15:32:31.091]     }
[15:32:31.091]     ...future.result$conditions <- ...future.conditions
[15:32:31.091]     ...future.result$finished <- base::Sys.time()
[15:32:31.091]     ...future.result
[15:32:31.091] }
[15:32:31.102] Exporting 5 global objects (848 bytes) to cluster node #1 ...
[15:32:31.102] Exporting '...future.FUN' (848 bytes) to cluster node #1 ...
[15:32:31.103] Exporting '...future.FUN' (848 bytes) to cluster node #1 ... DONE
[15:32:31.103] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:31.104] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:31.105] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ...
[15:32:31.105] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ... DONE
[15:32:31.106] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:31.106] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:31.107] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:31.107] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:31.107] Exporting 5 global objects (848 bytes) to cluster node #1 ... DONE
[15:32:31.108] MultisessionFuture started
[15:32:31.109] - Launch lazy future ... done
[15:32:31.109] run() for 'MultisessionFuture' ... done
[15:32:31.109] Created future:
[15:32:31.138] receiveMessageFromWorker() for ClusterFuture ...
[15:32:31.138] - Validating connection of MultisessionFuture
[15:32:31.138] - received message: FutureResult
[15:32:31.139] - Received FutureResult
[15:32:31.139] - Erased future from FutureRegistry
[15:32:31.139] result() for ClusterFuture ...
[15:32:31.139] - result already collected: FutureResult
[15:32:31.139] result() for ClusterFuture ... done
[15:32:31.140] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:31.110] MultisessionFuture:
[15:32:31.110] Label: 'future_sapply-2'
[15:32:31.110] Expression:
[15:32:31.110] {
[15:32:31.110]     do.call(function(...) {
[15:32:31.110]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:31.110]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:31.110]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:31.110]             on.exit(options(oopts), add = TRUE)
[15:32:31.110]         }
[15:32:31.110]         {
[15:32:31.110]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:31.110]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:31.110]                 ...future.FUN(...future.X_jj, ...)
[15:32:31.110]             })
[15:32:31.110]         }
[15:32:31.110]     }, args = future.call.arguments)
[15:32:31.110] }
[15:32:31.110] Lazy evaluation: FALSE
[15:32:31.110] Asynchronous evaluation: TRUE
[15:32:31.110] Local evaluation: TRUE
[15:32:31.110] Environment: R_GlobalEnv
[15:32:31.110] Capture standard output: TRUE
[15:32:31.110] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:31.110] Globals: 5 objects totaling 0.99 KiB (function '...future.FUN' of 848 bytes, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:31.110] Packages: <none>
[15:32:31.110] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:31.110] Resolved: TRUE
[15:32:31.110] Value: <not collected>
[15:32:31.110] Conditions captured: <none>
[15:32:31.110] Early signaling: FALSE
[15:32:31.110] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:31.110] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:31.141] Chunk #2 of 2 ... DONE
[15:32:31.141] Launching 2 futures (chunks) ... DONE
[15:32:31.141] Resolving 2 futures (chunks) ...
[15:32:31.141] resolve() on list ...
[15:32:31.142]  recursive: 0
[15:32:31.142]  length: 2
[15:32:31.142] 
[15:32:31.142] Future #1
[15:32:31.143] result() for ClusterFuture ...
[15:32:31.143] - result already collected: FutureResult
[15:32:31.143] result() for ClusterFuture ... done
[15:32:31.143] result() for ClusterFuture ...
[15:32:31.144] - result already collected: FutureResult
[15:32:31.144] result() for ClusterFuture ... done
[15:32:31.144] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:31.144] - nx: 2
[15:32:31.145] - relay: TRUE
[15:32:31.145] - stdout: TRUE
[15:32:31.145] - signal: TRUE
[15:32:31.145] - resignal: FALSE
[15:32:31.146] - force: TRUE
[15:32:31.146] - relayed: [n=2] FALSE, FALSE
[15:32:31.146] - queued futures: [n=2] FALSE, FALSE
[15:32:31.146]  - until=1
[15:32:31.147]  - relaying element #1
[15:32:31.147] result() for ClusterFuture ...
[15:32:31.147] - result already collected: FutureResult
[15:32:31.147] result() for ClusterFuture ... done
[15:32:31.148] result() for ClusterFuture ...
[15:32:31.148] - result already collected: FutureResult
[15:32:31.148] result() for ClusterFuture ... done
[15:32:31.148] result() for ClusterFuture ...
[15:32:31.149] - result already collected: FutureResult
[15:32:31.149] result() for ClusterFuture ... done
[15:32:31.149] result() for ClusterFuture ...
[15:32:31.149] - result already collected: FutureResult
[15:32:31.150] result() for ClusterFuture ... done
[15:32:31.150] - relayed: [n=2] TRUE, FALSE
[15:32:31.150] - queued futures: [n=2] TRUE, FALSE
[15:32:31.150] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:31.151]  length: 1 (resolved future 1)
[15:32:31.151] Future #2
[15:32:31.151] result() for ClusterFuture ...
[15:32:31.151] - result already collected: FutureResult
[15:32:31.152] result() for ClusterFuture ... done
[15:32:31.152] result() for ClusterFuture ...
[15:32:31.152] - result already collected: FutureResult
[15:32:31.152] result() for ClusterFuture ... done
[15:32:31.152] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:31.153] - nx: 2
[15:32:31.153] - relay: TRUE
[15:32:31.153] - stdout: TRUE
[15:32:31.153] - signal: TRUE
[15:32:31.153] - resignal: FALSE
[15:32:31.153] - force: TRUE
[15:32:31.153] - relayed: [n=2] TRUE, FALSE
[15:32:31.154] - queued futures: [n=2] TRUE, FALSE
[15:32:31.154]  - until=2
[15:32:31.154]  - relaying element #2
[15:32:31.154] result() for ClusterFuture ...
[15:32:31.154] - result already collected: FutureResult
[15:32:31.154] result() for ClusterFuture ... done
[15:32:31.155] result() for ClusterFuture ...
[15:32:31.155] - result already collected: FutureResult
[15:32:31.155] result() for ClusterFuture ... done
[15:32:31.155] result() for ClusterFuture ...
[15:32:31.155] - result already collected: FutureResult
[15:32:31.155] result() for ClusterFuture ... done
[15:32:31.156] result() for ClusterFuture ...
[15:32:31.156] - result already collected: FutureResult
[15:32:31.156] result() for ClusterFuture ... done
[15:32:31.156] - relayed: [n=2] TRUE, TRUE
[15:32:31.156] - queued futures: [n=2] TRUE, TRUE
[15:32:31.157] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:31.157]  length: 0 (resolved future 2)
[15:32:31.157] Relaying remaining futures
[15:32:31.157] signalConditionsASAP(NULL, pos=0) ...
[15:32:31.157] - nx: 2
[15:32:31.157] - relay: TRUE
[15:32:31.157] - stdout: TRUE
[15:32:31.158] - signal: TRUE
[15:32:31.158] - resignal: FALSE
[15:32:31.158] - force: TRUE
[15:32:31.158] - relayed: [n=2] TRUE, TRUE
[15:32:31.158] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:31.159] - relayed: [n=2] TRUE, TRUE
[15:32:31.159] - queued futures: [n=2] TRUE, TRUE
[15:32:31.159] signalConditionsASAP(NULL, pos=0) ... done
[15:32:31.159] resolve() on list ... DONE
[15:32:31.159] result() for ClusterFuture ...
[15:32:31.160] - result already collected: FutureResult
[15:32:31.160] result() for ClusterFuture ... done
[15:32:31.160] result() for ClusterFuture ...
[15:32:31.160] - result already collected: FutureResult
[15:32:31.161] result() for ClusterFuture ... done
[15:32:31.161] result() for ClusterFuture ...
[15:32:31.161] - result already collected: FutureResult
[15:32:31.161] result() for ClusterFuture ... done
[15:32:31.162] result() for ClusterFuture ...
[15:32:31.162] - result already collected: FutureResult
[15:32:31.162] result() for ClusterFuture ... done
[15:32:31.163]  - Number of value chunks collected: 2
[15:32:31.163] Resolving 2 futures (chunks) ... DONE
[15:32:31.163] Reducing values from 2 chunks ...
[15:32:31.163]  - Number of values collected after concatenation: 6
[15:32:31.164]  - Number of values expected: 6
[15:32:31.164] Reducing values from 2 chunks ... DONE
[15:32:31.164] future_lapply() ... DONE
List of 2
 $ y0:List of 6
  ..$ a1: int 1
  ..$ a2: int 2
  ..$ b1: int 2
  ..$ b2: int 3
  ..$ c1: int 3
  ..$ c2: int 4
 $ y1:List of 6
  ..$ a1: int 1
  ..$ a2: int 2
  ..$ b1: int 2
  ..$ b2: int 3
  ..$ c1: int 3
  ..$ c2: int 4
List of 2
 $ y0:List of 6
  ..$ a1: int 1
  ..$ a2: int 2
  ..$ b1: int 2
  ..$ b2: int 3
  ..$ c1: int 3
  ..$ c2: int 4
 $ y2:List of 6
  ..$ a1: int 1
  ..$ a2: int 2
  ..$ b1: int 2
  ..$ b2: int 3
  ..$ c1: int 3
  ..$ c2: int 4
[15:32:31.182] future_lapply() ...
[15:32:31.186] Number of chunks: 2
[15:32:31.187] getGlobalsAndPackagesXApply() ...
[15:32:31.187]  - future.globals: TRUE
[15:32:31.187] getGlobalsAndPackages() ...
[15:32:31.188] Searching for globals...
[15:32:31.190] - globals found: [2] 'FUN', 'UseMethod'
[15:32:31.190] Searching for globals ... DONE
[15:32:31.190] Resolving globals: FALSE
[15:32:31.191] The total size of the 1 globals is 1.22 KiB (1248 bytes)
[15:32:31.192] The total size of the 1 globals exported for future expression ('FUN()') is 1.22 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.22 KiB of class 'function')
[15:32:31.192] - globals: [1] 'FUN'
[15:32:31.192] 
[15:32:31.192] getGlobalsAndPackages() ... DONE
[15:32:31.193]  - globals found/used: [n=1] 'FUN'
[15:32:31.193]  - needed namespaces: [n=0] 
[15:32:31.193] Finding globals ... DONE
[15:32:31.193]  - use_args: TRUE
[15:32:31.194]  - Getting '...' globals ...
[15:32:31.194] resolve() on list ...
[15:32:31.195]  recursive: 0
[15:32:31.195]  length: 1
[15:32:31.195]  elements: '...'
[15:32:31.195]  length: 0 (resolved future 1)
[15:32:31.196] resolve() on list ... DONE
[15:32:31.196]    - '...' content: [n=0] 
[15:32:31.196] List of 1
[15:32:31.196]  $ ...: list()
[15:32:31.196]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:31.196]  - attr(*, "where")=List of 1
[15:32:31.196]   ..$ ...:<environment: 0x00000276e5d97060> 
[15:32:31.196]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:31.196]  - attr(*, "resolved")= logi TRUE
[15:32:31.196]  - attr(*, "total_size")= num NA
[15:32:31.201]  - Getting '...' globals ... DONE
[15:32:31.201] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:31.202] List of 2
[15:32:31.202]  $ ...future.FUN:function (x, ...)  
[15:32:31.202]  $ ...          : list()
[15:32:31.202]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:31.202]  - attr(*, "where")=List of 2
[15:32:31.202]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:31.202]   ..$ ...          :<environment: 0x00000276e5d97060> 
[15:32:31.202]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:31.202]  - attr(*, "resolved")= logi FALSE
[15:32:31.202]  - attr(*, "total_size")= num 1248
[15:32:31.206] Packages to be attached in all futures: [n=0] 
[15:32:31.207] getGlobalsAndPackagesXApply() ... DONE
[15:32:31.207] Number of futures (= number of chunks): 2
[15:32:31.208] Launching 2 futures (chunks) ...
[15:32:31.208] Chunk #1 of 2 ...
[15:32:31.208]  - Finding globals in 'X' for chunk #1 ...
[15:32:31.208] getGlobalsAndPackages() ...
[15:32:31.209] Searching for globals...
[15:32:31.209] 
[15:32:31.209] Searching for globals ... DONE
[15:32:31.210] - globals: [0] <none>
[15:32:31.210] getGlobalsAndPackages() ... DONE
[15:32:31.210]    + additional globals found: [n=0] 
[15:32:31.210]    + additional namespaces needed: [n=0] 
[15:32:31.211]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:31.211]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:31.211]  - seeds: <none>
[15:32:31.211]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:31.212] getGlobalsAndPackages() ...
[15:32:31.212] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:31.212] Resolving globals: FALSE
[15:32:31.212] Tweak future expression to call with '...' arguments ...
[15:32:31.213] {
[15:32:31.213]     do.call(function(...) {
[15:32:31.213]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:31.213]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:31.213]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:31.213]             on.exit(options(oopts), add = TRUE)
[15:32:31.213]         }
[15:32:31.213]         {
[15:32:31.213]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:31.213]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:31.213]                 ...future.FUN(...future.X_jj, ...)
[15:32:31.213]             })
[15:32:31.213]         }
[15:32:31.213]     }, args = future.call.arguments)
[15:32:31.213] }
[15:32:31.213] Tweak future expression to call with '...' arguments ... DONE
[15:32:31.214] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:31.214] 
[15:32:31.215] getGlobalsAndPackages() ... DONE
[15:32:31.215] run() for 'Future' ...
[15:32:31.216] - state: 'created'
[15:32:31.216] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:31.233] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:31.234] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:31.234]   - Field: 'node'
[15:32:31.235]   - Field: 'label'
[15:32:31.235]   - Field: 'local'
[15:32:31.235]   - Field: 'owner'
[15:32:31.236]   - Field: 'envir'
[15:32:31.236]   - Field: 'workers'
[15:32:31.236]   - Field: 'packages'
[15:32:31.237]   - Field: 'gc'
[15:32:31.237]   - Field: 'conditions'
[15:32:31.237]   - Field: 'persistent'
[15:32:31.237]   - Field: 'expr'
[15:32:31.238]   - Field: 'uuid'
[15:32:31.238]   - Field: 'seed'
[15:32:31.238]   - Field: 'version'
[15:32:31.239]   - Field: 'result'
[15:32:31.239]   - Field: 'asynchronous'
[15:32:31.239]   - Field: 'calls'
[15:32:31.239]   - Field: 'globals'
[15:32:31.240]   - Field: 'stdout'
[15:32:31.240]   - Field: 'earlySignal'
[15:32:31.240]   - Field: 'lazy'
[15:32:31.241]   - Field: 'state'
[15:32:31.241] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:31.241] - Launch lazy future ...
[15:32:31.242] Packages needed by the future expression (n = 0): <none>
[15:32:31.242] Packages needed by future strategies (n = 0): <none>
[15:32:31.243] {
[15:32:31.243]     {
[15:32:31.243]         {
[15:32:31.243]             ...future.startTime <- base::Sys.time()
[15:32:31.243]             {
[15:32:31.243]                 {
[15:32:31.243]                   {
[15:32:31.243]                     {
[15:32:31.243]                       base::local({
[15:32:31.243]                         has_future <- base::requireNamespace("future", 
[15:32:31.243]                           quietly = TRUE)
[15:32:31.243]                         if (has_future) {
[15:32:31.243]                           ns <- base::getNamespace("future")
[15:32:31.243]                           version <- ns[[".package"]][["version"]]
[15:32:31.243]                           if (is.null(version)) 
[15:32:31.243]                             version <- utils::packageVersion("future")
[15:32:31.243]                         }
[15:32:31.243]                         else {
[15:32:31.243]                           version <- NULL
[15:32:31.243]                         }
[15:32:31.243]                         if (!has_future || version < "1.8.0") {
[15:32:31.243]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:31.243]                             "", base::R.version$version.string), 
[15:32:31.243]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:31.243]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:31.243]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:31.243]                               "release", "version")], collapse = " "), 
[15:32:31.243]                             hostname = base::Sys.info()[["nodename"]])
[15:32:31.243]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:31.243]                             info)
[15:32:31.243]                           info <- base::paste(info, collapse = "; ")
[15:32:31.243]                           if (!has_future) {
[15:32:31.243]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:31.243]                               info)
[15:32:31.243]                           }
[15:32:31.243]                           else {
[15:32:31.243]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:31.243]                               info, version)
[15:32:31.243]                           }
[15:32:31.243]                           base::stop(msg)
[15:32:31.243]                         }
[15:32:31.243]                       })
[15:32:31.243]                     }
[15:32:31.243]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:31.243]                     base::options(mc.cores = 1L)
[15:32:31.243]                   }
[15:32:31.243]                   ...future.strategy.old <- future::plan("list")
[15:32:31.243]                   options(future.plan = NULL)
[15:32:31.243]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:31.243]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:31.243]                 }
[15:32:31.243]                 ...future.workdir <- getwd()
[15:32:31.243]             }
[15:32:31.243]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:31.243]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:31.243]         }
[15:32:31.243]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:31.243]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:31.243]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:31.243]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:31.243]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:31.243]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:31.243]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:31.243]             base::names(...future.oldOptions))
[15:32:31.243]     }
[15:32:31.243]     if (FALSE) {
[15:32:31.243]     }
[15:32:31.243]     else {
[15:32:31.243]         if (TRUE) {
[15:32:31.243]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:31.243]                 open = "w")
[15:32:31.243]         }
[15:32:31.243]         else {
[15:32:31.243]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:31.243]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:31.243]         }
[15:32:31.243]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:31.243]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:31.243]             base::sink(type = "output", split = FALSE)
[15:32:31.243]             base::close(...future.stdout)
[15:32:31.243]         }, add = TRUE)
[15:32:31.243]     }
[15:32:31.243]     ...future.frame <- base::sys.nframe()
[15:32:31.243]     ...future.conditions <- base::list()
[15:32:31.243]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:31.243]     if (FALSE) {
[15:32:31.243]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:31.243]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:31.243]     }
[15:32:31.243]     ...future.result <- base::tryCatch({
[15:32:31.243]         base::withCallingHandlers({
[15:32:31.243]             ...future.value <- base::withVisible(base::local({
[15:32:31.243]                 ...future.makeSendCondition <- base::local({
[15:32:31.243]                   sendCondition <- NULL
[15:32:31.243]                   function(frame = 1L) {
[15:32:31.243]                     if (is.function(sendCondition)) 
[15:32:31.243]                       return(sendCondition)
[15:32:31.243]                     ns <- getNamespace("parallel")
[15:32:31.243]                     if (exists("sendData", mode = "function", 
[15:32:31.243]                       envir = ns)) {
[15:32:31.243]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:31.243]                         envir = ns)
[15:32:31.243]                       envir <- sys.frame(frame)
[15:32:31.243]                       master <- NULL
[15:32:31.243]                       while (!identical(envir, .GlobalEnv) && 
[15:32:31.243]                         !identical(envir, emptyenv())) {
[15:32:31.243]                         if (exists("master", mode = "list", envir = envir, 
[15:32:31.243]                           inherits = FALSE)) {
[15:32:31.243]                           master <- get("master", mode = "list", 
[15:32:31.243]                             envir = envir, inherits = FALSE)
[15:32:31.243]                           if (inherits(master, c("SOCKnode", 
[15:32:31.243]                             "SOCK0node"))) {
[15:32:31.243]                             sendCondition <<- function(cond) {
[15:32:31.243]                               data <- list(type = "VALUE", value = cond, 
[15:32:31.243]                                 success = TRUE)
[15:32:31.243]                               parallel_sendData(master, data)
[15:32:31.243]                             }
[15:32:31.243]                             return(sendCondition)
[15:32:31.243]                           }
[15:32:31.243]                         }
[15:32:31.243]                         frame <- frame + 1L
[15:32:31.243]                         envir <- sys.frame(frame)
[15:32:31.243]                       }
[15:32:31.243]                     }
[15:32:31.243]                     sendCondition <<- function(cond) NULL
[15:32:31.243]                   }
[15:32:31.243]                 })
[15:32:31.243]                 withCallingHandlers({
[15:32:31.243]                   {
[15:32:31.243]                     do.call(function(...) {
[15:32:31.243]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:31.243]                       if (!identical(...future.globals.maxSize.org, 
[15:32:31.243]                         ...future.globals.maxSize)) {
[15:32:31.243]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:31.243]                         on.exit(options(oopts), add = TRUE)
[15:32:31.243]                       }
[15:32:31.243]                       {
[15:32:31.243]                         lapply(seq_along(...future.elements_ii), 
[15:32:31.243]                           FUN = function(jj) {
[15:32:31.243]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:31.243]                             ...future.FUN(...future.X_jj, ...)
[15:32:31.243]                           })
[15:32:31.243]                       }
[15:32:31.243]                     }, args = future.call.arguments)
[15:32:31.243]                   }
[15:32:31.243]                 }, immediateCondition = function(cond) {
[15:32:31.243]                   sendCondition <- ...future.makeSendCondition()
[15:32:31.243]                   sendCondition(cond)
[15:32:31.243]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:31.243]                   {
[15:32:31.243]                     inherits <- base::inherits
[15:32:31.243]                     invokeRestart <- base::invokeRestart
[15:32:31.243]                     is.null <- base::is.null
[15:32:31.243]                     muffled <- FALSE
[15:32:31.243]                     if (inherits(cond, "message")) {
[15:32:31.243]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:31.243]                       if (muffled) 
[15:32:31.243]                         invokeRestart("muffleMessage")
[15:32:31.243]                     }
[15:32:31.243]                     else if (inherits(cond, "warning")) {
[15:32:31.243]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:31.243]                       if (muffled) 
[15:32:31.243]                         invokeRestart("muffleWarning")
[15:32:31.243]                     }
[15:32:31.243]                     else if (inherits(cond, "condition")) {
[15:32:31.243]                       if (!is.null(pattern)) {
[15:32:31.243]                         computeRestarts <- base::computeRestarts
[15:32:31.243]                         grepl <- base::grepl
[15:32:31.243]                         restarts <- computeRestarts(cond)
[15:32:31.243]                         for (restart in restarts) {
[15:32:31.243]                           name <- restart$name
[15:32:31.243]                           if (is.null(name)) 
[15:32:31.243]                             next
[15:32:31.243]                           if (!grepl(pattern, name)) 
[15:32:31.243]                             next
[15:32:31.243]                           invokeRestart(restart)
[15:32:31.243]                           muffled <- TRUE
[15:32:31.243]                           break
[15:32:31.243]                         }
[15:32:31.243]                       }
[15:32:31.243]                     }
[15:32:31.243]                     invisible(muffled)
[15:32:31.243]                   }
[15:32:31.243]                   muffleCondition(cond)
[15:32:31.243]                 })
[15:32:31.243]             }))
[15:32:31.243]             future::FutureResult(value = ...future.value$value, 
[15:32:31.243]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:31.243]                   ...future.rng), globalenv = if (FALSE) 
[15:32:31.243]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:31.243]                     ...future.globalenv.names))
[15:32:31.243]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:31.243]         }, condition = base::local({
[15:32:31.243]             c <- base::c
[15:32:31.243]             inherits <- base::inherits
[15:32:31.243]             invokeRestart <- base::invokeRestart
[15:32:31.243]             length <- base::length
[15:32:31.243]             list <- base::list
[15:32:31.243]             seq.int <- base::seq.int
[15:32:31.243]             signalCondition <- base::signalCondition
[15:32:31.243]             sys.calls <- base::sys.calls
[15:32:31.243]             `[[` <- base::`[[`
[15:32:31.243]             `+` <- base::`+`
[15:32:31.243]             `<<-` <- base::`<<-`
[15:32:31.243]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:31.243]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:31.243]                   3L)]
[15:32:31.243]             }
[15:32:31.243]             function(cond) {
[15:32:31.243]                 is_error <- inherits(cond, "error")
[15:32:31.243]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:31.243]                   NULL)
[15:32:31.243]                 if (is_error) {
[15:32:31.243]                   sessionInformation <- function() {
[15:32:31.243]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:31.243]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:31.243]                       search = base::search(), system = base::Sys.info())
[15:32:31.243]                   }
[15:32:31.243]                   ...future.conditions[[length(...future.conditions) + 
[15:32:31.243]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:31.243]                     cond$call), session = sessionInformation(), 
[15:32:31.243]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:31.243]                   signalCondition(cond)
[15:32:31.243]                 }
[15:32:31.243]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:31.243]                 "immediateCondition"))) {
[15:32:31.243]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:31.243]                   ...future.conditions[[length(...future.conditions) + 
[15:32:31.243]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:31.243]                   if (TRUE && !signal) {
[15:32:31.243]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:31.243]                     {
[15:32:31.243]                       inherits <- base::inherits
[15:32:31.243]                       invokeRestart <- base::invokeRestart
[15:32:31.243]                       is.null <- base::is.null
[15:32:31.243]                       muffled <- FALSE
[15:32:31.243]                       if (inherits(cond, "message")) {
[15:32:31.243]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:31.243]                         if (muffled) 
[15:32:31.243]                           invokeRestart("muffleMessage")
[15:32:31.243]                       }
[15:32:31.243]                       else if (inherits(cond, "warning")) {
[15:32:31.243]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:31.243]                         if (muffled) 
[15:32:31.243]                           invokeRestart("muffleWarning")
[15:32:31.243]                       }
[15:32:31.243]                       else if (inherits(cond, "condition")) {
[15:32:31.243]                         if (!is.null(pattern)) {
[15:32:31.243]                           computeRestarts <- base::computeRestarts
[15:32:31.243]                           grepl <- base::grepl
[15:32:31.243]                           restarts <- computeRestarts(cond)
[15:32:31.243]                           for (restart in restarts) {
[15:32:31.243]                             name <- restart$name
[15:32:31.243]                             if (is.null(name)) 
[15:32:31.243]                               next
[15:32:31.243]                             if (!grepl(pattern, name)) 
[15:32:31.243]                               next
[15:32:31.243]                             invokeRestart(restart)
[15:32:31.243]                             muffled <- TRUE
[15:32:31.243]                             break
[15:32:31.243]                           }
[15:32:31.243]                         }
[15:32:31.243]                       }
[15:32:31.243]                       invisible(muffled)
[15:32:31.243]                     }
[15:32:31.243]                     muffleCondition(cond, pattern = "^muffle")
[15:32:31.243]                   }
[15:32:31.243]                 }
[15:32:31.243]                 else {
[15:32:31.243]                   if (TRUE) {
[15:32:31.243]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:31.243]                     {
[15:32:31.243]                       inherits <- base::inherits
[15:32:31.243]                       invokeRestart <- base::invokeRestart
[15:32:31.243]                       is.null <- base::is.null
[15:32:31.243]                       muffled <- FALSE
[15:32:31.243]                       if (inherits(cond, "message")) {
[15:32:31.243]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:31.243]                         if (muffled) 
[15:32:31.243]                           invokeRestart("muffleMessage")
[15:32:31.243]                       }
[15:32:31.243]                       else if (inherits(cond, "warning")) {
[15:32:31.243]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:31.243]                         if (muffled) 
[15:32:31.243]                           invokeRestart("muffleWarning")
[15:32:31.243]                       }
[15:32:31.243]                       else if (inherits(cond, "condition")) {
[15:32:31.243]                         if (!is.null(pattern)) {
[15:32:31.243]                           computeRestarts <- base::computeRestarts
[15:32:31.243]                           grepl <- base::grepl
[15:32:31.243]                           restarts <- computeRestarts(cond)
[15:32:31.243]                           for (restart in restarts) {
[15:32:31.243]                             name <- restart$name
[15:32:31.243]                             if (is.null(name)) 
[15:32:31.243]                               next
[15:32:31.243]                             if (!grepl(pattern, name)) 
[15:32:31.243]                               next
[15:32:31.243]                             invokeRestart(restart)
[15:32:31.243]                             muffled <- TRUE
[15:32:31.243]                             break
[15:32:31.243]                           }
[15:32:31.243]                         }
[15:32:31.243]                       }
[15:32:31.243]                       invisible(muffled)
[15:32:31.243]                     }
[15:32:31.243]                     muffleCondition(cond, pattern = "^muffle")
[15:32:31.243]                   }
[15:32:31.243]                 }
[15:32:31.243]             }
[15:32:31.243]         }))
[15:32:31.243]     }, error = function(ex) {
[15:32:31.243]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:31.243]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:31.243]                 ...future.rng), started = ...future.startTime, 
[15:32:31.243]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:31.243]             version = "1.8"), class = "FutureResult")
[15:32:31.243]     }, finally = {
[15:32:31.243]         if (!identical(...future.workdir, getwd())) 
[15:32:31.243]             setwd(...future.workdir)
[15:32:31.243]         {
[15:32:31.243]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:31.243]                 ...future.oldOptions$nwarnings <- NULL
[15:32:31.243]             }
[15:32:31.243]             base::options(...future.oldOptions)
[15:32:31.243]             if (.Platform$OS.type == "windows") {
[15:32:31.243]                 old_names <- names(...future.oldEnvVars)
[15:32:31.243]                 envs <- base::Sys.getenv()
[15:32:31.243]                 names <- names(envs)
[15:32:31.243]                 common <- intersect(names, old_names)
[15:32:31.243]                 added <- setdiff(names, old_names)
[15:32:31.243]                 removed <- setdiff(old_names, names)
[15:32:31.243]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:31.243]                   envs[common]]
[15:32:31.243]                 NAMES <- toupper(changed)
[15:32:31.243]                 args <- list()
[15:32:31.243]                 for (kk in seq_along(NAMES)) {
[15:32:31.243]                   name <- changed[[kk]]
[15:32:31.243]                   NAME <- NAMES[[kk]]
[15:32:31.243]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:31.243]                     next
[15:32:31.243]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:31.243]                 }
[15:32:31.243]                 NAMES <- toupper(added)
[15:32:31.243]                 for (kk in seq_along(NAMES)) {
[15:32:31.243]                   name <- added[[kk]]
[15:32:31.243]                   NAME <- NAMES[[kk]]
[15:32:31.243]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:31.243]                     next
[15:32:31.243]                   args[[name]] <- ""
[15:32:31.243]                 }
[15:32:31.243]                 NAMES <- toupper(removed)
[15:32:31.243]                 for (kk in seq_along(NAMES)) {
[15:32:31.243]                   name <- removed[[kk]]
[15:32:31.243]                   NAME <- NAMES[[kk]]
[15:32:31.243]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:31.243]                     next
[15:32:31.243]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:31.243]                 }
[15:32:31.243]                 if (length(args) > 0) 
[15:32:31.243]                   base::do.call(base::Sys.setenv, args = args)
[15:32:31.243]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:31.243]             }
[15:32:31.243]             else {
[15:32:31.243]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:31.243]             }
[15:32:31.243]             {
[15:32:31.243]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:31.243]                   0L) {
[15:32:31.243]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:31.243]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:31.243]                   base::options(opts)
[15:32:31.243]                 }
[15:32:31.243]                 {
[15:32:31.243]                   {
[15:32:31.243]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:31.243]                     NULL
[15:32:31.243]                   }
[15:32:31.243]                   options(future.plan = NULL)
[15:32:31.243]                   if (is.na(NA_character_)) 
[15:32:31.243]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:31.243]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:31.243]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:31.243]                     .init = FALSE)
[15:32:31.243]                 }
[15:32:31.243]             }
[15:32:31.243]         }
[15:32:31.243]     })
[15:32:31.243]     if (TRUE) {
[15:32:31.243]         base::sink(type = "output", split = FALSE)
[15:32:31.243]         if (TRUE) {
[15:32:31.243]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:31.243]         }
[15:32:31.243]         else {
[15:32:31.243]             ...future.result["stdout"] <- base::list(NULL)
[15:32:31.243]         }
[15:32:31.243]         base::close(...future.stdout)
[15:32:31.243]         ...future.stdout <- NULL
[15:32:31.243]     }
[15:32:31.243]     ...future.result$conditions <- ...future.conditions
[15:32:31.243]     ...future.result$finished <- base::Sys.time()
[15:32:31.243]     ...future.result
[15:32:31.243] }
[15:32:31.250] Exporting 5 global objects (1.22 KiB) to cluster node #1 ...
[15:32:31.250] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ...
[15:32:31.251] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ... DONE
[15:32:31.252] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:31.252] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:31.253] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ...
[15:32:31.253] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ... DONE
[15:32:31.254] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:31.254] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:31.254] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:31.255] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:31.255] Exporting 5 global objects (1.22 KiB) to cluster node #1 ... DONE
[15:32:31.256] MultisessionFuture started
[15:32:31.256] - Launch lazy future ... done
[15:32:31.256] run() for 'MultisessionFuture' ... done
[15:32:31.256] Created future:
[15:32:31.284] receiveMessageFromWorker() for ClusterFuture ...
[15:32:31.285] - Validating connection of MultisessionFuture
[15:32:31.285] - received message: FutureResult
[15:32:31.286] - Received FutureResult
[15:32:31.286] - Erased future from FutureRegistry
[15:32:31.286] result() for ClusterFuture ...
[15:32:31.287] - result already collected: FutureResult
[15:32:31.287] result() for ClusterFuture ... done
[15:32:31.287] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:31.256] MultisessionFuture:
[15:32:31.256] Label: 'future_sapply-1'
[15:32:31.256] Expression:
[15:32:31.256] {
[15:32:31.256]     do.call(function(...) {
[15:32:31.256]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:31.256]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:31.256]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:31.256]             on.exit(options(oopts), add = TRUE)
[15:32:31.256]         }
[15:32:31.256]         {
[15:32:31.256]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:31.256]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:31.256]                 ...future.FUN(...future.X_jj, ...)
[15:32:31.256]             })
[15:32:31.256]         }
[15:32:31.256]     }, args = future.call.arguments)
[15:32:31.256] }
[15:32:31.256] Lazy evaluation: FALSE
[15:32:31.256] Asynchronous evaluation: TRUE
[15:32:31.256] Local evaluation: TRUE
[15:32:31.256] Environment: R_GlobalEnv
[15:32:31.256] Capture standard output: TRUE
[15:32:31.256] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:31.256] Globals: 5 objects totaling 1.38 KiB (function '...future.FUN' of 1.22 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:31.256] Packages: <none>
[15:32:31.256] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:31.256] Resolved: TRUE
[15:32:31.256] Value: <not collected>
[15:32:31.256] Conditions captured: <none>
[15:32:31.256] Early signaling: FALSE
[15:32:31.256] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:31.256] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:31.288] Chunk #1 of 2 ... DONE
[15:32:31.288] Chunk #2 of 2 ...
[15:32:31.289]  - Finding globals in 'X' for chunk #2 ...
[15:32:31.289] getGlobalsAndPackages() ...
[15:32:31.289] Searching for globals...
[15:32:31.290] 
[15:32:31.290] Searching for globals ... DONE
[15:32:31.290] - globals: [0] <none>
[15:32:31.291] getGlobalsAndPackages() ... DONE
[15:32:31.291]    + additional globals found: [n=0] 
[15:32:31.291]    + additional namespaces needed: [n=0] 
[15:32:31.291]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:31.292]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:31.292]  - seeds: <none>
[15:32:31.292]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:31.293] getGlobalsAndPackages() ...
[15:32:31.293] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:31.293] Resolving globals: FALSE
[15:32:31.294] Tweak future expression to call with '...' arguments ...
[15:32:31.294] {
[15:32:31.294]     do.call(function(...) {
[15:32:31.294]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:31.294]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:31.294]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:31.294]             on.exit(options(oopts), add = TRUE)
[15:32:31.294]         }
[15:32:31.294]         {
[15:32:31.294]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:31.294]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:31.294]                 ...future.FUN(...future.X_jj, ...)
[15:32:31.294]             })
[15:32:31.294]         }
[15:32:31.294]     }, args = future.call.arguments)
[15:32:31.294] }
[15:32:31.295] Tweak future expression to call with '...' arguments ... DONE
[15:32:31.296] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:31.296] 
[15:32:31.296] getGlobalsAndPackages() ... DONE
[15:32:31.297] run() for 'Future' ...
[15:32:31.297] - state: 'created'
[15:32:31.297] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:31.315] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:31.316] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:31.316]   - Field: 'node'
[15:32:31.316]   - Field: 'label'
[15:32:31.317]   - Field: 'local'
[15:32:31.317]   - Field: 'owner'
[15:32:31.317]   - Field: 'envir'
[15:32:31.317]   - Field: 'workers'
[15:32:31.318]   - Field: 'packages'
[15:32:31.318]   - Field: 'gc'
[15:32:31.318]   - Field: 'conditions'
[15:32:31.319]   - Field: 'persistent'
[15:32:31.319]   - Field: 'expr'
[15:32:31.319]   - Field: 'uuid'
[15:32:31.320]   - Field: 'seed'
[15:32:31.320]   - Field: 'version'
[15:32:31.320]   - Field: 'result'
[15:32:31.320]   - Field: 'asynchronous'
[15:32:31.321]   - Field: 'calls'
[15:32:31.321]   - Field: 'globals'
[15:32:31.321]   - Field: 'stdout'
[15:32:31.322]   - Field: 'earlySignal'
[15:32:31.322]   - Field: 'lazy'
[15:32:31.322]   - Field: 'state'
[15:32:31.323] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:31.323] - Launch lazy future ...
[15:32:31.324] Packages needed by the future expression (n = 0): <none>
[15:32:31.324] Packages needed by future strategies (n = 0): <none>
[15:32:31.325] {
[15:32:31.325]     {
[15:32:31.325]         {
[15:32:31.325]             ...future.startTime <- base::Sys.time()
[15:32:31.325]             {
[15:32:31.325]                 {
[15:32:31.325]                   {
[15:32:31.325]                     {
[15:32:31.325]                       base::local({
[15:32:31.325]                         has_future <- base::requireNamespace("future", 
[15:32:31.325]                           quietly = TRUE)
[15:32:31.325]                         if (has_future) {
[15:32:31.325]                           ns <- base::getNamespace("future")
[15:32:31.325]                           version <- ns[[".package"]][["version"]]
[15:32:31.325]                           if (is.null(version)) 
[15:32:31.325]                             version <- utils::packageVersion("future")
[15:32:31.325]                         }
[15:32:31.325]                         else {
[15:32:31.325]                           version <- NULL
[15:32:31.325]                         }
[15:32:31.325]                         if (!has_future || version < "1.8.0") {
[15:32:31.325]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:31.325]                             "", base::R.version$version.string), 
[15:32:31.325]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:31.325]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:31.325]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:31.325]                               "release", "version")], collapse = " "), 
[15:32:31.325]                             hostname = base::Sys.info()[["nodename"]])
[15:32:31.325]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:31.325]                             info)
[15:32:31.325]                           info <- base::paste(info, collapse = "; ")
[15:32:31.325]                           if (!has_future) {
[15:32:31.325]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:31.325]                               info)
[15:32:31.325]                           }
[15:32:31.325]                           else {
[15:32:31.325]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:31.325]                               info, version)
[15:32:31.325]                           }
[15:32:31.325]                           base::stop(msg)
[15:32:31.325]                         }
[15:32:31.325]                       })
[15:32:31.325]                     }
[15:32:31.325]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:31.325]                     base::options(mc.cores = 1L)
[15:32:31.325]                   }
[15:32:31.325]                   ...future.strategy.old <- future::plan("list")
[15:32:31.325]                   options(future.plan = NULL)
[15:32:31.325]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:31.325]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:31.325]                 }
[15:32:31.325]                 ...future.workdir <- getwd()
[15:32:31.325]             }
[15:32:31.325]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:31.325]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:31.325]         }
[15:32:31.325]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:31.325]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:31.325]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:31.325]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:31.325]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:31.325]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:31.325]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:31.325]             base::names(...future.oldOptions))
[15:32:31.325]     }
[15:32:31.325]     if (FALSE) {
[15:32:31.325]     }
[15:32:31.325]     else {
[15:32:31.325]         if (TRUE) {
[15:32:31.325]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:31.325]                 open = "w")
[15:32:31.325]         }
[15:32:31.325]         else {
[15:32:31.325]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:31.325]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:31.325]         }
[15:32:31.325]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:31.325]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:31.325]             base::sink(type = "output", split = FALSE)
[15:32:31.325]             base::close(...future.stdout)
[15:32:31.325]         }, add = TRUE)
[15:32:31.325]     }
[15:32:31.325]     ...future.frame <- base::sys.nframe()
[15:32:31.325]     ...future.conditions <- base::list()
[15:32:31.325]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:31.325]     if (FALSE) {
[15:32:31.325]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:31.325]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:31.325]     }
[15:32:31.325]     ...future.result <- base::tryCatch({
[15:32:31.325]         base::withCallingHandlers({
[15:32:31.325]             ...future.value <- base::withVisible(base::local({
[15:32:31.325]                 ...future.makeSendCondition <- base::local({
[15:32:31.325]                   sendCondition <- NULL
[15:32:31.325]                   function(frame = 1L) {
[15:32:31.325]                     if (is.function(sendCondition)) 
[15:32:31.325]                       return(sendCondition)
[15:32:31.325]                     ns <- getNamespace("parallel")
[15:32:31.325]                     if (exists("sendData", mode = "function", 
[15:32:31.325]                       envir = ns)) {
[15:32:31.325]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:31.325]                         envir = ns)
[15:32:31.325]                       envir <- sys.frame(frame)
[15:32:31.325]                       master <- NULL
[15:32:31.325]                       while (!identical(envir, .GlobalEnv) && 
[15:32:31.325]                         !identical(envir, emptyenv())) {
[15:32:31.325]                         if (exists("master", mode = "list", envir = envir, 
[15:32:31.325]                           inherits = FALSE)) {
[15:32:31.325]                           master <- get("master", mode = "list", 
[15:32:31.325]                             envir = envir, inherits = FALSE)
[15:32:31.325]                           if (inherits(master, c("SOCKnode", 
[15:32:31.325]                             "SOCK0node"))) {
[15:32:31.325]                             sendCondition <<- function(cond) {
[15:32:31.325]                               data <- list(type = "VALUE", value = cond, 
[15:32:31.325]                                 success = TRUE)
[15:32:31.325]                               parallel_sendData(master, data)
[15:32:31.325]                             }
[15:32:31.325]                             return(sendCondition)
[15:32:31.325]                           }
[15:32:31.325]                         }
[15:32:31.325]                         frame <- frame + 1L
[15:32:31.325]                         envir <- sys.frame(frame)
[15:32:31.325]                       }
[15:32:31.325]                     }
[15:32:31.325]                     sendCondition <<- function(cond) NULL
[15:32:31.325]                   }
[15:32:31.325]                 })
[15:32:31.325]                 withCallingHandlers({
[15:32:31.325]                   {
[15:32:31.325]                     do.call(function(...) {
[15:32:31.325]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:31.325]                       if (!identical(...future.globals.maxSize.org, 
[15:32:31.325]                         ...future.globals.maxSize)) {
[15:32:31.325]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:31.325]                         on.exit(options(oopts), add = TRUE)
[15:32:31.325]                       }
[15:32:31.325]                       {
[15:32:31.325]                         lapply(seq_along(...future.elements_ii), 
[15:32:31.325]                           FUN = function(jj) {
[15:32:31.325]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:31.325]                             ...future.FUN(...future.X_jj, ...)
[15:32:31.325]                           })
[15:32:31.325]                       }
[15:32:31.325]                     }, args = future.call.arguments)
[15:32:31.325]                   }
[15:32:31.325]                 }, immediateCondition = function(cond) {
[15:32:31.325]                   sendCondition <- ...future.makeSendCondition()
[15:32:31.325]                   sendCondition(cond)
[15:32:31.325]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:31.325]                   {
[15:32:31.325]                     inherits <- base::inherits
[15:32:31.325]                     invokeRestart <- base::invokeRestart
[15:32:31.325]                     is.null <- base::is.null
[15:32:31.325]                     muffled <- FALSE
[15:32:31.325]                     if (inherits(cond, "message")) {
[15:32:31.325]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:31.325]                       if (muffled) 
[15:32:31.325]                         invokeRestart("muffleMessage")
[15:32:31.325]                     }
[15:32:31.325]                     else if (inherits(cond, "warning")) {
[15:32:31.325]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:31.325]                       if (muffled) 
[15:32:31.325]                         invokeRestart("muffleWarning")
[15:32:31.325]                     }
[15:32:31.325]                     else if (inherits(cond, "condition")) {
[15:32:31.325]                       if (!is.null(pattern)) {
[15:32:31.325]                         computeRestarts <- base::computeRestarts
[15:32:31.325]                         grepl <- base::grepl
[15:32:31.325]                         restarts <- computeRestarts(cond)
[15:32:31.325]                         for (restart in restarts) {
[15:32:31.325]                           name <- restart$name
[15:32:31.325]                           if (is.null(name)) 
[15:32:31.325]                             next
[15:32:31.325]                           if (!grepl(pattern, name)) 
[15:32:31.325]                             next
[15:32:31.325]                           invokeRestart(restart)
[15:32:31.325]                           muffled <- TRUE
[15:32:31.325]                           break
[15:32:31.325]                         }
[15:32:31.325]                       }
[15:32:31.325]                     }
[15:32:31.325]                     invisible(muffled)
[15:32:31.325]                   }
[15:32:31.325]                   muffleCondition(cond)
[15:32:31.325]                 })
[15:32:31.325]             }))
[15:32:31.325]             future::FutureResult(value = ...future.value$value, 
[15:32:31.325]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:31.325]                   ...future.rng), globalenv = if (FALSE) 
[15:32:31.325]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:31.325]                     ...future.globalenv.names))
[15:32:31.325]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:31.325]         }, condition = base::local({
[15:32:31.325]             c <- base::c
[15:32:31.325]             inherits <- base::inherits
[15:32:31.325]             invokeRestart <- base::invokeRestart
[15:32:31.325]             length <- base::length
[15:32:31.325]             list <- base::list
[15:32:31.325]             seq.int <- base::seq.int
[15:32:31.325]             signalCondition <- base::signalCondition
[15:32:31.325]             sys.calls <- base::sys.calls
[15:32:31.325]             `[[` <- base::`[[`
[15:32:31.325]             `+` <- base::`+`
[15:32:31.325]             `<<-` <- base::`<<-`
[15:32:31.325]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:31.325]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:31.325]                   3L)]
[15:32:31.325]             }
[15:32:31.325]             function(cond) {
[15:32:31.325]                 is_error <- inherits(cond, "error")
[15:32:31.325]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:31.325]                   NULL)
[15:32:31.325]                 if (is_error) {
[15:32:31.325]                   sessionInformation <- function() {
[15:32:31.325]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:31.325]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:31.325]                       search = base::search(), system = base::Sys.info())
[15:32:31.325]                   }
[15:32:31.325]                   ...future.conditions[[length(...future.conditions) + 
[15:32:31.325]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:31.325]                     cond$call), session = sessionInformation(), 
[15:32:31.325]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:31.325]                   signalCondition(cond)
[15:32:31.325]                 }
[15:32:31.325]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:31.325]                 "immediateCondition"))) {
[15:32:31.325]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:31.325]                   ...future.conditions[[length(...future.conditions) + 
[15:32:31.325]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:31.325]                   if (TRUE && !signal) {
[15:32:31.325]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:31.325]                     {
[15:32:31.325]                       inherits <- base::inherits
[15:32:31.325]                       invokeRestart <- base::invokeRestart
[15:32:31.325]                       is.null <- base::is.null
[15:32:31.325]                       muffled <- FALSE
[15:32:31.325]                       if (inherits(cond, "message")) {
[15:32:31.325]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:31.325]                         if (muffled) 
[15:32:31.325]                           invokeRestart("muffleMessage")
[15:32:31.325]                       }
[15:32:31.325]                       else if (inherits(cond, "warning")) {
[15:32:31.325]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:31.325]                         if (muffled) 
[15:32:31.325]                           invokeRestart("muffleWarning")
[15:32:31.325]                       }
[15:32:31.325]                       else if (inherits(cond, "condition")) {
[15:32:31.325]                         if (!is.null(pattern)) {
[15:32:31.325]                           computeRestarts <- base::computeRestarts
[15:32:31.325]                           grepl <- base::grepl
[15:32:31.325]                           restarts <- computeRestarts(cond)
[15:32:31.325]                           for (restart in restarts) {
[15:32:31.325]                             name <- restart$name
[15:32:31.325]                             if (is.null(name)) 
[15:32:31.325]                               next
[15:32:31.325]                             if (!grepl(pattern, name)) 
[15:32:31.325]                               next
[15:32:31.325]                             invokeRestart(restart)
[15:32:31.325]                             muffled <- TRUE
[15:32:31.325]                             break
[15:32:31.325]                           }
[15:32:31.325]                         }
[15:32:31.325]                       }
[15:32:31.325]                       invisible(muffled)
[15:32:31.325]                     }
[15:32:31.325]                     muffleCondition(cond, pattern = "^muffle")
[15:32:31.325]                   }
[15:32:31.325]                 }
[15:32:31.325]                 else {
[15:32:31.325]                   if (TRUE) {
[15:32:31.325]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:31.325]                     {
[15:32:31.325]                       inherits <- base::inherits
[15:32:31.325]                       invokeRestart <- base::invokeRestart
[15:32:31.325]                       is.null <- base::is.null
[15:32:31.325]                       muffled <- FALSE
[15:32:31.325]                       if (inherits(cond, "message")) {
[15:32:31.325]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:31.325]                         if (muffled) 
[15:32:31.325]                           invokeRestart("muffleMessage")
[15:32:31.325]                       }
[15:32:31.325]                       else if (inherits(cond, "warning")) {
[15:32:31.325]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:31.325]                         if (muffled) 
[15:32:31.325]                           invokeRestart("muffleWarning")
[15:32:31.325]                       }
[15:32:31.325]                       else if (inherits(cond, "condition")) {
[15:32:31.325]                         if (!is.null(pattern)) {
[15:32:31.325]                           computeRestarts <- base::computeRestarts
[15:32:31.325]                           grepl <- base::grepl
[15:32:31.325]                           restarts <- computeRestarts(cond)
[15:32:31.325]                           for (restart in restarts) {
[15:32:31.325]                             name <- restart$name
[15:32:31.325]                             if (is.null(name)) 
[15:32:31.325]                               next
[15:32:31.325]                             if (!grepl(pattern, name)) 
[15:32:31.325]                               next
[15:32:31.325]                             invokeRestart(restart)
[15:32:31.325]                             muffled <- TRUE
[15:32:31.325]                             break
[15:32:31.325]                           }
[15:32:31.325]                         }
[15:32:31.325]                       }
[15:32:31.325]                       invisible(muffled)
[15:32:31.325]                     }
[15:32:31.325]                     muffleCondition(cond, pattern = "^muffle")
[15:32:31.325]                   }
[15:32:31.325]                 }
[15:32:31.325]             }
[15:32:31.325]         }))
[15:32:31.325]     }, error = function(ex) {
[15:32:31.325]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:31.325]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:31.325]                 ...future.rng), started = ...future.startTime, 
[15:32:31.325]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:31.325]             version = "1.8"), class = "FutureResult")
[15:32:31.325]     }, finally = {
[15:32:31.325]         if (!identical(...future.workdir, getwd())) 
[15:32:31.325]             setwd(...future.workdir)
[15:32:31.325]         {
[15:32:31.325]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:31.325]                 ...future.oldOptions$nwarnings <- NULL
[15:32:31.325]             }
[15:32:31.325]             base::options(...future.oldOptions)
[15:32:31.325]             if (.Platform$OS.type == "windows") {
[15:32:31.325]                 old_names <- names(...future.oldEnvVars)
[15:32:31.325]                 envs <- base::Sys.getenv()
[15:32:31.325]                 names <- names(envs)
[15:32:31.325]                 common <- intersect(names, old_names)
[15:32:31.325]                 added <- setdiff(names, old_names)
[15:32:31.325]                 removed <- setdiff(old_names, names)
[15:32:31.325]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:31.325]                   envs[common]]
[15:32:31.325]                 NAMES <- toupper(changed)
[15:32:31.325]                 args <- list()
[15:32:31.325]                 for (kk in seq_along(NAMES)) {
[15:32:31.325]                   name <- changed[[kk]]
[15:32:31.325]                   NAME <- NAMES[[kk]]
[15:32:31.325]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:31.325]                     next
[15:32:31.325]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:31.325]                 }
[15:32:31.325]                 NAMES <- toupper(added)
[15:32:31.325]                 for (kk in seq_along(NAMES)) {
[15:32:31.325]                   name <- added[[kk]]
[15:32:31.325]                   NAME <- NAMES[[kk]]
[15:32:31.325]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:31.325]                     next
[15:32:31.325]                   args[[name]] <- ""
[15:32:31.325]                 }
[15:32:31.325]                 NAMES <- toupper(removed)
[15:32:31.325]                 for (kk in seq_along(NAMES)) {
[15:32:31.325]                   name <- removed[[kk]]
[15:32:31.325]                   NAME <- NAMES[[kk]]
[15:32:31.325]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:31.325]                     next
[15:32:31.325]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:31.325]                 }
[15:32:31.325]                 if (length(args) > 0) 
[15:32:31.325]                   base::do.call(base::Sys.setenv, args = args)
[15:32:31.325]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:31.325]             }
[15:32:31.325]             else {
[15:32:31.325]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:31.325]             }
[15:32:31.325]             {
[15:32:31.325]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:31.325]                   0L) {
[15:32:31.325]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:31.325]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:31.325]                   base::options(opts)
[15:32:31.325]                 }
[15:32:31.325]                 {
[15:32:31.325]                   {
[15:32:31.325]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:31.325]                     NULL
[15:32:31.325]                   }
[15:32:31.325]                   options(future.plan = NULL)
[15:32:31.325]                   if (is.na(NA_character_)) 
[15:32:31.325]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:31.325]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:31.325]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:31.325]                     .init = FALSE)
[15:32:31.325]                 }
[15:32:31.325]             }
[15:32:31.325]         }
[15:32:31.325]     })
[15:32:31.325]     if (TRUE) {
[15:32:31.325]         base::sink(type = "output", split = FALSE)
[15:32:31.325]         if (TRUE) {
[15:32:31.325]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:31.325]         }
[15:32:31.325]         else {
[15:32:31.325]             ...future.result["stdout"] <- base::list(NULL)
[15:32:31.325]         }
[15:32:31.325]         base::close(...future.stdout)
[15:32:31.325]         ...future.stdout <- NULL
[15:32:31.325]     }
[15:32:31.325]     ...future.result$conditions <- ...future.conditions
[15:32:31.325]     ...future.result$finished <- base::Sys.time()
[15:32:31.325]     ...future.result
[15:32:31.325] }
[15:32:31.334] Exporting 5 global objects (1.22 KiB) to cluster node #1 ...
[15:32:31.335] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ...
[15:32:31.335] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ... DONE
[15:32:31.336] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:31.336] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:31.337] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ...
[15:32:31.337] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ... DONE
[15:32:31.338] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:31.342] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:31.343] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:31.345] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:31.345] Exporting 5 global objects (1.22 KiB) to cluster node #1 ... DONE
[15:32:31.347] MultisessionFuture started
[15:32:31.347] - Launch lazy future ... done
[15:32:31.347] run() for 'MultisessionFuture' ... done
[15:32:31.348] Created future:
[15:32:31.380] receiveMessageFromWorker() for ClusterFuture ...
[15:32:31.381] - Validating connection of MultisessionFuture
[15:32:31.381] - received message: FutureResult
[15:32:31.382] - Received FutureResult
[15:32:31.382] - Erased future from FutureRegistry
[15:32:31.382] result() for ClusterFuture ...
[15:32:31.383] - result already collected: FutureResult
[15:32:31.383] result() for ClusterFuture ... done
[15:32:31.383] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:31.348] MultisessionFuture:
[15:32:31.348] Label: 'future_sapply-2'
[15:32:31.348] Expression:
[15:32:31.348] {
[15:32:31.348]     do.call(function(...) {
[15:32:31.348]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:31.348]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:31.348]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:31.348]             on.exit(options(oopts), add = TRUE)
[15:32:31.348]         }
[15:32:31.348]         {
[15:32:31.348]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:31.348]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:31.348]                 ...future.FUN(...future.X_jj, ...)
[15:32:31.348]             })
[15:32:31.348]         }
[15:32:31.348]     }, args = future.call.arguments)
[15:32:31.348] }
[15:32:31.348] Lazy evaluation: FALSE
[15:32:31.348] Asynchronous evaluation: TRUE
[15:32:31.348] Local evaluation: TRUE
[15:32:31.348] Environment: R_GlobalEnv
[15:32:31.348] Capture standard output: TRUE
[15:32:31.348] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:31.348] Globals: 5 objects totaling 1.38 KiB (function '...future.FUN' of 1.22 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:31.348] Packages: <none>
[15:32:31.348] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:31.348] Resolved: TRUE
[15:32:31.348] Value: <not collected>
[15:32:31.348] Conditions captured: <none>
[15:32:31.348] Early signaling: FALSE
[15:32:31.348] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:31.348] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:31.384] Chunk #2 of 2 ... DONE
[15:32:31.384] Launching 2 futures (chunks) ... DONE
[15:32:31.384] Resolving 2 futures (chunks) ...
[15:32:31.385] resolve() on list ...
[15:32:31.385]  recursive: 0
[15:32:31.385]  length: 2
[15:32:31.385] 
[15:32:31.386] Future #1
[15:32:31.386] result() for ClusterFuture ...
[15:32:31.386] - result already collected: FutureResult
[15:32:31.386] result() for ClusterFuture ... done
[15:32:31.387] result() for ClusterFuture ...
[15:32:31.387] - result already collected: FutureResult
[15:32:31.387] result() for ClusterFuture ... done
[15:32:31.387] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:31.388] - nx: 2
[15:32:31.388] - relay: TRUE
[15:32:31.388] - stdout: TRUE
[15:32:31.388] - signal: TRUE
[15:32:31.388] - resignal: FALSE
[15:32:31.389] - force: TRUE
[15:32:31.389] - relayed: [n=2] FALSE, FALSE
[15:32:31.389] - queued futures: [n=2] FALSE, FALSE
[15:32:31.389]  - until=1
[15:32:31.390]  - relaying element #1
[15:32:31.390] result() for ClusterFuture ...
[15:32:31.390] - result already collected: FutureResult
[15:32:31.390] result() for ClusterFuture ... done
[15:32:31.391] result() for ClusterFuture ...
[15:32:31.391] - result already collected: FutureResult
[15:32:31.391] result() for ClusterFuture ... done
[15:32:31.391] result() for ClusterFuture ...
[15:32:31.392] - result already collected: FutureResult
[15:32:31.392] result() for ClusterFuture ... done
[15:32:31.392] result() for ClusterFuture ...
[15:32:31.392] - result already collected: FutureResult
[15:32:31.393] result() for ClusterFuture ... done
[15:32:31.393] - relayed: [n=2] TRUE, FALSE
[15:32:31.393] - queued futures: [n=2] TRUE, FALSE
[15:32:31.393] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:31.394]  length: 1 (resolved future 1)
[15:32:31.394] Future #2
[15:32:31.394] result() for ClusterFuture ...
[15:32:31.395] - result already collected: FutureResult
[15:32:31.395] result() for ClusterFuture ... done
[15:32:31.395] result() for ClusterFuture ...
[15:32:31.395] - result already collected: FutureResult
[15:32:31.395] result() for ClusterFuture ... done
[15:32:31.396] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:31.396] - nx: 2
[15:32:31.396] - relay: TRUE
[15:32:31.396] - stdout: TRUE
[15:32:31.397] - signal: TRUE
[15:32:31.397] - resignal: FALSE
[15:32:31.397] - force: TRUE
[15:32:31.397] - relayed: [n=2] TRUE, FALSE
[15:32:31.398] - queued futures: [n=2] TRUE, FALSE
[15:32:31.398]  - until=2
[15:32:31.398]  - relaying element #2
[15:32:31.398] result() for ClusterFuture ...
[15:32:31.399] - result already collected: FutureResult
[15:32:31.399] result() for ClusterFuture ... done
[15:32:31.399] result() for ClusterFuture ...
[15:32:31.399] - result already collected: FutureResult
[15:32:31.400] result() for ClusterFuture ... done
[15:32:31.400] result() for ClusterFuture ...
[15:32:31.400] - result already collected: FutureResult
[15:32:31.400] result() for ClusterFuture ... done
[15:32:31.401] result() for ClusterFuture ...
[15:32:31.401] - result already collected: FutureResult
[15:32:31.401] result() for ClusterFuture ... done
[15:32:31.401] - relayed: [n=2] TRUE, TRUE
[15:32:31.402] - queued futures: [n=2] TRUE, TRUE
[15:32:31.402] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:31.402]  length: 0 (resolved future 2)
[15:32:31.403] Relaying remaining futures
[15:32:31.403] signalConditionsASAP(NULL, pos=0) ...
[15:32:31.403] - nx: 2
[15:32:31.403] - relay: TRUE
[15:32:31.403] - stdout: TRUE
[15:32:31.404] - signal: TRUE
[15:32:31.404] - resignal: FALSE
[15:32:31.404] - force: TRUE
[15:32:31.404] - relayed: [n=2] TRUE, TRUE
[15:32:31.405] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:31.405] - relayed: [n=2] TRUE, TRUE
[15:32:31.405] - queued futures: [n=2] TRUE, TRUE
[15:32:31.406] signalConditionsASAP(NULL, pos=0) ... done
[15:32:31.406] resolve() on list ... DONE
[15:32:31.406] result() for ClusterFuture ...
[15:32:31.406] - result already collected: FutureResult
[15:32:31.407] result() for ClusterFuture ... done
[15:32:31.407] result() for ClusterFuture ...
[15:32:31.407] - result already collected: FutureResult
[15:32:31.407] result() for ClusterFuture ... done
[15:32:31.408] result() for ClusterFuture ...
[15:32:31.408] - result already collected: FutureResult
[15:32:31.408] result() for ClusterFuture ... done
[15:32:31.408] result() for ClusterFuture ...
[15:32:31.409] - result already collected: FutureResult
[15:32:31.409] result() for ClusterFuture ... done
[15:32:31.409]  - Number of value chunks collected: 2
[15:32:31.409] Resolving 2 futures (chunks) ... DONE
[15:32:31.410] Reducing values from 2 chunks ...
[15:32:31.410]  - Number of values collected after concatenation: 6
[15:32:31.410]  - Number of values expected: 6
[15:32:31.410] Reducing values from 2 chunks ... DONE
[15:32:31.411] future_lapply() ... DONE
List of 2
 $ y0:List of 6
  ..$ a1: int [1, 1] 1
  ..$ a2: int [1, 1] 2
  ..$ b1: int [1, 1] 2
  ..$ b2: int [1, 1] 3
  ..$ c1: int [1, 1] 3
  ..$ c2: int [1, 1] 4
 $ y1:List of 6
  ..$ a1: int [1, 1] 1
  ..$ a2: int [1, 1] 2
  ..$ b1: int [1, 1] 2
  ..$ b2: int [1, 1] 3
  ..$ c1: int [1, 1] 3
  ..$ c2: int [1, 1] 4
List of 2
 $ y0:List of 6
  ..$ a1: int [1, 1] 1
  ..$ a2: int [1, 1] 2
  ..$ b1: int [1, 1] 2
  ..$ b2: int [1, 1] 3
  ..$ c1: int [1, 1] 3
  ..$ c2: int [1, 1] 4
 $ y2:List of 6
  ..$ a1: int [1, 1] 1
  ..$ a2: int [1, 1] 2
  ..$ b1: int [1, 1] 2
  ..$ b2: int [1, 1] 3
  ..$ c1: int [1, 1] 3
  ..$ c2: int [1, 1] 4
[15:32:31.429] future_lapply() ...
[15:32:31.434] Number of chunks: 2
[15:32:31.434] getGlobalsAndPackagesXApply() ...
[15:32:31.434]  - future.globals: TRUE
[15:32:31.435] getGlobalsAndPackages() ...
[15:32:31.435] Searching for globals...
[15:32:31.438] - globals found: [5] 'FUN', '*', ':', 'outer', 'rep'
[15:32:31.438] Searching for globals ... DONE
[15:32:31.438] Resolving globals: FALSE
[15:32:31.439] The total size of the 1 globals is 4.62 KiB (4728 bytes)
[15:32:31.440] The total size of the 1 globals exported for future expression ('FUN()') is 4.62 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.62 KiB of class 'function')
[15:32:31.440] - globals: [1] 'FUN'
[15:32:31.440] 
[15:32:31.440] getGlobalsAndPackages() ... DONE
[15:32:31.441]  - globals found/used: [n=1] 'FUN'
[15:32:31.441]  - needed namespaces: [n=0] 
[15:32:31.441] Finding globals ... DONE
[15:32:31.441]  - use_args: TRUE
[15:32:31.442]  - Getting '...' globals ...
[15:32:31.442] resolve() on list ...
[15:32:31.442]  recursive: 0
[15:32:31.443]  length: 1
[15:32:31.443]  elements: '...'
[15:32:31.443]  length: 0 (resolved future 1)
[15:32:31.444] resolve() on list ... DONE
[15:32:31.444]    - '...' content: [n=0] 
[15:32:31.444] List of 1
[15:32:31.444]  $ ...: list()
[15:32:31.444]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:31.444]  - attr(*, "where")=List of 1
[15:32:31.444]   ..$ ...:<environment: 0x00000276de912768> 
[15:32:31.444]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:31.444]  - attr(*, "resolved")= logi TRUE
[15:32:31.444]  - attr(*, "total_size")= num NA
[15:32:31.449]  - Getting '...' globals ... DONE
[15:32:31.449] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:31.449] List of 2
[15:32:31.449]  $ ...future.FUN:function (x, y = 2 * 1:5)  
[15:32:31.449]  $ ...          : list()
[15:32:31.449]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:31.449]  - attr(*, "where")=List of 2
[15:32:31.449]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:31.449]   ..$ ...          :<environment: 0x00000276de912768> 
[15:32:31.449]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:31.449]  - attr(*, "resolved")= logi FALSE
[15:32:31.449]  - attr(*, "total_size")= num 4728
[15:32:31.454] Packages to be attached in all futures: [n=0] 
[15:32:31.454] getGlobalsAndPackagesXApply() ... DONE
[15:32:31.455] Number of futures (= number of chunks): 2
[15:32:31.455] Launching 2 futures (chunks) ...
[15:32:31.455] Chunk #1 of 2 ...
[15:32:31.456]  - Finding globals in 'X' for chunk #1 ...
[15:32:31.456] getGlobalsAndPackages() ...
[15:32:31.456] Searching for globals...
[15:32:31.457] 
[15:32:31.457] Searching for globals ... DONE
[15:32:31.457] - globals: [0] <none>
[15:32:31.457] getGlobalsAndPackages() ... DONE
[15:32:31.458]    + additional globals found: [n=0] 
[15:32:31.458]    + additional namespaces needed: [n=0] 
[15:32:31.458]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:31.458]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:31.459]  - seeds: <none>
[15:32:31.459]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:31.459] getGlobalsAndPackages() ...
[15:32:31.459] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:31.460] Resolving globals: FALSE
[15:32:31.460] Tweak future expression to call with '...' arguments ...
[15:32:31.460] {
[15:32:31.460]     do.call(function(...) {
[15:32:31.460]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:31.460]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:31.460]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:31.460]             on.exit(options(oopts), add = TRUE)
[15:32:31.460]         }
[15:32:31.460]         {
[15:32:31.460]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:31.460]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:31.460]                 ...future.FUN(...future.X_jj, ...)
[15:32:31.460]             })
[15:32:31.460]         }
[15:32:31.460]     }, args = future.call.arguments)
[15:32:31.460] }
[15:32:31.461] Tweak future expression to call with '...' arguments ... DONE
[15:32:31.462] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:31.462] 
[15:32:31.462] getGlobalsAndPackages() ... DONE
[15:32:31.463] run() for 'Future' ...
[15:32:31.463] - state: 'created'
[15:32:31.463] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:31.480] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:31.480] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:31.481]   - Field: 'node'
[15:32:31.481]   - Field: 'label'
[15:32:31.481]   - Field: 'local'
[15:32:31.482]   - Field: 'owner'
[15:32:31.482]   - Field: 'envir'
[15:32:31.482]   - Field: 'workers'
[15:32:31.482]   - Field: 'packages'
[15:32:31.483]   - Field: 'gc'
[15:32:31.483]   - Field: 'conditions'
[15:32:31.483]   - Field: 'persistent'
[15:32:31.483]   - Field: 'expr'
[15:32:31.484]   - Field: 'uuid'
[15:32:31.484]   - Field: 'seed'
[15:32:31.484]   - Field: 'version'
[15:32:31.485]   - Field: 'result'
[15:32:31.485]   - Field: 'asynchronous'
[15:32:31.485]   - Field: 'calls'
[15:32:31.485]   - Field: 'globals'
[15:32:31.486]   - Field: 'stdout'
[15:32:31.486]   - Field: 'earlySignal'
[15:32:31.486]   - Field: 'lazy'
[15:32:31.487]   - Field: 'state'
[15:32:31.487] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:31.487] - Launch lazy future ...
[15:32:31.488] Packages needed by the future expression (n = 0): <none>
[15:32:31.488] Packages needed by future strategies (n = 0): <none>
[15:32:31.489] {
[15:32:31.489]     {
[15:32:31.489]         {
[15:32:31.489]             ...future.startTime <- base::Sys.time()
[15:32:31.489]             {
[15:32:31.489]                 {
[15:32:31.489]                   {
[15:32:31.489]                     {
[15:32:31.489]                       base::local({
[15:32:31.489]                         has_future <- base::requireNamespace("future", 
[15:32:31.489]                           quietly = TRUE)
[15:32:31.489]                         if (has_future) {
[15:32:31.489]                           ns <- base::getNamespace("future")
[15:32:31.489]                           version <- ns[[".package"]][["version"]]
[15:32:31.489]                           if (is.null(version)) 
[15:32:31.489]                             version <- utils::packageVersion("future")
[15:32:31.489]                         }
[15:32:31.489]                         else {
[15:32:31.489]                           version <- NULL
[15:32:31.489]                         }
[15:32:31.489]                         if (!has_future || version < "1.8.0") {
[15:32:31.489]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:31.489]                             "", base::R.version$version.string), 
[15:32:31.489]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:31.489]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:31.489]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:31.489]                               "release", "version")], collapse = " "), 
[15:32:31.489]                             hostname = base::Sys.info()[["nodename"]])
[15:32:31.489]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:31.489]                             info)
[15:32:31.489]                           info <- base::paste(info, collapse = "; ")
[15:32:31.489]                           if (!has_future) {
[15:32:31.489]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:31.489]                               info)
[15:32:31.489]                           }
[15:32:31.489]                           else {
[15:32:31.489]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:31.489]                               info, version)
[15:32:31.489]                           }
[15:32:31.489]                           base::stop(msg)
[15:32:31.489]                         }
[15:32:31.489]                       })
[15:32:31.489]                     }
[15:32:31.489]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:31.489]                     base::options(mc.cores = 1L)
[15:32:31.489]                   }
[15:32:31.489]                   ...future.strategy.old <- future::plan("list")
[15:32:31.489]                   options(future.plan = NULL)
[15:32:31.489]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:31.489]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:31.489]                 }
[15:32:31.489]                 ...future.workdir <- getwd()
[15:32:31.489]             }
[15:32:31.489]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:31.489]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:31.489]         }
[15:32:31.489]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:31.489]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:31.489]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:31.489]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:31.489]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:31.489]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:31.489]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:31.489]             base::names(...future.oldOptions))
[15:32:31.489]     }
[15:32:31.489]     if (FALSE) {
[15:32:31.489]     }
[15:32:31.489]     else {
[15:32:31.489]         if (TRUE) {
[15:32:31.489]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:31.489]                 open = "w")
[15:32:31.489]         }
[15:32:31.489]         else {
[15:32:31.489]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:31.489]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:31.489]         }
[15:32:31.489]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:31.489]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:31.489]             base::sink(type = "output", split = FALSE)
[15:32:31.489]             base::close(...future.stdout)
[15:32:31.489]         }, add = TRUE)
[15:32:31.489]     }
[15:32:31.489]     ...future.frame <- base::sys.nframe()
[15:32:31.489]     ...future.conditions <- base::list()
[15:32:31.489]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:31.489]     if (FALSE) {
[15:32:31.489]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:31.489]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:31.489]     }
[15:32:31.489]     ...future.result <- base::tryCatch({
[15:32:31.489]         base::withCallingHandlers({
[15:32:31.489]             ...future.value <- base::withVisible(base::local({
[15:32:31.489]                 ...future.makeSendCondition <- base::local({
[15:32:31.489]                   sendCondition <- NULL
[15:32:31.489]                   function(frame = 1L) {
[15:32:31.489]                     if (is.function(sendCondition)) 
[15:32:31.489]                       return(sendCondition)
[15:32:31.489]                     ns <- getNamespace("parallel")
[15:32:31.489]                     if (exists("sendData", mode = "function", 
[15:32:31.489]                       envir = ns)) {
[15:32:31.489]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:31.489]                         envir = ns)
[15:32:31.489]                       envir <- sys.frame(frame)
[15:32:31.489]                       master <- NULL
[15:32:31.489]                       while (!identical(envir, .GlobalEnv) && 
[15:32:31.489]                         !identical(envir, emptyenv())) {
[15:32:31.489]                         if (exists("master", mode = "list", envir = envir, 
[15:32:31.489]                           inherits = FALSE)) {
[15:32:31.489]                           master <- get("master", mode = "list", 
[15:32:31.489]                             envir = envir, inherits = FALSE)
[15:32:31.489]                           if (inherits(master, c("SOCKnode", 
[15:32:31.489]                             "SOCK0node"))) {
[15:32:31.489]                             sendCondition <<- function(cond) {
[15:32:31.489]                               data <- list(type = "VALUE", value = cond, 
[15:32:31.489]                                 success = TRUE)
[15:32:31.489]                               parallel_sendData(master, data)
[15:32:31.489]                             }
[15:32:31.489]                             return(sendCondition)
[15:32:31.489]                           }
[15:32:31.489]                         }
[15:32:31.489]                         frame <- frame + 1L
[15:32:31.489]                         envir <- sys.frame(frame)
[15:32:31.489]                       }
[15:32:31.489]                     }
[15:32:31.489]                     sendCondition <<- function(cond) NULL
[15:32:31.489]                   }
[15:32:31.489]                 })
[15:32:31.489]                 withCallingHandlers({
[15:32:31.489]                   {
[15:32:31.489]                     do.call(function(...) {
[15:32:31.489]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:31.489]                       if (!identical(...future.globals.maxSize.org, 
[15:32:31.489]                         ...future.globals.maxSize)) {
[15:32:31.489]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:31.489]                         on.exit(options(oopts), add = TRUE)
[15:32:31.489]                       }
[15:32:31.489]                       {
[15:32:31.489]                         lapply(seq_along(...future.elements_ii), 
[15:32:31.489]                           FUN = function(jj) {
[15:32:31.489]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:31.489]                             ...future.FUN(...future.X_jj, ...)
[15:32:31.489]                           })
[15:32:31.489]                       }
[15:32:31.489]                     }, args = future.call.arguments)
[15:32:31.489]                   }
[15:32:31.489]                 }, immediateCondition = function(cond) {
[15:32:31.489]                   sendCondition <- ...future.makeSendCondition()
[15:32:31.489]                   sendCondition(cond)
[15:32:31.489]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:31.489]                   {
[15:32:31.489]                     inherits <- base::inherits
[15:32:31.489]                     invokeRestart <- base::invokeRestart
[15:32:31.489]                     is.null <- base::is.null
[15:32:31.489]                     muffled <- FALSE
[15:32:31.489]                     if (inherits(cond, "message")) {
[15:32:31.489]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:31.489]                       if (muffled) 
[15:32:31.489]                         invokeRestart("muffleMessage")
[15:32:31.489]                     }
[15:32:31.489]                     else if (inherits(cond, "warning")) {
[15:32:31.489]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:31.489]                       if (muffled) 
[15:32:31.489]                         invokeRestart("muffleWarning")
[15:32:31.489]                     }
[15:32:31.489]                     else if (inherits(cond, "condition")) {
[15:32:31.489]                       if (!is.null(pattern)) {
[15:32:31.489]                         computeRestarts <- base::computeRestarts
[15:32:31.489]                         grepl <- base::grepl
[15:32:31.489]                         restarts <- computeRestarts(cond)
[15:32:31.489]                         for (restart in restarts) {
[15:32:31.489]                           name <- restart$name
[15:32:31.489]                           if (is.null(name)) 
[15:32:31.489]                             next
[15:32:31.489]                           if (!grepl(pattern, name)) 
[15:32:31.489]                             next
[15:32:31.489]                           invokeRestart(restart)
[15:32:31.489]                           muffled <- TRUE
[15:32:31.489]                           break
[15:32:31.489]                         }
[15:32:31.489]                       }
[15:32:31.489]                     }
[15:32:31.489]                     invisible(muffled)
[15:32:31.489]                   }
[15:32:31.489]                   muffleCondition(cond)
[15:32:31.489]                 })
[15:32:31.489]             }))
[15:32:31.489]             future::FutureResult(value = ...future.value$value, 
[15:32:31.489]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:31.489]                   ...future.rng), globalenv = if (FALSE) 
[15:32:31.489]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:31.489]                     ...future.globalenv.names))
[15:32:31.489]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:31.489]         }, condition = base::local({
[15:32:31.489]             c <- base::c
[15:32:31.489]             inherits <- base::inherits
[15:32:31.489]             invokeRestart <- base::invokeRestart
[15:32:31.489]             length <- base::length
[15:32:31.489]             list <- base::list
[15:32:31.489]             seq.int <- base::seq.int
[15:32:31.489]             signalCondition <- base::signalCondition
[15:32:31.489]             sys.calls <- base::sys.calls
[15:32:31.489]             `[[` <- base::`[[`
[15:32:31.489]             `+` <- base::`+`
[15:32:31.489]             `<<-` <- base::`<<-`
[15:32:31.489]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:31.489]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:31.489]                   3L)]
[15:32:31.489]             }
[15:32:31.489]             function(cond) {
[15:32:31.489]                 is_error <- inherits(cond, "error")
[15:32:31.489]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:31.489]                   NULL)
[15:32:31.489]                 if (is_error) {
[15:32:31.489]                   sessionInformation <- function() {
[15:32:31.489]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:31.489]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:31.489]                       search = base::search(), system = base::Sys.info())
[15:32:31.489]                   }
[15:32:31.489]                   ...future.conditions[[length(...future.conditions) + 
[15:32:31.489]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:31.489]                     cond$call), session = sessionInformation(), 
[15:32:31.489]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:31.489]                   signalCondition(cond)
[15:32:31.489]                 }
[15:32:31.489]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:31.489]                 "immediateCondition"))) {
[15:32:31.489]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:31.489]                   ...future.conditions[[length(...future.conditions) + 
[15:32:31.489]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:31.489]                   if (TRUE && !signal) {
[15:32:31.489]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:31.489]                     {
[15:32:31.489]                       inherits <- base::inherits
[15:32:31.489]                       invokeRestart <- base::invokeRestart
[15:32:31.489]                       is.null <- base::is.null
[15:32:31.489]                       muffled <- FALSE
[15:32:31.489]                       if (inherits(cond, "message")) {
[15:32:31.489]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:31.489]                         if (muffled) 
[15:32:31.489]                           invokeRestart("muffleMessage")
[15:32:31.489]                       }
[15:32:31.489]                       else if (inherits(cond, "warning")) {
[15:32:31.489]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:31.489]                         if (muffled) 
[15:32:31.489]                           invokeRestart("muffleWarning")
[15:32:31.489]                       }
[15:32:31.489]                       else if (inherits(cond, "condition")) {
[15:32:31.489]                         if (!is.null(pattern)) {
[15:32:31.489]                           computeRestarts <- base::computeRestarts
[15:32:31.489]                           grepl <- base::grepl
[15:32:31.489]                           restarts <- computeRestarts(cond)
[15:32:31.489]                           for (restart in restarts) {
[15:32:31.489]                             name <- restart$name
[15:32:31.489]                             if (is.null(name)) 
[15:32:31.489]                               next
[15:32:31.489]                             if (!grepl(pattern, name)) 
[15:32:31.489]                               next
[15:32:31.489]                             invokeRestart(restart)
[15:32:31.489]                             muffled <- TRUE
[15:32:31.489]                             break
[15:32:31.489]                           }
[15:32:31.489]                         }
[15:32:31.489]                       }
[15:32:31.489]                       invisible(muffled)
[15:32:31.489]                     }
[15:32:31.489]                     muffleCondition(cond, pattern = "^muffle")
[15:32:31.489]                   }
[15:32:31.489]                 }
[15:32:31.489]                 else {
[15:32:31.489]                   if (TRUE) {
[15:32:31.489]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:31.489]                     {
[15:32:31.489]                       inherits <- base::inherits
[15:32:31.489]                       invokeRestart <- base::invokeRestart
[15:32:31.489]                       is.null <- base::is.null
[15:32:31.489]                       muffled <- FALSE
[15:32:31.489]                       if (inherits(cond, "message")) {
[15:32:31.489]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:31.489]                         if (muffled) 
[15:32:31.489]                           invokeRestart("muffleMessage")
[15:32:31.489]                       }
[15:32:31.489]                       else if (inherits(cond, "warning")) {
[15:32:31.489]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:31.489]                         if (muffled) 
[15:32:31.489]                           invokeRestart("muffleWarning")
[15:32:31.489]                       }
[15:32:31.489]                       else if (inherits(cond, "condition")) {
[15:32:31.489]                         if (!is.null(pattern)) {
[15:32:31.489]                           computeRestarts <- base::computeRestarts
[15:32:31.489]                           grepl <- base::grepl
[15:32:31.489]                           restarts <- computeRestarts(cond)
[15:32:31.489]                           for (restart in restarts) {
[15:32:31.489]                             name <- restart$name
[15:32:31.489]                             if (is.null(name)) 
[15:32:31.489]                               next
[15:32:31.489]                             if (!grepl(pattern, name)) 
[15:32:31.489]                               next
[15:32:31.489]                             invokeRestart(restart)
[15:32:31.489]                             muffled <- TRUE
[15:32:31.489]                             break
[15:32:31.489]                           }
[15:32:31.489]                         }
[15:32:31.489]                       }
[15:32:31.489]                       invisible(muffled)
[15:32:31.489]                     }
[15:32:31.489]                     muffleCondition(cond, pattern = "^muffle")
[15:32:31.489]                   }
[15:32:31.489]                 }
[15:32:31.489]             }
[15:32:31.489]         }))
[15:32:31.489]     }, error = function(ex) {
[15:32:31.489]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:31.489]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:31.489]                 ...future.rng), started = ...future.startTime, 
[15:32:31.489]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:31.489]             version = "1.8"), class = "FutureResult")
[15:32:31.489]     }, finally = {
[15:32:31.489]         if (!identical(...future.workdir, getwd())) 
[15:32:31.489]             setwd(...future.workdir)
[15:32:31.489]         {
[15:32:31.489]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:31.489]                 ...future.oldOptions$nwarnings <- NULL
[15:32:31.489]             }
[15:32:31.489]             base::options(...future.oldOptions)
[15:32:31.489]             if (.Platform$OS.type == "windows") {
[15:32:31.489]                 old_names <- names(...future.oldEnvVars)
[15:32:31.489]                 envs <- base::Sys.getenv()
[15:32:31.489]                 names <- names(envs)
[15:32:31.489]                 common <- intersect(names, old_names)
[15:32:31.489]                 added <- setdiff(names, old_names)
[15:32:31.489]                 removed <- setdiff(old_names, names)
[15:32:31.489]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:31.489]                   envs[common]]
[15:32:31.489]                 NAMES <- toupper(changed)
[15:32:31.489]                 args <- list()
[15:32:31.489]                 for (kk in seq_along(NAMES)) {
[15:32:31.489]                   name <- changed[[kk]]
[15:32:31.489]                   NAME <- NAMES[[kk]]
[15:32:31.489]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:31.489]                     next
[15:32:31.489]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:31.489]                 }
[15:32:31.489]                 NAMES <- toupper(added)
[15:32:31.489]                 for (kk in seq_along(NAMES)) {
[15:32:31.489]                   name <- added[[kk]]
[15:32:31.489]                   NAME <- NAMES[[kk]]
[15:32:31.489]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:31.489]                     next
[15:32:31.489]                   args[[name]] <- ""
[15:32:31.489]                 }
[15:32:31.489]                 NAMES <- toupper(removed)
[15:32:31.489]                 for (kk in seq_along(NAMES)) {
[15:32:31.489]                   name <- removed[[kk]]
[15:32:31.489]                   NAME <- NAMES[[kk]]
[15:32:31.489]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:31.489]                     next
[15:32:31.489]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:31.489]                 }
[15:32:31.489]                 if (length(args) > 0) 
[15:32:31.489]                   base::do.call(base::Sys.setenv, args = args)
[15:32:31.489]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:31.489]             }
[15:32:31.489]             else {
[15:32:31.489]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:31.489]             }
[15:32:31.489]             {
[15:32:31.489]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:31.489]                   0L) {
[15:32:31.489]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:31.489]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:31.489]                   base::options(opts)
[15:32:31.489]                 }
[15:32:31.489]                 {
[15:32:31.489]                   {
[15:32:31.489]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:31.489]                     NULL
[15:32:31.489]                   }
[15:32:31.489]                   options(future.plan = NULL)
[15:32:31.489]                   if (is.na(NA_character_)) 
[15:32:31.489]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:31.489]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:31.489]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:31.489]                     .init = FALSE)
[15:32:31.489]                 }
[15:32:31.489]             }
[15:32:31.489]         }
[15:32:31.489]     })
[15:32:31.489]     if (TRUE) {
[15:32:31.489]         base::sink(type = "output", split = FALSE)
[15:32:31.489]         if (TRUE) {
[15:32:31.489]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:31.489]         }
[15:32:31.489]         else {
[15:32:31.489]             ...future.result["stdout"] <- base::list(NULL)
[15:32:31.489]         }
[15:32:31.489]         base::close(...future.stdout)
[15:32:31.489]         ...future.stdout <- NULL
[15:32:31.489]     }
[15:32:31.489]     ...future.result$conditions <- ...future.conditions
[15:32:31.489]     ...future.result$finished <- base::Sys.time()
[15:32:31.489]     ...future.result
[15:32:31.489] }
[15:32:31.498] Exporting 5 global objects (4.62 KiB) to cluster node #1 ...
[15:32:31.498] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ...
[15:32:31.499] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ... DONE
[15:32:31.499] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:31.500] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:31.500] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ...
[15:32:31.501] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ... DONE
[15:32:31.501] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:31.502] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:31.502] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:31.503] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:31.503] Exporting 5 global objects (4.62 KiB) to cluster node #1 ... DONE
[15:32:31.504] MultisessionFuture started
[15:32:31.505] - Launch lazy future ... done
[15:32:31.505] run() for 'MultisessionFuture' ... done
[15:32:31.505] Created future:
[15:32:31.534] receiveMessageFromWorker() for ClusterFuture ...
[15:32:31.535] - Validating connection of MultisessionFuture
[15:32:31.536] - received message: FutureResult
[15:32:31.536] - Received FutureResult
[15:32:31.536] - Erased future from FutureRegistry
[15:32:31.537] result() for ClusterFuture ...
[15:32:31.537] - result already collected: FutureResult
[15:32:31.537] result() for ClusterFuture ... done
[15:32:31.537] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:31.506] MultisessionFuture:
[15:32:31.506] Label: 'future_sapply-1'
[15:32:31.506] Expression:
[15:32:31.506] {
[15:32:31.506]     do.call(function(...) {
[15:32:31.506]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:31.506]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:31.506]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:31.506]             on.exit(options(oopts), add = TRUE)
[15:32:31.506]         }
[15:32:31.506]         {
[15:32:31.506]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:31.506]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:31.506]                 ...future.FUN(...future.X_jj, ...)
[15:32:31.506]             })
[15:32:31.506]         }
[15:32:31.506]     }, args = future.call.arguments)
[15:32:31.506] }
[15:32:31.506] Lazy evaluation: FALSE
[15:32:31.506] Asynchronous evaluation: TRUE
[15:32:31.506] Local evaluation: TRUE
[15:32:31.506] Environment: R_GlobalEnv
[15:32:31.506] Capture standard output: TRUE
[15:32:31.506] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:31.506] Globals: 5 objects totaling 4.78 KiB (function '...future.FUN' of 4.62 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:31.506] Packages: <none>
[15:32:31.506] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:31.506] Resolved: TRUE
[15:32:31.506] Value: <not collected>
[15:32:31.506] Conditions captured: <none>
[15:32:31.506] Early signaling: FALSE
[15:32:31.506] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:31.506] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:31.538] Chunk #1 of 2 ... DONE
[15:32:31.539] Chunk #2 of 2 ...
[15:32:31.539]  - Finding globals in 'X' for chunk #2 ...
[15:32:31.539] getGlobalsAndPackages() ...
[15:32:31.539] Searching for globals...
[15:32:31.540] 
[15:32:31.540] Searching for globals ... DONE
[15:32:31.541] - globals: [0] <none>
[15:32:31.541] getGlobalsAndPackages() ... DONE
[15:32:31.541]    + additional globals found: [n=0] 
[15:32:31.541]    + additional namespaces needed: [n=0] 
[15:32:31.542]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:31.542]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:31.542]  - seeds: <none>
[15:32:31.542]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:31.543] getGlobalsAndPackages() ...
[15:32:31.543] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:31.543] Resolving globals: FALSE
[15:32:31.544] Tweak future expression to call with '...' arguments ...
[15:32:31.544] {
[15:32:31.544]     do.call(function(...) {
[15:32:31.544]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:31.544]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:31.544]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:31.544]             on.exit(options(oopts), add = TRUE)
[15:32:31.544]         }
[15:32:31.544]         {
[15:32:31.544]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:31.544]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:31.544]                 ...future.FUN(...future.X_jj, ...)
[15:32:31.544]             })
[15:32:31.544]         }
[15:32:31.544]     }, args = future.call.arguments)
[15:32:31.544] }
[15:32:31.545] Tweak future expression to call with '...' arguments ... DONE
[15:32:31.546] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:31.546] 
[15:32:31.546] getGlobalsAndPackages() ... DONE
[15:32:31.547] run() for 'Future' ...
[15:32:31.547] - state: 'created'
[15:32:31.548] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:31.568] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:31.568] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:31.569]   - Field: 'node'
[15:32:31.569]   - Field: 'label'
[15:32:31.569]   - Field: 'local'
[15:32:31.570]   - Field: 'owner'
[15:32:31.570]   - Field: 'envir'
[15:32:31.571]   - Field: 'workers'
[15:32:31.571]   - Field: 'packages'
[15:32:31.571]   - Field: 'gc'
[15:32:31.572]   - Field: 'conditions'
[15:32:31.572]   - Field: 'persistent'
[15:32:31.573]   - Field: 'expr'
[15:32:31.573]   - Field: 'uuid'
[15:32:31.573]   - Field: 'seed'
[15:32:31.574]   - Field: 'version'
[15:32:31.574]   - Field: 'result'
[15:32:31.574]   - Field: 'asynchronous'
[15:32:31.575]   - Field: 'calls'
[15:32:31.575]   - Field: 'globals'
[15:32:31.576]   - Field: 'stdout'
[15:32:31.576]   - Field: 'earlySignal'
[15:32:31.576]   - Field: 'lazy'
[15:32:31.577]   - Field: 'state'
[15:32:31.577] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:31.577] - Launch lazy future ...
[15:32:31.578] Packages needed by the future expression (n = 0): <none>
[15:32:31.578] Packages needed by future strategies (n = 0): <none>
[15:32:31.579] {
[15:32:31.579]     {
[15:32:31.579]         {
[15:32:31.579]             ...future.startTime <- base::Sys.time()
[15:32:31.579]             {
[15:32:31.579]                 {
[15:32:31.579]                   {
[15:32:31.579]                     {
[15:32:31.579]                       base::local({
[15:32:31.579]                         has_future <- base::requireNamespace("future", 
[15:32:31.579]                           quietly = TRUE)
[15:32:31.579]                         if (has_future) {
[15:32:31.579]                           ns <- base::getNamespace("future")
[15:32:31.579]                           version <- ns[[".package"]][["version"]]
[15:32:31.579]                           if (is.null(version)) 
[15:32:31.579]                             version <- utils::packageVersion("future")
[15:32:31.579]                         }
[15:32:31.579]                         else {
[15:32:31.579]                           version <- NULL
[15:32:31.579]                         }
[15:32:31.579]                         if (!has_future || version < "1.8.0") {
[15:32:31.579]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:31.579]                             "", base::R.version$version.string), 
[15:32:31.579]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:31.579]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:31.579]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:31.579]                               "release", "version")], collapse = " "), 
[15:32:31.579]                             hostname = base::Sys.info()[["nodename"]])
[15:32:31.579]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:31.579]                             info)
[15:32:31.579]                           info <- base::paste(info, collapse = "; ")
[15:32:31.579]                           if (!has_future) {
[15:32:31.579]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:31.579]                               info)
[15:32:31.579]                           }
[15:32:31.579]                           else {
[15:32:31.579]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:31.579]                               info, version)
[15:32:31.579]                           }
[15:32:31.579]                           base::stop(msg)
[15:32:31.579]                         }
[15:32:31.579]                       })
[15:32:31.579]                     }
[15:32:31.579]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:31.579]                     base::options(mc.cores = 1L)
[15:32:31.579]                   }
[15:32:31.579]                   ...future.strategy.old <- future::plan("list")
[15:32:31.579]                   options(future.plan = NULL)
[15:32:31.579]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:31.579]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:31.579]                 }
[15:32:31.579]                 ...future.workdir <- getwd()
[15:32:31.579]             }
[15:32:31.579]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:31.579]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:31.579]         }
[15:32:31.579]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:31.579]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:31.579]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:31.579]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:31.579]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:31.579]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:31.579]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:31.579]             base::names(...future.oldOptions))
[15:32:31.579]     }
[15:32:31.579]     if (FALSE) {
[15:32:31.579]     }
[15:32:31.579]     else {
[15:32:31.579]         if (TRUE) {
[15:32:31.579]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:31.579]                 open = "w")
[15:32:31.579]         }
[15:32:31.579]         else {
[15:32:31.579]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:31.579]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:31.579]         }
[15:32:31.579]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:31.579]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:31.579]             base::sink(type = "output", split = FALSE)
[15:32:31.579]             base::close(...future.stdout)
[15:32:31.579]         }, add = TRUE)
[15:32:31.579]     }
[15:32:31.579]     ...future.frame <- base::sys.nframe()
[15:32:31.579]     ...future.conditions <- base::list()
[15:32:31.579]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:31.579]     if (FALSE) {
[15:32:31.579]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:31.579]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:31.579]     }
[15:32:31.579]     ...future.result <- base::tryCatch({
[15:32:31.579]         base::withCallingHandlers({
[15:32:31.579]             ...future.value <- base::withVisible(base::local({
[15:32:31.579]                 ...future.makeSendCondition <- base::local({
[15:32:31.579]                   sendCondition <- NULL
[15:32:31.579]                   function(frame = 1L) {
[15:32:31.579]                     if (is.function(sendCondition)) 
[15:32:31.579]                       return(sendCondition)
[15:32:31.579]                     ns <- getNamespace("parallel")
[15:32:31.579]                     if (exists("sendData", mode = "function", 
[15:32:31.579]                       envir = ns)) {
[15:32:31.579]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:31.579]                         envir = ns)
[15:32:31.579]                       envir <- sys.frame(frame)
[15:32:31.579]                       master <- NULL
[15:32:31.579]                       while (!identical(envir, .GlobalEnv) && 
[15:32:31.579]                         !identical(envir, emptyenv())) {
[15:32:31.579]                         if (exists("master", mode = "list", envir = envir, 
[15:32:31.579]                           inherits = FALSE)) {
[15:32:31.579]                           master <- get("master", mode = "list", 
[15:32:31.579]                             envir = envir, inherits = FALSE)
[15:32:31.579]                           if (inherits(master, c("SOCKnode", 
[15:32:31.579]                             "SOCK0node"))) {
[15:32:31.579]                             sendCondition <<- function(cond) {
[15:32:31.579]                               data <- list(type = "VALUE", value = cond, 
[15:32:31.579]                                 success = TRUE)
[15:32:31.579]                               parallel_sendData(master, data)
[15:32:31.579]                             }
[15:32:31.579]                             return(sendCondition)
[15:32:31.579]                           }
[15:32:31.579]                         }
[15:32:31.579]                         frame <- frame + 1L
[15:32:31.579]                         envir <- sys.frame(frame)
[15:32:31.579]                       }
[15:32:31.579]                     }
[15:32:31.579]                     sendCondition <<- function(cond) NULL
[15:32:31.579]                   }
[15:32:31.579]                 })
[15:32:31.579]                 withCallingHandlers({
[15:32:31.579]                   {
[15:32:31.579]                     do.call(function(...) {
[15:32:31.579]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:31.579]                       if (!identical(...future.globals.maxSize.org, 
[15:32:31.579]                         ...future.globals.maxSize)) {
[15:32:31.579]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:31.579]                         on.exit(options(oopts), add = TRUE)
[15:32:31.579]                       }
[15:32:31.579]                       {
[15:32:31.579]                         lapply(seq_along(...future.elements_ii), 
[15:32:31.579]                           FUN = function(jj) {
[15:32:31.579]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:31.579]                             ...future.FUN(...future.X_jj, ...)
[15:32:31.579]                           })
[15:32:31.579]                       }
[15:32:31.579]                     }, args = future.call.arguments)
[15:32:31.579]                   }
[15:32:31.579]                 }, immediateCondition = function(cond) {
[15:32:31.579]                   sendCondition <- ...future.makeSendCondition()
[15:32:31.579]                   sendCondition(cond)
[15:32:31.579]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:31.579]                   {
[15:32:31.579]                     inherits <- base::inherits
[15:32:31.579]                     invokeRestart <- base::invokeRestart
[15:32:31.579]                     is.null <- base::is.null
[15:32:31.579]                     muffled <- FALSE
[15:32:31.579]                     if (inherits(cond, "message")) {
[15:32:31.579]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:31.579]                       if (muffled) 
[15:32:31.579]                         invokeRestart("muffleMessage")
[15:32:31.579]                     }
[15:32:31.579]                     else if (inherits(cond, "warning")) {
[15:32:31.579]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:31.579]                       if (muffled) 
[15:32:31.579]                         invokeRestart("muffleWarning")
[15:32:31.579]                     }
[15:32:31.579]                     else if (inherits(cond, "condition")) {
[15:32:31.579]                       if (!is.null(pattern)) {
[15:32:31.579]                         computeRestarts <- base::computeRestarts
[15:32:31.579]                         grepl <- base::grepl
[15:32:31.579]                         restarts <- computeRestarts(cond)
[15:32:31.579]                         for (restart in restarts) {
[15:32:31.579]                           name <- restart$name
[15:32:31.579]                           if (is.null(name)) 
[15:32:31.579]                             next
[15:32:31.579]                           if (!grepl(pattern, name)) 
[15:32:31.579]                             next
[15:32:31.579]                           invokeRestart(restart)
[15:32:31.579]                           muffled <- TRUE
[15:32:31.579]                           break
[15:32:31.579]                         }
[15:32:31.579]                       }
[15:32:31.579]                     }
[15:32:31.579]                     invisible(muffled)
[15:32:31.579]                   }
[15:32:31.579]                   muffleCondition(cond)
[15:32:31.579]                 })
[15:32:31.579]             }))
[15:32:31.579]             future::FutureResult(value = ...future.value$value, 
[15:32:31.579]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:31.579]                   ...future.rng), globalenv = if (FALSE) 
[15:32:31.579]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:31.579]                     ...future.globalenv.names))
[15:32:31.579]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:31.579]         }, condition = base::local({
[15:32:31.579]             c <- base::c
[15:32:31.579]             inherits <- base::inherits
[15:32:31.579]             invokeRestart <- base::invokeRestart
[15:32:31.579]             length <- base::length
[15:32:31.579]             list <- base::list
[15:32:31.579]             seq.int <- base::seq.int
[15:32:31.579]             signalCondition <- base::signalCondition
[15:32:31.579]             sys.calls <- base::sys.calls
[15:32:31.579]             `[[` <- base::`[[`
[15:32:31.579]             `+` <- base::`+`
[15:32:31.579]             `<<-` <- base::`<<-`
[15:32:31.579]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:31.579]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:31.579]                   3L)]
[15:32:31.579]             }
[15:32:31.579]             function(cond) {
[15:32:31.579]                 is_error <- inherits(cond, "error")
[15:32:31.579]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:31.579]                   NULL)
[15:32:31.579]                 if (is_error) {
[15:32:31.579]                   sessionInformation <- function() {
[15:32:31.579]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:31.579]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:31.579]                       search = base::search(), system = base::Sys.info())
[15:32:31.579]                   }
[15:32:31.579]                   ...future.conditions[[length(...future.conditions) + 
[15:32:31.579]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:31.579]                     cond$call), session = sessionInformation(), 
[15:32:31.579]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:31.579]                   signalCondition(cond)
[15:32:31.579]                 }
[15:32:31.579]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:31.579]                 "immediateCondition"))) {
[15:32:31.579]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:31.579]                   ...future.conditions[[length(...future.conditions) + 
[15:32:31.579]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:31.579]                   if (TRUE && !signal) {
[15:32:31.579]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:31.579]                     {
[15:32:31.579]                       inherits <- base::inherits
[15:32:31.579]                       invokeRestart <- base::invokeRestart
[15:32:31.579]                       is.null <- base::is.null
[15:32:31.579]                       muffled <- FALSE
[15:32:31.579]                       if (inherits(cond, "message")) {
[15:32:31.579]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:31.579]                         if (muffled) 
[15:32:31.579]                           invokeRestart("muffleMessage")
[15:32:31.579]                       }
[15:32:31.579]                       else if (inherits(cond, "warning")) {
[15:32:31.579]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:31.579]                         if (muffled) 
[15:32:31.579]                           invokeRestart("muffleWarning")
[15:32:31.579]                       }
[15:32:31.579]                       else if (inherits(cond, "condition")) {
[15:32:31.579]                         if (!is.null(pattern)) {
[15:32:31.579]                           computeRestarts <- base::computeRestarts
[15:32:31.579]                           grepl <- base::grepl
[15:32:31.579]                           restarts <- computeRestarts(cond)
[15:32:31.579]                           for (restart in restarts) {
[15:32:31.579]                             name <- restart$name
[15:32:31.579]                             if (is.null(name)) 
[15:32:31.579]                               next
[15:32:31.579]                             if (!grepl(pattern, name)) 
[15:32:31.579]                               next
[15:32:31.579]                             invokeRestart(restart)
[15:32:31.579]                             muffled <- TRUE
[15:32:31.579]                             break
[15:32:31.579]                           }
[15:32:31.579]                         }
[15:32:31.579]                       }
[15:32:31.579]                       invisible(muffled)
[15:32:31.579]                     }
[15:32:31.579]                     muffleCondition(cond, pattern = "^muffle")
[15:32:31.579]                   }
[15:32:31.579]                 }
[15:32:31.579]                 else {
[15:32:31.579]                   if (TRUE) {
[15:32:31.579]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:31.579]                     {
[15:32:31.579]                       inherits <- base::inherits
[15:32:31.579]                       invokeRestart <- base::invokeRestart
[15:32:31.579]                       is.null <- base::is.null
[15:32:31.579]                       muffled <- FALSE
[15:32:31.579]                       if (inherits(cond, "message")) {
[15:32:31.579]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:31.579]                         if (muffled) 
[15:32:31.579]                           invokeRestart("muffleMessage")
[15:32:31.579]                       }
[15:32:31.579]                       else if (inherits(cond, "warning")) {
[15:32:31.579]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:31.579]                         if (muffled) 
[15:32:31.579]                           invokeRestart("muffleWarning")
[15:32:31.579]                       }
[15:32:31.579]                       else if (inherits(cond, "condition")) {
[15:32:31.579]                         if (!is.null(pattern)) {
[15:32:31.579]                           computeRestarts <- base::computeRestarts
[15:32:31.579]                           grepl <- base::grepl
[15:32:31.579]                           restarts <- computeRestarts(cond)
[15:32:31.579]                           for (restart in restarts) {
[15:32:31.579]                             name <- restart$name
[15:32:31.579]                             if (is.null(name)) 
[15:32:31.579]                               next
[15:32:31.579]                             if (!grepl(pattern, name)) 
[15:32:31.579]                               next
[15:32:31.579]                             invokeRestart(restart)
[15:32:31.579]                             muffled <- TRUE
[15:32:31.579]                             break
[15:32:31.579]                           }
[15:32:31.579]                         }
[15:32:31.579]                       }
[15:32:31.579]                       invisible(muffled)
[15:32:31.579]                     }
[15:32:31.579]                     muffleCondition(cond, pattern = "^muffle")
[15:32:31.579]                   }
[15:32:31.579]                 }
[15:32:31.579]             }
[15:32:31.579]         }))
[15:32:31.579]     }, error = function(ex) {
[15:32:31.579]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:31.579]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:31.579]                 ...future.rng), started = ...future.startTime, 
[15:32:31.579]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:31.579]             version = "1.8"), class = "FutureResult")
[15:32:31.579]     }, finally = {
[15:32:31.579]         if (!identical(...future.workdir, getwd())) 
[15:32:31.579]             setwd(...future.workdir)
[15:32:31.579]         {
[15:32:31.579]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:31.579]                 ...future.oldOptions$nwarnings <- NULL
[15:32:31.579]             }
[15:32:31.579]             base::options(...future.oldOptions)
[15:32:31.579]             if (.Platform$OS.type == "windows") {
[15:32:31.579]                 old_names <- names(...future.oldEnvVars)
[15:32:31.579]                 envs <- base::Sys.getenv()
[15:32:31.579]                 names <- names(envs)
[15:32:31.579]                 common <- intersect(names, old_names)
[15:32:31.579]                 added <- setdiff(names, old_names)
[15:32:31.579]                 removed <- setdiff(old_names, names)
[15:32:31.579]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:31.579]                   envs[common]]
[15:32:31.579]                 NAMES <- toupper(changed)
[15:32:31.579]                 args <- list()
[15:32:31.579]                 for (kk in seq_along(NAMES)) {
[15:32:31.579]                   name <- changed[[kk]]
[15:32:31.579]                   NAME <- NAMES[[kk]]
[15:32:31.579]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:31.579]                     next
[15:32:31.579]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:31.579]                 }
[15:32:31.579]                 NAMES <- toupper(added)
[15:32:31.579]                 for (kk in seq_along(NAMES)) {
[15:32:31.579]                   name <- added[[kk]]
[15:32:31.579]                   NAME <- NAMES[[kk]]
[15:32:31.579]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:31.579]                     next
[15:32:31.579]                   args[[name]] <- ""
[15:32:31.579]                 }
[15:32:31.579]                 NAMES <- toupper(removed)
[15:32:31.579]                 for (kk in seq_along(NAMES)) {
[15:32:31.579]                   name <- removed[[kk]]
[15:32:31.579]                   NAME <- NAMES[[kk]]
[15:32:31.579]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:31.579]                     next
[15:32:31.579]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:31.579]                 }
[15:32:31.579]                 if (length(args) > 0) 
[15:32:31.579]                   base::do.call(base::Sys.setenv, args = args)
[15:32:31.579]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:31.579]             }
[15:32:31.579]             else {
[15:32:31.579]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:31.579]             }
[15:32:31.579]             {
[15:32:31.579]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:31.579]                   0L) {
[15:32:31.579]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:31.579]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:31.579]                   base::options(opts)
[15:32:31.579]                 }
[15:32:31.579]                 {
[15:32:31.579]                   {
[15:32:31.579]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:31.579]                     NULL
[15:32:31.579]                   }
[15:32:31.579]                   options(future.plan = NULL)
[15:32:31.579]                   if (is.na(NA_character_)) 
[15:32:31.579]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:31.579]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:31.579]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:31.579]                     .init = FALSE)
[15:32:31.579]                 }
[15:32:31.579]             }
[15:32:31.579]         }
[15:32:31.579]     })
[15:32:31.579]     if (TRUE) {
[15:32:31.579]         base::sink(type = "output", split = FALSE)
[15:32:31.579]         if (TRUE) {
[15:32:31.579]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:31.579]         }
[15:32:31.579]         else {
[15:32:31.579]             ...future.result["stdout"] <- base::list(NULL)
[15:32:31.579]         }
[15:32:31.579]         base::close(...future.stdout)
[15:32:31.579]         ...future.stdout <- NULL
[15:32:31.579]     }
[15:32:31.579]     ...future.result$conditions <- ...future.conditions
[15:32:31.579]     ...future.result$finished <- base::Sys.time()
[15:32:31.579]     ...future.result
[15:32:31.579] }
[15:32:31.587] Exporting 5 global objects (4.62 KiB) to cluster node #1 ...
[15:32:31.587] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ...
[15:32:31.588] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ... DONE
[15:32:31.589] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:31.590] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:31.590] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ...
[15:32:31.591] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ... DONE
[15:32:31.591] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:31.597] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:31.597] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:31.598] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:31.598] Exporting 5 global objects (4.62 KiB) to cluster node #1 ... DONE
[15:32:31.600] MultisessionFuture started
[15:32:31.600] - Launch lazy future ... done
[15:32:31.600] run() for 'MultisessionFuture' ... done
[15:32:31.601] Created future:
[15:32:31.634] receiveMessageFromWorker() for ClusterFuture ...
[15:32:31.635] - Validating connection of MultisessionFuture
[15:32:31.635] - received message: FutureResult
[15:32:31.636] - Received FutureResult
[15:32:31.636] - Erased future from FutureRegistry
[15:32:31.636] result() for ClusterFuture ...
[15:32:31.637] - result already collected: FutureResult
[15:32:31.637] result() for ClusterFuture ... done
[15:32:31.637] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:31.601] MultisessionFuture:
[15:32:31.601] Label: 'future_sapply-2'
[15:32:31.601] Expression:
[15:32:31.601] {
[15:32:31.601]     do.call(function(...) {
[15:32:31.601]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:31.601]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:31.601]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:31.601]             on.exit(options(oopts), add = TRUE)
[15:32:31.601]         }
[15:32:31.601]         {
[15:32:31.601]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:31.601]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:31.601]                 ...future.FUN(...future.X_jj, ...)
[15:32:31.601]             })
[15:32:31.601]         }
[15:32:31.601]     }, args = future.call.arguments)
[15:32:31.601] }
[15:32:31.601] Lazy evaluation: FALSE
[15:32:31.601] Asynchronous evaluation: TRUE
[15:32:31.601] Local evaluation: TRUE
[15:32:31.601] Environment: R_GlobalEnv
[15:32:31.601] Capture standard output: TRUE
[15:32:31.601] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:31.601] Globals: 5 objects totaling 4.78 KiB (function '...future.FUN' of 4.62 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:31.601] Packages: <none>
[15:32:31.601] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:31.601] Resolved: TRUE
[15:32:31.601] Value: <not collected>
[15:32:31.601] Conditions captured: <none>
[15:32:31.601] Early signaling: FALSE
[15:32:31.601] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:31.601] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:31.638] Chunk #2 of 2 ... DONE
[15:32:31.638] Launching 2 futures (chunks) ... DONE
[15:32:31.638] Resolving 2 futures (chunks) ...
[15:32:31.639] resolve() on list ...
[15:32:31.639]  recursive: 0
[15:32:31.639]  length: 2
[15:32:31.640] 
[15:32:31.640] Future #1
[15:32:31.640] result() for ClusterFuture ...
[15:32:31.640] - result already collected: FutureResult
[15:32:31.641] result() for ClusterFuture ... done
[15:32:31.641] result() for ClusterFuture ...
[15:32:31.641] - result already collected: FutureResult
[15:32:31.641] result() for ClusterFuture ... done
[15:32:31.642] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:31.642] - nx: 2
[15:32:31.642] - relay: TRUE
[15:32:31.642] - stdout: TRUE
[15:32:31.643] - signal: TRUE
[15:32:31.643] - resignal: FALSE
[15:32:31.643] - force: TRUE
[15:32:31.644] - relayed: [n=2] FALSE, FALSE
[15:32:31.644] - queued futures: [n=2] FALSE, FALSE
[15:32:31.644]  - until=1
[15:32:31.644]  - relaying element #1
[15:32:31.645] result() for ClusterFuture ...
[15:32:31.645] - result already collected: FutureResult
[15:32:31.645] result() for ClusterFuture ... done
[15:32:31.645] result() for ClusterFuture ...
[15:32:31.646] - result already collected: FutureResult
[15:32:31.646] result() for ClusterFuture ... done
[15:32:31.646] result() for ClusterFuture ...
[15:32:31.646] - result already collected: FutureResult
[15:32:31.647] result() for ClusterFuture ... done
[15:32:31.647] result() for ClusterFuture ...
[15:32:31.647] - result already collected: FutureResult
[15:32:31.647] result() for ClusterFuture ... done
[15:32:31.648] - relayed: [n=2] TRUE, FALSE
[15:32:31.648] - queued futures: [n=2] TRUE, FALSE
[15:32:31.648] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:31.648]  length: 1 (resolved future 1)
[15:32:31.649] Future #2
[15:32:31.649] result() for ClusterFuture ...
[15:32:31.649] - result already collected: FutureResult
[15:32:31.650] result() for ClusterFuture ... done
[15:32:31.650] result() for ClusterFuture ...
[15:32:31.650] - result already collected: FutureResult
[15:32:31.650] result() for ClusterFuture ... done
[15:32:31.651] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:31.651] - nx: 2
[15:32:31.651] - relay: TRUE
[15:32:31.651] - stdout: TRUE
[15:32:31.652] - signal: TRUE
[15:32:31.652] - resignal: FALSE
[15:32:31.652] - force: TRUE
[15:32:31.652] - relayed: [n=2] TRUE, FALSE
[15:32:31.653] - queued futures: [n=2] TRUE, FALSE
[15:32:31.653]  - until=2
[15:32:31.653]  - relaying element #2
[15:32:31.653] result() for ClusterFuture ...
[15:32:31.654] - result already collected: FutureResult
[15:32:31.654] result() for ClusterFuture ... done
[15:32:31.654] result() for ClusterFuture ...
[15:32:31.654] - result already collected: FutureResult
[15:32:31.655] result() for ClusterFuture ... done
[15:32:31.655] result() for ClusterFuture ...
[15:32:31.655] - result already collected: FutureResult
[15:32:31.655] result() for ClusterFuture ... done
[15:32:31.656] result() for ClusterFuture ...
[15:32:31.656] - result already collected: FutureResult
[15:32:31.656] result() for ClusterFuture ... done
[15:32:31.656] - relayed: [n=2] TRUE, TRUE
[15:32:31.657] - queued futures: [n=2] TRUE, TRUE
[15:32:31.657] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:31.657]  length: 0 (resolved future 2)
[15:32:31.657] Relaying remaining futures
[15:32:31.658] signalConditionsASAP(NULL, pos=0) ...
[15:32:31.658] - nx: 2
[15:32:31.658] - relay: TRUE
[15:32:31.658] - stdout: TRUE
[15:32:31.659] - signal: TRUE
[15:32:31.659] - resignal: FALSE
[15:32:31.659] - force: TRUE
[15:32:31.659] - relayed: [n=2] TRUE, TRUE
[15:32:31.660] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:31.660] - relayed: [n=2] TRUE, TRUE
[15:32:31.660] - queued futures: [n=2] TRUE, TRUE
[15:32:31.660] signalConditionsASAP(NULL, pos=0) ... done
[15:32:31.661] resolve() on list ... DONE
[15:32:31.661] result() for ClusterFuture ...
[15:32:31.661] - result already collected: FutureResult
[15:32:31.661] result() for ClusterFuture ... done
[15:32:31.662] result() for ClusterFuture ...
[15:32:31.662] - result already collected: FutureResult
[15:32:31.662] result() for ClusterFuture ... done
[15:32:31.663] result() for ClusterFuture ...
[15:32:31.663] - result already collected: FutureResult
[15:32:31.663] result() for ClusterFuture ... done
[15:32:31.663] result() for ClusterFuture ...
[15:32:31.664] - result already collected: FutureResult
[15:32:31.664] result() for ClusterFuture ... done
[15:32:31.664]  - Number of value chunks collected: 2
[15:32:31.664] Resolving 2 futures (chunks) ... DONE
[15:32:31.665] Reducing values from 2 chunks ...
[15:32:31.665]  - Number of values collected after concatenation: 6
[15:32:31.665]  - Number of values expected: 6
[15:32:31.666] Reducing values from 2 chunks ... DONE
[15:32:31.666] future_lapply() ... DONE
List of 2
 $ y0:List of 6
  ..$ a1: num [1:3, 1:5] 2 2 2 4 4 4 6 6 6 8 ...
  ..$ a2: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
  ..$ b1: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
  ..$ b2: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
  ..$ c1: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
  ..$ c2: num [1:3, 1:5] 8 8 8 16 16 16 24 24 24 32 ...
 $ y1:List of 6
  ..$ a1: num [1:3, 1:5] 2 2 2 4 4 4 6 6 6 8 ...
  ..$ a2: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
  ..$ b1: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
  ..$ b2: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
  ..$ c1: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
  ..$ c2: num [1:3, 1:5] 8 8 8 16 16 16 24 24 24 32 ...
List of 2
 $ y0:List of 6
  ..$ a1: num [1:3, 1:5] 2 2 2 4 4 4 6 6 6 8 ...
  ..$ a2: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
  ..$ b1: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
  ..$ b2: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
  ..$ c1: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
  ..$ c2: num [1:3, 1:5] 8 8 8 16 16 16 24 24 24 32 ...
 $ y2:List of 6
  ..$ a1: num [1:3, 1:5] 2 2 2 4 4 4 6 6 6 8 ...
  ..$ a2: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
  ..$ b1: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
  ..$ b2: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
  ..$ c1: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
  ..$ c2: num [1:3, 1:5] 8 8 8 16 16 16 24 24 24 32 ...
[15:32:31.686] future_lapply() ...
[15:32:31.691] Number of chunks: 2
[15:32:31.691] getGlobalsAndPackagesXApply() ...
[15:32:31.692]  - future.globals: TRUE
[15:32:31.692] getGlobalsAndPackages() ...
[15:32:31.692] Searching for globals...
[15:32:31.694] - globals found: [1] 'FUN'
[15:32:31.695] Searching for globals ... DONE
[15:32:31.695] Resolving globals: FALSE
[15:32:31.695] The total size of the 1 globals is 848 bytes (848 bytes)
[15:32:31.696] The total size of the 1 globals exported for future expression ('FUN()') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:32:31.696] - globals: [1] 'FUN'
[15:32:31.697] 
[15:32:31.697] getGlobalsAndPackages() ... DONE
[15:32:31.697]  - globals found/used: [n=1] 'FUN'
[15:32:31.698]  - needed namespaces: [n=0] 
[15:32:31.698] Finding globals ... DONE
[15:32:31.698]  - use_args: TRUE
[15:32:31.698]  - Getting '...' globals ...
[15:32:31.699] resolve() on list ...
[15:32:31.699]  recursive: 0
[15:32:31.700]  length: 1
[15:32:31.700]  elements: '...'
[15:32:31.700]  length: 0 (resolved future 1)
[15:32:31.701] resolve() on list ... DONE
[15:32:31.701]    - '...' content: [n=0] 
[15:32:31.701] List of 1
[15:32:31.701]  $ ...: list()
[15:32:31.701]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:31.701]  - attr(*, "where")=List of 1
[15:32:31.701]   ..$ ...:<environment: 0x00000276e5e4a610> 
[15:32:31.701]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:31.701]  - attr(*, "resolved")= logi TRUE
[15:32:31.701]  - attr(*, "total_size")= num NA
[15:32:31.706]  - Getting '...' globals ... DONE
[15:32:31.706] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:31.707] List of 2
[15:32:31.707]  $ ...future.FUN:function (x)  
[15:32:31.707]  $ ...          : list()
[15:32:31.707]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:31.707]  - attr(*, "where")=List of 2
[15:32:31.707]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:31.707]   ..$ ...          :<environment: 0x00000276e5e4a610> 
[15:32:31.707]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:31.707]  - attr(*, "resolved")= logi FALSE
[15:32:31.707]  - attr(*, "total_size")= num 848
[15:32:31.712] Packages to be attached in all futures: [n=0] 
[15:32:31.712] getGlobalsAndPackagesXApply() ... DONE
[15:32:31.713] Number of futures (= number of chunks): 2
[15:32:31.713] Launching 2 futures (chunks) ...
[15:32:31.713] Chunk #1 of 2 ...
[15:32:31.713]  - Finding globals in 'X' for chunk #1 ...
[15:32:31.714] getGlobalsAndPackages() ...
[15:32:31.714] Searching for globals...
[15:32:31.715] 
[15:32:31.715] Searching for globals ... DONE
[15:32:31.715] - globals: [0] <none>
[15:32:31.715] getGlobalsAndPackages() ... DONE
[15:32:31.716]    + additional globals found: [n=0] 
[15:32:31.716]    + additional namespaces needed: [n=0] 
[15:32:31.716]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:31.716]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:31.717]  - seeds: <none>
[15:32:31.717]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:31.717] getGlobalsAndPackages() ...
[15:32:31.717] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:31.718] Resolving globals: FALSE
[15:32:31.718] Tweak future expression to call with '...' arguments ...
[15:32:31.718] {
[15:32:31.718]     do.call(function(...) {
[15:32:31.718]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:31.718]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:31.718]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:31.718]             on.exit(options(oopts), add = TRUE)
[15:32:31.718]         }
[15:32:31.718]         {
[15:32:31.718]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:31.718]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:31.718]                 ...future.FUN(...future.X_jj, ...)
[15:32:31.718]             })
[15:32:31.718]         }
[15:32:31.718]     }, args = future.call.arguments)
[15:32:31.718] }
[15:32:31.719] Tweak future expression to call with '...' arguments ... DONE
[15:32:31.720] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:31.720] 
[15:32:31.720] getGlobalsAndPackages() ... DONE
[15:32:31.721] run() for 'Future' ...
[15:32:31.721] - state: 'created'
[15:32:31.722] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:31.739] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:31.739] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:31.740]   - Field: 'node'
[15:32:31.740]   - Field: 'label'
[15:32:31.741]   - Field: 'local'
[15:32:31.741]   - Field: 'owner'
[15:32:31.741]   - Field: 'envir'
[15:32:31.742]   - Field: 'workers'
[15:32:31.742]   - Field: 'packages'
[15:32:31.742]   - Field: 'gc'
[15:32:31.743]   - Field: 'conditions'
[15:32:31.743]   - Field: 'persistent'
[15:32:31.743]   - Field: 'expr'
[15:32:31.744]   - Field: 'uuid'
[15:32:31.747]   - Field: 'seed'
[15:32:31.747]   - Field: 'version'
[15:32:31.747]   - Field: 'result'
[15:32:31.748]   - Field: 'asynchronous'
[15:32:31.748]   - Field: 'calls'
[15:32:31.748]   - Field: 'globals'
[15:32:31.748]   - Field: 'stdout'
[15:32:31.749]   - Field: 'earlySignal'
[15:32:31.749]   - Field: 'lazy'
[15:32:31.749]   - Field: 'state'
[15:32:31.750] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:31.750] - Launch lazy future ...
[15:32:31.750] Packages needed by the future expression (n = 0): <none>
[15:32:31.751] Packages needed by future strategies (n = 0): <none>
[15:32:31.752] {
[15:32:31.752]     {
[15:32:31.752]         {
[15:32:31.752]             ...future.startTime <- base::Sys.time()
[15:32:31.752]             {
[15:32:31.752]                 {
[15:32:31.752]                   {
[15:32:31.752]                     {
[15:32:31.752]                       base::local({
[15:32:31.752]                         has_future <- base::requireNamespace("future", 
[15:32:31.752]                           quietly = TRUE)
[15:32:31.752]                         if (has_future) {
[15:32:31.752]                           ns <- base::getNamespace("future")
[15:32:31.752]                           version <- ns[[".package"]][["version"]]
[15:32:31.752]                           if (is.null(version)) 
[15:32:31.752]                             version <- utils::packageVersion("future")
[15:32:31.752]                         }
[15:32:31.752]                         else {
[15:32:31.752]                           version <- NULL
[15:32:31.752]                         }
[15:32:31.752]                         if (!has_future || version < "1.8.0") {
[15:32:31.752]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:31.752]                             "", base::R.version$version.string), 
[15:32:31.752]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:31.752]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:31.752]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:31.752]                               "release", "version")], collapse = " "), 
[15:32:31.752]                             hostname = base::Sys.info()[["nodename"]])
[15:32:31.752]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:31.752]                             info)
[15:32:31.752]                           info <- base::paste(info, collapse = "; ")
[15:32:31.752]                           if (!has_future) {
[15:32:31.752]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:31.752]                               info)
[15:32:31.752]                           }
[15:32:31.752]                           else {
[15:32:31.752]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:31.752]                               info, version)
[15:32:31.752]                           }
[15:32:31.752]                           base::stop(msg)
[15:32:31.752]                         }
[15:32:31.752]                       })
[15:32:31.752]                     }
[15:32:31.752]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:31.752]                     base::options(mc.cores = 1L)
[15:32:31.752]                   }
[15:32:31.752]                   ...future.strategy.old <- future::plan("list")
[15:32:31.752]                   options(future.plan = NULL)
[15:32:31.752]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:31.752]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:31.752]                 }
[15:32:31.752]                 ...future.workdir <- getwd()
[15:32:31.752]             }
[15:32:31.752]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:31.752]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:31.752]         }
[15:32:31.752]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:31.752]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:31.752]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:31.752]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:31.752]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:31.752]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:31.752]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:31.752]             base::names(...future.oldOptions))
[15:32:31.752]     }
[15:32:31.752]     if (FALSE) {
[15:32:31.752]     }
[15:32:31.752]     else {
[15:32:31.752]         if (TRUE) {
[15:32:31.752]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:31.752]                 open = "w")
[15:32:31.752]         }
[15:32:31.752]         else {
[15:32:31.752]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:31.752]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:31.752]         }
[15:32:31.752]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:31.752]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:31.752]             base::sink(type = "output", split = FALSE)
[15:32:31.752]             base::close(...future.stdout)
[15:32:31.752]         }, add = TRUE)
[15:32:31.752]     }
[15:32:31.752]     ...future.frame <- base::sys.nframe()
[15:32:31.752]     ...future.conditions <- base::list()
[15:32:31.752]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:31.752]     if (FALSE) {
[15:32:31.752]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:31.752]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:31.752]     }
[15:32:31.752]     ...future.result <- base::tryCatch({
[15:32:31.752]         base::withCallingHandlers({
[15:32:31.752]             ...future.value <- base::withVisible(base::local({
[15:32:31.752]                 ...future.makeSendCondition <- base::local({
[15:32:31.752]                   sendCondition <- NULL
[15:32:31.752]                   function(frame = 1L) {
[15:32:31.752]                     if (is.function(sendCondition)) 
[15:32:31.752]                       return(sendCondition)
[15:32:31.752]                     ns <- getNamespace("parallel")
[15:32:31.752]                     if (exists("sendData", mode = "function", 
[15:32:31.752]                       envir = ns)) {
[15:32:31.752]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:31.752]                         envir = ns)
[15:32:31.752]                       envir <- sys.frame(frame)
[15:32:31.752]                       master <- NULL
[15:32:31.752]                       while (!identical(envir, .GlobalEnv) && 
[15:32:31.752]                         !identical(envir, emptyenv())) {
[15:32:31.752]                         if (exists("master", mode = "list", envir = envir, 
[15:32:31.752]                           inherits = FALSE)) {
[15:32:31.752]                           master <- get("master", mode = "list", 
[15:32:31.752]                             envir = envir, inherits = FALSE)
[15:32:31.752]                           if (inherits(master, c("SOCKnode", 
[15:32:31.752]                             "SOCK0node"))) {
[15:32:31.752]                             sendCondition <<- function(cond) {
[15:32:31.752]                               data <- list(type = "VALUE", value = cond, 
[15:32:31.752]                                 success = TRUE)
[15:32:31.752]                               parallel_sendData(master, data)
[15:32:31.752]                             }
[15:32:31.752]                             return(sendCondition)
[15:32:31.752]                           }
[15:32:31.752]                         }
[15:32:31.752]                         frame <- frame + 1L
[15:32:31.752]                         envir <- sys.frame(frame)
[15:32:31.752]                       }
[15:32:31.752]                     }
[15:32:31.752]                     sendCondition <<- function(cond) NULL
[15:32:31.752]                   }
[15:32:31.752]                 })
[15:32:31.752]                 withCallingHandlers({
[15:32:31.752]                   {
[15:32:31.752]                     do.call(function(...) {
[15:32:31.752]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:31.752]                       if (!identical(...future.globals.maxSize.org, 
[15:32:31.752]                         ...future.globals.maxSize)) {
[15:32:31.752]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:31.752]                         on.exit(options(oopts), add = TRUE)
[15:32:31.752]                       }
[15:32:31.752]                       {
[15:32:31.752]                         lapply(seq_along(...future.elements_ii), 
[15:32:31.752]                           FUN = function(jj) {
[15:32:31.752]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:31.752]                             ...future.FUN(...future.X_jj, ...)
[15:32:31.752]                           })
[15:32:31.752]                       }
[15:32:31.752]                     }, args = future.call.arguments)
[15:32:31.752]                   }
[15:32:31.752]                 }, immediateCondition = function(cond) {
[15:32:31.752]                   sendCondition <- ...future.makeSendCondition()
[15:32:31.752]                   sendCondition(cond)
[15:32:31.752]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:31.752]                   {
[15:32:31.752]                     inherits <- base::inherits
[15:32:31.752]                     invokeRestart <- base::invokeRestart
[15:32:31.752]                     is.null <- base::is.null
[15:32:31.752]                     muffled <- FALSE
[15:32:31.752]                     if (inherits(cond, "message")) {
[15:32:31.752]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:31.752]                       if (muffled) 
[15:32:31.752]                         invokeRestart("muffleMessage")
[15:32:31.752]                     }
[15:32:31.752]                     else if (inherits(cond, "warning")) {
[15:32:31.752]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:31.752]                       if (muffled) 
[15:32:31.752]                         invokeRestart("muffleWarning")
[15:32:31.752]                     }
[15:32:31.752]                     else if (inherits(cond, "condition")) {
[15:32:31.752]                       if (!is.null(pattern)) {
[15:32:31.752]                         computeRestarts <- base::computeRestarts
[15:32:31.752]                         grepl <- base::grepl
[15:32:31.752]                         restarts <- computeRestarts(cond)
[15:32:31.752]                         for (restart in restarts) {
[15:32:31.752]                           name <- restart$name
[15:32:31.752]                           if (is.null(name)) 
[15:32:31.752]                             next
[15:32:31.752]                           if (!grepl(pattern, name)) 
[15:32:31.752]                             next
[15:32:31.752]                           invokeRestart(restart)
[15:32:31.752]                           muffled <- TRUE
[15:32:31.752]                           break
[15:32:31.752]                         }
[15:32:31.752]                       }
[15:32:31.752]                     }
[15:32:31.752]                     invisible(muffled)
[15:32:31.752]                   }
[15:32:31.752]                   muffleCondition(cond)
[15:32:31.752]                 })
[15:32:31.752]             }))
[15:32:31.752]             future::FutureResult(value = ...future.value$value, 
[15:32:31.752]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:31.752]                   ...future.rng), globalenv = if (FALSE) 
[15:32:31.752]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:31.752]                     ...future.globalenv.names))
[15:32:31.752]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:31.752]         }, condition = base::local({
[15:32:31.752]             c <- base::c
[15:32:31.752]             inherits <- base::inherits
[15:32:31.752]             invokeRestart <- base::invokeRestart
[15:32:31.752]             length <- base::length
[15:32:31.752]             list <- base::list
[15:32:31.752]             seq.int <- base::seq.int
[15:32:31.752]             signalCondition <- base::signalCondition
[15:32:31.752]             sys.calls <- base::sys.calls
[15:32:31.752]             `[[` <- base::`[[`
[15:32:31.752]             `+` <- base::`+`
[15:32:31.752]             `<<-` <- base::`<<-`
[15:32:31.752]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:31.752]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:31.752]                   3L)]
[15:32:31.752]             }
[15:32:31.752]             function(cond) {
[15:32:31.752]                 is_error <- inherits(cond, "error")
[15:32:31.752]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:31.752]                   NULL)
[15:32:31.752]                 if (is_error) {
[15:32:31.752]                   sessionInformation <- function() {
[15:32:31.752]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:31.752]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:31.752]                       search = base::search(), system = base::Sys.info())
[15:32:31.752]                   }
[15:32:31.752]                   ...future.conditions[[length(...future.conditions) + 
[15:32:31.752]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:31.752]                     cond$call), session = sessionInformation(), 
[15:32:31.752]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:31.752]                   signalCondition(cond)
[15:32:31.752]                 }
[15:32:31.752]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:31.752]                 "immediateCondition"))) {
[15:32:31.752]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:31.752]                   ...future.conditions[[length(...future.conditions) + 
[15:32:31.752]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:31.752]                   if (TRUE && !signal) {
[15:32:31.752]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:31.752]                     {
[15:32:31.752]                       inherits <- base::inherits
[15:32:31.752]                       invokeRestart <- base::invokeRestart
[15:32:31.752]                       is.null <- base::is.null
[15:32:31.752]                       muffled <- FALSE
[15:32:31.752]                       if (inherits(cond, "message")) {
[15:32:31.752]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:31.752]                         if (muffled) 
[15:32:31.752]                           invokeRestart("muffleMessage")
[15:32:31.752]                       }
[15:32:31.752]                       else if (inherits(cond, "warning")) {
[15:32:31.752]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:31.752]                         if (muffled) 
[15:32:31.752]                           invokeRestart("muffleWarning")
[15:32:31.752]                       }
[15:32:31.752]                       else if (inherits(cond, "condition")) {
[15:32:31.752]                         if (!is.null(pattern)) {
[15:32:31.752]                           computeRestarts <- base::computeRestarts
[15:32:31.752]                           grepl <- base::grepl
[15:32:31.752]                           restarts <- computeRestarts(cond)
[15:32:31.752]                           for (restart in restarts) {
[15:32:31.752]                             name <- restart$name
[15:32:31.752]                             if (is.null(name)) 
[15:32:31.752]                               next
[15:32:31.752]                             if (!grepl(pattern, name)) 
[15:32:31.752]                               next
[15:32:31.752]                             invokeRestart(restart)
[15:32:31.752]                             muffled <- TRUE
[15:32:31.752]                             break
[15:32:31.752]                           }
[15:32:31.752]                         }
[15:32:31.752]                       }
[15:32:31.752]                       invisible(muffled)
[15:32:31.752]                     }
[15:32:31.752]                     muffleCondition(cond, pattern = "^muffle")
[15:32:31.752]                   }
[15:32:31.752]                 }
[15:32:31.752]                 else {
[15:32:31.752]                   if (TRUE) {
[15:32:31.752]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:31.752]                     {
[15:32:31.752]                       inherits <- base::inherits
[15:32:31.752]                       invokeRestart <- base::invokeRestart
[15:32:31.752]                       is.null <- base::is.null
[15:32:31.752]                       muffled <- FALSE
[15:32:31.752]                       if (inherits(cond, "message")) {
[15:32:31.752]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:31.752]                         if (muffled) 
[15:32:31.752]                           invokeRestart("muffleMessage")
[15:32:31.752]                       }
[15:32:31.752]                       else if (inherits(cond, "warning")) {
[15:32:31.752]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:31.752]                         if (muffled) 
[15:32:31.752]                           invokeRestart("muffleWarning")
[15:32:31.752]                       }
[15:32:31.752]                       else if (inherits(cond, "condition")) {
[15:32:31.752]                         if (!is.null(pattern)) {
[15:32:31.752]                           computeRestarts <- base::computeRestarts
[15:32:31.752]                           grepl <- base::grepl
[15:32:31.752]                           restarts <- computeRestarts(cond)
[15:32:31.752]                           for (restart in restarts) {
[15:32:31.752]                             name <- restart$name
[15:32:31.752]                             if (is.null(name)) 
[15:32:31.752]                               next
[15:32:31.752]                             if (!grepl(pattern, name)) 
[15:32:31.752]                               next
[15:32:31.752]                             invokeRestart(restart)
[15:32:31.752]                             muffled <- TRUE
[15:32:31.752]                             break
[15:32:31.752]                           }
[15:32:31.752]                         }
[15:32:31.752]                       }
[15:32:31.752]                       invisible(muffled)
[15:32:31.752]                     }
[15:32:31.752]                     muffleCondition(cond, pattern = "^muffle")
[15:32:31.752]                   }
[15:32:31.752]                 }
[15:32:31.752]             }
[15:32:31.752]         }))
[15:32:31.752]     }, error = function(ex) {
[15:32:31.752]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:31.752]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:31.752]                 ...future.rng), started = ...future.startTime, 
[15:32:31.752]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:31.752]             version = "1.8"), class = "FutureResult")
[15:32:31.752]     }, finally = {
[15:32:31.752]         if (!identical(...future.workdir, getwd())) 
[15:32:31.752]             setwd(...future.workdir)
[15:32:31.752]         {
[15:32:31.752]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:31.752]                 ...future.oldOptions$nwarnings <- NULL
[15:32:31.752]             }
[15:32:31.752]             base::options(...future.oldOptions)
[15:32:31.752]             if (.Platform$OS.type == "windows") {
[15:32:31.752]                 old_names <- names(...future.oldEnvVars)
[15:32:31.752]                 envs <- base::Sys.getenv()
[15:32:31.752]                 names <- names(envs)
[15:32:31.752]                 common <- intersect(names, old_names)
[15:32:31.752]                 added <- setdiff(names, old_names)
[15:32:31.752]                 removed <- setdiff(old_names, names)
[15:32:31.752]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:31.752]                   envs[common]]
[15:32:31.752]                 NAMES <- toupper(changed)
[15:32:31.752]                 args <- list()
[15:32:31.752]                 for (kk in seq_along(NAMES)) {
[15:32:31.752]                   name <- changed[[kk]]
[15:32:31.752]                   NAME <- NAMES[[kk]]
[15:32:31.752]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:31.752]                     next
[15:32:31.752]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:31.752]                 }
[15:32:31.752]                 NAMES <- toupper(added)
[15:32:31.752]                 for (kk in seq_along(NAMES)) {
[15:32:31.752]                   name <- added[[kk]]
[15:32:31.752]                   NAME <- NAMES[[kk]]
[15:32:31.752]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:31.752]                     next
[15:32:31.752]                   args[[name]] <- ""
[15:32:31.752]                 }
[15:32:31.752]                 NAMES <- toupper(removed)
[15:32:31.752]                 for (kk in seq_along(NAMES)) {
[15:32:31.752]                   name <- removed[[kk]]
[15:32:31.752]                   NAME <- NAMES[[kk]]
[15:32:31.752]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:31.752]                     next
[15:32:31.752]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:31.752]                 }
[15:32:31.752]                 if (length(args) > 0) 
[15:32:31.752]                   base::do.call(base::Sys.setenv, args = args)
[15:32:31.752]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:31.752]             }
[15:32:31.752]             else {
[15:32:31.752]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:31.752]             }
[15:32:31.752]             {
[15:32:31.752]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:31.752]                   0L) {
[15:32:31.752]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:31.752]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:31.752]                   base::options(opts)
[15:32:31.752]                 }
[15:32:31.752]                 {
[15:32:31.752]                   {
[15:32:31.752]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:31.752]                     NULL
[15:32:31.752]                   }
[15:32:31.752]                   options(future.plan = NULL)
[15:32:31.752]                   if (is.na(NA_character_)) 
[15:32:31.752]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:31.752]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:31.752]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:31.752]                     .init = FALSE)
[15:32:31.752]                 }
[15:32:31.752]             }
[15:32:31.752]         }
[15:32:31.752]     })
[15:32:31.752]     if (TRUE) {
[15:32:31.752]         base::sink(type = "output", split = FALSE)
[15:32:31.752]         if (TRUE) {
[15:32:31.752]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:31.752]         }
[15:32:31.752]         else {
[15:32:31.752]             ...future.result["stdout"] <- base::list(NULL)
[15:32:31.752]         }
[15:32:31.752]         base::close(...future.stdout)
[15:32:31.752]         ...future.stdout <- NULL
[15:32:31.752]     }
[15:32:31.752]     ...future.result$conditions <- ...future.conditions
[15:32:31.752]     ...future.result$finished <- base::Sys.time()
[15:32:31.752]     ...future.result
[15:32:31.752] }
[15:32:31.758] Exporting 5 global objects (848 bytes) to cluster node #1 ...
[15:32:31.759] Exporting '...future.FUN' (848 bytes) to cluster node #1 ...
[15:32:31.759] Exporting '...future.FUN' (848 bytes) to cluster node #1 ... DONE
[15:32:31.760] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:31.760] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:31.760] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ...
[15:32:31.761] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ... DONE
[15:32:31.761] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:31.762] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:31.762] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:31.762] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:31.762] Exporting 5 global objects (848 bytes) to cluster node #1 ... DONE
[15:32:31.763] MultisessionFuture started
[15:32:31.763] - Launch lazy future ... done
[15:32:31.764] run() for 'MultisessionFuture' ... done
[15:32:31.764] Created future:
[15:32:31.781] receiveMessageFromWorker() for ClusterFuture ...
[15:32:31.781] - Validating connection of MultisessionFuture
[15:32:31.782] - received message: FutureResult
[15:32:31.782] - Received FutureResult
[15:32:31.782] - Erased future from FutureRegistry
[15:32:31.782] result() for ClusterFuture ...
[15:32:31.782] - result already collected: FutureResult
[15:32:31.783] result() for ClusterFuture ... done
[15:32:31.783] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:31.764] MultisessionFuture:
[15:32:31.764] Label: 'future_sapply-1'
[15:32:31.764] Expression:
[15:32:31.764] {
[15:32:31.764]     do.call(function(...) {
[15:32:31.764]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:31.764]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:31.764]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:31.764]             on.exit(options(oopts), add = TRUE)
[15:32:31.764]         }
[15:32:31.764]         {
[15:32:31.764]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:31.764]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:31.764]                 ...future.FUN(...future.X_jj, ...)
[15:32:31.764]             })
[15:32:31.764]         }
[15:32:31.764]     }, args = future.call.arguments)
[15:32:31.764] }
[15:32:31.764] Lazy evaluation: FALSE
[15:32:31.764] Asynchronous evaluation: TRUE
[15:32:31.764] Local evaluation: TRUE
[15:32:31.764] Environment: R_GlobalEnv
[15:32:31.764] Capture standard output: TRUE
[15:32:31.764] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:31.764] Globals: 5 objects totaling 0.99 KiB (function '...future.FUN' of 848 bytes, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:31.764] Packages: <none>
[15:32:31.764] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:31.764] Resolved: TRUE
[15:32:31.764] Value: <not collected>
[15:32:31.764] Conditions captured: <none>
[15:32:31.764] Early signaling: FALSE
[15:32:31.764] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:31.764] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:31.783] Chunk #1 of 2 ... DONE
[15:32:31.783] Chunk #2 of 2 ...
[15:32:31.784]  - Finding globals in 'X' for chunk #2 ...
[15:32:31.784] getGlobalsAndPackages() ...
[15:32:31.784] Searching for globals...
[15:32:31.784] 
[15:32:31.785] Searching for globals ... DONE
[15:32:31.785] - globals: [0] <none>
[15:32:31.785] getGlobalsAndPackages() ... DONE
[15:32:31.785]    + additional globals found: [n=0] 
[15:32:31.785]    + additional namespaces needed: [n=0] 
[15:32:31.785]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:31.786]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:31.786]  - seeds: <none>
[15:32:31.786]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:31.786] getGlobalsAndPackages() ...
[15:32:31.786] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:31.787] Resolving globals: FALSE
[15:32:31.787] Tweak future expression to call with '...' arguments ...
[15:32:31.787] {
[15:32:31.787]     do.call(function(...) {
[15:32:31.787]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:31.787]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:31.787]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:31.787]             on.exit(options(oopts), add = TRUE)
[15:32:31.787]         }
[15:32:31.787]         {
[15:32:31.787]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:31.787]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:31.787]                 ...future.FUN(...future.X_jj, ...)
[15:32:31.787]             })
[15:32:31.787]         }
[15:32:31.787]     }, args = future.call.arguments)
[15:32:31.787] }
[15:32:31.787] Tweak future expression to call with '...' arguments ... DONE
[15:32:31.788] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:31.788] 
[15:32:31.788] getGlobalsAndPackages() ... DONE
[15:32:31.789] run() for 'Future' ...
[15:32:31.789] - state: 'created'
[15:32:31.789] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:31.804] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:31.804] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:31.804]   - Field: 'node'
[15:32:31.805]   - Field: 'label'
[15:32:31.805]   - Field: 'local'
[15:32:31.805]   - Field: 'owner'
[15:32:31.805]   - Field: 'envir'
[15:32:31.806]   - Field: 'workers'
[15:32:31.806]   - Field: 'packages'
[15:32:31.806]   - Field: 'gc'
[15:32:31.806]   - Field: 'conditions'
[15:32:31.806]   - Field: 'persistent'
[15:32:31.806]   - Field: 'expr'
[15:32:31.807]   - Field: 'uuid'
[15:32:31.807]   - Field: 'seed'
[15:32:31.807]   - Field: 'version'
[15:32:31.807]   - Field: 'result'
[15:32:31.807]   - Field: 'asynchronous'
[15:32:31.808]   - Field: 'calls'
[15:32:31.808]   - Field: 'globals'
[15:32:31.808]   - Field: 'stdout'
[15:32:31.808]   - Field: 'earlySignal'
[15:32:31.808]   - Field: 'lazy'
[15:32:31.808]   - Field: 'state'
[15:32:31.809] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:31.809] - Launch lazy future ...
[15:32:31.809] Packages needed by the future expression (n = 0): <none>
[15:32:31.809] Packages needed by future strategies (n = 0): <none>
[15:32:31.810] {
[15:32:31.810]     {
[15:32:31.810]         {
[15:32:31.810]             ...future.startTime <- base::Sys.time()
[15:32:31.810]             {
[15:32:31.810]                 {
[15:32:31.810]                   {
[15:32:31.810]                     {
[15:32:31.810]                       base::local({
[15:32:31.810]                         has_future <- base::requireNamespace("future", 
[15:32:31.810]                           quietly = TRUE)
[15:32:31.810]                         if (has_future) {
[15:32:31.810]                           ns <- base::getNamespace("future")
[15:32:31.810]                           version <- ns[[".package"]][["version"]]
[15:32:31.810]                           if (is.null(version)) 
[15:32:31.810]                             version <- utils::packageVersion("future")
[15:32:31.810]                         }
[15:32:31.810]                         else {
[15:32:31.810]                           version <- NULL
[15:32:31.810]                         }
[15:32:31.810]                         if (!has_future || version < "1.8.0") {
[15:32:31.810]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:31.810]                             "", base::R.version$version.string), 
[15:32:31.810]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:31.810]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:31.810]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:31.810]                               "release", "version")], collapse = " "), 
[15:32:31.810]                             hostname = base::Sys.info()[["nodename"]])
[15:32:31.810]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:31.810]                             info)
[15:32:31.810]                           info <- base::paste(info, collapse = "; ")
[15:32:31.810]                           if (!has_future) {
[15:32:31.810]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:31.810]                               info)
[15:32:31.810]                           }
[15:32:31.810]                           else {
[15:32:31.810]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:31.810]                               info, version)
[15:32:31.810]                           }
[15:32:31.810]                           base::stop(msg)
[15:32:31.810]                         }
[15:32:31.810]                       })
[15:32:31.810]                     }
[15:32:31.810]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:31.810]                     base::options(mc.cores = 1L)
[15:32:31.810]                   }
[15:32:31.810]                   ...future.strategy.old <- future::plan("list")
[15:32:31.810]                   options(future.plan = NULL)
[15:32:31.810]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:31.810]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:31.810]                 }
[15:32:31.810]                 ...future.workdir <- getwd()
[15:32:31.810]             }
[15:32:31.810]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:31.810]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:31.810]         }
[15:32:31.810]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:31.810]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:31.810]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:31.810]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:31.810]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:31.810]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:31.810]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:31.810]             base::names(...future.oldOptions))
[15:32:31.810]     }
[15:32:31.810]     if (FALSE) {
[15:32:31.810]     }
[15:32:31.810]     else {
[15:32:31.810]         if (TRUE) {
[15:32:31.810]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:31.810]                 open = "w")
[15:32:31.810]         }
[15:32:31.810]         else {
[15:32:31.810]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:31.810]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:31.810]         }
[15:32:31.810]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:31.810]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:31.810]             base::sink(type = "output", split = FALSE)
[15:32:31.810]             base::close(...future.stdout)
[15:32:31.810]         }, add = TRUE)
[15:32:31.810]     }
[15:32:31.810]     ...future.frame <- base::sys.nframe()
[15:32:31.810]     ...future.conditions <- base::list()
[15:32:31.810]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:31.810]     if (FALSE) {
[15:32:31.810]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:31.810]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:31.810]     }
[15:32:31.810]     ...future.result <- base::tryCatch({
[15:32:31.810]         base::withCallingHandlers({
[15:32:31.810]             ...future.value <- base::withVisible(base::local({
[15:32:31.810]                 ...future.makeSendCondition <- base::local({
[15:32:31.810]                   sendCondition <- NULL
[15:32:31.810]                   function(frame = 1L) {
[15:32:31.810]                     if (is.function(sendCondition)) 
[15:32:31.810]                       return(sendCondition)
[15:32:31.810]                     ns <- getNamespace("parallel")
[15:32:31.810]                     if (exists("sendData", mode = "function", 
[15:32:31.810]                       envir = ns)) {
[15:32:31.810]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:31.810]                         envir = ns)
[15:32:31.810]                       envir <- sys.frame(frame)
[15:32:31.810]                       master <- NULL
[15:32:31.810]                       while (!identical(envir, .GlobalEnv) && 
[15:32:31.810]                         !identical(envir, emptyenv())) {
[15:32:31.810]                         if (exists("master", mode = "list", envir = envir, 
[15:32:31.810]                           inherits = FALSE)) {
[15:32:31.810]                           master <- get("master", mode = "list", 
[15:32:31.810]                             envir = envir, inherits = FALSE)
[15:32:31.810]                           if (inherits(master, c("SOCKnode", 
[15:32:31.810]                             "SOCK0node"))) {
[15:32:31.810]                             sendCondition <<- function(cond) {
[15:32:31.810]                               data <- list(type = "VALUE", value = cond, 
[15:32:31.810]                                 success = TRUE)
[15:32:31.810]                               parallel_sendData(master, data)
[15:32:31.810]                             }
[15:32:31.810]                             return(sendCondition)
[15:32:31.810]                           }
[15:32:31.810]                         }
[15:32:31.810]                         frame <- frame + 1L
[15:32:31.810]                         envir <- sys.frame(frame)
[15:32:31.810]                       }
[15:32:31.810]                     }
[15:32:31.810]                     sendCondition <<- function(cond) NULL
[15:32:31.810]                   }
[15:32:31.810]                 })
[15:32:31.810]                 withCallingHandlers({
[15:32:31.810]                   {
[15:32:31.810]                     do.call(function(...) {
[15:32:31.810]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:31.810]                       if (!identical(...future.globals.maxSize.org, 
[15:32:31.810]                         ...future.globals.maxSize)) {
[15:32:31.810]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:31.810]                         on.exit(options(oopts), add = TRUE)
[15:32:31.810]                       }
[15:32:31.810]                       {
[15:32:31.810]                         lapply(seq_along(...future.elements_ii), 
[15:32:31.810]                           FUN = function(jj) {
[15:32:31.810]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:31.810]                             ...future.FUN(...future.X_jj, ...)
[15:32:31.810]                           })
[15:32:31.810]                       }
[15:32:31.810]                     }, args = future.call.arguments)
[15:32:31.810]                   }
[15:32:31.810]                 }, immediateCondition = function(cond) {
[15:32:31.810]                   sendCondition <- ...future.makeSendCondition()
[15:32:31.810]                   sendCondition(cond)
[15:32:31.810]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:31.810]                   {
[15:32:31.810]                     inherits <- base::inherits
[15:32:31.810]                     invokeRestart <- base::invokeRestart
[15:32:31.810]                     is.null <- base::is.null
[15:32:31.810]                     muffled <- FALSE
[15:32:31.810]                     if (inherits(cond, "message")) {
[15:32:31.810]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:31.810]                       if (muffled) 
[15:32:31.810]                         invokeRestart("muffleMessage")
[15:32:31.810]                     }
[15:32:31.810]                     else if (inherits(cond, "warning")) {
[15:32:31.810]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:31.810]                       if (muffled) 
[15:32:31.810]                         invokeRestart("muffleWarning")
[15:32:31.810]                     }
[15:32:31.810]                     else if (inherits(cond, "condition")) {
[15:32:31.810]                       if (!is.null(pattern)) {
[15:32:31.810]                         computeRestarts <- base::computeRestarts
[15:32:31.810]                         grepl <- base::grepl
[15:32:31.810]                         restarts <- computeRestarts(cond)
[15:32:31.810]                         for (restart in restarts) {
[15:32:31.810]                           name <- restart$name
[15:32:31.810]                           if (is.null(name)) 
[15:32:31.810]                             next
[15:32:31.810]                           if (!grepl(pattern, name)) 
[15:32:31.810]                             next
[15:32:31.810]                           invokeRestart(restart)
[15:32:31.810]                           muffled <- TRUE
[15:32:31.810]                           break
[15:32:31.810]                         }
[15:32:31.810]                       }
[15:32:31.810]                     }
[15:32:31.810]                     invisible(muffled)
[15:32:31.810]                   }
[15:32:31.810]                   muffleCondition(cond)
[15:32:31.810]                 })
[15:32:31.810]             }))
[15:32:31.810]             future::FutureResult(value = ...future.value$value, 
[15:32:31.810]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:31.810]                   ...future.rng), globalenv = if (FALSE) 
[15:32:31.810]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:31.810]                     ...future.globalenv.names))
[15:32:31.810]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:31.810]         }, condition = base::local({
[15:32:31.810]             c <- base::c
[15:32:31.810]             inherits <- base::inherits
[15:32:31.810]             invokeRestart <- base::invokeRestart
[15:32:31.810]             length <- base::length
[15:32:31.810]             list <- base::list
[15:32:31.810]             seq.int <- base::seq.int
[15:32:31.810]             signalCondition <- base::signalCondition
[15:32:31.810]             sys.calls <- base::sys.calls
[15:32:31.810]             `[[` <- base::`[[`
[15:32:31.810]             `+` <- base::`+`
[15:32:31.810]             `<<-` <- base::`<<-`
[15:32:31.810]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:31.810]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:31.810]                   3L)]
[15:32:31.810]             }
[15:32:31.810]             function(cond) {
[15:32:31.810]                 is_error <- inherits(cond, "error")
[15:32:31.810]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:31.810]                   NULL)
[15:32:31.810]                 if (is_error) {
[15:32:31.810]                   sessionInformation <- function() {
[15:32:31.810]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:31.810]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:31.810]                       search = base::search(), system = base::Sys.info())
[15:32:31.810]                   }
[15:32:31.810]                   ...future.conditions[[length(...future.conditions) + 
[15:32:31.810]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:31.810]                     cond$call), session = sessionInformation(), 
[15:32:31.810]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:31.810]                   signalCondition(cond)
[15:32:31.810]                 }
[15:32:31.810]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:31.810]                 "immediateCondition"))) {
[15:32:31.810]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:31.810]                   ...future.conditions[[length(...future.conditions) + 
[15:32:31.810]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:31.810]                   if (TRUE && !signal) {
[15:32:31.810]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:31.810]                     {
[15:32:31.810]                       inherits <- base::inherits
[15:32:31.810]                       invokeRestart <- base::invokeRestart
[15:32:31.810]                       is.null <- base::is.null
[15:32:31.810]                       muffled <- FALSE
[15:32:31.810]                       if (inherits(cond, "message")) {
[15:32:31.810]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:31.810]                         if (muffled) 
[15:32:31.810]                           invokeRestart("muffleMessage")
[15:32:31.810]                       }
[15:32:31.810]                       else if (inherits(cond, "warning")) {
[15:32:31.810]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:31.810]                         if (muffled) 
[15:32:31.810]                           invokeRestart("muffleWarning")
[15:32:31.810]                       }
[15:32:31.810]                       else if (inherits(cond, "condition")) {
[15:32:31.810]                         if (!is.null(pattern)) {
[15:32:31.810]                           computeRestarts <- base::computeRestarts
[15:32:31.810]                           grepl <- base::grepl
[15:32:31.810]                           restarts <- computeRestarts(cond)
[15:32:31.810]                           for (restart in restarts) {
[15:32:31.810]                             name <- restart$name
[15:32:31.810]                             if (is.null(name)) 
[15:32:31.810]                               next
[15:32:31.810]                             if (!grepl(pattern, name)) 
[15:32:31.810]                               next
[15:32:31.810]                             invokeRestart(restart)
[15:32:31.810]                             muffled <- TRUE
[15:32:31.810]                             break
[15:32:31.810]                           }
[15:32:31.810]                         }
[15:32:31.810]                       }
[15:32:31.810]                       invisible(muffled)
[15:32:31.810]                     }
[15:32:31.810]                     muffleCondition(cond, pattern = "^muffle")
[15:32:31.810]                   }
[15:32:31.810]                 }
[15:32:31.810]                 else {
[15:32:31.810]                   if (TRUE) {
[15:32:31.810]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:31.810]                     {
[15:32:31.810]                       inherits <- base::inherits
[15:32:31.810]                       invokeRestart <- base::invokeRestart
[15:32:31.810]                       is.null <- base::is.null
[15:32:31.810]                       muffled <- FALSE
[15:32:31.810]                       if (inherits(cond, "message")) {
[15:32:31.810]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:31.810]                         if (muffled) 
[15:32:31.810]                           invokeRestart("muffleMessage")
[15:32:31.810]                       }
[15:32:31.810]                       else if (inherits(cond, "warning")) {
[15:32:31.810]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:31.810]                         if (muffled) 
[15:32:31.810]                           invokeRestart("muffleWarning")
[15:32:31.810]                       }
[15:32:31.810]                       else if (inherits(cond, "condition")) {
[15:32:31.810]                         if (!is.null(pattern)) {
[15:32:31.810]                           computeRestarts <- base::computeRestarts
[15:32:31.810]                           grepl <- base::grepl
[15:32:31.810]                           restarts <- computeRestarts(cond)
[15:32:31.810]                           for (restart in restarts) {
[15:32:31.810]                             name <- restart$name
[15:32:31.810]                             if (is.null(name)) 
[15:32:31.810]                               next
[15:32:31.810]                             if (!grepl(pattern, name)) 
[15:32:31.810]                               next
[15:32:31.810]                             invokeRestart(restart)
[15:32:31.810]                             muffled <- TRUE
[15:32:31.810]                             break
[15:32:31.810]                           }
[15:32:31.810]                         }
[15:32:31.810]                       }
[15:32:31.810]                       invisible(muffled)
[15:32:31.810]                     }
[15:32:31.810]                     muffleCondition(cond, pattern = "^muffle")
[15:32:31.810]                   }
[15:32:31.810]                 }
[15:32:31.810]             }
[15:32:31.810]         }))
[15:32:31.810]     }, error = function(ex) {
[15:32:31.810]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:31.810]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:31.810]                 ...future.rng), started = ...future.startTime, 
[15:32:31.810]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:31.810]             version = "1.8"), class = "FutureResult")
[15:32:31.810]     }, finally = {
[15:32:31.810]         if (!identical(...future.workdir, getwd())) 
[15:32:31.810]             setwd(...future.workdir)
[15:32:31.810]         {
[15:32:31.810]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:31.810]                 ...future.oldOptions$nwarnings <- NULL
[15:32:31.810]             }
[15:32:31.810]             base::options(...future.oldOptions)
[15:32:31.810]             if (.Platform$OS.type == "windows") {
[15:32:31.810]                 old_names <- names(...future.oldEnvVars)
[15:32:31.810]                 envs <- base::Sys.getenv()
[15:32:31.810]                 names <- names(envs)
[15:32:31.810]                 common <- intersect(names, old_names)
[15:32:31.810]                 added <- setdiff(names, old_names)
[15:32:31.810]                 removed <- setdiff(old_names, names)
[15:32:31.810]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:31.810]                   envs[common]]
[15:32:31.810]                 NAMES <- toupper(changed)
[15:32:31.810]                 args <- list()
[15:32:31.810]                 for (kk in seq_along(NAMES)) {
[15:32:31.810]                   name <- changed[[kk]]
[15:32:31.810]                   NAME <- NAMES[[kk]]
[15:32:31.810]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:31.810]                     next
[15:32:31.810]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:31.810]                 }
[15:32:31.810]                 NAMES <- toupper(added)
[15:32:31.810]                 for (kk in seq_along(NAMES)) {
[15:32:31.810]                   name <- added[[kk]]
[15:32:31.810]                   NAME <- NAMES[[kk]]
[15:32:31.810]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:31.810]                     next
[15:32:31.810]                   args[[name]] <- ""
[15:32:31.810]                 }
[15:32:31.810]                 NAMES <- toupper(removed)
[15:32:31.810]                 for (kk in seq_along(NAMES)) {
[15:32:31.810]                   name <- removed[[kk]]
[15:32:31.810]                   NAME <- NAMES[[kk]]
[15:32:31.810]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:31.810]                     next
[15:32:31.810]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:31.810]                 }
[15:32:31.810]                 if (length(args) > 0) 
[15:32:31.810]                   base::do.call(base::Sys.setenv, args = args)
[15:32:31.810]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:31.810]             }
[15:32:31.810]             else {
[15:32:31.810]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:31.810]             }
[15:32:31.810]             {
[15:32:31.810]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:31.810]                   0L) {
[15:32:31.810]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:31.810]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:31.810]                   base::options(opts)
[15:32:31.810]                 }
[15:32:31.810]                 {
[15:32:31.810]                   {
[15:32:31.810]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:31.810]                     NULL
[15:32:31.810]                   }
[15:32:31.810]                   options(future.plan = NULL)
[15:32:31.810]                   if (is.na(NA_character_)) 
[15:32:31.810]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:31.810]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:31.810]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:31.810]                     .init = FALSE)
[15:32:31.810]                 }
[15:32:31.810]             }
[15:32:31.810]         }
[15:32:31.810]     })
[15:32:31.810]     if (TRUE) {
[15:32:31.810]         base::sink(type = "output", split = FALSE)
[15:32:31.810]         if (TRUE) {
[15:32:31.810]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:31.810]         }
[15:32:31.810]         else {
[15:32:31.810]             ...future.result["stdout"] <- base::list(NULL)
[15:32:31.810]         }
[15:32:31.810]         base::close(...future.stdout)
[15:32:31.810]         ...future.stdout <- NULL
[15:32:31.810]     }
[15:32:31.810]     ...future.result$conditions <- ...future.conditions
[15:32:31.810]     ...future.result$finished <- base::Sys.time()
[15:32:31.810]     ...future.result
[15:32:31.810] }
[15:32:31.816] Exporting 5 global objects (848 bytes) to cluster node #1 ...
[15:32:31.816] Exporting '...future.FUN' (848 bytes) to cluster node #1 ...
[15:32:31.817] Exporting '...future.FUN' (848 bytes) to cluster node #1 ... DONE
[15:32:31.817] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:31.817] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:31.818] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ...
[15:32:31.818] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ... DONE
[15:32:31.818] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:31.819] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:31.819] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:31.829] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:31.829] Exporting 5 global objects (848 bytes) to cluster node #1 ... DONE
[15:32:31.830] MultisessionFuture started
[15:32:31.830] - Launch lazy future ... done
[15:32:31.830] run() for 'MultisessionFuture' ... done
[15:32:31.831] Created future:
[15:32:31.854] receiveMessageFromWorker() for ClusterFuture ...
[15:32:31.855] - Validating connection of MultisessionFuture
[15:32:31.855] - received message: FutureResult
[15:32:31.856] - Received FutureResult
[15:32:31.856] - Erased future from FutureRegistry
[15:32:31.856] result() for ClusterFuture ...
[15:32:31.856] - result already collected: FutureResult
[15:32:31.856] result() for ClusterFuture ... done
[15:32:31.857] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:31.831] MultisessionFuture:
[15:32:31.831] Label: 'future_sapply-2'
[15:32:31.831] Expression:
[15:32:31.831] {
[15:32:31.831]     do.call(function(...) {
[15:32:31.831]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:31.831]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:31.831]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:31.831]             on.exit(options(oopts), add = TRUE)
[15:32:31.831]         }
[15:32:31.831]         {
[15:32:31.831]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:31.831]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:31.831]                 ...future.FUN(...future.X_jj, ...)
[15:32:31.831]             })
[15:32:31.831]         }
[15:32:31.831]     }, args = future.call.arguments)
[15:32:31.831] }
[15:32:31.831] Lazy evaluation: FALSE
[15:32:31.831] Asynchronous evaluation: TRUE
[15:32:31.831] Local evaluation: TRUE
[15:32:31.831] Environment: R_GlobalEnv
[15:32:31.831] Capture standard output: TRUE
[15:32:31.831] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:31.831] Globals: 5 objects totaling 0.99 KiB (function '...future.FUN' of 848 bytes, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:31.831] Packages: <none>
[15:32:31.831] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:31.831] Resolved: TRUE
[15:32:31.831] Value: <not collected>
[15:32:31.831] Conditions captured: <none>
[15:32:31.831] Early signaling: FALSE
[15:32:31.831] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:31.831] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:31.857] Chunk #2 of 2 ... DONE
[15:32:31.857] Launching 2 futures (chunks) ... DONE
[15:32:31.857] Resolving 2 futures (chunks) ...
[15:32:31.858] resolve() on list ...
[15:32:31.858]  recursive: 0
[15:32:31.858]  length: 2
[15:32:31.858] 
[15:32:31.858] Future #1
[15:32:31.859] result() for ClusterFuture ...
[15:32:31.859] - result already collected: FutureResult
[15:32:31.859] result() for ClusterFuture ... done
[15:32:31.859] result() for ClusterFuture ...
[15:32:31.859] - result already collected: FutureResult
[15:32:31.859] result() for ClusterFuture ... done
[15:32:31.860] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:31.860] - nx: 2
[15:32:31.860] - relay: TRUE
[15:32:31.860] - stdout: TRUE
[15:32:31.860] - signal: TRUE
[15:32:31.860] - resignal: FALSE
[15:32:31.861] - force: TRUE
[15:32:31.861] - relayed: [n=2] FALSE, FALSE
[15:32:31.861] - queued futures: [n=2] FALSE, FALSE
[15:32:31.861]  - until=1
[15:32:31.861]  - relaying element #1
[15:32:31.861] result() for ClusterFuture ...
[15:32:31.862] - result already collected: FutureResult
[15:32:31.862] result() for ClusterFuture ... done
[15:32:31.862] result() for ClusterFuture ...
[15:32:31.862] - result already collected: FutureResult
[15:32:31.862] result() for ClusterFuture ... done
[15:32:31.863] result() for ClusterFuture ...
[15:32:31.863] - result already collected: FutureResult
[15:32:31.863] result() for ClusterFuture ... done
[15:32:31.863] result() for ClusterFuture ...
[15:32:31.863] - result already collected: FutureResult
[15:32:31.863] result() for ClusterFuture ... done
[15:32:31.863] - relayed: [n=2] TRUE, FALSE
[15:32:31.864] - queued futures: [n=2] TRUE, FALSE
[15:32:31.864] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:31.864]  length: 1 (resolved future 1)
[15:32:31.864] Future #2
[15:32:31.864] result() for ClusterFuture ...
[15:32:31.865] - result already collected: FutureResult
[15:32:31.865] result() for ClusterFuture ... done
[15:32:31.865] result() for ClusterFuture ...
[15:32:31.865] - result already collected: FutureResult
[15:32:31.865] result() for ClusterFuture ... done
[15:32:31.865] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:31.866] - nx: 2
[15:32:31.866] - relay: TRUE
[15:32:31.866] - stdout: TRUE
[15:32:31.866] - signal: TRUE
[15:32:31.866] - resignal: FALSE
[15:32:31.866] - force: TRUE
[15:32:31.867] - relayed: [n=2] TRUE, FALSE
[15:32:31.867] - queued futures: [n=2] TRUE, FALSE
[15:32:31.867]  - until=2
[15:32:31.867]  - relaying element #2
[15:32:31.867] result() for ClusterFuture ...
[15:32:31.867] - result already collected: FutureResult
[15:32:31.868] result() for ClusterFuture ... done
[15:32:31.868] result() for ClusterFuture ...
[15:32:31.868] - result already collected: FutureResult
[15:32:31.868] result() for ClusterFuture ... done
[15:32:31.868] result() for ClusterFuture ...
[15:32:31.868] - result already collected: FutureResult
[15:32:31.869] result() for ClusterFuture ... done
[15:32:31.869] result() for ClusterFuture ...
[15:32:31.869] - result already collected: FutureResult
[15:32:31.869] result() for ClusterFuture ... done
[15:32:31.869] - relayed: [n=2] TRUE, TRUE
[15:32:31.869] - queued futures: [n=2] TRUE, TRUE
[15:32:31.870] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:31.870]  length: 0 (resolved future 2)
[15:32:31.870] Relaying remaining futures
[15:32:31.870] signalConditionsASAP(NULL, pos=0) ...
[15:32:31.870] - nx: 2
[15:32:31.870] - relay: TRUE
[15:32:31.871] - stdout: TRUE
[15:32:31.871] - signal: TRUE
[15:32:31.871] - resignal: FALSE
[15:32:31.871] - force: TRUE
[15:32:31.871] - relayed: [n=2] TRUE, TRUE
[15:32:31.871] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:31.872] - relayed: [n=2] TRUE, TRUE
[15:32:31.872] - queued futures: [n=2] TRUE, TRUE
[15:32:31.872] signalConditionsASAP(NULL, pos=0) ... done
[15:32:31.872] resolve() on list ... DONE
[15:32:31.872] result() for ClusterFuture ...
[15:32:31.872] - result already collected: FutureResult
[15:32:31.873] result() for ClusterFuture ... done
[15:32:31.873] result() for ClusterFuture ...
[15:32:31.873] - result already collected: FutureResult
[15:32:31.873] result() for ClusterFuture ... done
[15:32:31.873] result() for ClusterFuture ...
[15:32:31.873] - result already collected: FutureResult
[15:32:31.874] result() for ClusterFuture ... done
[15:32:31.874] result() for ClusterFuture ...
[15:32:31.874] - result already collected: FutureResult
[15:32:31.874] result() for ClusterFuture ... done
[15:32:31.874]  - Number of value chunks collected: 2
[15:32:31.874] Resolving 2 futures (chunks) ... DONE
[15:32:31.875] Reducing values from 2 chunks ...
[15:32:31.875]  - Number of values collected after concatenation: 6
[15:32:31.875]  - Number of values expected: 6
[15:32:31.875] Reducing values from 2 chunks ... DONE
[15:32:31.875] future_lapply() ... DONE
List of 2
 $ y0: Named int [1:6] 1 2 2 3 3 4
  ..- attr(*, "names")= chr [1:6] "a1" "a2" "b1" "b2" ...
 $ y1: Named int [1:6] 1 2 2 3 3 4
  ..- attr(*, "names")= chr [1:6] "a1" "a2" "b1" "b2" ...
[15:32:31.878] future_lapply() ...
[15:32:31.881] Number of chunks: 2
[15:32:31.881] getGlobalsAndPackagesXApply() ...
[15:32:31.881]  - future.globals: TRUE
[15:32:31.881] getGlobalsAndPackages() ...
[15:32:31.881] Searching for globals...
[15:32:31.883] - globals found: [2] 'FUN', 'UseMethod'
[15:32:31.883] Searching for globals ... DONE
[15:32:31.883] Resolving globals: FALSE
[15:32:31.884] The total size of the 1 globals is 1.22 KiB (1248 bytes)
[15:32:31.884] The total size of the 1 globals exported for future expression ('FUN()') is 1.22 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.22 KiB of class 'function')
[15:32:31.884] - globals: [1] 'FUN'
[15:32:31.885] 
[15:32:31.885] getGlobalsAndPackages() ... DONE
[15:32:31.885]  - globals found/used: [n=1] 'FUN'
[15:32:31.885]  - needed namespaces: [n=0] 
[15:32:31.885] Finding globals ... DONE
[15:32:31.886]  - use_args: TRUE
[15:32:31.886]  - Getting '...' globals ...
[15:32:31.886] resolve() on list ...
[15:32:31.886]  recursive: 0
[15:32:31.886]  length: 1
[15:32:31.887]  elements: '...'
[15:32:31.887]  length: 0 (resolved future 1)
[15:32:31.887] resolve() on list ... DONE
[15:32:31.887]    - '...' content: [n=0] 
[15:32:31.887] List of 1
[15:32:31.887]  $ ...: list()
[15:32:31.887]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:31.887]  - attr(*, "where")=List of 1
[15:32:31.887]   ..$ ...:<environment: 0x00000276e1eaf418> 
[15:32:31.887]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:31.887]  - attr(*, "resolved")= logi TRUE
[15:32:31.887]  - attr(*, "total_size")= num NA
[15:32:31.891]  - Getting '...' globals ... DONE
[15:32:31.891] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:31.891] List of 2
[15:32:31.891]  $ ...future.FUN:function (x, ...)  
[15:32:31.891]  $ ...          : list()
[15:32:31.891]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:31.891]  - attr(*, "where")=List of 2
[15:32:31.891]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:31.891]   ..$ ...          :<environment: 0x00000276e1eaf418> 
[15:32:31.891]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:31.891]  - attr(*, "resolved")= logi FALSE
[15:32:31.891]  - attr(*, "total_size")= num 1248
[15:32:31.895] Packages to be attached in all futures: [n=0] 
[15:32:31.895] getGlobalsAndPackagesXApply() ... DONE
[15:32:31.895] Number of futures (= number of chunks): 2
[15:32:31.895] Launching 2 futures (chunks) ...
[15:32:31.895] Chunk #1 of 2 ...
[15:32:31.896]  - Finding globals in 'X' for chunk #1 ...
[15:32:31.896] getGlobalsAndPackages() ...
[15:32:31.896] Searching for globals...
[15:32:31.896] 
[15:32:31.897] Searching for globals ... DONE
[15:32:31.897] - globals: [0] <none>
[15:32:31.897] getGlobalsAndPackages() ... DONE
[15:32:31.897]    + additional globals found: [n=0] 
[15:32:31.897]    + additional namespaces needed: [n=0] 
[15:32:31.897]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:31.898]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:31.898]  - seeds: <none>
[15:32:31.898]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:31.898] getGlobalsAndPackages() ...
[15:32:31.898] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:31.898] Resolving globals: FALSE
[15:32:31.899] Tweak future expression to call with '...' arguments ...
[15:32:31.899] {
[15:32:31.899]     do.call(function(...) {
[15:32:31.899]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:31.899]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:31.899]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:31.899]             on.exit(options(oopts), add = TRUE)
[15:32:31.899]         }
[15:32:31.899]         {
[15:32:31.899]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:31.899]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:31.899]                 ...future.FUN(...future.X_jj, ...)
[15:32:31.899]             })
[15:32:31.899]         }
[15:32:31.899]     }, args = future.call.arguments)
[15:32:31.899] }
[15:32:31.899] Tweak future expression to call with '...' arguments ... DONE
[15:32:31.900] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:31.900] 
[15:32:31.900] getGlobalsAndPackages() ... DONE
[15:32:31.901] run() for 'Future' ...
[15:32:31.901] - state: 'created'
[15:32:31.901] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:31.917] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:31.917] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:31.918]   - Field: 'node'
[15:32:31.918]   - Field: 'label'
[15:32:31.918]   - Field: 'local'
[15:32:31.918]   - Field: 'owner'
[15:32:31.919]   - Field: 'envir'
[15:32:31.919]   - Field: 'workers'
[15:32:31.919]   - Field: 'packages'
[15:32:31.919]   - Field: 'gc'
[15:32:31.920]   - Field: 'conditions'
[15:32:31.920]   - Field: 'persistent'
[15:32:31.920]   - Field: 'expr'
[15:32:31.921]   - Field: 'uuid'
[15:32:31.921]   - Field: 'seed'
[15:32:31.921]   - Field: 'version'
[15:32:31.922]   - Field: 'result'
[15:32:31.922]   - Field: 'asynchronous'
[15:32:31.922]   - Field: 'calls'
[15:32:31.923]   - Field: 'globals'
[15:32:31.923]   - Field: 'stdout'
[15:32:31.923]   - Field: 'earlySignal'
[15:32:31.924]   - Field: 'lazy'
[15:32:31.924]   - Field: 'state'
[15:32:31.924] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:31.925] - Launch lazy future ...
[15:32:31.925] Packages needed by the future expression (n = 0): <none>
[15:32:31.926] Packages needed by future strategies (n = 0): <none>
[15:32:31.927] {
[15:32:31.927]     {
[15:32:31.927]         {
[15:32:31.927]             ...future.startTime <- base::Sys.time()
[15:32:31.927]             {
[15:32:31.927]                 {
[15:32:31.927]                   {
[15:32:31.927]                     {
[15:32:31.927]                       base::local({
[15:32:31.927]                         has_future <- base::requireNamespace("future", 
[15:32:31.927]                           quietly = TRUE)
[15:32:31.927]                         if (has_future) {
[15:32:31.927]                           ns <- base::getNamespace("future")
[15:32:31.927]                           version <- ns[[".package"]][["version"]]
[15:32:31.927]                           if (is.null(version)) 
[15:32:31.927]                             version <- utils::packageVersion("future")
[15:32:31.927]                         }
[15:32:31.927]                         else {
[15:32:31.927]                           version <- NULL
[15:32:31.927]                         }
[15:32:31.927]                         if (!has_future || version < "1.8.0") {
[15:32:31.927]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:31.927]                             "", base::R.version$version.string), 
[15:32:31.927]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:31.927]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:31.927]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:31.927]                               "release", "version")], collapse = " "), 
[15:32:31.927]                             hostname = base::Sys.info()[["nodename"]])
[15:32:31.927]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:31.927]                             info)
[15:32:31.927]                           info <- base::paste(info, collapse = "; ")
[15:32:31.927]                           if (!has_future) {
[15:32:31.927]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:31.927]                               info)
[15:32:31.927]                           }
[15:32:31.927]                           else {
[15:32:31.927]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:31.927]                               info, version)
[15:32:31.927]                           }
[15:32:31.927]                           base::stop(msg)
[15:32:31.927]                         }
[15:32:31.927]                       })
[15:32:31.927]                     }
[15:32:31.927]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:31.927]                     base::options(mc.cores = 1L)
[15:32:31.927]                   }
[15:32:31.927]                   ...future.strategy.old <- future::plan("list")
[15:32:31.927]                   options(future.plan = NULL)
[15:32:31.927]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:31.927]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:31.927]                 }
[15:32:31.927]                 ...future.workdir <- getwd()
[15:32:31.927]             }
[15:32:31.927]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:31.927]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:31.927]         }
[15:32:31.927]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:31.927]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:31.927]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:31.927]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:31.927]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:31.927]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:31.927]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:31.927]             base::names(...future.oldOptions))
[15:32:31.927]     }
[15:32:31.927]     if (FALSE) {
[15:32:31.927]     }
[15:32:31.927]     else {
[15:32:31.927]         if (TRUE) {
[15:32:31.927]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:31.927]                 open = "w")
[15:32:31.927]         }
[15:32:31.927]         else {
[15:32:31.927]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:31.927]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:31.927]         }
[15:32:31.927]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:31.927]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:31.927]             base::sink(type = "output", split = FALSE)
[15:32:31.927]             base::close(...future.stdout)
[15:32:31.927]         }, add = TRUE)
[15:32:31.927]     }
[15:32:31.927]     ...future.frame <- base::sys.nframe()
[15:32:31.927]     ...future.conditions <- base::list()
[15:32:31.927]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:31.927]     if (FALSE) {
[15:32:31.927]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:31.927]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:31.927]     }
[15:32:31.927]     ...future.result <- base::tryCatch({
[15:32:31.927]         base::withCallingHandlers({
[15:32:31.927]             ...future.value <- base::withVisible(base::local({
[15:32:31.927]                 ...future.makeSendCondition <- base::local({
[15:32:31.927]                   sendCondition <- NULL
[15:32:31.927]                   function(frame = 1L) {
[15:32:31.927]                     if (is.function(sendCondition)) 
[15:32:31.927]                       return(sendCondition)
[15:32:31.927]                     ns <- getNamespace("parallel")
[15:32:31.927]                     if (exists("sendData", mode = "function", 
[15:32:31.927]                       envir = ns)) {
[15:32:31.927]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:31.927]                         envir = ns)
[15:32:31.927]                       envir <- sys.frame(frame)
[15:32:31.927]                       master <- NULL
[15:32:31.927]                       while (!identical(envir, .GlobalEnv) && 
[15:32:31.927]                         !identical(envir, emptyenv())) {
[15:32:31.927]                         if (exists("master", mode = "list", envir = envir, 
[15:32:31.927]                           inherits = FALSE)) {
[15:32:31.927]                           master <- get("master", mode = "list", 
[15:32:31.927]                             envir = envir, inherits = FALSE)
[15:32:31.927]                           if (inherits(master, c("SOCKnode", 
[15:32:31.927]                             "SOCK0node"))) {
[15:32:31.927]                             sendCondition <<- function(cond) {
[15:32:31.927]                               data <- list(type = "VALUE", value = cond, 
[15:32:31.927]                                 success = TRUE)
[15:32:31.927]                               parallel_sendData(master, data)
[15:32:31.927]                             }
[15:32:31.927]                             return(sendCondition)
[15:32:31.927]                           }
[15:32:31.927]                         }
[15:32:31.927]                         frame <- frame + 1L
[15:32:31.927]                         envir <- sys.frame(frame)
[15:32:31.927]                       }
[15:32:31.927]                     }
[15:32:31.927]                     sendCondition <<- function(cond) NULL
[15:32:31.927]                   }
[15:32:31.927]                 })
[15:32:31.927]                 withCallingHandlers({
[15:32:31.927]                   {
[15:32:31.927]                     do.call(function(...) {
[15:32:31.927]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:31.927]                       if (!identical(...future.globals.maxSize.org, 
[15:32:31.927]                         ...future.globals.maxSize)) {
[15:32:31.927]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:31.927]                         on.exit(options(oopts), add = TRUE)
[15:32:31.927]                       }
[15:32:31.927]                       {
[15:32:31.927]                         lapply(seq_along(...future.elements_ii), 
[15:32:31.927]                           FUN = function(jj) {
[15:32:31.927]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:31.927]                             ...future.FUN(...future.X_jj, ...)
[15:32:31.927]                           })
[15:32:31.927]                       }
[15:32:31.927]                     }, args = future.call.arguments)
[15:32:31.927]                   }
[15:32:31.927]                 }, immediateCondition = function(cond) {
[15:32:31.927]                   sendCondition <- ...future.makeSendCondition()
[15:32:31.927]                   sendCondition(cond)
[15:32:31.927]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:31.927]                   {
[15:32:31.927]                     inherits <- base::inherits
[15:32:31.927]                     invokeRestart <- base::invokeRestart
[15:32:31.927]                     is.null <- base::is.null
[15:32:31.927]                     muffled <- FALSE
[15:32:31.927]                     if (inherits(cond, "message")) {
[15:32:31.927]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:31.927]                       if (muffled) 
[15:32:31.927]                         invokeRestart("muffleMessage")
[15:32:31.927]                     }
[15:32:31.927]                     else if (inherits(cond, "warning")) {
[15:32:31.927]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:31.927]                       if (muffled) 
[15:32:31.927]                         invokeRestart("muffleWarning")
[15:32:31.927]                     }
[15:32:31.927]                     else if (inherits(cond, "condition")) {
[15:32:31.927]                       if (!is.null(pattern)) {
[15:32:31.927]                         computeRestarts <- base::computeRestarts
[15:32:31.927]                         grepl <- base::grepl
[15:32:31.927]                         restarts <- computeRestarts(cond)
[15:32:31.927]                         for (restart in restarts) {
[15:32:31.927]                           name <- restart$name
[15:32:31.927]                           if (is.null(name)) 
[15:32:31.927]                             next
[15:32:31.927]                           if (!grepl(pattern, name)) 
[15:32:31.927]                             next
[15:32:31.927]                           invokeRestart(restart)
[15:32:31.927]                           muffled <- TRUE
[15:32:31.927]                           break
[15:32:31.927]                         }
[15:32:31.927]                       }
[15:32:31.927]                     }
[15:32:31.927]                     invisible(muffled)
[15:32:31.927]                   }
[15:32:31.927]                   muffleCondition(cond)
[15:32:31.927]                 })
[15:32:31.927]             }))
[15:32:31.927]             future::FutureResult(value = ...future.value$value, 
[15:32:31.927]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:31.927]                   ...future.rng), globalenv = if (FALSE) 
[15:32:31.927]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:31.927]                     ...future.globalenv.names))
[15:32:31.927]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:31.927]         }, condition = base::local({
[15:32:31.927]             c <- base::c
[15:32:31.927]             inherits <- base::inherits
[15:32:31.927]             invokeRestart <- base::invokeRestart
[15:32:31.927]             length <- base::length
[15:32:31.927]             list <- base::list
[15:32:31.927]             seq.int <- base::seq.int
[15:32:31.927]             signalCondition <- base::signalCondition
[15:32:31.927]             sys.calls <- base::sys.calls
[15:32:31.927]             `[[` <- base::`[[`
[15:32:31.927]             `+` <- base::`+`
[15:32:31.927]             `<<-` <- base::`<<-`
[15:32:31.927]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:31.927]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:31.927]                   3L)]
[15:32:31.927]             }
[15:32:31.927]             function(cond) {
[15:32:31.927]                 is_error <- inherits(cond, "error")
[15:32:31.927]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:31.927]                   NULL)
[15:32:31.927]                 if (is_error) {
[15:32:31.927]                   sessionInformation <- function() {
[15:32:31.927]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:31.927]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:31.927]                       search = base::search(), system = base::Sys.info())
[15:32:31.927]                   }
[15:32:31.927]                   ...future.conditions[[length(...future.conditions) + 
[15:32:31.927]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:31.927]                     cond$call), session = sessionInformation(), 
[15:32:31.927]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:31.927]                   signalCondition(cond)
[15:32:31.927]                 }
[15:32:31.927]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:31.927]                 "immediateCondition"))) {
[15:32:31.927]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:31.927]                   ...future.conditions[[length(...future.conditions) + 
[15:32:31.927]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:31.927]                   if (TRUE && !signal) {
[15:32:31.927]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:31.927]                     {
[15:32:31.927]                       inherits <- base::inherits
[15:32:31.927]                       invokeRestart <- base::invokeRestart
[15:32:31.927]                       is.null <- base::is.null
[15:32:31.927]                       muffled <- FALSE
[15:32:31.927]                       if (inherits(cond, "message")) {
[15:32:31.927]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:31.927]                         if (muffled) 
[15:32:31.927]                           invokeRestart("muffleMessage")
[15:32:31.927]                       }
[15:32:31.927]                       else if (inherits(cond, "warning")) {
[15:32:31.927]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:31.927]                         if (muffled) 
[15:32:31.927]                           invokeRestart("muffleWarning")
[15:32:31.927]                       }
[15:32:31.927]                       else if (inherits(cond, "condition")) {
[15:32:31.927]                         if (!is.null(pattern)) {
[15:32:31.927]                           computeRestarts <- base::computeRestarts
[15:32:31.927]                           grepl <- base::grepl
[15:32:31.927]                           restarts <- computeRestarts(cond)
[15:32:31.927]                           for (restart in restarts) {
[15:32:31.927]                             name <- restart$name
[15:32:31.927]                             if (is.null(name)) 
[15:32:31.927]                               next
[15:32:31.927]                             if (!grepl(pattern, name)) 
[15:32:31.927]                               next
[15:32:31.927]                             invokeRestart(restart)
[15:32:31.927]                             muffled <- TRUE
[15:32:31.927]                             break
[15:32:31.927]                           }
[15:32:31.927]                         }
[15:32:31.927]                       }
[15:32:31.927]                       invisible(muffled)
[15:32:31.927]                     }
[15:32:31.927]                     muffleCondition(cond, pattern = "^muffle")
[15:32:31.927]                   }
[15:32:31.927]                 }
[15:32:31.927]                 else {
[15:32:31.927]                   if (TRUE) {
[15:32:31.927]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:31.927]                     {
[15:32:31.927]                       inherits <- base::inherits
[15:32:31.927]                       invokeRestart <- base::invokeRestart
[15:32:31.927]                       is.null <- base::is.null
[15:32:31.927]                       muffled <- FALSE
[15:32:31.927]                       if (inherits(cond, "message")) {
[15:32:31.927]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:31.927]                         if (muffled) 
[15:32:31.927]                           invokeRestart("muffleMessage")
[15:32:31.927]                       }
[15:32:31.927]                       else if (inherits(cond, "warning")) {
[15:32:31.927]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:31.927]                         if (muffled) 
[15:32:31.927]                           invokeRestart("muffleWarning")
[15:32:31.927]                       }
[15:32:31.927]                       else if (inherits(cond, "condition")) {
[15:32:31.927]                         if (!is.null(pattern)) {
[15:32:31.927]                           computeRestarts <- base::computeRestarts
[15:32:31.927]                           grepl <- base::grepl
[15:32:31.927]                           restarts <- computeRestarts(cond)
[15:32:31.927]                           for (restart in restarts) {
[15:32:31.927]                             name <- restart$name
[15:32:31.927]                             if (is.null(name)) 
[15:32:31.927]                               next
[15:32:31.927]                             if (!grepl(pattern, name)) 
[15:32:31.927]                               next
[15:32:31.927]                             invokeRestart(restart)
[15:32:31.927]                             muffled <- TRUE
[15:32:31.927]                             break
[15:32:31.927]                           }
[15:32:31.927]                         }
[15:32:31.927]                       }
[15:32:31.927]                       invisible(muffled)
[15:32:31.927]                     }
[15:32:31.927]                     muffleCondition(cond, pattern = "^muffle")
[15:32:31.927]                   }
[15:32:31.927]                 }
[15:32:31.927]             }
[15:32:31.927]         }))
[15:32:31.927]     }, error = function(ex) {
[15:32:31.927]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:31.927]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:31.927]                 ...future.rng), started = ...future.startTime, 
[15:32:31.927]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:31.927]             version = "1.8"), class = "FutureResult")
[15:32:31.927]     }, finally = {
[15:32:31.927]         if (!identical(...future.workdir, getwd())) 
[15:32:31.927]             setwd(...future.workdir)
[15:32:31.927]         {
[15:32:31.927]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:31.927]                 ...future.oldOptions$nwarnings <- NULL
[15:32:31.927]             }
[15:32:31.927]             base::options(...future.oldOptions)
[15:32:31.927]             if (.Platform$OS.type == "windows") {
[15:32:31.927]                 old_names <- names(...future.oldEnvVars)
[15:32:31.927]                 envs <- base::Sys.getenv()
[15:32:31.927]                 names <- names(envs)
[15:32:31.927]                 common <- intersect(names, old_names)
[15:32:31.927]                 added <- setdiff(names, old_names)
[15:32:31.927]                 removed <- setdiff(old_names, names)
[15:32:31.927]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:31.927]                   envs[common]]
[15:32:31.927]                 NAMES <- toupper(changed)
[15:32:31.927]                 args <- list()
[15:32:31.927]                 for (kk in seq_along(NAMES)) {
[15:32:31.927]                   name <- changed[[kk]]
[15:32:31.927]                   NAME <- NAMES[[kk]]
[15:32:31.927]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:31.927]                     next
[15:32:31.927]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:31.927]                 }
[15:32:31.927]                 NAMES <- toupper(added)
[15:32:31.927]                 for (kk in seq_along(NAMES)) {
[15:32:31.927]                   name <- added[[kk]]
[15:32:31.927]                   NAME <- NAMES[[kk]]
[15:32:31.927]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:31.927]                     next
[15:32:31.927]                   args[[name]] <- ""
[15:32:31.927]                 }
[15:32:31.927]                 NAMES <- toupper(removed)
[15:32:31.927]                 for (kk in seq_along(NAMES)) {
[15:32:31.927]                   name <- removed[[kk]]
[15:32:31.927]                   NAME <- NAMES[[kk]]
[15:32:31.927]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:31.927]                     next
[15:32:31.927]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:31.927]                 }
[15:32:31.927]                 if (length(args) > 0) 
[15:32:31.927]                   base::do.call(base::Sys.setenv, args = args)
[15:32:31.927]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:31.927]             }
[15:32:31.927]             else {
[15:32:31.927]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:31.927]             }
[15:32:31.927]             {
[15:32:31.927]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:31.927]                   0L) {
[15:32:31.927]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:31.927]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:31.927]                   base::options(opts)
[15:32:31.927]                 }
[15:32:31.927]                 {
[15:32:31.927]                   {
[15:32:31.927]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:31.927]                     NULL
[15:32:31.927]                   }
[15:32:31.927]                   options(future.plan = NULL)
[15:32:31.927]                   if (is.na(NA_character_)) 
[15:32:31.927]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:31.927]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:31.927]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:31.927]                     .init = FALSE)
[15:32:31.927]                 }
[15:32:31.927]             }
[15:32:31.927]         }
[15:32:31.927]     })
[15:32:31.927]     if (TRUE) {
[15:32:31.927]         base::sink(type = "output", split = FALSE)
[15:32:31.927]         if (TRUE) {
[15:32:31.927]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:31.927]         }
[15:32:31.927]         else {
[15:32:31.927]             ...future.result["stdout"] <- base::list(NULL)
[15:32:31.927]         }
[15:32:31.927]         base::close(...future.stdout)
[15:32:31.927]         ...future.stdout <- NULL
[15:32:31.927]     }
[15:32:31.927]     ...future.result$conditions <- ...future.conditions
[15:32:31.927]     ...future.result$finished <- base::Sys.time()
[15:32:31.927]     ...future.result
[15:32:31.927] }
[15:32:31.934] Exporting 5 global objects (1.22 KiB) to cluster node #1 ...
[15:32:31.934] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ...
[15:32:31.934] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ... DONE
[15:32:31.935] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:31.935] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:31.935] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ...
[15:32:31.936] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ... DONE
[15:32:31.936] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:31.936] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:31.937] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:31.937] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:31.938] Exporting 5 global objects (1.22 KiB) to cluster node #1 ... DONE
[15:32:31.938] MultisessionFuture started
[15:32:31.939] - Launch lazy future ... done
[15:32:31.939] run() for 'MultisessionFuture' ... done
[15:32:31.939] Created future:
[15:32:31.959] receiveMessageFromWorker() for ClusterFuture ...
[15:32:31.960] - Validating connection of MultisessionFuture
[15:32:31.960] - received message: FutureResult
[15:32:31.961] - Received FutureResult
[15:32:31.961] - Erased future from FutureRegistry
[15:32:31.961] result() for ClusterFuture ...
[15:32:31.962] - result already collected: FutureResult
[15:32:31.962] result() for ClusterFuture ... done
[15:32:31.962] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:31.939] MultisessionFuture:
[15:32:31.939] Label: 'future_sapply-1'
[15:32:31.939] Expression:
[15:32:31.939] {
[15:32:31.939]     do.call(function(...) {
[15:32:31.939]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:31.939]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:31.939]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:31.939]             on.exit(options(oopts), add = TRUE)
[15:32:31.939]         }
[15:32:31.939]         {
[15:32:31.939]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:31.939]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:31.939]                 ...future.FUN(...future.X_jj, ...)
[15:32:31.939]             })
[15:32:31.939]         }
[15:32:31.939]     }, args = future.call.arguments)
[15:32:31.939] }
[15:32:31.939] Lazy evaluation: FALSE
[15:32:31.939] Asynchronous evaluation: TRUE
[15:32:31.939] Local evaluation: TRUE
[15:32:31.939] Environment: R_GlobalEnv
[15:32:31.939] Capture standard output: TRUE
[15:32:31.939] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:31.939] Globals: 5 objects totaling 1.38 KiB (function '...future.FUN' of 1.22 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:31.939] Packages: <none>
[15:32:31.939] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:31.939] Resolved: TRUE
[15:32:31.939] Value: <not collected>
[15:32:31.939] Conditions captured: <none>
[15:32:31.939] Early signaling: FALSE
[15:32:31.939] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:31.939] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:31.963] Chunk #1 of 2 ... DONE
[15:32:31.963] Chunk #2 of 2 ...
[15:32:31.964]  - Finding globals in 'X' for chunk #2 ...
[15:32:31.964] getGlobalsAndPackages() ...
[15:32:31.964] Searching for globals...
[15:32:31.965] 
[15:32:31.965] Searching for globals ... DONE
[15:32:31.966] - globals: [0] <none>
[15:32:31.966] getGlobalsAndPackages() ... DONE
[15:32:31.966]    + additional globals found: [n=0] 
[15:32:31.966]    + additional namespaces needed: [n=0] 
[15:32:31.967]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:31.967]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:31.967]  - seeds: <none>
[15:32:31.968]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:31.968] getGlobalsAndPackages() ...
[15:32:31.968] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:31.969] Resolving globals: FALSE
[15:32:31.969] Tweak future expression to call with '...' arguments ...
[15:32:31.969] {
[15:32:31.969]     do.call(function(...) {
[15:32:31.969]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:31.969]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:31.969]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:31.969]             on.exit(options(oopts), add = TRUE)
[15:32:31.969]         }
[15:32:31.969]         {
[15:32:31.969]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:31.969]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:31.969]                 ...future.FUN(...future.X_jj, ...)
[15:32:31.969]             })
[15:32:31.969]         }
[15:32:31.969]     }, args = future.call.arguments)
[15:32:31.969] }
[15:32:31.970] Tweak future expression to call with '...' arguments ... DONE
[15:32:31.971] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:31.971] 
[15:32:31.971] getGlobalsAndPackages() ... DONE
[15:32:31.972] run() for 'Future' ...
[15:32:31.972] - state: 'created'
[15:32:31.973] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:31.990] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:31.991] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:31.991]   - Field: 'node'
[15:32:31.991]   - Field: 'label'
[15:32:31.991]   - Field: 'local'
[15:32:31.991]   - Field: 'owner'
[15:32:31.992]   - Field: 'envir'
[15:32:31.992]   - Field: 'workers'
[15:32:31.992]   - Field: 'packages'
[15:32:31.992]   - Field: 'gc'
[15:32:31.992]   - Field: 'conditions'
[15:32:31.992]   - Field: 'persistent'
[15:32:31.993]   - Field: 'expr'
[15:32:31.993]   - Field: 'uuid'
[15:32:31.993]   - Field: 'seed'
[15:32:31.993]   - Field: 'version'
[15:32:31.993]   - Field: 'result'
[15:32:31.994]   - Field: 'asynchronous'
[15:32:31.994]   - Field: 'calls'
[15:32:31.994]   - Field: 'globals'
[15:32:31.994]   - Field: 'stdout'
[15:32:31.994]   - Field: 'earlySignal'
[15:32:31.994]   - Field: 'lazy'
[15:32:31.995]   - Field: 'state'
[15:32:31.995] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:31.995] - Launch lazy future ...
[15:32:31.995] Packages needed by the future expression (n = 0): <none>
[15:32:31.996] Packages needed by future strategies (n = 0): <none>
[15:32:31.996] {
[15:32:31.996]     {
[15:32:31.996]         {
[15:32:31.996]             ...future.startTime <- base::Sys.time()
[15:32:31.996]             {
[15:32:31.996]                 {
[15:32:31.996]                   {
[15:32:31.996]                     {
[15:32:31.996]                       base::local({
[15:32:31.996]                         has_future <- base::requireNamespace("future", 
[15:32:31.996]                           quietly = TRUE)
[15:32:31.996]                         if (has_future) {
[15:32:31.996]                           ns <- base::getNamespace("future")
[15:32:31.996]                           version <- ns[[".package"]][["version"]]
[15:32:31.996]                           if (is.null(version)) 
[15:32:31.996]                             version <- utils::packageVersion("future")
[15:32:31.996]                         }
[15:32:31.996]                         else {
[15:32:31.996]                           version <- NULL
[15:32:31.996]                         }
[15:32:31.996]                         if (!has_future || version < "1.8.0") {
[15:32:31.996]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:31.996]                             "", base::R.version$version.string), 
[15:32:31.996]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:31.996]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:31.996]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:31.996]                               "release", "version")], collapse = " "), 
[15:32:31.996]                             hostname = base::Sys.info()[["nodename"]])
[15:32:31.996]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:31.996]                             info)
[15:32:31.996]                           info <- base::paste(info, collapse = "; ")
[15:32:31.996]                           if (!has_future) {
[15:32:31.996]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:31.996]                               info)
[15:32:31.996]                           }
[15:32:31.996]                           else {
[15:32:31.996]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:31.996]                               info, version)
[15:32:31.996]                           }
[15:32:31.996]                           base::stop(msg)
[15:32:31.996]                         }
[15:32:31.996]                       })
[15:32:31.996]                     }
[15:32:31.996]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:31.996]                     base::options(mc.cores = 1L)
[15:32:31.996]                   }
[15:32:31.996]                   ...future.strategy.old <- future::plan("list")
[15:32:31.996]                   options(future.plan = NULL)
[15:32:31.996]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:31.996]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:31.996]                 }
[15:32:31.996]                 ...future.workdir <- getwd()
[15:32:31.996]             }
[15:32:31.996]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:31.996]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:31.996]         }
[15:32:31.996]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:31.996]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:31.996]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:31.996]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:31.996]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:31.996]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:31.996]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:31.996]             base::names(...future.oldOptions))
[15:32:31.996]     }
[15:32:31.996]     if (FALSE) {
[15:32:31.996]     }
[15:32:31.996]     else {
[15:32:31.996]         if (TRUE) {
[15:32:31.996]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:31.996]                 open = "w")
[15:32:31.996]         }
[15:32:31.996]         else {
[15:32:31.996]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:31.996]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:31.996]         }
[15:32:31.996]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:31.996]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:31.996]             base::sink(type = "output", split = FALSE)
[15:32:31.996]             base::close(...future.stdout)
[15:32:31.996]         }, add = TRUE)
[15:32:31.996]     }
[15:32:31.996]     ...future.frame <- base::sys.nframe()
[15:32:31.996]     ...future.conditions <- base::list()
[15:32:31.996]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:31.996]     if (FALSE) {
[15:32:31.996]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:31.996]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:31.996]     }
[15:32:31.996]     ...future.result <- base::tryCatch({
[15:32:31.996]         base::withCallingHandlers({
[15:32:31.996]             ...future.value <- base::withVisible(base::local({
[15:32:31.996]                 ...future.makeSendCondition <- base::local({
[15:32:31.996]                   sendCondition <- NULL
[15:32:31.996]                   function(frame = 1L) {
[15:32:31.996]                     if (is.function(sendCondition)) 
[15:32:31.996]                       return(sendCondition)
[15:32:31.996]                     ns <- getNamespace("parallel")
[15:32:31.996]                     if (exists("sendData", mode = "function", 
[15:32:31.996]                       envir = ns)) {
[15:32:31.996]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:31.996]                         envir = ns)
[15:32:31.996]                       envir <- sys.frame(frame)
[15:32:31.996]                       master <- NULL
[15:32:31.996]                       while (!identical(envir, .GlobalEnv) && 
[15:32:31.996]                         !identical(envir, emptyenv())) {
[15:32:31.996]                         if (exists("master", mode = "list", envir = envir, 
[15:32:31.996]                           inherits = FALSE)) {
[15:32:31.996]                           master <- get("master", mode = "list", 
[15:32:31.996]                             envir = envir, inherits = FALSE)
[15:32:31.996]                           if (inherits(master, c("SOCKnode", 
[15:32:31.996]                             "SOCK0node"))) {
[15:32:31.996]                             sendCondition <<- function(cond) {
[15:32:31.996]                               data <- list(type = "VALUE", value = cond, 
[15:32:31.996]                                 success = TRUE)
[15:32:31.996]                               parallel_sendData(master, data)
[15:32:31.996]                             }
[15:32:31.996]                             return(sendCondition)
[15:32:31.996]                           }
[15:32:31.996]                         }
[15:32:31.996]                         frame <- frame + 1L
[15:32:31.996]                         envir <- sys.frame(frame)
[15:32:31.996]                       }
[15:32:31.996]                     }
[15:32:31.996]                     sendCondition <<- function(cond) NULL
[15:32:31.996]                   }
[15:32:31.996]                 })
[15:32:31.996]                 withCallingHandlers({
[15:32:31.996]                   {
[15:32:31.996]                     do.call(function(...) {
[15:32:31.996]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:31.996]                       if (!identical(...future.globals.maxSize.org, 
[15:32:31.996]                         ...future.globals.maxSize)) {
[15:32:31.996]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:31.996]                         on.exit(options(oopts), add = TRUE)
[15:32:31.996]                       }
[15:32:31.996]                       {
[15:32:31.996]                         lapply(seq_along(...future.elements_ii), 
[15:32:31.996]                           FUN = function(jj) {
[15:32:31.996]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:31.996]                             ...future.FUN(...future.X_jj, ...)
[15:32:31.996]                           })
[15:32:31.996]                       }
[15:32:31.996]                     }, args = future.call.arguments)
[15:32:31.996]                   }
[15:32:31.996]                 }, immediateCondition = function(cond) {
[15:32:31.996]                   sendCondition <- ...future.makeSendCondition()
[15:32:31.996]                   sendCondition(cond)
[15:32:31.996]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:31.996]                   {
[15:32:31.996]                     inherits <- base::inherits
[15:32:31.996]                     invokeRestart <- base::invokeRestart
[15:32:31.996]                     is.null <- base::is.null
[15:32:31.996]                     muffled <- FALSE
[15:32:31.996]                     if (inherits(cond, "message")) {
[15:32:31.996]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:31.996]                       if (muffled) 
[15:32:31.996]                         invokeRestart("muffleMessage")
[15:32:31.996]                     }
[15:32:31.996]                     else if (inherits(cond, "warning")) {
[15:32:31.996]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:31.996]                       if (muffled) 
[15:32:31.996]                         invokeRestart("muffleWarning")
[15:32:31.996]                     }
[15:32:31.996]                     else if (inherits(cond, "condition")) {
[15:32:31.996]                       if (!is.null(pattern)) {
[15:32:31.996]                         computeRestarts <- base::computeRestarts
[15:32:31.996]                         grepl <- base::grepl
[15:32:31.996]                         restarts <- computeRestarts(cond)
[15:32:31.996]                         for (restart in restarts) {
[15:32:31.996]                           name <- restart$name
[15:32:31.996]                           if (is.null(name)) 
[15:32:31.996]                             next
[15:32:31.996]                           if (!grepl(pattern, name)) 
[15:32:31.996]                             next
[15:32:31.996]                           invokeRestart(restart)
[15:32:31.996]                           muffled <- TRUE
[15:32:31.996]                           break
[15:32:31.996]                         }
[15:32:31.996]                       }
[15:32:31.996]                     }
[15:32:31.996]                     invisible(muffled)
[15:32:31.996]                   }
[15:32:31.996]                   muffleCondition(cond)
[15:32:31.996]                 })
[15:32:31.996]             }))
[15:32:31.996]             future::FutureResult(value = ...future.value$value, 
[15:32:31.996]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:31.996]                   ...future.rng), globalenv = if (FALSE) 
[15:32:31.996]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:31.996]                     ...future.globalenv.names))
[15:32:31.996]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:31.996]         }, condition = base::local({
[15:32:31.996]             c <- base::c
[15:32:31.996]             inherits <- base::inherits
[15:32:31.996]             invokeRestart <- base::invokeRestart
[15:32:31.996]             length <- base::length
[15:32:31.996]             list <- base::list
[15:32:31.996]             seq.int <- base::seq.int
[15:32:31.996]             signalCondition <- base::signalCondition
[15:32:31.996]             sys.calls <- base::sys.calls
[15:32:31.996]             `[[` <- base::`[[`
[15:32:31.996]             `+` <- base::`+`
[15:32:31.996]             `<<-` <- base::`<<-`
[15:32:31.996]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:31.996]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:31.996]                   3L)]
[15:32:31.996]             }
[15:32:31.996]             function(cond) {
[15:32:31.996]                 is_error <- inherits(cond, "error")
[15:32:31.996]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:31.996]                   NULL)
[15:32:31.996]                 if (is_error) {
[15:32:31.996]                   sessionInformation <- function() {
[15:32:31.996]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:31.996]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:31.996]                       search = base::search(), system = base::Sys.info())
[15:32:31.996]                   }
[15:32:31.996]                   ...future.conditions[[length(...future.conditions) + 
[15:32:31.996]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:31.996]                     cond$call), session = sessionInformation(), 
[15:32:31.996]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:31.996]                   signalCondition(cond)
[15:32:31.996]                 }
[15:32:31.996]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:31.996]                 "immediateCondition"))) {
[15:32:31.996]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:31.996]                   ...future.conditions[[length(...future.conditions) + 
[15:32:31.996]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:31.996]                   if (TRUE && !signal) {
[15:32:31.996]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:31.996]                     {
[15:32:31.996]                       inherits <- base::inherits
[15:32:31.996]                       invokeRestart <- base::invokeRestart
[15:32:31.996]                       is.null <- base::is.null
[15:32:31.996]                       muffled <- FALSE
[15:32:31.996]                       if (inherits(cond, "message")) {
[15:32:31.996]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:31.996]                         if (muffled) 
[15:32:31.996]                           invokeRestart("muffleMessage")
[15:32:31.996]                       }
[15:32:31.996]                       else if (inherits(cond, "warning")) {
[15:32:31.996]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:31.996]                         if (muffled) 
[15:32:31.996]                           invokeRestart("muffleWarning")
[15:32:31.996]                       }
[15:32:31.996]                       else if (inherits(cond, "condition")) {
[15:32:31.996]                         if (!is.null(pattern)) {
[15:32:31.996]                           computeRestarts <- base::computeRestarts
[15:32:31.996]                           grepl <- base::grepl
[15:32:31.996]                           restarts <- computeRestarts(cond)
[15:32:31.996]                           for (restart in restarts) {
[15:32:31.996]                             name <- restart$name
[15:32:31.996]                             if (is.null(name)) 
[15:32:31.996]                               next
[15:32:31.996]                             if (!grepl(pattern, name)) 
[15:32:31.996]                               next
[15:32:31.996]                             invokeRestart(restart)
[15:32:31.996]                             muffled <- TRUE
[15:32:31.996]                             break
[15:32:31.996]                           }
[15:32:31.996]                         }
[15:32:31.996]                       }
[15:32:31.996]                       invisible(muffled)
[15:32:31.996]                     }
[15:32:31.996]                     muffleCondition(cond, pattern = "^muffle")
[15:32:31.996]                   }
[15:32:31.996]                 }
[15:32:31.996]                 else {
[15:32:31.996]                   if (TRUE) {
[15:32:31.996]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:31.996]                     {
[15:32:31.996]                       inherits <- base::inherits
[15:32:31.996]                       invokeRestart <- base::invokeRestart
[15:32:31.996]                       is.null <- base::is.null
[15:32:31.996]                       muffled <- FALSE
[15:32:31.996]                       if (inherits(cond, "message")) {
[15:32:31.996]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:31.996]                         if (muffled) 
[15:32:31.996]                           invokeRestart("muffleMessage")
[15:32:31.996]                       }
[15:32:31.996]                       else if (inherits(cond, "warning")) {
[15:32:31.996]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:31.996]                         if (muffled) 
[15:32:31.996]                           invokeRestart("muffleWarning")
[15:32:31.996]                       }
[15:32:31.996]                       else if (inherits(cond, "condition")) {
[15:32:31.996]                         if (!is.null(pattern)) {
[15:32:31.996]                           computeRestarts <- base::computeRestarts
[15:32:31.996]                           grepl <- base::grepl
[15:32:31.996]                           restarts <- computeRestarts(cond)
[15:32:31.996]                           for (restart in restarts) {
[15:32:31.996]                             name <- restart$name
[15:32:31.996]                             if (is.null(name)) 
[15:32:31.996]                               next
[15:32:31.996]                             if (!grepl(pattern, name)) 
[15:32:31.996]                               next
[15:32:31.996]                             invokeRestart(restart)
[15:32:31.996]                             muffled <- TRUE
[15:32:31.996]                             break
[15:32:31.996]                           }
[15:32:31.996]                         }
[15:32:31.996]                       }
[15:32:31.996]                       invisible(muffled)
[15:32:31.996]                     }
[15:32:31.996]                     muffleCondition(cond, pattern = "^muffle")
[15:32:31.996]                   }
[15:32:31.996]                 }
[15:32:31.996]             }
[15:32:31.996]         }))
[15:32:31.996]     }, error = function(ex) {
[15:32:31.996]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:31.996]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:31.996]                 ...future.rng), started = ...future.startTime, 
[15:32:31.996]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:31.996]             version = "1.8"), class = "FutureResult")
[15:32:31.996]     }, finally = {
[15:32:31.996]         if (!identical(...future.workdir, getwd())) 
[15:32:31.996]             setwd(...future.workdir)
[15:32:31.996]         {
[15:32:31.996]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:31.996]                 ...future.oldOptions$nwarnings <- NULL
[15:32:31.996]             }
[15:32:31.996]             base::options(...future.oldOptions)
[15:32:31.996]             if (.Platform$OS.type == "windows") {
[15:32:31.996]                 old_names <- names(...future.oldEnvVars)
[15:32:31.996]                 envs <- base::Sys.getenv()
[15:32:31.996]                 names <- names(envs)
[15:32:31.996]                 common <- intersect(names, old_names)
[15:32:31.996]                 added <- setdiff(names, old_names)
[15:32:31.996]                 removed <- setdiff(old_names, names)
[15:32:31.996]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:31.996]                   envs[common]]
[15:32:31.996]                 NAMES <- toupper(changed)
[15:32:31.996]                 args <- list()
[15:32:31.996]                 for (kk in seq_along(NAMES)) {
[15:32:31.996]                   name <- changed[[kk]]
[15:32:31.996]                   NAME <- NAMES[[kk]]
[15:32:31.996]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:31.996]                     next
[15:32:31.996]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:31.996]                 }
[15:32:31.996]                 NAMES <- toupper(added)
[15:32:31.996]                 for (kk in seq_along(NAMES)) {
[15:32:31.996]                   name <- added[[kk]]
[15:32:31.996]                   NAME <- NAMES[[kk]]
[15:32:31.996]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:31.996]                     next
[15:32:31.996]                   args[[name]] <- ""
[15:32:31.996]                 }
[15:32:31.996]                 NAMES <- toupper(removed)
[15:32:31.996]                 for (kk in seq_along(NAMES)) {
[15:32:31.996]                   name <- removed[[kk]]
[15:32:31.996]                   NAME <- NAMES[[kk]]
[15:32:31.996]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:31.996]                     next
[15:32:31.996]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:31.996]                 }
[15:32:31.996]                 if (length(args) > 0) 
[15:32:31.996]                   base::do.call(base::Sys.setenv, args = args)
[15:32:31.996]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:31.996]             }
[15:32:31.996]             else {
[15:32:31.996]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:31.996]             }
[15:32:31.996]             {
[15:32:31.996]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:31.996]                   0L) {
[15:32:31.996]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:31.996]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:31.996]                   base::options(opts)
[15:32:31.996]                 }
[15:32:31.996]                 {
[15:32:31.996]                   {
[15:32:31.996]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:31.996]                     NULL
[15:32:31.996]                   }
[15:32:31.996]                   options(future.plan = NULL)
[15:32:31.996]                   if (is.na(NA_character_)) 
[15:32:31.996]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:31.996]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:31.996]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:31.996]                     .init = FALSE)
[15:32:31.996]                 }
[15:32:31.996]             }
[15:32:31.996]         }
[15:32:31.996]     })
[15:32:31.996]     if (TRUE) {
[15:32:31.996]         base::sink(type = "output", split = FALSE)
[15:32:31.996]         if (TRUE) {
[15:32:31.996]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:31.996]         }
[15:32:31.996]         else {
[15:32:31.996]             ...future.result["stdout"] <- base::list(NULL)
[15:32:31.996]         }
[15:32:31.996]         base::close(...future.stdout)
[15:32:31.996]         ...future.stdout <- NULL
[15:32:31.996]     }
[15:32:31.996]     ...future.result$conditions <- ...future.conditions
[15:32:31.996]     ...future.result$finished <- base::Sys.time()
[15:32:31.996]     ...future.result
[15:32:31.996] }
[15:32:32.004] Exporting 5 global objects (1.22 KiB) to cluster node #1 ...
[15:32:32.004] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ...
[15:32:32.005] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ... DONE
[15:32:32.005] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:32.006] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:32.006] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ...
[15:32:32.007] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ... DONE
[15:32:32.007] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:32.008] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:32.008] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:32.009] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:32.009] Exporting 5 global objects (1.22 KiB) to cluster node #1 ... DONE
[15:32:32.010] MultisessionFuture started
[15:32:32.010] - Launch lazy future ... done
[15:32:32.010] run() for 'MultisessionFuture' ... done
[15:32:32.011] Created future:
[15:32:32.035] receiveMessageFromWorker() for ClusterFuture ...
[15:32:32.036] - Validating connection of MultisessionFuture
[15:32:32.036] - received message: FutureResult
[15:32:32.037] - Received FutureResult
[15:32:32.037] - Erased future from FutureRegistry
[15:32:32.037] result() for ClusterFuture ...
[15:32:32.037] - result already collected: FutureResult
[15:32:32.038] result() for ClusterFuture ... done
[15:32:32.038] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:32.011] MultisessionFuture:
[15:32:32.011] Label: 'future_sapply-2'
[15:32:32.011] Expression:
[15:32:32.011] {
[15:32:32.011]     do.call(function(...) {
[15:32:32.011]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:32.011]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:32.011]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:32.011]             on.exit(options(oopts), add = TRUE)
[15:32:32.011]         }
[15:32:32.011]         {
[15:32:32.011]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:32.011]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:32.011]                 ...future.FUN(...future.X_jj, ...)
[15:32:32.011]             })
[15:32:32.011]         }
[15:32:32.011]     }, args = future.call.arguments)
[15:32:32.011] }
[15:32:32.011] Lazy evaluation: FALSE
[15:32:32.011] Asynchronous evaluation: TRUE
[15:32:32.011] Local evaluation: TRUE
[15:32:32.011] Environment: R_GlobalEnv
[15:32:32.011] Capture standard output: TRUE
[15:32:32.011] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:32.011] Globals: 5 objects totaling 1.38 KiB (function '...future.FUN' of 1.22 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:32.011] Packages: <none>
[15:32:32.011] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:32.011] Resolved: TRUE
[15:32:32.011] Value: <not collected>
[15:32:32.011] Conditions captured: <none>
[15:32:32.011] Early signaling: FALSE
[15:32:32.011] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:32.011] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:32.039] Chunk #2 of 2 ... DONE
[15:32:32.039] Launching 2 futures (chunks) ... DONE
[15:32:32.039] Resolving 2 futures (chunks) ...
[15:32:32.040] resolve() on list ...
[15:32:32.040]  recursive: 0
[15:32:32.040]  length: 2
[15:32:32.041] 
[15:32:32.041] Future #1
[15:32:32.041] result() for ClusterFuture ...
[15:32:32.042] - result already collected: FutureResult
[15:32:32.042] result() for ClusterFuture ... done
[15:32:32.042] result() for ClusterFuture ...
[15:32:32.042] - result already collected: FutureResult
[15:32:32.043] result() for ClusterFuture ... done
[15:32:32.043] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:32.043] - nx: 2
[15:32:32.043] - relay: TRUE
[15:32:32.044] - stdout: TRUE
[15:32:32.044] - signal: TRUE
[15:32:32.044] - resignal: FALSE
[15:32:32.045] - force: TRUE
[15:32:32.045] - relayed: [n=2] FALSE, FALSE
[15:32:32.045] - queued futures: [n=2] FALSE, FALSE
[15:32:32.045]  - until=1
[15:32:32.046]  - relaying element #1
[15:32:32.046] result() for ClusterFuture ...
[15:32:32.046] - result already collected: FutureResult
[15:32:32.047] result() for ClusterFuture ... done
[15:32:32.047] result() for ClusterFuture ...
[15:32:32.047] - result already collected: FutureResult
[15:32:32.048] result() for ClusterFuture ... done
[15:32:32.048] result() for ClusterFuture ...
[15:32:32.048] - result already collected: FutureResult
[15:32:32.049] result() for ClusterFuture ... done
[15:32:32.049] result() for ClusterFuture ...
[15:32:32.049] - result already collected: FutureResult
[15:32:32.049] result() for ClusterFuture ... done
[15:32:32.050] - relayed: [n=2] TRUE, FALSE
[15:32:32.050] - queued futures: [n=2] TRUE, FALSE
[15:32:32.050] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:32.051]  length: 1 (resolved future 1)
[15:32:32.051] Future #2
[15:32:32.051] result() for ClusterFuture ...
[15:32:32.052] - result already collected: FutureResult
[15:32:32.052] result() for ClusterFuture ... done
[15:32:32.052] result() for ClusterFuture ...
[15:32:32.053] - result already collected: FutureResult
[15:32:32.053] result() for ClusterFuture ... done
[15:32:32.053] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:32.053] - nx: 2
[15:32:32.054] - relay: TRUE
[15:32:32.054] - stdout: TRUE
[15:32:32.054] - signal: TRUE
[15:32:32.055] - resignal: FALSE
[15:32:32.055] - force: TRUE
[15:32:32.055] - relayed: [n=2] TRUE, FALSE
[15:32:32.056] - queued futures: [n=2] TRUE, FALSE
[15:32:32.056]  - until=2
[15:32:32.056]  - relaying element #2
[15:32:32.056] result() for ClusterFuture ...
[15:32:32.057] - result already collected: FutureResult
[15:32:32.057] result() for ClusterFuture ... done
[15:32:32.057] result() for ClusterFuture ...
[15:32:32.058] - result already collected: FutureResult
[15:32:32.058] result() for ClusterFuture ... done
[15:32:32.058] result() for ClusterFuture ...
[15:32:32.059] - result already collected: FutureResult
[15:32:32.059] result() for ClusterFuture ... done
[15:32:32.059] result() for ClusterFuture ...
[15:32:32.059] - result already collected: FutureResult
[15:32:32.060] result() for ClusterFuture ... done
[15:32:32.060] - relayed: [n=2] TRUE, TRUE
[15:32:32.060] - queued futures: [n=2] TRUE, TRUE
[15:32:32.061] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:32.061]  length: 0 (resolved future 2)
[15:32:32.061] Relaying remaining futures
[15:32:32.062] signalConditionsASAP(NULL, pos=0) ...
[15:32:32.062] - nx: 2
[15:32:32.062] - relay: TRUE
[15:32:32.062] - stdout: TRUE
[15:32:32.063] - signal: TRUE
[15:32:32.063] - resignal: FALSE
[15:32:32.063] - force: TRUE
[15:32:32.064] - relayed: [n=2] TRUE, TRUE
[15:32:32.064] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:32.064] - relayed: [n=2] TRUE, TRUE
[15:32:32.065] - queued futures: [n=2] TRUE, TRUE
[15:32:32.065] signalConditionsASAP(NULL, pos=0) ... done
[15:32:32.065] resolve() on list ... DONE
[15:32:32.066] result() for ClusterFuture ...
[15:32:32.066] - result already collected: FutureResult
[15:32:32.066] result() for ClusterFuture ... done
[15:32:32.066] result() for ClusterFuture ...
[15:32:32.067] - result already collected: FutureResult
[15:32:32.067] result() for ClusterFuture ... done
[15:32:32.067] result() for ClusterFuture ...
[15:32:32.068] - result already collected: FutureResult
[15:32:32.068] result() for ClusterFuture ... done
[15:32:32.074] result() for ClusterFuture ...
[15:32:32.074] - result already collected: FutureResult
[15:32:32.075] result() for ClusterFuture ... done
[15:32:32.075]  - Number of value chunks collected: 2
[15:32:32.075] Resolving 2 futures (chunks) ... DONE
[15:32:32.076] Reducing values from 2 chunks ...
[15:32:32.076]  - Number of values collected after concatenation: 6
[15:32:32.076]  - Number of values expected: 6
[15:32:32.077] Reducing values from 2 chunks ... DONE
[15:32:32.077] future_lapply() ... DONE
List of 2
 $ y0: Named int [1:6] 1 2 2 3 3 4
  ..- attr(*, "names")= chr [1:6] "a1" "a2" "b1" "b2" ...
 $ y1: Named int [1:6] 1 2 2 3 3 4
  ..- attr(*, "names")= chr [1:6] "a1" "a2" "b1" "b2" ...
[15:32:32.081] future_lapply() ...
[15:32:32.087] Number of chunks: 2
[15:32:32.087] getGlobalsAndPackagesXApply() ...
[15:32:32.087]  - future.globals: TRUE
[15:32:32.088] getGlobalsAndPackages() ...
[15:32:32.088] Searching for globals...
[15:32:32.090] - globals found: [5] 'FUN', '*', ':', 'outer', 'rep'
[15:32:32.090] Searching for globals ... DONE
[15:32:32.090] Resolving globals: FALSE
[15:32:32.091] The total size of the 1 globals is 4.62 KiB (4728 bytes)
[15:32:32.091] The total size of the 1 globals exported for future expression ('FUN()') is 4.62 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.62 KiB of class 'function')
[15:32:32.092] - globals: [1] 'FUN'
[15:32:32.092] 
[15:32:32.092] getGlobalsAndPackages() ... DONE
[15:32:32.092]  - globals found/used: [n=1] 'FUN'
[15:32:32.092]  - needed namespaces: [n=0] 
[15:32:32.092] Finding globals ... DONE
[15:32:32.093]  - use_args: TRUE
[15:32:32.093]  - Getting '...' globals ...
[15:32:32.093] resolve() on list ...
[15:32:32.093]  recursive: 0
[15:32:32.094]  length: 1
[15:32:32.094]  elements: '...'
[15:32:32.094]  length: 0 (resolved future 1)
[15:32:32.094] resolve() on list ... DONE
[15:32:32.094]    - '...' content: [n=0] 
[15:32:32.095] List of 1
[15:32:32.095]  $ ...: list()
[15:32:32.095]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:32.095]  - attr(*, "where")=List of 1
[15:32:32.095]   ..$ ...:<environment: 0x00000276e44b9a70> 
[15:32:32.095]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:32.095]  - attr(*, "resolved")= logi TRUE
[15:32:32.095]  - attr(*, "total_size")= num NA
[15:32:32.098]  - Getting '...' globals ... DONE
[15:32:32.098] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:32.098] List of 2
[15:32:32.098]  $ ...future.FUN:function (x, y = 2 * 1:5)  
[15:32:32.098]  $ ...          : list()
[15:32:32.098]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:32.098]  - attr(*, "where")=List of 2
[15:32:32.098]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:32.098]   ..$ ...          :<environment: 0x00000276e44b9a70> 
[15:32:32.098]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:32.098]  - attr(*, "resolved")= logi FALSE
[15:32:32.098]  - attr(*, "total_size")= num 4728
[15:32:32.102] Packages to be attached in all futures: [n=0] 
[15:32:32.102] getGlobalsAndPackagesXApply() ... DONE
[15:32:32.102] Number of futures (= number of chunks): 2
[15:32:32.102] Launching 2 futures (chunks) ...
[15:32:32.103] Chunk #1 of 2 ...
[15:32:32.103]  - Finding globals in 'X' for chunk #1 ...
[15:32:32.103] getGlobalsAndPackages() ...
[15:32:32.103] Searching for globals...
[15:32:32.103] 
[15:32:32.104] Searching for globals ... DONE
[15:32:32.104] - globals: [0] <none>
[15:32:32.104] getGlobalsAndPackages() ... DONE
[15:32:32.104]    + additional globals found: [n=0] 
[15:32:32.104]    + additional namespaces needed: [n=0] 
[15:32:32.104]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:32.105]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:32.105]  - seeds: <none>
[15:32:32.105]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:32.105] getGlobalsAndPackages() ...
[15:32:32.105] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:32.106] Resolving globals: FALSE
[15:32:32.106] Tweak future expression to call with '...' arguments ...
[15:32:32.106] {
[15:32:32.106]     do.call(function(...) {
[15:32:32.106]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:32.106]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:32.106]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:32.106]             on.exit(options(oopts), add = TRUE)
[15:32:32.106]         }
[15:32:32.106]         {
[15:32:32.106]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:32.106]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:32.106]                 ...future.FUN(...future.X_jj, ...)
[15:32:32.106]             })
[15:32:32.106]         }
[15:32:32.106]     }, args = future.call.arguments)
[15:32:32.106] }
[15:32:32.106] Tweak future expression to call with '...' arguments ... DONE
[15:32:32.107] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:32.107] 
[15:32:32.107] getGlobalsAndPackages() ... DONE
[15:32:32.108] run() for 'Future' ...
[15:32:32.108] - state: 'created'
[15:32:32.108] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:32.126] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:32.126] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:32.127]   - Field: 'node'
[15:32:32.127]   - Field: 'label'
[15:32:32.127]   - Field: 'local'
[15:32:32.128]   - Field: 'owner'
[15:32:32.128]   - Field: 'envir'
[15:32:32.128]   - Field: 'workers'
[15:32:32.128]   - Field: 'packages'
[15:32:32.129]   - Field: 'gc'
[15:32:32.129]   - Field: 'conditions'
[15:32:32.129]   - Field: 'persistent'
[15:32:32.130]   - Field: 'expr'
[15:32:32.130]   - Field: 'uuid'
[15:32:32.130]   - Field: 'seed'
[15:32:32.130]   - Field: 'version'
[15:32:32.131]   - Field: 'result'
[15:32:32.131]   - Field: 'asynchronous'
[15:32:32.131]   - Field: 'calls'
[15:32:32.132]   - Field: 'globals'
[15:32:32.132]   - Field: 'stdout'
[15:32:32.132]   - Field: 'earlySignal'
[15:32:32.133]   - Field: 'lazy'
[15:32:32.133]   - Field: 'state'
[15:32:32.133] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:32.133] - Launch lazy future ...
[15:32:32.134] Packages needed by the future expression (n = 0): <none>
[15:32:32.134] Packages needed by future strategies (n = 0): <none>
[15:32:32.135] {
[15:32:32.135]     {
[15:32:32.135]         {
[15:32:32.135]             ...future.startTime <- base::Sys.time()
[15:32:32.135]             {
[15:32:32.135]                 {
[15:32:32.135]                   {
[15:32:32.135]                     {
[15:32:32.135]                       base::local({
[15:32:32.135]                         has_future <- base::requireNamespace("future", 
[15:32:32.135]                           quietly = TRUE)
[15:32:32.135]                         if (has_future) {
[15:32:32.135]                           ns <- base::getNamespace("future")
[15:32:32.135]                           version <- ns[[".package"]][["version"]]
[15:32:32.135]                           if (is.null(version)) 
[15:32:32.135]                             version <- utils::packageVersion("future")
[15:32:32.135]                         }
[15:32:32.135]                         else {
[15:32:32.135]                           version <- NULL
[15:32:32.135]                         }
[15:32:32.135]                         if (!has_future || version < "1.8.0") {
[15:32:32.135]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:32.135]                             "", base::R.version$version.string), 
[15:32:32.135]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:32.135]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:32.135]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:32.135]                               "release", "version")], collapse = " "), 
[15:32:32.135]                             hostname = base::Sys.info()[["nodename"]])
[15:32:32.135]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:32.135]                             info)
[15:32:32.135]                           info <- base::paste(info, collapse = "; ")
[15:32:32.135]                           if (!has_future) {
[15:32:32.135]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:32.135]                               info)
[15:32:32.135]                           }
[15:32:32.135]                           else {
[15:32:32.135]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:32.135]                               info, version)
[15:32:32.135]                           }
[15:32:32.135]                           base::stop(msg)
[15:32:32.135]                         }
[15:32:32.135]                       })
[15:32:32.135]                     }
[15:32:32.135]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:32.135]                     base::options(mc.cores = 1L)
[15:32:32.135]                   }
[15:32:32.135]                   ...future.strategy.old <- future::plan("list")
[15:32:32.135]                   options(future.plan = NULL)
[15:32:32.135]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:32.135]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:32.135]                 }
[15:32:32.135]                 ...future.workdir <- getwd()
[15:32:32.135]             }
[15:32:32.135]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:32.135]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:32.135]         }
[15:32:32.135]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:32.135]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:32.135]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:32.135]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:32.135]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:32.135]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:32.135]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:32.135]             base::names(...future.oldOptions))
[15:32:32.135]     }
[15:32:32.135]     if (FALSE) {
[15:32:32.135]     }
[15:32:32.135]     else {
[15:32:32.135]         if (TRUE) {
[15:32:32.135]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:32.135]                 open = "w")
[15:32:32.135]         }
[15:32:32.135]         else {
[15:32:32.135]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:32.135]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:32.135]         }
[15:32:32.135]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:32.135]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:32.135]             base::sink(type = "output", split = FALSE)
[15:32:32.135]             base::close(...future.stdout)
[15:32:32.135]         }, add = TRUE)
[15:32:32.135]     }
[15:32:32.135]     ...future.frame <- base::sys.nframe()
[15:32:32.135]     ...future.conditions <- base::list()
[15:32:32.135]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:32.135]     if (FALSE) {
[15:32:32.135]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:32.135]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:32.135]     }
[15:32:32.135]     ...future.result <- base::tryCatch({
[15:32:32.135]         base::withCallingHandlers({
[15:32:32.135]             ...future.value <- base::withVisible(base::local({
[15:32:32.135]                 ...future.makeSendCondition <- base::local({
[15:32:32.135]                   sendCondition <- NULL
[15:32:32.135]                   function(frame = 1L) {
[15:32:32.135]                     if (is.function(sendCondition)) 
[15:32:32.135]                       return(sendCondition)
[15:32:32.135]                     ns <- getNamespace("parallel")
[15:32:32.135]                     if (exists("sendData", mode = "function", 
[15:32:32.135]                       envir = ns)) {
[15:32:32.135]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:32.135]                         envir = ns)
[15:32:32.135]                       envir <- sys.frame(frame)
[15:32:32.135]                       master <- NULL
[15:32:32.135]                       while (!identical(envir, .GlobalEnv) && 
[15:32:32.135]                         !identical(envir, emptyenv())) {
[15:32:32.135]                         if (exists("master", mode = "list", envir = envir, 
[15:32:32.135]                           inherits = FALSE)) {
[15:32:32.135]                           master <- get("master", mode = "list", 
[15:32:32.135]                             envir = envir, inherits = FALSE)
[15:32:32.135]                           if (inherits(master, c("SOCKnode", 
[15:32:32.135]                             "SOCK0node"))) {
[15:32:32.135]                             sendCondition <<- function(cond) {
[15:32:32.135]                               data <- list(type = "VALUE", value = cond, 
[15:32:32.135]                                 success = TRUE)
[15:32:32.135]                               parallel_sendData(master, data)
[15:32:32.135]                             }
[15:32:32.135]                             return(sendCondition)
[15:32:32.135]                           }
[15:32:32.135]                         }
[15:32:32.135]                         frame <- frame + 1L
[15:32:32.135]                         envir <- sys.frame(frame)
[15:32:32.135]                       }
[15:32:32.135]                     }
[15:32:32.135]                     sendCondition <<- function(cond) NULL
[15:32:32.135]                   }
[15:32:32.135]                 })
[15:32:32.135]                 withCallingHandlers({
[15:32:32.135]                   {
[15:32:32.135]                     do.call(function(...) {
[15:32:32.135]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:32.135]                       if (!identical(...future.globals.maxSize.org, 
[15:32:32.135]                         ...future.globals.maxSize)) {
[15:32:32.135]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:32.135]                         on.exit(options(oopts), add = TRUE)
[15:32:32.135]                       }
[15:32:32.135]                       {
[15:32:32.135]                         lapply(seq_along(...future.elements_ii), 
[15:32:32.135]                           FUN = function(jj) {
[15:32:32.135]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:32.135]                             ...future.FUN(...future.X_jj, ...)
[15:32:32.135]                           })
[15:32:32.135]                       }
[15:32:32.135]                     }, args = future.call.arguments)
[15:32:32.135]                   }
[15:32:32.135]                 }, immediateCondition = function(cond) {
[15:32:32.135]                   sendCondition <- ...future.makeSendCondition()
[15:32:32.135]                   sendCondition(cond)
[15:32:32.135]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:32.135]                   {
[15:32:32.135]                     inherits <- base::inherits
[15:32:32.135]                     invokeRestart <- base::invokeRestart
[15:32:32.135]                     is.null <- base::is.null
[15:32:32.135]                     muffled <- FALSE
[15:32:32.135]                     if (inherits(cond, "message")) {
[15:32:32.135]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:32.135]                       if (muffled) 
[15:32:32.135]                         invokeRestart("muffleMessage")
[15:32:32.135]                     }
[15:32:32.135]                     else if (inherits(cond, "warning")) {
[15:32:32.135]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:32.135]                       if (muffled) 
[15:32:32.135]                         invokeRestart("muffleWarning")
[15:32:32.135]                     }
[15:32:32.135]                     else if (inherits(cond, "condition")) {
[15:32:32.135]                       if (!is.null(pattern)) {
[15:32:32.135]                         computeRestarts <- base::computeRestarts
[15:32:32.135]                         grepl <- base::grepl
[15:32:32.135]                         restarts <- computeRestarts(cond)
[15:32:32.135]                         for (restart in restarts) {
[15:32:32.135]                           name <- restart$name
[15:32:32.135]                           if (is.null(name)) 
[15:32:32.135]                             next
[15:32:32.135]                           if (!grepl(pattern, name)) 
[15:32:32.135]                             next
[15:32:32.135]                           invokeRestart(restart)
[15:32:32.135]                           muffled <- TRUE
[15:32:32.135]                           break
[15:32:32.135]                         }
[15:32:32.135]                       }
[15:32:32.135]                     }
[15:32:32.135]                     invisible(muffled)
[15:32:32.135]                   }
[15:32:32.135]                   muffleCondition(cond)
[15:32:32.135]                 })
[15:32:32.135]             }))
[15:32:32.135]             future::FutureResult(value = ...future.value$value, 
[15:32:32.135]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:32.135]                   ...future.rng), globalenv = if (FALSE) 
[15:32:32.135]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:32.135]                     ...future.globalenv.names))
[15:32:32.135]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:32.135]         }, condition = base::local({
[15:32:32.135]             c <- base::c
[15:32:32.135]             inherits <- base::inherits
[15:32:32.135]             invokeRestart <- base::invokeRestart
[15:32:32.135]             length <- base::length
[15:32:32.135]             list <- base::list
[15:32:32.135]             seq.int <- base::seq.int
[15:32:32.135]             signalCondition <- base::signalCondition
[15:32:32.135]             sys.calls <- base::sys.calls
[15:32:32.135]             `[[` <- base::`[[`
[15:32:32.135]             `+` <- base::`+`
[15:32:32.135]             `<<-` <- base::`<<-`
[15:32:32.135]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:32.135]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:32.135]                   3L)]
[15:32:32.135]             }
[15:32:32.135]             function(cond) {
[15:32:32.135]                 is_error <- inherits(cond, "error")
[15:32:32.135]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:32.135]                   NULL)
[15:32:32.135]                 if (is_error) {
[15:32:32.135]                   sessionInformation <- function() {
[15:32:32.135]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:32.135]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:32.135]                       search = base::search(), system = base::Sys.info())
[15:32:32.135]                   }
[15:32:32.135]                   ...future.conditions[[length(...future.conditions) + 
[15:32:32.135]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:32.135]                     cond$call), session = sessionInformation(), 
[15:32:32.135]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:32.135]                   signalCondition(cond)
[15:32:32.135]                 }
[15:32:32.135]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:32.135]                 "immediateCondition"))) {
[15:32:32.135]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:32.135]                   ...future.conditions[[length(...future.conditions) + 
[15:32:32.135]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:32.135]                   if (TRUE && !signal) {
[15:32:32.135]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:32.135]                     {
[15:32:32.135]                       inherits <- base::inherits
[15:32:32.135]                       invokeRestart <- base::invokeRestart
[15:32:32.135]                       is.null <- base::is.null
[15:32:32.135]                       muffled <- FALSE
[15:32:32.135]                       if (inherits(cond, "message")) {
[15:32:32.135]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:32.135]                         if (muffled) 
[15:32:32.135]                           invokeRestart("muffleMessage")
[15:32:32.135]                       }
[15:32:32.135]                       else if (inherits(cond, "warning")) {
[15:32:32.135]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:32.135]                         if (muffled) 
[15:32:32.135]                           invokeRestart("muffleWarning")
[15:32:32.135]                       }
[15:32:32.135]                       else if (inherits(cond, "condition")) {
[15:32:32.135]                         if (!is.null(pattern)) {
[15:32:32.135]                           computeRestarts <- base::computeRestarts
[15:32:32.135]                           grepl <- base::grepl
[15:32:32.135]                           restarts <- computeRestarts(cond)
[15:32:32.135]                           for (restart in restarts) {
[15:32:32.135]                             name <- restart$name
[15:32:32.135]                             if (is.null(name)) 
[15:32:32.135]                               next
[15:32:32.135]                             if (!grepl(pattern, name)) 
[15:32:32.135]                               next
[15:32:32.135]                             invokeRestart(restart)
[15:32:32.135]                             muffled <- TRUE
[15:32:32.135]                             break
[15:32:32.135]                           }
[15:32:32.135]                         }
[15:32:32.135]                       }
[15:32:32.135]                       invisible(muffled)
[15:32:32.135]                     }
[15:32:32.135]                     muffleCondition(cond, pattern = "^muffle")
[15:32:32.135]                   }
[15:32:32.135]                 }
[15:32:32.135]                 else {
[15:32:32.135]                   if (TRUE) {
[15:32:32.135]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:32.135]                     {
[15:32:32.135]                       inherits <- base::inherits
[15:32:32.135]                       invokeRestart <- base::invokeRestart
[15:32:32.135]                       is.null <- base::is.null
[15:32:32.135]                       muffled <- FALSE
[15:32:32.135]                       if (inherits(cond, "message")) {
[15:32:32.135]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:32.135]                         if (muffled) 
[15:32:32.135]                           invokeRestart("muffleMessage")
[15:32:32.135]                       }
[15:32:32.135]                       else if (inherits(cond, "warning")) {
[15:32:32.135]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:32.135]                         if (muffled) 
[15:32:32.135]                           invokeRestart("muffleWarning")
[15:32:32.135]                       }
[15:32:32.135]                       else if (inherits(cond, "condition")) {
[15:32:32.135]                         if (!is.null(pattern)) {
[15:32:32.135]                           computeRestarts <- base::computeRestarts
[15:32:32.135]                           grepl <- base::grepl
[15:32:32.135]                           restarts <- computeRestarts(cond)
[15:32:32.135]                           for (restart in restarts) {
[15:32:32.135]                             name <- restart$name
[15:32:32.135]                             if (is.null(name)) 
[15:32:32.135]                               next
[15:32:32.135]                             if (!grepl(pattern, name)) 
[15:32:32.135]                               next
[15:32:32.135]                             invokeRestart(restart)
[15:32:32.135]                             muffled <- TRUE
[15:32:32.135]                             break
[15:32:32.135]                           }
[15:32:32.135]                         }
[15:32:32.135]                       }
[15:32:32.135]                       invisible(muffled)
[15:32:32.135]                     }
[15:32:32.135]                     muffleCondition(cond, pattern = "^muffle")
[15:32:32.135]                   }
[15:32:32.135]                 }
[15:32:32.135]             }
[15:32:32.135]         }))
[15:32:32.135]     }, error = function(ex) {
[15:32:32.135]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:32.135]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:32.135]                 ...future.rng), started = ...future.startTime, 
[15:32:32.135]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:32.135]             version = "1.8"), class = "FutureResult")
[15:32:32.135]     }, finally = {
[15:32:32.135]         if (!identical(...future.workdir, getwd())) 
[15:32:32.135]             setwd(...future.workdir)
[15:32:32.135]         {
[15:32:32.135]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:32.135]                 ...future.oldOptions$nwarnings <- NULL
[15:32:32.135]             }
[15:32:32.135]             base::options(...future.oldOptions)
[15:32:32.135]             if (.Platform$OS.type == "windows") {
[15:32:32.135]                 old_names <- names(...future.oldEnvVars)
[15:32:32.135]                 envs <- base::Sys.getenv()
[15:32:32.135]                 names <- names(envs)
[15:32:32.135]                 common <- intersect(names, old_names)
[15:32:32.135]                 added <- setdiff(names, old_names)
[15:32:32.135]                 removed <- setdiff(old_names, names)
[15:32:32.135]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:32.135]                   envs[common]]
[15:32:32.135]                 NAMES <- toupper(changed)
[15:32:32.135]                 args <- list()
[15:32:32.135]                 for (kk in seq_along(NAMES)) {
[15:32:32.135]                   name <- changed[[kk]]
[15:32:32.135]                   NAME <- NAMES[[kk]]
[15:32:32.135]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:32.135]                     next
[15:32:32.135]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:32.135]                 }
[15:32:32.135]                 NAMES <- toupper(added)
[15:32:32.135]                 for (kk in seq_along(NAMES)) {
[15:32:32.135]                   name <- added[[kk]]
[15:32:32.135]                   NAME <- NAMES[[kk]]
[15:32:32.135]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:32.135]                     next
[15:32:32.135]                   args[[name]] <- ""
[15:32:32.135]                 }
[15:32:32.135]                 NAMES <- toupper(removed)
[15:32:32.135]                 for (kk in seq_along(NAMES)) {
[15:32:32.135]                   name <- removed[[kk]]
[15:32:32.135]                   NAME <- NAMES[[kk]]
[15:32:32.135]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:32.135]                     next
[15:32:32.135]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:32.135]                 }
[15:32:32.135]                 if (length(args) > 0) 
[15:32:32.135]                   base::do.call(base::Sys.setenv, args = args)
[15:32:32.135]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:32.135]             }
[15:32:32.135]             else {
[15:32:32.135]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:32.135]             }
[15:32:32.135]             {
[15:32:32.135]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:32.135]                   0L) {
[15:32:32.135]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:32.135]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:32.135]                   base::options(opts)
[15:32:32.135]                 }
[15:32:32.135]                 {
[15:32:32.135]                   {
[15:32:32.135]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:32.135]                     NULL
[15:32:32.135]                   }
[15:32:32.135]                   options(future.plan = NULL)
[15:32:32.135]                   if (is.na(NA_character_)) 
[15:32:32.135]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:32.135]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:32.135]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:32.135]                     .init = FALSE)
[15:32:32.135]                 }
[15:32:32.135]             }
[15:32:32.135]         }
[15:32:32.135]     })
[15:32:32.135]     if (TRUE) {
[15:32:32.135]         base::sink(type = "output", split = FALSE)
[15:32:32.135]         if (TRUE) {
[15:32:32.135]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:32.135]         }
[15:32:32.135]         else {
[15:32:32.135]             ...future.result["stdout"] <- base::list(NULL)
[15:32:32.135]         }
[15:32:32.135]         base::close(...future.stdout)
[15:32:32.135]         ...future.stdout <- NULL
[15:32:32.135]     }
[15:32:32.135]     ...future.result$conditions <- ...future.conditions
[15:32:32.135]     ...future.result$finished <- base::Sys.time()
[15:32:32.135]     ...future.result
[15:32:32.135] }
[15:32:32.144] Exporting 5 global objects (4.62 KiB) to cluster node #1 ...
[15:32:32.145] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ...
[15:32:32.145] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ... DONE
[15:32:32.146] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:32.147] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:32.147] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ...
[15:32:32.148] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ... DONE
[15:32:32.148] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:32.149] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:32.150] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:32.150] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:32.150] Exporting 5 global objects (4.62 KiB) to cluster node #1 ... DONE
[15:32:32.152] MultisessionFuture started
[15:32:32.152] - Launch lazy future ... done
[15:32:32.152] run() for 'MultisessionFuture' ... done
[15:32:32.153] Created future:
[15:32:32.177] receiveMessageFromWorker() for ClusterFuture ...
[15:32:32.178] - Validating connection of MultisessionFuture
[15:32:32.178] - received message: FutureResult
[15:32:32.179] - Received FutureResult
[15:32:32.179] - Erased future from FutureRegistry
[15:32:32.179] result() for ClusterFuture ...
[15:32:32.180] - result already collected: FutureResult
[15:32:32.180] result() for ClusterFuture ... done
[15:32:32.180] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:32.153] MultisessionFuture:
[15:32:32.153] Label: 'future_sapply-1'
[15:32:32.153] Expression:
[15:32:32.153] {
[15:32:32.153]     do.call(function(...) {
[15:32:32.153]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:32.153]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:32.153]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:32.153]             on.exit(options(oopts), add = TRUE)
[15:32:32.153]         }
[15:32:32.153]         {
[15:32:32.153]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:32.153]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:32.153]                 ...future.FUN(...future.X_jj, ...)
[15:32:32.153]             })
[15:32:32.153]         }
[15:32:32.153]     }, args = future.call.arguments)
[15:32:32.153] }
[15:32:32.153] Lazy evaluation: FALSE
[15:32:32.153] Asynchronous evaluation: TRUE
[15:32:32.153] Local evaluation: TRUE
[15:32:32.153] Environment: R_GlobalEnv
[15:32:32.153] Capture standard output: TRUE
[15:32:32.153] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:32.153] Globals: 5 objects totaling 4.78 KiB (function '...future.FUN' of 4.62 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:32.153] Packages: <none>
[15:32:32.153] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:32.153] Resolved: TRUE
[15:32:32.153] Value: <not collected>
[15:32:32.153] Conditions captured: <none>
[15:32:32.153] Early signaling: FALSE
[15:32:32.153] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:32.153] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:32.181] Chunk #1 of 2 ... DONE
[15:32:32.182] Chunk #2 of 2 ...
[15:32:32.182]  - Finding globals in 'X' for chunk #2 ...
[15:32:32.182] getGlobalsAndPackages() ...
[15:32:32.183] Searching for globals...
[15:32:32.183] 
[15:32:32.183] Searching for globals ... DONE
[15:32:32.184] - globals: [0] <none>
[15:32:32.184] getGlobalsAndPackages() ... DONE
[15:32:32.184]    + additional globals found: [n=0] 
[15:32:32.184]    + additional namespaces needed: [n=0] 
[15:32:32.185]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:32.185]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:32.185]  - seeds: <none>
[15:32:32.185]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:32.186] getGlobalsAndPackages() ...
[15:32:32.186] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:32.186] Resolving globals: FALSE
[15:32:32.187] Tweak future expression to call with '...' arguments ...
[15:32:32.187] {
[15:32:32.187]     do.call(function(...) {
[15:32:32.187]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:32.187]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:32.187]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:32.187]             on.exit(options(oopts), add = TRUE)
[15:32:32.187]         }
[15:32:32.187]         {
[15:32:32.187]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:32.187]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:32.187]                 ...future.FUN(...future.X_jj, ...)
[15:32:32.187]             })
[15:32:32.187]         }
[15:32:32.187]     }, args = future.call.arguments)
[15:32:32.187] }
[15:32:32.188] Tweak future expression to call with '...' arguments ... DONE
[15:32:32.188] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:32.189] 
[15:32:32.189] getGlobalsAndPackages() ... DONE
[15:32:32.190] run() for 'Future' ...
[15:32:32.190] - state: 'created'
[15:32:32.190] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:32.209] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:32.209] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:32.210]   - Field: 'node'
[15:32:32.210]   - Field: 'label'
[15:32:32.210]   - Field: 'local'
[15:32:32.211]   - Field: 'owner'
[15:32:32.211]   - Field: 'envir'
[15:32:32.211]   - Field: 'workers'
[15:32:32.212]   - Field: 'packages'
[15:32:32.212]   - Field: 'gc'
[15:32:32.212]   - Field: 'conditions'
[15:32:32.213]   - Field: 'persistent'
[15:32:32.213]   - Field: 'expr'
[15:32:32.213]   - Field: 'uuid'
[15:32:32.213]   - Field: 'seed'
[15:32:32.214]   - Field: 'version'
[15:32:32.214]   - Field: 'result'
[15:32:32.214]   - Field: 'asynchronous'
[15:32:32.215]   - Field: 'calls'
[15:32:32.215]   - Field: 'globals'
[15:32:32.215]   - Field: 'stdout'
[15:32:32.215]   - Field: 'earlySignal'
[15:32:32.216]   - Field: 'lazy'
[15:32:32.216]   - Field: 'state'
[15:32:32.216] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:32.217] - Launch lazy future ...
[15:32:32.217] Packages needed by the future expression (n = 0): <none>
[15:32:32.218] Packages needed by future strategies (n = 0): <none>
[15:32:32.219] {
[15:32:32.219]     {
[15:32:32.219]         {
[15:32:32.219]             ...future.startTime <- base::Sys.time()
[15:32:32.219]             {
[15:32:32.219]                 {
[15:32:32.219]                   {
[15:32:32.219]                     {
[15:32:32.219]                       base::local({
[15:32:32.219]                         has_future <- base::requireNamespace("future", 
[15:32:32.219]                           quietly = TRUE)
[15:32:32.219]                         if (has_future) {
[15:32:32.219]                           ns <- base::getNamespace("future")
[15:32:32.219]                           version <- ns[[".package"]][["version"]]
[15:32:32.219]                           if (is.null(version)) 
[15:32:32.219]                             version <- utils::packageVersion("future")
[15:32:32.219]                         }
[15:32:32.219]                         else {
[15:32:32.219]                           version <- NULL
[15:32:32.219]                         }
[15:32:32.219]                         if (!has_future || version < "1.8.0") {
[15:32:32.219]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:32.219]                             "", base::R.version$version.string), 
[15:32:32.219]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:32.219]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:32.219]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:32.219]                               "release", "version")], collapse = " "), 
[15:32:32.219]                             hostname = base::Sys.info()[["nodename"]])
[15:32:32.219]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:32.219]                             info)
[15:32:32.219]                           info <- base::paste(info, collapse = "; ")
[15:32:32.219]                           if (!has_future) {
[15:32:32.219]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:32.219]                               info)
[15:32:32.219]                           }
[15:32:32.219]                           else {
[15:32:32.219]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:32.219]                               info, version)
[15:32:32.219]                           }
[15:32:32.219]                           base::stop(msg)
[15:32:32.219]                         }
[15:32:32.219]                       })
[15:32:32.219]                     }
[15:32:32.219]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:32.219]                     base::options(mc.cores = 1L)
[15:32:32.219]                   }
[15:32:32.219]                   ...future.strategy.old <- future::plan("list")
[15:32:32.219]                   options(future.plan = NULL)
[15:32:32.219]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:32.219]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:32.219]                 }
[15:32:32.219]                 ...future.workdir <- getwd()
[15:32:32.219]             }
[15:32:32.219]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:32.219]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:32.219]         }
[15:32:32.219]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:32.219]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:32.219]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:32.219]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:32.219]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:32.219]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:32.219]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:32.219]             base::names(...future.oldOptions))
[15:32:32.219]     }
[15:32:32.219]     if (FALSE) {
[15:32:32.219]     }
[15:32:32.219]     else {
[15:32:32.219]         if (TRUE) {
[15:32:32.219]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:32.219]                 open = "w")
[15:32:32.219]         }
[15:32:32.219]         else {
[15:32:32.219]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:32.219]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:32.219]         }
[15:32:32.219]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:32.219]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:32.219]             base::sink(type = "output", split = FALSE)
[15:32:32.219]             base::close(...future.stdout)
[15:32:32.219]         }, add = TRUE)
[15:32:32.219]     }
[15:32:32.219]     ...future.frame <- base::sys.nframe()
[15:32:32.219]     ...future.conditions <- base::list()
[15:32:32.219]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:32.219]     if (FALSE) {
[15:32:32.219]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:32.219]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:32.219]     }
[15:32:32.219]     ...future.result <- base::tryCatch({
[15:32:32.219]         base::withCallingHandlers({
[15:32:32.219]             ...future.value <- base::withVisible(base::local({
[15:32:32.219]                 ...future.makeSendCondition <- base::local({
[15:32:32.219]                   sendCondition <- NULL
[15:32:32.219]                   function(frame = 1L) {
[15:32:32.219]                     if (is.function(sendCondition)) 
[15:32:32.219]                       return(sendCondition)
[15:32:32.219]                     ns <- getNamespace("parallel")
[15:32:32.219]                     if (exists("sendData", mode = "function", 
[15:32:32.219]                       envir = ns)) {
[15:32:32.219]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:32.219]                         envir = ns)
[15:32:32.219]                       envir <- sys.frame(frame)
[15:32:32.219]                       master <- NULL
[15:32:32.219]                       while (!identical(envir, .GlobalEnv) && 
[15:32:32.219]                         !identical(envir, emptyenv())) {
[15:32:32.219]                         if (exists("master", mode = "list", envir = envir, 
[15:32:32.219]                           inherits = FALSE)) {
[15:32:32.219]                           master <- get("master", mode = "list", 
[15:32:32.219]                             envir = envir, inherits = FALSE)
[15:32:32.219]                           if (inherits(master, c("SOCKnode", 
[15:32:32.219]                             "SOCK0node"))) {
[15:32:32.219]                             sendCondition <<- function(cond) {
[15:32:32.219]                               data <- list(type = "VALUE", value = cond, 
[15:32:32.219]                                 success = TRUE)
[15:32:32.219]                               parallel_sendData(master, data)
[15:32:32.219]                             }
[15:32:32.219]                             return(sendCondition)
[15:32:32.219]                           }
[15:32:32.219]                         }
[15:32:32.219]                         frame <- frame + 1L
[15:32:32.219]                         envir <- sys.frame(frame)
[15:32:32.219]                       }
[15:32:32.219]                     }
[15:32:32.219]                     sendCondition <<- function(cond) NULL
[15:32:32.219]                   }
[15:32:32.219]                 })
[15:32:32.219]                 withCallingHandlers({
[15:32:32.219]                   {
[15:32:32.219]                     do.call(function(...) {
[15:32:32.219]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:32.219]                       if (!identical(...future.globals.maxSize.org, 
[15:32:32.219]                         ...future.globals.maxSize)) {
[15:32:32.219]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:32.219]                         on.exit(options(oopts), add = TRUE)
[15:32:32.219]                       }
[15:32:32.219]                       {
[15:32:32.219]                         lapply(seq_along(...future.elements_ii), 
[15:32:32.219]                           FUN = function(jj) {
[15:32:32.219]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:32.219]                             ...future.FUN(...future.X_jj, ...)
[15:32:32.219]                           })
[15:32:32.219]                       }
[15:32:32.219]                     }, args = future.call.arguments)
[15:32:32.219]                   }
[15:32:32.219]                 }, immediateCondition = function(cond) {
[15:32:32.219]                   sendCondition <- ...future.makeSendCondition()
[15:32:32.219]                   sendCondition(cond)
[15:32:32.219]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:32.219]                   {
[15:32:32.219]                     inherits <- base::inherits
[15:32:32.219]                     invokeRestart <- base::invokeRestart
[15:32:32.219]                     is.null <- base::is.null
[15:32:32.219]                     muffled <- FALSE
[15:32:32.219]                     if (inherits(cond, "message")) {
[15:32:32.219]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:32.219]                       if (muffled) 
[15:32:32.219]                         invokeRestart("muffleMessage")
[15:32:32.219]                     }
[15:32:32.219]                     else if (inherits(cond, "warning")) {
[15:32:32.219]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:32.219]                       if (muffled) 
[15:32:32.219]                         invokeRestart("muffleWarning")
[15:32:32.219]                     }
[15:32:32.219]                     else if (inherits(cond, "condition")) {
[15:32:32.219]                       if (!is.null(pattern)) {
[15:32:32.219]                         computeRestarts <- base::computeRestarts
[15:32:32.219]                         grepl <- base::grepl
[15:32:32.219]                         restarts <- computeRestarts(cond)
[15:32:32.219]                         for (restart in restarts) {
[15:32:32.219]                           name <- restart$name
[15:32:32.219]                           if (is.null(name)) 
[15:32:32.219]                             next
[15:32:32.219]                           if (!grepl(pattern, name)) 
[15:32:32.219]                             next
[15:32:32.219]                           invokeRestart(restart)
[15:32:32.219]                           muffled <- TRUE
[15:32:32.219]                           break
[15:32:32.219]                         }
[15:32:32.219]                       }
[15:32:32.219]                     }
[15:32:32.219]                     invisible(muffled)
[15:32:32.219]                   }
[15:32:32.219]                   muffleCondition(cond)
[15:32:32.219]                 })
[15:32:32.219]             }))
[15:32:32.219]             future::FutureResult(value = ...future.value$value, 
[15:32:32.219]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:32.219]                   ...future.rng), globalenv = if (FALSE) 
[15:32:32.219]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:32.219]                     ...future.globalenv.names))
[15:32:32.219]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:32.219]         }, condition = base::local({
[15:32:32.219]             c <- base::c
[15:32:32.219]             inherits <- base::inherits
[15:32:32.219]             invokeRestart <- base::invokeRestart
[15:32:32.219]             length <- base::length
[15:32:32.219]             list <- base::list
[15:32:32.219]             seq.int <- base::seq.int
[15:32:32.219]             signalCondition <- base::signalCondition
[15:32:32.219]             sys.calls <- base::sys.calls
[15:32:32.219]             `[[` <- base::`[[`
[15:32:32.219]             `+` <- base::`+`
[15:32:32.219]             `<<-` <- base::`<<-`
[15:32:32.219]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:32.219]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:32.219]                   3L)]
[15:32:32.219]             }
[15:32:32.219]             function(cond) {
[15:32:32.219]                 is_error <- inherits(cond, "error")
[15:32:32.219]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:32.219]                   NULL)
[15:32:32.219]                 if (is_error) {
[15:32:32.219]                   sessionInformation <- function() {
[15:32:32.219]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:32.219]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:32.219]                       search = base::search(), system = base::Sys.info())
[15:32:32.219]                   }
[15:32:32.219]                   ...future.conditions[[length(...future.conditions) + 
[15:32:32.219]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:32.219]                     cond$call), session = sessionInformation(), 
[15:32:32.219]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:32.219]                   signalCondition(cond)
[15:32:32.219]                 }
[15:32:32.219]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:32.219]                 "immediateCondition"))) {
[15:32:32.219]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:32.219]                   ...future.conditions[[length(...future.conditions) + 
[15:32:32.219]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:32.219]                   if (TRUE && !signal) {
[15:32:32.219]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:32.219]                     {
[15:32:32.219]                       inherits <- base::inherits
[15:32:32.219]                       invokeRestart <- base::invokeRestart
[15:32:32.219]                       is.null <- base::is.null
[15:32:32.219]                       muffled <- FALSE
[15:32:32.219]                       if (inherits(cond, "message")) {
[15:32:32.219]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:32.219]                         if (muffled) 
[15:32:32.219]                           invokeRestart("muffleMessage")
[15:32:32.219]                       }
[15:32:32.219]                       else if (inherits(cond, "warning")) {
[15:32:32.219]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:32.219]                         if (muffled) 
[15:32:32.219]                           invokeRestart("muffleWarning")
[15:32:32.219]                       }
[15:32:32.219]                       else if (inherits(cond, "condition")) {
[15:32:32.219]                         if (!is.null(pattern)) {
[15:32:32.219]                           computeRestarts <- base::computeRestarts
[15:32:32.219]                           grepl <- base::grepl
[15:32:32.219]                           restarts <- computeRestarts(cond)
[15:32:32.219]                           for (restart in restarts) {
[15:32:32.219]                             name <- restart$name
[15:32:32.219]                             if (is.null(name)) 
[15:32:32.219]                               next
[15:32:32.219]                             if (!grepl(pattern, name)) 
[15:32:32.219]                               next
[15:32:32.219]                             invokeRestart(restart)
[15:32:32.219]                             muffled <- TRUE
[15:32:32.219]                             break
[15:32:32.219]                           }
[15:32:32.219]                         }
[15:32:32.219]                       }
[15:32:32.219]                       invisible(muffled)
[15:32:32.219]                     }
[15:32:32.219]                     muffleCondition(cond, pattern = "^muffle")
[15:32:32.219]                   }
[15:32:32.219]                 }
[15:32:32.219]                 else {
[15:32:32.219]                   if (TRUE) {
[15:32:32.219]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:32.219]                     {
[15:32:32.219]                       inherits <- base::inherits
[15:32:32.219]                       invokeRestart <- base::invokeRestart
[15:32:32.219]                       is.null <- base::is.null
[15:32:32.219]                       muffled <- FALSE
[15:32:32.219]                       if (inherits(cond, "message")) {
[15:32:32.219]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:32.219]                         if (muffled) 
[15:32:32.219]                           invokeRestart("muffleMessage")
[15:32:32.219]                       }
[15:32:32.219]                       else if (inherits(cond, "warning")) {
[15:32:32.219]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:32.219]                         if (muffled) 
[15:32:32.219]                           invokeRestart("muffleWarning")
[15:32:32.219]                       }
[15:32:32.219]                       else if (inherits(cond, "condition")) {
[15:32:32.219]                         if (!is.null(pattern)) {
[15:32:32.219]                           computeRestarts <- base::computeRestarts
[15:32:32.219]                           grepl <- base::grepl
[15:32:32.219]                           restarts <- computeRestarts(cond)
[15:32:32.219]                           for (restart in restarts) {
[15:32:32.219]                             name <- restart$name
[15:32:32.219]                             if (is.null(name)) 
[15:32:32.219]                               next
[15:32:32.219]                             if (!grepl(pattern, name)) 
[15:32:32.219]                               next
[15:32:32.219]                             invokeRestart(restart)
[15:32:32.219]                             muffled <- TRUE
[15:32:32.219]                             break
[15:32:32.219]                           }
[15:32:32.219]                         }
[15:32:32.219]                       }
[15:32:32.219]                       invisible(muffled)
[15:32:32.219]                     }
[15:32:32.219]                     muffleCondition(cond, pattern = "^muffle")
[15:32:32.219]                   }
[15:32:32.219]                 }
[15:32:32.219]             }
[15:32:32.219]         }))
[15:32:32.219]     }, error = function(ex) {
[15:32:32.219]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:32.219]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:32.219]                 ...future.rng), started = ...future.startTime, 
[15:32:32.219]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:32.219]             version = "1.8"), class = "FutureResult")
[15:32:32.219]     }, finally = {
[15:32:32.219]         if (!identical(...future.workdir, getwd())) 
[15:32:32.219]             setwd(...future.workdir)
[15:32:32.219]         {
[15:32:32.219]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:32.219]                 ...future.oldOptions$nwarnings <- NULL
[15:32:32.219]             }
[15:32:32.219]             base::options(...future.oldOptions)
[15:32:32.219]             if (.Platform$OS.type == "windows") {
[15:32:32.219]                 old_names <- names(...future.oldEnvVars)
[15:32:32.219]                 envs <- base::Sys.getenv()
[15:32:32.219]                 names <- names(envs)
[15:32:32.219]                 common <- intersect(names, old_names)
[15:32:32.219]                 added <- setdiff(names, old_names)
[15:32:32.219]                 removed <- setdiff(old_names, names)
[15:32:32.219]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:32.219]                   envs[common]]
[15:32:32.219]                 NAMES <- toupper(changed)
[15:32:32.219]                 args <- list()
[15:32:32.219]                 for (kk in seq_along(NAMES)) {
[15:32:32.219]                   name <- changed[[kk]]
[15:32:32.219]                   NAME <- NAMES[[kk]]
[15:32:32.219]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:32.219]                     next
[15:32:32.219]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:32.219]                 }
[15:32:32.219]                 NAMES <- toupper(added)
[15:32:32.219]                 for (kk in seq_along(NAMES)) {
[15:32:32.219]                   name <- added[[kk]]
[15:32:32.219]                   NAME <- NAMES[[kk]]
[15:32:32.219]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:32.219]                     next
[15:32:32.219]                   args[[name]] <- ""
[15:32:32.219]                 }
[15:32:32.219]                 NAMES <- toupper(removed)
[15:32:32.219]                 for (kk in seq_along(NAMES)) {
[15:32:32.219]                   name <- removed[[kk]]
[15:32:32.219]                   NAME <- NAMES[[kk]]
[15:32:32.219]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:32.219]                     next
[15:32:32.219]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:32.219]                 }
[15:32:32.219]                 if (length(args) > 0) 
[15:32:32.219]                   base::do.call(base::Sys.setenv, args = args)
[15:32:32.219]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:32.219]             }
[15:32:32.219]             else {
[15:32:32.219]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:32.219]             }
[15:32:32.219]             {
[15:32:32.219]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:32.219]                   0L) {
[15:32:32.219]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:32.219]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:32.219]                   base::options(opts)
[15:32:32.219]                 }
[15:32:32.219]                 {
[15:32:32.219]                   {
[15:32:32.219]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:32.219]                     NULL
[15:32:32.219]                   }
[15:32:32.219]                   options(future.plan = NULL)
[15:32:32.219]                   if (is.na(NA_character_)) 
[15:32:32.219]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:32.219]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:32.219]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:32.219]                     .init = FALSE)
[15:32:32.219]                 }
[15:32:32.219]             }
[15:32:32.219]         }
[15:32:32.219]     })
[15:32:32.219]     if (TRUE) {
[15:32:32.219]         base::sink(type = "output", split = FALSE)
[15:32:32.219]         if (TRUE) {
[15:32:32.219]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:32.219]         }
[15:32:32.219]         else {
[15:32:32.219]             ...future.result["stdout"] <- base::list(NULL)
[15:32:32.219]         }
[15:32:32.219]         base::close(...future.stdout)
[15:32:32.219]         ...future.stdout <- NULL
[15:32:32.219]     }
[15:32:32.219]     ...future.result$conditions <- ...future.conditions
[15:32:32.219]     ...future.result$finished <- base::Sys.time()
[15:32:32.219]     ...future.result
[15:32:32.219] }
[15:32:32.229] Exporting 5 global objects (4.62 KiB) to cluster node #1 ...
[15:32:32.229] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ...
[15:32:32.230] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ... DONE
[15:32:32.231] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:32.232] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:32.232] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ...
[15:32:32.233] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ... DONE
[15:32:32.233] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:32.234] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:32.234] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:32.235] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:32.235] Exporting 5 global objects (4.62 KiB) to cluster node #1 ... DONE
[15:32:32.236] MultisessionFuture started
[15:32:32.236] - Launch lazy future ... done
[15:32:32.237] run() for 'MultisessionFuture' ... done
[15:32:32.237] Created future:
[15:32:32.260] receiveMessageFromWorker() for ClusterFuture ...
[15:32:32.261] - Validating connection of MultisessionFuture
[15:32:32.262] - received message: FutureResult
[15:32:32.262] - Received FutureResult
[15:32:32.262] - Erased future from FutureRegistry
[15:32:32.263] result() for ClusterFuture ...
[15:32:32.263] - result already collected: FutureResult
[15:32:32.263] result() for ClusterFuture ... done
[15:32:32.263] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:32.237] MultisessionFuture:
[15:32:32.237] Label: 'future_sapply-2'
[15:32:32.237] Expression:
[15:32:32.237] {
[15:32:32.237]     do.call(function(...) {
[15:32:32.237]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:32.237]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:32.237]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:32.237]             on.exit(options(oopts), add = TRUE)
[15:32:32.237]         }
[15:32:32.237]         {
[15:32:32.237]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:32.237]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:32.237]                 ...future.FUN(...future.X_jj, ...)
[15:32:32.237]             })
[15:32:32.237]         }
[15:32:32.237]     }, args = future.call.arguments)
[15:32:32.237] }
[15:32:32.237] Lazy evaluation: FALSE
[15:32:32.237] Asynchronous evaluation: TRUE
[15:32:32.237] Local evaluation: TRUE
[15:32:32.237] Environment: R_GlobalEnv
[15:32:32.237] Capture standard output: TRUE
[15:32:32.237] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:32.237] Globals: 5 objects totaling 4.78 KiB (function '...future.FUN' of 4.62 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:32.237] Packages: <none>
[15:32:32.237] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:32.237] Resolved: TRUE
[15:32:32.237] Value: <not collected>
[15:32:32.237] Conditions captured: <none>
[15:32:32.237] Early signaling: FALSE
[15:32:32.237] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:32.237] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:32.264] Chunk #2 of 2 ... DONE
[15:32:32.265] Launching 2 futures (chunks) ... DONE
[15:32:32.265] Resolving 2 futures (chunks) ...
[15:32:32.265] resolve() on list ...
[15:32:32.266]  recursive: 0
[15:32:32.266]  length: 2
[15:32:32.266] 
[15:32:32.266] Future #1
[15:32:32.267] result() for ClusterFuture ...
[15:32:32.267] - result already collected: FutureResult
[15:32:32.267] result() for ClusterFuture ... done
[15:32:32.268] result() for ClusterFuture ...
[15:32:32.268] - result already collected: FutureResult
[15:32:32.268] result() for ClusterFuture ... done
[15:32:32.269] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:32.269] - nx: 2
[15:32:32.269] - relay: TRUE
[15:32:32.269] - stdout: TRUE
[15:32:32.270] - signal: TRUE
[15:32:32.270] - resignal: FALSE
[15:32:32.270] - force: TRUE
[15:32:32.270] - relayed: [n=2] FALSE, FALSE
[15:32:32.271] - queued futures: [n=2] FALSE, FALSE
[15:32:32.271]  - until=1
[15:32:32.271]  - relaying element #1
[15:32:32.271] result() for ClusterFuture ...
[15:32:32.272] - result already collected: FutureResult
[15:32:32.272] result() for ClusterFuture ... done
[15:32:32.272] result() for ClusterFuture ...
[15:32:32.273] - result already collected: FutureResult
[15:32:32.273] result() for ClusterFuture ... done
[15:32:32.273] result() for ClusterFuture ...
[15:32:32.274] - result already collected: FutureResult
[15:32:32.274] result() for ClusterFuture ... done
[15:32:32.274] result() for ClusterFuture ...
[15:32:32.274] - result already collected: FutureResult
[15:32:32.275] result() for ClusterFuture ... done
[15:32:32.275] - relayed: [n=2] TRUE, FALSE
[15:32:32.275] - queued futures: [n=2] TRUE, FALSE
[15:32:32.275] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:32.276]  length: 1 (resolved future 1)
[15:32:32.276] Future #2
[15:32:32.276] result() for ClusterFuture ...
[15:32:32.277] - result already collected: FutureResult
[15:32:32.277] result() for ClusterFuture ... done
[15:32:32.277] result() for ClusterFuture ...
[15:32:32.277] - result already collected: FutureResult
[15:32:32.278] result() for ClusterFuture ... done
[15:32:32.278] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:32.278] - nx: 2
[15:32:32.279] - relay: TRUE
[15:32:32.279] - stdout: TRUE
[15:32:32.279] - signal: TRUE
[15:32:32.279] - resignal: FALSE
[15:32:32.280] - force: TRUE
[15:32:32.280] - relayed: [n=2] TRUE, FALSE
[15:32:32.280] - queued futures: [n=2] TRUE, FALSE
[15:32:32.280]  - until=2
[15:32:32.281]  - relaying element #2
[15:32:32.281] result() for ClusterFuture ...
[15:32:32.281] - result already collected: FutureResult
[15:32:32.282] result() for ClusterFuture ... done
[15:32:32.282] result() for ClusterFuture ...
[15:32:32.282] - result already collected: FutureResult
[15:32:32.282] result() for ClusterFuture ... done
[15:32:32.283] result() for ClusterFuture ...
[15:32:32.283] - result already collected: FutureResult
[15:32:32.283] result() for ClusterFuture ... done
[15:32:32.284] result() for ClusterFuture ...
[15:32:32.284] - result already collected: FutureResult
[15:32:32.284] result() for ClusterFuture ... done
[15:32:32.284] - relayed: [n=2] TRUE, TRUE
[15:32:32.285] - queued futures: [n=2] TRUE, TRUE
[15:32:32.285] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:32.285]  length: 0 (resolved future 2)
[15:32:32.286] Relaying remaining futures
[15:32:32.286] signalConditionsASAP(NULL, pos=0) ...
[15:32:32.286] - nx: 2
[15:32:32.286] - relay: TRUE
[15:32:32.287] - stdout: TRUE
[15:32:32.287] - signal: TRUE
[15:32:32.287] - resignal: FALSE
[15:32:32.288] - force: TRUE
[15:32:32.288] - relayed: [n=2] TRUE, TRUE
[15:32:32.288] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:32.289] - relayed: [n=2] TRUE, TRUE
[15:32:32.289] - queued futures: [n=2] TRUE, TRUE
[15:32:32.289] signalConditionsASAP(NULL, pos=0) ... done
[15:32:32.289] resolve() on list ... DONE
[15:32:32.290] result() for ClusterFuture ...
[15:32:32.290] - result already collected: FutureResult
[15:32:32.290] result() for ClusterFuture ... done
[15:32:32.291] result() for ClusterFuture ...
[15:32:32.291] - result already collected: FutureResult
[15:32:32.291] result() for ClusterFuture ... done
[15:32:32.291] result() for ClusterFuture ...
[15:32:32.292] - result already collected: FutureResult
[15:32:32.292] result() for ClusterFuture ... done
[15:32:32.292] result() for ClusterFuture ...
[15:32:32.293] - result already collected: FutureResult
[15:32:32.293] result() for ClusterFuture ... done
[15:32:32.293]  - Number of value chunks collected: 2
[15:32:32.293] Resolving 2 futures (chunks) ... DONE
[15:32:32.294] Reducing values from 2 chunks ...
[15:32:32.294]  - Number of values collected after concatenation: 6
[15:32:32.294]  - Number of values expected: 6
[15:32:32.295] Reducing values from 2 chunks ... DONE
[15:32:32.295] future_lapply() ... DONE
List of 2
 $ y0: num [1:15, 1:6] 2 2 2 4 4 4 6 6 6 8 ...
  ..- attr(*, "dimnames")=List of 2
  .. ..$ : NULL
  .. ..$ : chr [1:6] "a1" "a2" "b1" "b2" ...
 $ y1: num [1:15, 1:6] 2 2 2 4 4 4 6 6 6 8 ...
  ..- attr(*, "dimnames")=List of 2
  .. ..$ : NULL
  .. ..$ : chr [1:6] "a1" "a2" "b1" "b2" ...
[15:32:32.300] future_lapply() ...
[15:32:32.306] Number of chunks: 2
[15:32:32.306] getGlobalsAndPackagesXApply() ...
[15:32:32.306]  - future.globals: TRUE
[15:32:32.307] getGlobalsAndPackages() ...
[15:32:32.307] Searching for globals...
[15:32:32.309] - globals found: [1] 'FUN'
[15:32:32.309] Searching for globals ... DONE
[15:32:32.310] Resolving globals: FALSE
[15:32:32.310] The total size of the 1 globals is 848 bytes (848 bytes)
[15:32:32.311] The total size of the 1 globals exported for future expression ('FUN()') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:32:32.311] - globals: [1] 'FUN'
[15:32:32.311] 
[15:32:32.312] getGlobalsAndPackages() ... DONE
[15:32:32.312]  - globals found/used: [n=1] 'FUN'
[15:32:32.312]  - needed namespaces: [n=0] 
[15:32:32.313] Finding globals ... DONE
[15:32:32.313]  - use_args: TRUE
[15:32:32.313]  - Getting '...' globals ...
[15:32:32.314] resolve() on list ...
[15:32:32.314]  recursive: 0
[15:32:32.314]  length: 1
[15:32:32.315]  elements: '...'
[15:32:32.315]  length: 0 (resolved future 1)
[15:32:32.315] resolve() on list ... DONE
[15:32:32.316]    - '...' content: [n=0] 
[15:32:32.316] List of 1
[15:32:32.316]  $ ...: list()
[15:32:32.316]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:32.316]  - attr(*, "where")=List of 1
[15:32:32.316]   ..$ ...:<environment: 0x00000276e482e148> 
[15:32:32.316]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:32.316]  - attr(*, "resolved")= logi TRUE
[15:32:32.316]  - attr(*, "total_size")= num NA
[15:32:32.325]  - Getting '...' globals ... DONE
[15:32:32.325] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:32.325] List of 2
[15:32:32.325]  $ ...future.FUN:function (x)  
[15:32:32.325]  $ ...          : list()
[15:32:32.325]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:32.325]  - attr(*, "where")=List of 2
[15:32:32.325]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:32.325]   ..$ ...          :<environment: 0x00000276e482e148> 
[15:32:32.325]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:32.325]  - attr(*, "resolved")= logi FALSE
[15:32:32.325]  - attr(*, "total_size")= num 848
[15:32:32.329] Packages to be attached in all futures: [n=0] 
[15:32:32.330] getGlobalsAndPackagesXApply() ... DONE
[15:32:32.330] Number of futures (= number of chunks): 2
[15:32:32.330] Launching 2 futures (chunks) ...
[15:32:32.330] Chunk #1 of 2 ...
[15:32:32.330]  - Finding globals in 'X' for chunk #1 ...
[15:32:32.331] getGlobalsAndPackages() ...
[15:32:32.331] Searching for globals...
[15:32:32.331] 
[15:32:32.331] Searching for globals ... DONE
[15:32:32.331] - globals: [0] <none>
[15:32:32.332] getGlobalsAndPackages() ... DONE
[15:32:32.332]    + additional globals found: [n=0] 
[15:32:32.332]    + additional namespaces needed: [n=0] 
[15:32:32.332]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:32.332]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:32.332]  - seeds: <none>
[15:32:32.332]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:32.333] getGlobalsAndPackages() ...
[15:32:32.333] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:32.333] Resolving globals: FALSE
[15:32:32.333] Tweak future expression to call with '...' arguments ...
[15:32:32.333] {
[15:32:32.333]     do.call(function(...) {
[15:32:32.333]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:32.333]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:32.333]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:32.333]             on.exit(options(oopts), add = TRUE)
[15:32:32.333]         }
[15:32:32.333]         {
[15:32:32.333]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:32.333]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:32.333]                 ...future.FUN(...future.X_jj, ...)
[15:32:32.333]             })
[15:32:32.333]         }
[15:32:32.333]     }, args = future.call.arguments)
[15:32:32.333] }
[15:32:32.334] Tweak future expression to call with '...' arguments ... DONE
[15:32:32.334] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:32.335] 
[15:32:32.335] getGlobalsAndPackages() ... DONE
[15:32:32.335] run() for 'Future' ...
[15:32:32.335] - state: 'created'
[15:32:32.335] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:32.352] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:32.353] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:32.353]   - Field: 'node'
[15:32:32.353]   - Field: 'label'
[15:32:32.354]   - Field: 'local'
[15:32:32.354]   - Field: 'owner'
[15:32:32.354]   - Field: 'envir'
[15:32:32.354]   - Field: 'workers'
[15:32:32.355]   - Field: 'packages'
[15:32:32.355]   - Field: 'gc'
[15:32:32.355]   - Field: 'conditions'
[15:32:32.356]   - Field: 'persistent'
[15:32:32.356]   - Field: 'expr'
[15:32:32.356]   - Field: 'uuid'
[15:32:32.356]   - Field: 'seed'
[15:32:32.357]   - Field: 'version'
[15:32:32.357]   - Field: 'result'
[15:32:32.357]   - Field: 'asynchronous'
[15:32:32.358]   - Field: 'calls'
[15:32:32.358]   - Field: 'globals'
[15:32:32.358]   - Field: 'stdout'
[15:32:32.358]   - Field: 'earlySignal'
[15:32:32.359]   - Field: 'lazy'
[15:32:32.359]   - Field: 'state'
[15:32:32.359] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:32.360] - Launch lazy future ...
[15:32:32.360] Packages needed by the future expression (n = 0): <none>
[15:32:32.360] Packages needed by future strategies (n = 0): <none>
[15:32:32.361] {
[15:32:32.361]     {
[15:32:32.361]         {
[15:32:32.361]             ...future.startTime <- base::Sys.time()
[15:32:32.361]             {
[15:32:32.361]                 {
[15:32:32.361]                   {
[15:32:32.361]                     {
[15:32:32.361]                       base::local({
[15:32:32.361]                         has_future <- base::requireNamespace("future", 
[15:32:32.361]                           quietly = TRUE)
[15:32:32.361]                         if (has_future) {
[15:32:32.361]                           ns <- base::getNamespace("future")
[15:32:32.361]                           version <- ns[[".package"]][["version"]]
[15:32:32.361]                           if (is.null(version)) 
[15:32:32.361]                             version <- utils::packageVersion("future")
[15:32:32.361]                         }
[15:32:32.361]                         else {
[15:32:32.361]                           version <- NULL
[15:32:32.361]                         }
[15:32:32.361]                         if (!has_future || version < "1.8.0") {
[15:32:32.361]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:32.361]                             "", base::R.version$version.string), 
[15:32:32.361]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:32.361]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:32.361]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:32.361]                               "release", "version")], collapse = " "), 
[15:32:32.361]                             hostname = base::Sys.info()[["nodename"]])
[15:32:32.361]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:32.361]                             info)
[15:32:32.361]                           info <- base::paste(info, collapse = "; ")
[15:32:32.361]                           if (!has_future) {
[15:32:32.361]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:32.361]                               info)
[15:32:32.361]                           }
[15:32:32.361]                           else {
[15:32:32.361]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:32.361]                               info, version)
[15:32:32.361]                           }
[15:32:32.361]                           base::stop(msg)
[15:32:32.361]                         }
[15:32:32.361]                       })
[15:32:32.361]                     }
[15:32:32.361]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:32.361]                     base::options(mc.cores = 1L)
[15:32:32.361]                   }
[15:32:32.361]                   ...future.strategy.old <- future::plan("list")
[15:32:32.361]                   options(future.plan = NULL)
[15:32:32.361]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:32.361]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:32.361]                 }
[15:32:32.361]                 ...future.workdir <- getwd()
[15:32:32.361]             }
[15:32:32.361]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:32.361]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:32.361]         }
[15:32:32.361]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:32.361]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:32.361]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:32.361]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:32.361]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:32.361]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:32.361]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:32.361]             base::names(...future.oldOptions))
[15:32:32.361]     }
[15:32:32.361]     if (FALSE) {
[15:32:32.361]     }
[15:32:32.361]     else {
[15:32:32.361]         if (TRUE) {
[15:32:32.361]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:32.361]                 open = "w")
[15:32:32.361]         }
[15:32:32.361]         else {
[15:32:32.361]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:32.361]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:32.361]         }
[15:32:32.361]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:32.361]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:32.361]             base::sink(type = "output", split = FALSE)
[15:32:32.361]             base::close(...future.stdout)
[15:32:32.361]         }, add = TRUE)
[15:32:32.361]     }
[15:32:32.361]     ...future.frame <- base::sys.nframe()
[15:32:32.361]     ...future.conditions <- base::list()
[15:32:32.361]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:32.361]     if (FALSE) {
[15:32:32.361]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:32.361]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:32.361]     }
[15:32:32.361]     ...future.result <- base::tryCatch({
[15:32:32.361]         base::withCallingHandlers({
[15:32:32.361]             ...future.value <- base::withVisible(base::local({
[15:32:32.361]                 ...future.makeSendCondition <- base::local({
[15:32:32.361]                   sendCondition <- NULL
[15:32:32.361]                   function(frame = 1L) {
[15:32:32.361]                     if (is.function(sendCondition)) 
[15:32:32.361]                       return(sendCondition)
[15:32:32.361]                     ns <- getNamespace("parallel")
[15:32:32.361]                     if (exists("sendData", mode = "function", 
[15:32:32.361]                       envir = ns)) {
[15:32:32.361]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:32.361]                         envir = ns)
[15:32:32.361]                       envir <- sys.frame(frame)
[15:32:32.361]                       master <- NULL
[15:32:32.361]                       while (!identical(envir, .GlobalEnv) && 
[15:32:32.361]                         !identical(envir, emptyenv())) {
[15:32:32.361]                         if (exists("master", mode = "list", envir = envir, 
[15:32:32.361]                           inherits = FALSE)) {
[15:32:32.361]                           master <- get("master", mode = "list", 
[15:32:32.361]                             envir = envir, inherits = FALSE)
[15:32:32.361]                           if (inherits(master, c("SOCKnode", 
[15:32:32.361]                             "SOCK0node"))) {
[15:32:32.361]                             sendCondition <<- function(cond) {
[15:32:32.361]                               data <- list(type = "VALUE", value = cond, 
[15:32:32.361]                                 success = TRUE)
[15:32:32.361]                               parallel_sendData(master, data)
[15:32:32.361]                             }
[15:32:32.361]                             return(sendCondition)
[15:32:32.361]                           }
[15:32:32.361]                         }
[15:32:32.361]                         frame <- frame + 1L
[15:32:32.361]                         envir <- sys.frame(frame)
[15:32:32.361]                       }
[15:32:32.361]                     }
[15:32:32.361]                     sendCondition <<- function(cond) NULL
[15:32:32.361]                   }
[15:32:32.361]                 })
[15:32:32.361]                 withCallingHandlers({
[15:32:32.361]                   {
[15:32:32.361]                     do.call(function(...) {
[15:32:32.361]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:32.361]                       if (!identical(...future.globals.maxSize.org, 
[15:32:32.361]                         ...future.globals.maxSize)) {
[15:32:32.361]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:32.361]                         on.exit(options(oopts), add = TRUE)
[15:32:32.361]                       }
[15:32:32.361]                       {
[15:32:32.361]                         lapply(seq_along(...future.elements_ii), 
[15:32:32.361]                           FUN = function(jj) {
[15:32:32.361]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:32.361]                             ...future.FUN(...future.X_jj, ...)
[15:32:32.361]                           })
[15:32:32.361]                       }
[15:32:32.361]                     }, args = future.call.arguments)
[15:32:32.361]                   }
[15:32:32.361]                 }, immediateCondition = function(cond) {
[15:32:32.361]                   sendCondition <- ...future.makeSendCondition()
[15:32:32.361]                   sendCondition(cond)
[15:32:32.361]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:32.361]                   {
[15:32:32.361]                     inherits <- base::inherits
[15:32:32.361]                     invokeRestart <- base::invokeRestart
[15:32:32.361]                     is.null <- base::is.null
[15:32:32.361]                     muffled <- FALSE
[15:32:32.361]                     if (inherits(cond, "message")) {
[15:32:32.361]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:32.361]                       if (muffled) 
[15:32:32.361]                         invokeRestart("muffleMessage")
[15:32:32.361]                     }
[15:32:32.361]                     else if (inherits(cond, "warning")) {
[15:32:32.361]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:32.361]                       if (muffled) 
[15:32:32.361]                         invokeRestart("muffleWarning")
[15:32:32.361]                     }
[15:32:32.361]                     else if (inherits(cond, "condition")) {
[15:32:32.361]                       if (!is.null(pattern)) {
[15:32:32.361]                         computeRestarts <- base::computeRestarts
[15:32:32.361]                         grepl <- base::grepl
[15:32:32.361]                         restarts <- computeRestarts(cond)
[15:32:32.361]                         for (restart in restarts) {
[15:32:32.361]                           name <- restart$name
[15:32:32.361]                           if (is.null(name)) 
[15:32:32.361]                             next
[15:32:32.361]                           if (!grepl(pattern, name)) 
[15:32:32.361]                             next
[15:32:32.361]                           invokeRestart(restart)
[15:32:32.361]                           muffled <- TRUE
[15:32:32.361]                           break
[15:32:32.361]                         }
[15:32:32.361]                       }
[15:32:32.361]                     }
[15:32:32.361]                     invisible(muffled)
[15:32:32.361]                   }
[15:32:32.361]                   muffleCondition(cond)
[15:32:32.361]                 })
[15:32:32.361]             }))
[15:32:32.361]             future::FutureResult(value = ...future.value$value, 
[15:32:32.361]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:32.361]                   ...future.rng), globalenv = if (FALSE) 
[15:32:32.361]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:32.361]                     ...future.globalenv.names))
[15:32:32.361]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:32.361]         }, condition = base::local({
[15:32:32.361]             c <- base::c
[15:32:32.361]             inherits <- base::inherits
[15:32:32.361]             invokeRestart <- base::invokeRestart
[15:32:32.361]             length <- base::length
[15:32:32.361]             list <- base::list
[15:32:32.361]             seq.int <- base::seq.int
[15:32:32.361]             signalCondition <- base::signalCondition
[15:32:32.361]             sys.calls <- base::sys.calls
[15:32:32.361]             `[[` <- base::`[[`
[15:32:32.361]             `+` <- base::`+`
[15:32:32.361]             `<<-` <- base::`<<-`
[15:32:32.361]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:32.361]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:32.361]                   3L)]
[15:32:32.361]             }
[15:32:32.361]             function(cond) {
[15:32:32.361]                 is_error <- inherits(cond, "error")
[15:32:32.361]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:32.361]                   NULL)
[15:32:32.361]                 if (is_error) {
[15:32:32.361]                   sessionInformation <- function() {
[15:32:32.361]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:32.361]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:32.361]                       search = base::search(), system = base::Sys.info())
[15:32:32.361]                   }
[15:32:32.361]                   ...future.conditions[[length(...future.conditions) + 
[15:32:32.361]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:32.361]                     cond$call), session = sessionInformation(), 
[15:32:32.361]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:32.361]                   signalCondition(cond)
[15:32:32.361]                 }
[15:32:32.361]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:32.361]                 "immediateCondition"))) {
[15:32:32.361]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:32.361]                   ...future.conditions[[length(...future.conditions) + 
[15:32:32.361]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:32.361]                   if (TRUE && !signal) {
[15:32:32.361]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:32.361]                     {
[15:32:32.361]                       inherits <- base::inherits
[15:32:32.361]                       invokeRestart <- base::invokeRestart
[15:32:32.361]                       is.null <- base::is.null
[15:32:32.361]                       muffled <- FALSE
[15:32:32.361]                       if (inherits(cond, "message")) {
[15:32:32.361]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:32.361]                         if (muffled) 
[15:32:32.361]                           invokeRestart("muffleMessage")
[15:32:32.361]                       }
[15:32:32.361]                       else if (inherits(cond, "warning")) {
[15:32:32.361]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:32.361]                         if (muffled) 
[15:32:32.361]                           invokeRestart("muffleWarning")
[15:32:32.361]                       }
[15:32:32.361]                       else if (inherits(cond, "condition")) {
[15:32:32.361]                         if (!is.null(pattern)) {
[15:32:32.361]                           computeRestarts <- base::computeRestarts
[15:32:32.361]                           grepl <- base::grepl
[15:32:32.361]                           restarts <- computeRestarts(cond)
[15:32:32.361]                           for (restart in restarts) {
[15:32:32.361]                             name <- restart$name
[15:32:32.361]                             if (is.null(name)) 
[15:32:32.361]                               next
[15:32:32.361]                             if (!grepl(pattern, name)) 
[15:32:32.361]                               next
[15:32:32.361]                             invokeRestart(restart)
[15:32:32.361]                             muffled <- TRUE
[15:32:32.361]                             break
[15:32:32.361]                           }
[15:32:32.361]                         }
[15:32:32.361]                       }
[15:32:32.361]                       invisible(muffled)
[15:32:32.361]                     }
[15:32:32.361]                     muffleCondition(cond, pattern = "^muffle")
[15:32:32.361]                   }
[15:32:32.361]                 }
[15:32:32.361]                 else {
[15:32:32.361]                   if (TRUE) {
[15:32:32.361]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:32.361]                     {
[15:32:32.361]                       inherits <- base::inherits
[15:32:32.361]                       invokeRestart <- base::invokeRestart
[15:32:32.361]                       is.null <- base::is.null
[15:32:32.361]                       muffled <- FALSE
[15:32:32.361]                       if (inherits(cond, "message")) {
[15:32:32.361]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:32.361]                         if (muffled) 
[15:32:32.361]                           invokeRestart("muffleMessage")
[15:32:32.361]                       }
[15:32:32.361]                       else if (inherits(cond, "warning")) {
[15:32:32.361]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:32.361]                         if (muffled) 
[15:32:32.361]                           invokeRestart("muffleWarning")
[15:32:32.361]                       }
[15:32:32.361]                       else if (inherits(cond, "condition")) {
[15:32:32.361]                         if (!is.null(pattern)) {
[15:32:32.361]                           computeRestarts <- base::computeRestarts
[15:32:32.361]                           grepl <- base::grepl
[15:32:32.361]                           restarts <- computeRestarts(cond)
[15:32:32.361]                           for (restart in restarts) {
[15:32:32.361]                             name <- restart$name
[15:32:32.361]                             if (is.null(name)) 
[15:32:32.361]                               next
[15:32:32.361]                             if (!grepl(pattern, name)) 
[15:32:32.361]                               next
[15:32:32.361]                             invokeRestart(restart)
[15:32:32.361]                             muffled <- TRUE
[15:32:32.361]                             break
[15:32:32.361]                           }
[15:32:32.361]                         }
[15:32:32.361]                       }
[15:32:32.361]                       invisible(muffled)
[15:32:32.361]                     }
[15:32:32.361]                     muffleCondition(cond, pattern = "^muffle")
[15:32:32.361]                   }
[15:32:32.361]                 }
[15:32:32.361]             }
[15:32:32.361]         }))
[15:32:32.361]     }, error = function(ex) {
[15:32:32.361]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:32.361]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:32.361]                 ...future.rng), started = ...future.startTime, 
[15:32:32.361]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:32.361]             version = "1.8"), class = "FutureResult")
[15:32:32.361]     }, finally = {
[15:32:32.361]         if (!identical(...future.workdir, getwd())) 
[15:32:32.361]             setwd(...future.workdir)
[15:32:32.361]         {
[15:32:32.361]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:32.361]                 ...future.oldOptions$nwarnings <- NULL
[15:32:32.361]             }
[15:32:32.361]             base::options(...future.oldOptions)
[15:32:32.361]             if (.Platform$OS.type == "windows") {
[15:32:32.361]                 old_names <- names(...future.oldEnvVars)
[15:32:32.361]                 envs <- base::Sys.getenv()
[15:32:32.361]                 names <- names(envs)
[15:32:32.361]                 common <- intersect(names, old_names)
[15:32:32.361]                 added <- setdiff(names, old_names)
[15:32:32.361]                 removed <- setdiff(old_names, names)
[15:32:32.361]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:32.361]                   envs[common]]
[15:32:32.361]                 NAMES <- toupper(changed)
[15:32:32.361]                 args <- list()
[15:32:32.361]                 for (kk in seq_along(NAMES)) {
[15:32:32.361]                   name <- changed[[kk]]
[15:32:32.361]                   NAME <- NAMES[[kk]]
[15:32:32.361]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:32.361]                     next
[15:32:32.361]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:32.361]                 }
[15:32:32.361]                 NAMES <- toupper(added)
[15:32:32.361]                 for (kk in seq_along(NAMES)) {
[15:32:32.361]                   name <- added[[kk]]
[15:32:32.361]                   NAME <- NAMES[[kk]]
[15:32:32.361]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:32.361]                     next
[15:32:32.361]                   args[[name]] <- ""
[15:32:32.361]                 }
[15:32:32.361]                 NAMES <- toupper(removed)
[15:32:32.361]                 for (kk in seq_along(NAMES)) {
[15:32:32.361]                   name <- removed[[kk]]
[15:32:32.361]                   NAME <- NAMES[[kk]]
[15:32:32.361]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:32.361]                     next
[15:32:32.361]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:32.361]                 }
[15:32:32.361]                 if (length(args) > 0) 
[15:32:32.361]                   base::do.call(base::Sys.setenv, args = args)
[15:32:32.361]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:32.361]             }
[15:32:32.361]             else {
[15:32:32.361]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:32.361]             }
[15:32:32.361]             {
[15:32:32.361]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:32.361]                   0L) {
[15:32:32.361]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:32.361]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:32.361]                   base::options(opts)
[15:32:32.361]                 }
[15:32:32.361]                 {
[15:32:32.361]                   {
[15:32:32.361]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:32.361]                     NULL
[15:32:32.361]                   }
[15:32:32.361]                   options(future.plan = NULL)
[15:32:32.361]                   if (is.na(NA_character_)) 
[15:32:32.361]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:32.361]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:32.361]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:32.361]                     .init = FALSE)
[15:32:32.361]                 }
[15:32:32.361]             }
[15:32:32.361]         }
[15:32:32.361]     })
[15:32:32.361]     if (TRUE) {
[15:32:32.361]         base::sink(type = "output", split = FALSE)
[15:32:32.361]         if (TRUE) {
[15:32:32.361]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:32.361]         }
[15:32:32.361]         else {
[15:32:32.361]             ...future.result["stdout"] <- base::list(NULL)
[15:32:32.361]         }
[15:32:32.361]         base::close(...future.stdout)
[15:32:32.361]         ...future.stdout <- NULL
[15:32:32.361]     }
[15:32:32.361]     ...future.result$conditions <- ...future.conditions
[15:32:32.361]     ...future.result$finished <- base::Sys.time()
[15:32:32.361]     ...future.result
[15:32:32.361] }
[15:32:32.370] Exporting 5 global objects (848 bytes) to cluster node #1 ...
[15:32:32.371] Exporting '...future.FUN' (848 bytes) to cluster node #1 ...
[15:32:32.371] Exporting '...future.FUN' (848 bytes) to cluster node #1 ... DONE
[15:32:32.372] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:32.372] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:32.373] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ...
[15:32:32.373] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ... DONE
[15:32:32.374] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:32.374] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:32.375] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:32.375] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:32.375] Exporting 5 global objects (848 bytes) to cluster node #1 ... DONE
[15:32:32.376] MultisessionFuture started
[15:32:32.377] - Launch lazy future ... done
[15:32:32.377] run() for 'MultisessionFuture' ... done
[15:32:32.377] Created future:
[15:32:32.399] receiveMessageFromWorker() for ClusterFuture ...
[15:32:32.400] - Validating connection of MultisessionFuture
[15:32:32.400] - received message: FutureResult
[15:32:32.400] - Received FutureResult
[15:32:32.401] - Erased future from FutureRegistry
[15:32:32.401] result() for ClusterFuture ...
[15:32:32.401] - result already collected: FutureResult
[15:32:32.401] result() for ClusterFuture ... done
[15:32:32.401] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:32.378] MultisessionFuture:
[15:32:32.378] Label: 'future_sapply-1'
[15:32:32.378] Expression:
[15:32:32.378] {
[15:32:32.378]     do.call(function(...) {
[15:32:32.378]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:32.378]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:32.378]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:32.378]             on.exit(options(oopts), add = TRUE)
[15:32:32.378]         }
[15:32:32.378]         {
[15:32:32.378]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:32.378]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:32.378]                 ...future.FUN(...future.X_jj, ...)
[15:32:32.378]             })
[15:32:32.378]         }
[15:32:32.378]     }, args = future.call.arguments)
[15:32:32.378] }
[15:32:32.378] Lazy evaluation: FALSE
[15:32:32.378] Asynchronous evaluation: TRUE
[15:32:32.378] Local evaluation: TRUE
[15:32:32.378] Environment: R_GlobalEnv
[15:32:32.378] Capture standard output: TRUE
[15:32:32.378] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:32.378] Globals: 5 objects totaling 0.99 KiB (function '...future.FUN' of 848 bytes, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:32.378] Packages: <none>
[15:32:32.378] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:32.378] Resolved: TRUE
[15:32:32.378] Value: <not collected>
[15:32:32.378] Conditions captured: <none>
[15:32:32.378] Early signaling: FALSE
[15:32:32.378] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:32.378] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:32.402] Chunk #1 of 2 ... DONE
[15:32:32.402] Chunk #2 of 2 ...
[15:32:32.402]  - Finding globals in 'X' for chunk #2 ...
[15:32:32.402] getGlobalsAndPackages() ...
[15:32:32.402] Searching for globals...
[15:32:32.403] 
[15:32:32.403] Searching for globals ... DONE
[15:32:32.403] - globals: [0] <none>
[15:32:32.403] getGlobalsAndPackages() ... DONE
[15:32:32.403]    + additional globals found: [n=0] 
[15:32:32.404]    + additional namespaces needed: [n=0] 
[15:32:32.404]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:32.404]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:32.404]  - seeds: <none>
[15:32:32.404]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:32.404] getGlobalsAndPackages() ...
[15:32:32.405] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:32.405] Resolving globals: FALSE
[15:32:32.405] Tweak future expression to call with '...' arguments ...
[15:32:32.405] {
[15:32:32.405]     do.call(function(...) {
[15:32:32.405]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:32.405]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:32.405]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:32.405]             on.exit(options(oopts), add = TRUE)
[15:32:32.405]         }
[15:32:32.405]         {
[15:32:32.405]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:32.405]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:32.405]                 ...future.FUN(...future.X_jj, ...)
[15:32:32.405]             })
[15:32:32.405]         }
[15:32:32.405]     }, args = future.call.arguments)
[15:32:32.405] }
[15:32:32.406] Tweak future expression to call with '...' arguments ... DONE
[15:32:32.407] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:32.407] 
[15:32:32.407] getGlobalsAndPackages() ... DONE
[15:32:32.408] run() for 'Future' ...
[15:32:32.408] - state: 'created'
[15:32:32.409] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:32.427] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:32.428] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:32.428]   - Field: 'node'
[15:32:32.429]   - Field: 'label'
[15:32:32.429]   - Field: 'local'
[15:32:32.429]   - Field: 'owner'
[15:32:32.429]   - Field: 'envir'
[15:32:32.430]   - Field: 'workers'
[15:32:32.430]   - Field: 'packages'
[15:32:32.430]   - Field: 'gc'
[15:32:32.431]   - Field: 'conditions'
[15:32:32.431]   - Field: 'persistent'
[15:32:32.431]   - Field: 'expr'
[15:32:32.431]   - Field: 'uuid'
[15:32:32.432]   - Field: 'seed'
[15:32:32.432]   - Field: 'version'
[15:32:32.432]   - Field: 'result'
[15:32:32.433]   - Field: 'asynchronous'
[15:32:32.433]   - Field: 'calls'
[15:32:32.433]   - Field: 'globals'
[15:32:32.433]   - Field: 'stdout'
[15:32:32.434]   - Field: 'earlySignal'
[15:32:32.434]   - Field: 'lazy'
[15:32:32.434]   - Field: 'state'
[15:32:32.435] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:32.435] - Launch lazy future ...
[15:32:32.436] Packages needed by the future expression (n = 0): <none>
[15:32:32.436] Packages needed by future strategies (n = 0): <none>
[15:32:32.437] {
[15:32:32.437]     {
[15:32:32.437]         {
[15:32:32.437]             ...future.startTime <- base::Sys.time()
[15:32:32.437]             {
[15:32:32.437]                 {
[15:32:32.437]                   {
[15:32:32.437]                     {
[15:32:32.437]                       base::local({
[15:32:32.437]                         has_future <- base::requireNamespace("future", 
[15:32:32.437]                           quietly = TRUE)
[15:32:32.437]                         if (has_future) {
[15:32:32.437]                           ns <- base::getNamespace("future")
[15:32:32.437]                           version <- ns[[".package"]][["version"]]
[15:32:32.437]                           if (is.null(version)) 
[15:32:32.437]                             version <- utils::packageVersion("future")
[15:32:32.437]                         }
[15:32:32.437]                         else {
[15:32:32.437]                           version <- NULL
[15:32:32.437]                         }
[15:32:32.437]                         if (!has_future || version < "1.8.0") {
[15:32:32.437]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:32.437]                             "", base::R.version$version.string), 
[15:32:32.437]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:32.437]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:32.437]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:32.437]                               "release", "version")], collapse = " "), 
[15:32:32.437]                             hostname = base::Sys.info()[["nodename"]])
[15:32:32.437]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:32.437]                             info)
[15:32:32.437]                           info <- base::paste(info, collapse = "; ")
[15:32:32.437]                           if (!has_future) {
[15:32:32.437]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:32.437]                               info)
[15:32:32.437]                           }
[15:32:32.437]                           else {
[15:32:32.437]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:32.437]                               info, version)
[15:32:32.437]                           }
[15:32:32.437]                           base::stop(msg)
[15:32:32.437]                         }
[15:32:32.437]                       })
[15:32:32.437]                     }
[15:32:32.437]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:32.437]                     base::options(mc.cores = 1L)
[15:32:32.437]                   }
[15:32:32.437]                   ...future.strategy.old <- future::plan("list")
[15:32:32.437]                   options(future.plan = NULL)
[15:32:32.437]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:32.437]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:32.437]                 }
[15:32:32.437]                 ...future.workdir <- getwd()
[15:32:32.437]             }
[15:32:32.437]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:32.437]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:32.437]         }
[15:32:32.437]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:32.437]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:32.437]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:32.437]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:32.437]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:32.437]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:32.437]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:32.437]             base::names(...future.oldOptions))
[15:32:32.437]     }
[15:32:32.437]     if (FALSE) {
[15:32:32.437]     }
[15:32:32.437]     else {
[15:32:32.437]         if (TRUE) {
[15:32:32.437]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:32.437]                 open = "w")
[15:32:32.437]         }
[15:32:32.437]         else {
[15:32:32.437]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:32.437]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:32.437]         }
[15:32:32.437]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:32.437]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:32.437]             base::sink(type = "output", split = FALSE)
[15:32:32.437]             base::close(...future.stdout)
[15:32:32.437]         }, add = TRUE)
[15:32:32.437]     }
[15:32:32.437]     ...future.frame <- base::sys.nframe()
[15:32:32.437]     ...future.conditions <- base::list()
[15:32:32.437]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:32.437]     if (FALSE) {
[15:32:32.437]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:32.437]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:32.437]     }
[15:32:32.437]     ...future.result <- base::tryCatch({
[15:32:32.437]         base::withCallingHandlers({
[15:32:32.437]             ...future.value <- base::withVisible(base::local({
[15:32:32.437]                 ...future.makeSendCondition <- base::local({
[15:32:32.437]                   sendCondition <- NULL
[15:32:32.437]                   function(frame = 1L) {
[15:32:32.437]                     if (is.function(sendCondition)) 
[15:32:32.437]                       return(sendCondition)
[15:32:32.437]                     ns <- getNamespace("parallel")
[15:32:32.437]                     if (exists("sendData", mode = "function", 
[15:32:32.437]                       envir = ns)) {
[15:32:32.437]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:32.437]                         envir = ns)
[15:32:32.437]                       envir <- sys.frame(frame)
[15:32:32.437]                       master <- NULL
[15:32:32.437]                       while (!identical(envir, .GlobalEnv) && 
[15:32:32.437]                         !identical(envir, emptyenv())) {
[15:32:32.437]                         if (exists("master", mode = "list", envir = envir, 
[15:32:32.437]                           inherits = FALSE)) {
[15:32:32.437]                           master <- get("master", mode = "list", 
[15:32:32.437]                             envir = envir, inherits = FALSE)
[15:32:32.437]                           if (inherits(master, c("SOCKnode", 
[15:32:32.437]                             "SOCK0node"))) {
[15:32:32.437]                             sendCondition <<- function(cond) {
[15:32:32.437]                               data <- list(type = "VALUE", value = cond, 
[15:32:32.437]                                 success = TRUE)
[15:32:32.437]                               parallel_sendData(master, data)
[15:32:32.437]                             }
[15:32:32.437]                             return(sendCondition)
[15:32:32.437]                           }
[15:32:32.437]                         }
[15:32:32.437]                         frame <- frame + 1L
[15:32:32.437]                         envir <- sys.frame(frame)
[15:32:32.437]                       }
[15:32:32.437]                     }
[15:32:32.437]                     sendCondition <<- function(cond) NULL
[15:32:32.437]                   }
[15:32:32.437]                 })
[15:32:32.437]                 withCallingHandlers({
[15:32:32.437]                   {
[15:32:32.437]                     do.call(function(...) {
[15:32:32.437]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:32.437]                       if (!identical(...future.globals.maxSize.org, 
[15:32:32.437]                         ...future.globals.maxSize)) {
[15:32:32.437]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:32.437]                         on.exit(options(oopts), add = TRUE)
[15:32:32.437]                       }
[15:32:32.437]                       {
[15:32:32.437]                         lapply(seq_along(...future.elements_ii), 
[15:32:32.437]                           FUN = function(jj) {
[15:32:32.437]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:32.437]                             ...future.FUN(...future.X_jj, ...)
[15:32:32.437]                           })
[15:32:32.437]                       }
[15:32:32.437]                     }, args = future.call.arguments)
[15:32:32.437]                   }
[15:32:32.437]                 }, immediateCondition = function(cond) {
[15:32:32.437]                   sendCondition <- ...future.makeSendCondition()
[15:32:32.437]                   sendCondition(cond)
[15:32:32.437]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:32.437]                   {
[15:32:32.437]                     inherits <- base::inherits
[15:32:32.437]                     invokeRestart <- base::invokeRestart
[15:32:32.437]                     is.null <- base::is.null
[15:32:32.437]                     muffled <- FALSE
[15:32:32.437]                     if (inherits(cond, "message")) {
[15:32:32.437]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:32.437]                       if (muffled) 
[15:32:32.437]                         invokeRestart("muffleMessage")
[15:32:32.437]                     }
[15:32:32.437]                     else if (inherits(cond, "warning")) {
[15:32:32.437]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:32.437]                       if (muffled) 
[15:32:32.437]                         invokeRestart("muffleWarning")
[15:32:32.437]                     }
[15:32:32.437]                     else if (inherits(cond, "condition")) {
[15:32:32.437]                       if (!is.null(pattern)) {
[15:32:32.437]                         computeRestarts <- base::computeRestarts
[15:32:32.437]                         grepl <- base::grepl
[15:32:32.437]                         restarts <- computeRestarts(cond)
[15:32:32.437]                         for (restart in restarts) {
[15:32:32.437]                           name <- restart$name
[15:32:32.437]                           if (is.null(name)) 
[15:32:32.437]                             next
[15:32:32.437]                           if (!grepl(pattern, name)) 
[15:32:32.437]                             next
[15:32:32.437]                           invokeRestart(restart)
[15:32:32.437]                           muffled <- TRUE
[15:32:32.437]                           break
[15:32:32.437]                         }
[15:32:32.437]                       }
[15:32:32.437]                     }
[15:32:32.437]                     invisible(muffled)
[15:32:32.437]                   }
[15:32:32.437]                   muffleCondition(cond)
[15:32:32.437]                 })
[15:32:32.437]             }))
[15:32:32.437]             future::FutureResult(value = ...future.value$value, 
[15:32:32.437]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:32.437]                   ...future.rng), globalenv = if (FALSE) 
[15:32:32.437]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:32.437]                     ...future.globalenv.names))
[15:32:32.437]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:32.437]         }, condition = base::local({
[15:32:32.437]             c <- base::c
[15:32:32.437]             inherits <- base::inherits
[15:32:32.437]             invokeRestart <- base::invokeRestart
[15:32:32.437]             length <- base::length
[15:32:32.437]             list <- base::list
[15:32:32.437]             seq.int <- base::seq.int
[15:32:32.437]             signalCondition <- base::signalCondition
[15:32:32.437]             sys.calls <- base::sys.calls
[15:32:32.437]             `[[` <- base::`[[`
[15:32:32.437]             `+` <- base::`+`
[15:32:32.437]             `<<-` <- base::`<<-`
[15:32:32.437]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:32.437]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:32.437]                   3L)]
[15:32:32.437]             }
[15:32:32.437]             function(cond) {
[15:32:32.437]                 is_error <- inherits(cond, "error")
[15:32:32.437]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:32.437]                   NULL)
[15:32:32.437]                 if (is_error) {
[15:32:32.437]                   sessionInformation <- function() {
[15:32:32.437]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:32.437]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:32.437]                       search = base::search(), system = base::Sys.info())
[15:32:32.437]                   }
[15:32:32.437]                   ...future.conditions[[length(...future.conditions) + 
[15:32:32.437]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:32.437]                     cond$call), session = sessionInformation(), 
[15:32:32.437]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:32.437]                   signalCondition(cond)
[15:32:32.437]                 }
[15:32:32.437]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:32.437]                 "immediateCondition"))) {
[15:32:32.437]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:32.437]                   ...future.conditions[[length(...future.conditions) + 
[15:32:32.437]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:32.437]                   if (TRUE && !signal) {
[15:32:32.437]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:32.437]                     {
[15:32:32.437]                       inherits <- base::inherits
[15:32:32.437]                       invokeRestart <- base::invokeRestart
[15:32:32.437]                       is.null <- base::is.null
[15:32:32.437]                       muffled <- FALSE
[15:32:32.437]                       if (inherits(cond, "message")) {
[15:32:32.437]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:32.437]                         if (muffled) 
[15:32:32.437]                           invokeRestart("muffleMessage")
[15:32:32.437]                       }
[15:32:32.437]                       else if (inherits(cond, "warning")) {
[15:32:32.437]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:32.437]                         if (muffled) 
[15:32:32.437]                           invokeRestart("muffleWarning")
[15:32:32.437]                       }
[15:32:32.437]                       else if (inherits(cond, "condition")) {
[15:32:32.437]                         if (!is.null(pattern)) {
[15:32:32.437]                           computeRestarts <- base::computeRestarts
[15:32:32.437]                           grepl <- base::grepl
[15:32:32.437]                           restarts <- computeRestarts(cond)
[15:32:32.437]                           for (restart in restarts) {
[15:32:32.437]                             name <- restart$name
[15:32:32.437]                             if (is.null(name)) 
[15:32:32.437]                               next
[15:32:32.437]                             if (!grepl(pattern, name)) 
[15:32:32.437]                               next
[15:32:32.437]                             invokeRestart(restart)
[15:32:32.437]                             muffled <- TRUE
[15:32:32.437]                             break
[15:32:32.437]                           }
[15:32:32.437]                         }
[15:32:32.437]                       }
[15:32:32.437]                       invisible(muffled)
[15:32:32.437]                     }
[15:32:32.437]                     muffleCondition(cond, pattern = "^muffle")
[15:32:32.437]                   }
[15:32:32.437]                 }
[15:32:32.437]                 else {
[15:32:32.437]                   if (TRUE) {
[15:32:32.437]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:32.437]                     {
[15:32:32.437]                       inherits <- base::inherits
[15:32:32.437]                       invokeRestart <- base::invokeRestart
[15:32:32.437]                       is.null <- base::is.null
[15:32:32.437]                       muffled <- FALSE
[15:32:32.437]                       if (inherits(cond, "message")) {
[15:32:32.437]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:32.437]                         if (muffled) 
[15:32:32.437]                           invokeRestart("muffleMessage")
[15:32:32.437]                       }
[15:32:32.437]                       else if (inherits(cond, "warning")) {
[15:32:32.437]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:32.437]                         if (muffled) 
[15:32:32.437]                           invokeRestart("muffleWarning")
[15:32:32.437]                       }
[15:32:32.437]                       else if (inherits(cond, "condition")) {
[15:32:32.437]                         if (!is.null(pattern)) {
[15:32:32.437]                           computeRestarts <- base::computeRestarts
[15:32:32.437]                           grepl <- base::grepl
[15:32:32.437]                           restarts <- computeRestarts(cond)
[15:32:32.437]                           for (restart in restarts) {
[15:32:32.437]                             name <- restart$name
[15:32:32.437]                             if (is.null(name)) 
[15:32:32.437]                               next
[15:32:32.437]                             if (!grepl(pattern, name)) 
[15:32:32.437]                               next
[15:32:32.437]                             invokeRestart(restart)
[15:32:32.437]                             muffled <- TRUE
[15:32:32.437]                             break
[15:32:32.437]                           }
[15:32:32.437]                         }
[15:32:32.437]                       }
[15:32:32.437]                       invisible(muffled)
[15:32:32.437]                     }
[15:32:32.437]                     muffleCondition(cond, pattern = "^muffle")
[15:32:32.437]                   }
[15:32:32.437]                 }
[15:32:32.437]             }
[15:32:32.437]         }))
[15:32:32.437]     }, error = function(ex) {
[15:32:32.437]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:32.437]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:32.437]                 ...future.rng), started = ...future.startTime, 
[15:32:32.437]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:32.437]             version = "1.8"), class = "FutureResult")
[15:32:32.437]     }, finally = {
[15:32:32.437]         if (!identical(...future.workdir, getwd())) 
[15:32:32.437]             setwd(...future.workdir)
[15:32:32.437]         {
[15:32:32.437]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:32.437]                 ...future.oldOptions$nwarnings <- NULL
[15:32:32.437]             }
[15:32:32.437]             base::options(...future.oldOptions)
[15:32:32.437]             if (.Platform$OS.type == "windows") {
[15:32:32.437]                 old_names <- names(...future.oldEnvVars)
[15:32:32.437]                 envs <- base::Sys.getenv()
[15:32:32.437]                 names <- names(envs)
[15:32:32.437]                 common <- intersect(names, old_names)
[15:32:32.437]                 added <- setdiff(names, old_names)
[15:32:32.437]                 removed <- setdiff(old_names, names)
[15:32:32.437]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:32.437]                   envs[common]]
[15:32:32.437]                 NAMES <- toupper(changed)
[15:32:32.437]                 args <- list()
[15:32:32.437]                 for (kk in seq_along(NAMES)) {
[15:32:32.437]                   name <- changed[[kk]]
[15:32:32.437]                   NAME <- NAMES[[kk]]
[15:32:32.437]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:32.437]                     next
[15:32:32.437]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:32.437]                 }
[15:32:32.437]                 NAMES <- toupper(added)
[15:32:32.437]                 for (kk in seq_along(NAMES)) {
[15:32:32.437]                   name <- added[[kk]]
[15:32:32.437]                   NAME <- NAMES[[kk]]
[15:32:32.437]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:32.437]                     next
[15:32:32.437]                   args[[name]] <- ""
[15:32:32.437]                 }
[15:32:32.437]                 NAMES <- toupper(removed)
[15:32:32.437]                 for (kk in seq_along(NAMES)) {
[15:32:32.437]                   name <- removed[[kk]]
[15:32:32.437]                   NAME <- NAMES[[kk]]
[15:32:32.437]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:32.437]                     next
[15:32:32.437]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:32.437]                 }
[15:32:32.437]                 if (length(args) > 0) 
[15:32:32.437]                   base::do.call(base::Sys.setenv, args = args)
[15:32:32.437]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:32.437]             }
[15:32:32.437]             else {
[15:32:32.437]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:32.437]             }
[15:32:32.437]             {
[15:32:32.437]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:32.437]                   0L) {
[15:32:32.437]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:32.437]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:32.437]                   base::options(opts)
[15:32:32.437]                 }
[15:32:32.437]                 {
[15:32:32.437]                   {
[15:32:32.437]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:32.437]                     NULL
[15:32:32.437]                   }
[15:32:32.437]                   options(future.plan = NULL)
[15:32:32.437]                   if (is.na(NA_character_)) 
[15:32:32.437]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:32.437]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:32.437]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:32.437]                     .init = FALSE)
[15:32:32.437]                 }
[15:32:32.437]             }
[15:32:32.437]         }
[15:32:32.437]     })
[15:32:32.437]     if (TRUE) {
[15:32:32.437]         base::sink(type = "output", split = FALSE)
[15:32:32.437]         if (TRUE) {
[15:32:32.437]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:32.437]         }
[15:32:32.437]         else {
[15:32:32.437]             ...future.result["stdout"] <- base::list(NULL)
[15:32:32.437]         }
[15:32:32.437]         base::close(...future.stdout)
[15:32:32.437]         ...future.stdout <- NULL
[15:32:32.437]     }
[15:32:32.437]     ...future.result$conditions <- ...future.conditions
[15:32:32.437]     ...future.result$finished <- base::Sys.time()
[15:32:32.437]     ...future.result
[15:32:32.437] }
[15:32:32.445] Exporting 5 global objects (848 bytes) to cluster node #1 ...
[15:32:32.446] Exporting '...future.FUN' (848 bytes) to cluster node #1 ...
[15:32:32.446] Exporting '...future.FUN' (848 bytes) to cluster node #1 ... DONE
[15:32:32.447] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:32.448] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:32.448] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ...
[15:32:32.448] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ... DONE
[15:32:32.449] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:32.449] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:32.450] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:32.450] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:32.451] Exporting 5 global objects (848 bytes) to cluster node #1 ... DONE
[15:32:32.452] MultisessionFuture started
[15:32:32.452] - Launch lazy future ... done
[15:32:32.452] run() for 'MultisessionFuture' ... done
[15:32:32.452] Created future:
[15:32:32.478] receiveMessageFromWorker() for ClusterFuture ...
[15:32:32.479] - Validating connection of MultisessionFuture
[15:32:32.479] - received message: FutureResult
[15:32:32.479] - Received FutureResult
[15:32:32.480] - Erased future from FutureRegistry
[15:32:32.480] result() for ClusterFuture ...
[15:32:32.480] - result already collected: FutureResult
[15:32:32.480] result() for ClusterFuture ... done
[15:32:32.481] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:32.453] MultisessionFuture:
[15:32:32.453] Label: 'future_sapply-2'
[15:32:32.453] Expression:
[15:32:32.453] {
[15:32:32.453]     do.call(function(...) {
[15:32:32.453]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:32.453]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:32.453]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:32.453]             on.exit(options(oopts), add = TRUE)
[15:32:32.453]         }
[15:32:32.453]         {
[15:32:32.453]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:32.453]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:32.453]                 ...future.FUN(...future.X_jj, ...)
[15:32:32.453]             })
[15:32:32.453]         }
[15:32:32.453]     }, args = future.call.arguments)
[15:32:32.453] }
[15:32:32.453] Lazy evaluation: FALSE
[15:32:32.453] Asynchronous evaluation: TRUE
[15:32:32.453] Local evaluation: TRUE
[15:32:32.453] Environment: R_GlobalEnv
[15:32:32.453] Capture standard output: TRUE
[15:32:32.453] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:32.453] Globals: 5 objects totaling 0.99 KiB (function '...future.FUN' of 848 bytes, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:32.453] Packages: <none>
[15:32:32.453] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:32.453] Resolved: TRUE
[15:32:32.453] Value: <not collected>
[15:32:32.453] Conditions captured: <none>
[15:32:32.453] Early signaling: FALSE
[15:32:32.453] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:32.453] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:32.481] Chunk #2 of 2 ... DONE
[15:32:32.482] Launching 2 futures (chunks) ... DONE
[15:32:32.482] Resolving 2 futures (chunks) ...
[15:32:32.482] resolve() on list ...
[15:32:32.482]  recursive: 0
[15:32:32.483]  length: 2
[15:32:32.483] 
[15:32:32.483] Future #1
[15:32:32.483] result() for ClusterFuture ...
[15:32:32.484] - result already collected: FutureResult
[15:32:32.484] result() for ClusterFuture ... done
[15:32:32.484] result() for ClusterFuture ...
[15:32:32.484] - result already collected: FutureResult
[15:32:32.485] result() for ClusterFuture ... done
[15:32:32.485] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:32.485] - nx: 2
[15:32:32.485] - relay: TRUE
[15:32:32.485] - stdout: TRUE
[15:32:32.486] - signal: TRUE
[15:32:32.486] - resignal: FALSE
[15:32:32.486] - force: TRUE
[15:32:32.486] - relayed: [n=2] FALSE, FALSE
[15:32:32.487] - queued futures: [n=2] FALSE, FALSE
[15:32:32.487]  - until=1
[15:32:32.487]  - relaying element #1
[15:32:32.487] result() for ClusterFuture ...
[15:32:32.487] - result already collected: FutureResult
[15:32:32.488] result() for ClusterFuture ... done
[15:32:32.488] result() for ClusterFuture ...
[15:32:32.488] - result already collected: FutureResult
[15:32:32.488] result() for ClusterFuture ... done
[15:32:32.489] result() for ClusterFuture ...
[15:32:32.489] - result already collected: FutureResult
[15:32:32.489] result() for ClusterFuture ... done
[15:32:32.489] result() for ClusterFuture ...
[15:32:32.490] - result already collected: FutureResult
[15:32:32.490] result() for ClusterFuture ... done
[15:32:32.490] - relayed: [n=2] TRUE, FALSE
[15:32:32.490] - queued futures: [n=2] TRUE, FALSE
[15:32:32.491] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:32.491]  length: 1 (resolved future 1)
[15:32:32.491] Future #2
[15:32:32.491] result() for ClusterFuture ...
[15:32:32.492] - result already collected: FutureResult
[15:32:32.492] result() for ClusterFuture ... done
[15:32:32.492] result() for ClusterFuture ...
[15:32:32.492] - result already collected: FutureResult
[15:32:32.492] result() for ClusterFuture ... done
[15:32:32.493] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:32.493] - nx: 2
[15:32:32.493] - relay: TRUE
[15:32:32.493] - stdout: TRUE
[15:32:32.494] - signal: TRUE
[15:32:32.494] - resignal: FALSE
[15:32:32.494] - force: TRUE
[15:32:32.494] - relayed: [n=2] TRUE, FALSE
[15:32:32.495] - queued futures: [n=2] TRUE, FALSE
[15:32:32.495]  - until=2
[15:32:32.495]  - relaying element #2
[15:32:32.495] result() for ClusterFuture ...
[15:32:32.495] - result already collected: FutureResult
[15:32:32.496] result() for ClusterFuture ... done
[15:32:32.496] result() for ClusterFuture ...
[15:32:32.496] - result already collected: FutureResult
[15:32:32.496] result() for ClusterFuture ... done
[15:32:32.497] result() for ClusterFuture ...
[15:32:32.497] - result already collected: FutureResult
[15:32:32.497] result() for ClusterFuture ... done
[15:32:32.497] result() for ClusterFuture ...
[15:32:32.498] - result already collected: FutureResult
[15:32:32.498] result() for ClusterFuture ... done
[15:32:32.498] - relayed: [n=2] TRUE, TRUE
[15:32:32.498] - queued futures: [n=2] TRUE, TRUE
[15:32:32.499] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:32.499]  length: 0 (resolved future 2)
[15:32:32.499] Relaying remaining futures
[15:32:32.499] signalConditionsASAP(NULL, pos=0) ...
[15:32:32.499] - nx: 2
[15:32:32.500] - relay: TRUE
[15:32:32.500] - stdout: TRUE
[15:32:32.500] - signal: TRUE
[15:32:32.500] - resignal: FALSE
[15:32:32.501] - force: TRUE
[15:32:32.501] - relayed: [n=2] TRUE, TRUE
[15:32:32.501] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:32.501] - relayed: [n=2] TRUE, TRUE
[15:32:32.502] - queued futures: [n=2] TRUE, TRUE
[15:32:32.502] signalConditionsASAP(NULL, pos=0) ... done
[15:32:32.502] resolve() on list ... DONE
[15:32:32.502] result() for ClusterFuture ...
[15:32:32.503] - result already collected: FutureResult
[15:32:32.503] result() for ClusterFuture ... done
[15:32:32.503] result() for ClusterFuture ...
[15:32:32.503] - result already collected: FutureResult
[15:32:32.503] result() for ClusterFuture ... done
[15:32:32.504] result() for ClusterFuture ...
[15:32:32.504] - result already collected: FutureResult
[15:32:32.504] result() for ClusterFuture ... done
[15:32:32.504] result() for ClusterFuture ...
[15:32:32.505] - result already collected: FutureResult
[15:32:32.505] result() for ClusterFuture ... done
[15:32:32.505]  - Number of value chunks collected: 2
[15:32:32.505] Resolving 2 futures (chunks) ... DONE
[15:32:32.506] Reducing values from 2 chunks ...
[15:32:32.506]  - Number of values collected after concatenation: 6
[15:32:32.506]  - Number of values expected: 6
[15:32:32.506] Reducing values from 2 chunks ... DONE
[15:32:32.507] future_lapply() ... DONE
List of 2
 $ y0: Named int [1:6] 1 2 2 3 3 4
  ..- attr(*, "names")= chr [1:6] "a1" "a2" "b1" "b2" ...
 $ y1: Named int [1:6] 1 2 2 3 3 4
  ..- attr(*, "names")= chr [1:6] "a1" "a2" "b1" "b2" ...
[15:32:32.510] future_lapply() ...
[15:32:32.514] Number of chunks: 2
[15:32:32.514] getGlobalsAndPackagesXApply() ...
[15:32:32.515]  - future.globals: TRUE
[15:32:32.515] getGlobalsAndPackages() ...
[15:32:32.515] Searching for globals...
[15:32:32.517] - globals found: [2] 'FUN', 'UseMethod'
[15:32:32.517] Searching for globals ... DONE
[15:32:32.518] Resolving globals: FALSE
[15:32:32.518] The total size of the 1 globals is 1.22 KiB (1248 bytes)
[15:32:32.519] The total size of the 1 globals exported for future expression ('FUN()') is 1.22 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.22 KiB of class 'function')
[15:32:32.519] - globals: [1] 'FUN'
[15:32:32.519] 
[15:32:32.520] getGlobalsAndPackages() ... DONE
[15:32:32.520]  - globals found/used: [n=1] 'FUN'
[15:32:32.520]  - needed namespaces: [n=0] 
[15:32:32.520] Finding globals ... DONE
[15:32:32.521]  - use_args: TRUE
[15:32:32.521]  - Getting '...' globals ...
[15:32:32.521] resolve() on list ...
[15:32:32.522]  recursive: 0
[15:32:32.522]  length: 1
[15:32:32.522]  elements: '...'
[15:32:32.522]  length: 0 (resolved future 1)
[15:32:32.523] resolve() on list ... DONE
[15:32:32.523]    - '...' content: [n=0] 
[15:32:32.523] List of 1
[15:32:32.523]  $ ...: list()
[15:32:32.523]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:32.523]  - attr(*, "where")=List of 1
[15:32:32.523]   ..$ ...:<environment: 0x00000276e5191530> 
[15:32:32.523]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:32.523]  - attr(*, "resolved")= logi TRUE
[15:32:32.523]  - attr(*, "total_size")= num NA
[15:32:32.527]  - Getting '...' globals ... DONE
[15:32:32.528] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:32.528] List of 2
[15:32:32.528]  $ ...future.FUN:function (x, ...)  
[15:32:32.528]  $ ...          : list()
[15:32:32.528]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:32.528]  - attr(*, "where")=List of 2
[15:32:32.528]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:32.528]   ..$ ...          :<environment: 0x00000276e5191530> 
[15:32:32.528]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:32.528]  - attr(*, "resolved")= logi FALSE
[15:32:32.528]  - attr(*, "total_size")= num 1248
[15:32:32.533] Packages to be attached in all futures: [n=0] 
[15:32:32.533] getGlobalsAndPackagesXApply() ... DONE
[15:32:32.533] Number of futures (= number of chunks): 2
[15:32:32.534] Launching 2 futures (chunks) ...
[15:32:32.534] Chunk #1 of 2 ...
[15:32:32.534]  - Finding globals in 'X' for chunk #1 ...
[15:32:32.534] getGlobalsAndPackages() ...
[15:32:32.535] Searching for globals...
[15:32:32.535] 
[15:32:32.535] Searching for globals ... DONE
[15:32:32.536] - globals: [0] <none>
[15:32:32.536] getGlobalsAndPackages() ... DONE
[15:32:32.536]    + additional globals found: [n=0] 
[15:32:32.536]    + additional namespaces needed: [n=0] 
[15:32:32.537]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:32.537]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:32.537]  - seeds: <none>
[15:32:32.537]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:32.538] getGlobalsAndPackages() ...
[15:32:32.538] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:32.538] Resolving globals: FALSE
[15:32:32.538] Tweak future expression to call with '...' arguments ...
[15:32:32.539] {
[15:32:32.539]     do.call(function(...) {
[15:32:32.539]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:32.539]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:32.539]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:32.539]             on.exit(options(oopts), add = TRUE)
[15:32:32.539]         }
[15:32:32.539]         {
[15:32:32.539]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:32.539]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:32.539]                 ...future.FUN(...future.X_jj, ...)
[15:32:32.539]             })
[15:32:32.539]         }
[15:32:32.539]     }, args = future.call.arguments)
[15:32:32.539] }
[15:32:32.539] Tweak future expression to call with '...' arguments ... DONE
[15:32:32.540] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:32.540] 
[15:32:32.541] getGlobalsAndPackages() ... DONE
[15:32:32.541] run() for 'Future' ...
[15:32:32.541] - state: 'created'
[15:32:32.542] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:32.559] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:32.560] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:32.560]   - Field: 'node'
[15:32:32.560]   - Field: 'label'
[15:32:32.560]   - Field: 'local'
[15:32:32.561]   - Field: 'owner'
[15:32:32.561]   - Field: 'envir'
[15:32:32.561]   - Field: 'workers'
[15:32:32.561]   - Field: 'packages'
[15:32:32.562]   - Field: 'gc'
[15:32:32.562]   - Field: 'conditions'
[15:32:32.562]   - Field: 'persistent'
[15:32:32.562]   - Field: 'expr'
[15:32:32.563]   - Field: 'uuid'
[15:32:32.563]   - Field: 'seed'
[15:32:32.563]   - Field: 'version'
[15:32:32.563]   - Field: 'result'
[15:32:32.567]   - Field: 'asynchronous'
[15:32:32.568]   - Field: 'calls'
[15:32:32.568]   - Field: 'globals'
[15:32:32.568]   - Field: 'stdout'
[15:32:32.569]   - Field: 'earlySignal'
[15:32:32.569]   - Field: 'lazy'
[15:32:32.569]   - Field: 'state'
[15:32:32.569] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:32.570] - Launch lazy future ...
[15:32:32.570] Packages needed by the future expression (n = 0): <none>
[15:32:32.571] Packages needed by future strategies (n = 0): <none>
[15:32:32.572] {
[15:32:32.572]     {
[15:32:32.572]         {
[15:32:32.572]             ...future.startTime <- base::Sys.time()
[15:32:32.572]             {
[15:32:32.572]                 {
[15:32:32.572]                   {
[15:32:32.572]                     {
[15:32:32.572]                       base::local({
[15:32:32.572]                         has_future <- base::requireNamespace("future", 
[15:32:32.572]                           quietly = TRUE)
[15:32:32.572]                         if (has_future) {
[15:32:32.572]                           ns <- base::getNamespace("future")
[15:32:32.572]                           version <- ns[[".package"]][["version"]]
[15:32:32.572]                           if (is.null(version)) 
[15:32:32.572]                             version <- utils::packageVersion("future")
[15:32:32.572]                         }
[15:32:32.572]                         else {
[15:32:32.572]                           version <- NULL
[15:32:32.572]                         }
[15:32:32.572]                         if (!has_future || version < "1.8.0") {
[15:32:32.572]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:32.572]                             "", base::R.version$version.string), 
[15:32:32.572]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:32.572]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:32.572]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:32.572]                               "release", "version")], collapse = " "), 
[15:32:32.572]                             hostname = base::Sys.info()[["nodename"]])
[15:32:32.572]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:32.572]                             info)
[15:32:32.572]                           info <- base::paste(info, collapse = "; ")
[15:32:32.572]                           if (!has_future) {
[15:32:32.572]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:32.572]                               info)
[15:32:32.572]                           }
[15:32:32.572]                           else {
[15:32:32.572]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:32.572]                               info, version)
[15:32:32.572]                           }
[15:32:32.572]                           base::stop(msg)
[15:32:32.572]                         }
[15:32:32.572]                       })
[15:32:32.572]                     }
[15:32:32.572]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:32.572]                     base::options(mc.cores = 1L)
[15:32:32.572]                   }
[15:32:32.572]                   ...future.strategy.old <- future::plan("list")
[15:32:32.572]                   options(future.plan = NULL)
[15:32:32.572]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:32.572]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:32.572]                 }
[15:32:32.572]                 ...future.workdir <- getwd()
[15:32:32.572]             }
[15:32:32.572]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:32.572]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:32.572]         }
[15:32:32.572]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:32.572]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:32.572]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:32.572]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:32.572]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:32.572]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:32.572]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:32.572]             base::names(...future.oldOptions))
[15:32:32.572]     }
[15:32:32.572]     if (FALSE) {
[15:32:32.572]     }
[15:32:32.572]     else {
[15:32:32.572]         if (TRUE) {
[15:32:32.572]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:32.572]                 open = "w")
[15:32:32.572]         }
[15:32:32.572]         else {
[15:32:32.572]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:32.572]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:32.572]         }
[15:32:32.572]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:32.572]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:32.572]             base::sink(type = "output", split = FALSE)
[15:32:32.572]             base::close(...future.stdout)
[15:32:32.572]         }, add = TRUE)
[15:32:32.572]     }
[15:32:32.572]     ...future.frame <- base::sys.nframe()
[15:32:32.572]     ...future.conditions <- base::list()
[15:32:32.572]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:32.572]     if (FALSE) {
[15:32:32.572]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:32.572]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:32.572]     }
[15:32:32.572]     ...future.result <- base::tryCatch({
[15:32:32.572]         base::withCallingHandlers({
[15:32:32.572]             ...future.value <- base::withVisible(base::local({
[15:32:32.572]                 ...future.makeSendCondition <- base::local({
[15:32:32.572]                   sendCondition <- NULL
[15:32:32.572]                   function(frame = 1L) {
[15:32:32.572]                     if (is.function(sendCondition)) 
[15:32:32.572]                       return(sendCondition)
[15:32:32.572]                     ns <- getNamespace("parallel")
[15:32:32.572]                     if (exists("sendData", mode = "function", 
[15:32:32.572]                       envir = ns)) {
[15:32:32.572]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:32.572]                         envir = ns)
[15:32:32.572]                       envir <- sys.frame(frame)
[15:32:32.572]                       master <- NULL
[15:32:32.572]                       while (!identical(envir, .GlobalEnv) && 
[15:32:32.572]                         !identical(envir, emptyenv())) {
[15:32:32.572]                         if (exists("master", mode = "list", envir = envir, 
[15:32:32.572]                           inherits = FALSE)) {
[15:32:32.572]                           master <- get("master", mode = "list", 
[15:32:32.572]                             envir = envir, inherits = FALSE)
[15:32:32.572]                           if (inherits(master, c("SOCKnode", 
[15:32:32.572]                             "SOCK0node"))) {
[15:32:32.572]                             sendCondition <<- function(cond) {
[15:32:32.572]                               data <- list(type = "VALUE", value = cond, 
[15:32:32.572]                                 success = TRUE)
[15:32:32.572]                               parallel_sendData(master, data)
[15:32:32.572]                             }
[15:32:32.572]                             return(sendCondition)
[15:32:32.572]                           }
[15:32:32.572]                         }
[15:32:32.572]                         frame <- frame + 1L
[15:32:32.572]                         envir <- sys.frame(frame)
[15:32:32.572]                       }
[15:32:32.572]                     }
[15:32:32.572]                     sendCondition <<- function(cond) NULL
[15:32:32.572]                   }
[15:32:32.572]                 })
[15:32:32.572]                 withCallingHandlers({
[15:32:32.572]                   {
[15:32:32.572]                     do.call(function(...) {
[15:32:32.572]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:32.572]                       if (!identical(...future.globals.maxSize.org, 
[15:32:32.572]                         ...future.globals.maxSize)) {
[15:32:32.572]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:32.572]                         on.exit(options(oopts), add = TRUE)
[15:32:32.572]                       }
[15:32:32.572]                       {
[15:32:32.572]                         lapply(seq_along(...future.elements_ii), 
[15:32:32.572]                           FUN = function(jj) {
[15:32:32.572]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:32.572]                             ...future.FUN(...future.X_jj, ...)
[15:32:32.572]                           })
[15:32:32.572]                       }
[15:32:32.572]                     }, args = future.call.arguments)
[15:32:32.572]                   }
[15:32:32.572]                 }, immediateCondition = function(cond) {
[15:32:32.572]                   sendCondition <- ...future.makeSendCondition()
[15:32:32.572]                   sendCondition(cond)
[15:32:32.572]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:32.572]                   {
[15:32:32.572]                     inherits <- base::inherits
[15:32:32.572]                     invokeRestart <- base::invokeRestart
[15:32:32.572]                     is.null <- base::is.null
[15:32:32.572]                     muffled <- FALSE
[15:32:32.572]                     if (inherits(cond, "message")) {
[15:32:32.572]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:32.572]                       if (muffled) 
[15:32:32.572]                         invokeRestart("muffleMessage")
[15:32:32.572]                     }
[15:32:32.572]                     else if (inherits(cond, "warning")) {
[15:32:32.572]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:32.572]                       if (muffled) 
[15:32:32.572]                         invokeRestart("muffleWarning")
[15:32:32.572]                     }
[15:32:32.572]                     else if (inherits(cond, "condition")) {
[15:32:32.572]                       if (!is.null(pattern)) {
[15:32:32.572]                         computeRestarts <- base::computeRestarts
[15:32:32.572]                         grepl <- base::grepl
[15:32:32.572]                         restarts <- computeRestarts(cond)
[15:32:32.572]                         for (restart in restarts) {
[15:32:32.572]                           name <- restart$name
[15:32:32.572]                           if (is.null(name)) 
[15:32:32.572]                             next
[15:32:32.572]                           if (!grepl(pattern, name)) 
[15:32:32.572]                             next
[15:32:32.572]                           invokeRestart(restart)
[15:32:32.572]                           muffled <- TRUE
[15:32:32.572]                           break
[15:32:32.572]                         }
[15:32:32.572]                       }
[15:32:32.572]                     }
[15:32:32.572]                     invisible(muffled)
[15:32:32.572]                   }
[15:32:32.572]                   muffleCondition(cond)
[15:32:32.572]                 })
[15:32:32.572]             }))
[15:32:32.572]             future::FutureResult(value = ...future.value$value, 
[15:32:32.572]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:32.572]                   ...future.rng), globalenv = if (FALSE) 
[15:32:32.572]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:32.572]                     ...future.globalenv.names))
[15:32:32.572]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:32.572]         }, condition = base::local({
[15:32:32.572]             c <- base::c
[15:32:32.572]             inherits <- base::inherits
[15:32:32.572]             invokeRestart <- base::invokeRestart
[15:32:32.572]             length <- base::length
[15:32:32.572]             list <- base::list
[15:32:32.572]             seq.int <- base::seq.int
[15:32:32.572]             signalCondition <- base::signalCondition
[15:32:32.572]             sys.calls <- base::sys.calls
[15:32:32.572]             `[[` <- base::`[[`
[15:32:32.572]             `+` <- base::`+`
[15:32:32.572]             `<<-` <- base::`<<-`
[15:32:32.572]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:32.572]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:32.572]                   3L)]
[15:32:32.572]             }
[15:32:32.572]             function(cond) {
[15:32:32.572]                 is_error <- inherits(cond, "error")
[15:32:32.572]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:32.572]                   NULL)
[15:32:32.572]                 if (is_error) {
[15:32:32.572]                   sessionInformation <- function() {
[15:32:32.572]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:32.572]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:32.572]                       search = base::search(), system = base::Sys.info())
[15:32:32.572]                   }
[15:32:32.572]                   ...future.conditions[[length(...future.conditions) + 
[15:32:32.572]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:32.572]                     cond$call), session = sessionInformation(), 
[15:32:32.572]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:32.572]                   signalCondition(cond)
[15:32:32.572]                 }
[15:32:32.572]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:32.572]                 "immediateCondition"))) {
[15:32:32.572]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:32.572]                   ...future.conditions[[length(...future.conditions) + 
[15:32:32.572]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:32.572]                   if (TRUE && !signal) {
[15:32:32.572]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:32.572]                     {
[15:32:32.572]                       inherits <- base::inherits
[15:32:32.572]                       invokeRestart <- base::invokeRestart
[15:32:32.572]                       is.null <- base::is.null
[15:32:32.572]                       muffled <- FALSE
[15:32:32.572]                       if (inherits(cond, "message")) {
[15:32:32.572]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:32.572]                         if (muffled) 
[15:32:32.572]                           invokeRestart("muffleMessage")
[15:32:32.572]                       }
[15:32:32.572]                       else if (inherits(cond, "warning")) {
[15:32:32.572]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:32.572]                         if (muffled) 
[15:32:32.572]                           invokeRestart("muffleWarning")
[15:32:32.572]                       }
[15:32:32.572]                       else if (inherits(cond, "condition")) {
[15:32:32.572]                         if (!is.null(pattern)) {
[15:32:32.572]                           computeRestarts <- base::computeRestarts
[15:32:32.572]                           grepl <- base::grepl
[15:32:32.572]                           restarts <- computeRestarts(cond)
[15:32:32.572]                           for (restart in restarts) {
[15:32:32.572]                             name <- restart$name
[15:32:32.572]                             if (is.null(name)) 
[15:32:32.572]                               next
[15:32:32.572]                             if (!grepl(pattern, name)) 
[15:32:32.572]                               next
[15:32:32.572]                             invokeRestart(restart)
[15:32:32.572]                             muffled <- TRUE
[15:32:32.572]                             break
[15:32:32.572]                           }
[15:32:32.572]                         }
[15:32:32.572]                       }
[15:32:32.572]                       invisible(muffled)
[15:32:32.572]                     }
[15:32:32.572]                     muffleCondition(cond, pattern = "^muffle")
[15:32:32.572]                   }
[15:32:32.572]                 }
[15:32:32.572]                 else {
[15:32:32.572]                   if (TRUE) {
[15:32:32.572]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:32.572]                     {
[15:32:32.572]                       inherits <- base::inherits
[15:32:32.572]                       invokeRestart <- base::invokeRestart
[15:32:32.572]                       is.null <- base::is.null
[15:32:32.572]                       muffled <- FALSE
[15:32:32.572]                       if (inherits(cond, "message")) {
[15:32:32.572]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:32.572]                         if (muffled) 
[15:32:32.572]                           invokeRestart("muffleMessage")
[15:32:32.572]                       }
[15:32:32.572]                       else if (inherits(cond, "warning")) {
[15:32:32.572]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:32.572]                         if (muffled) 
[15:32:32.572]                           invokeRestart("muffleWarning")
[15:32:32.572]                       }
[15:32:32.572]                       else if (inherits(cond, "condition")) {
[15:32:32.572]                         if (!is.null(pattern)) {
[15:32:32.572]                           computeRestarts <- base::computeRestarts
[15:32:32.572]                           grepl <- base::grepl
[15:32:32.572]                           restarts <- computeRestarts(cond)
[15:32:32.572]                           for (restart in restarts) {
[15:32:32.572]                             name <- restart$name
[15:32:32.572]                             if (is.null(name)) 
[15:32:32.572]                               next
[15:32:32.572]                             if (!grepl(pattern, name)) 
[15:32:32.572]                               next
[15:32:32.572]                             invokeRestart(restart)
[15:32:32.572]                             muffled <- TRUE
[15:32:32.572]                             break
[15:32:32.572]                           }
[15:32:32.572]                         }
[15:32:32.572]                       }
[15:32:32.572]                       invisible(muffled)
[15:32:32.572]                     }
[15:32:32.572]                     muffleCondition(cond, pattern = "^muffle")
[15:32:32.572]                   }
[15:32:32.572]                 }
[15:32:32.572]             }
[15:32:32.572]         }))
[15:32:32.572]     }, error = function(ex) {
[15:32:32.572]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:32.572]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:32.572]                 ...future.rng), started = ...future.startTime, 
[15:32:32.572]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:32.572]             version = "1.8"), class = "FutureResult")
[15:32:32.572]     }, finally = {
[15:32:32.572]         if (!identical(...future.workdir, getwd())) 
[15:32:32.572]             setwd(...future.workdir)
[15:32:32.572]         {
[15:32:32.572]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:32.572]                 ...future.oldOptions$nwarnings <- NULL
[15:32:32.572]             }
[15:32:32.572]             base::options(...future.oldOptions)
[15:32:32.572]             if (.Platform$OS.type == "windows") {
[15:32:32.572]                 old_names <- names(...future.oldEnvVars)
[15:32:32.572]                 envs <- base::Sys.getenv()
[15:32:32.572]                 names <- names(envs)
[15:32:32.572]                 common <- intersect(names, old_names)
[15:32:32.572]                 added <- setdiff(names, old_names)
[15:32:32.572]                 removed <- setdiff(old_names, names)
[15:32:32.572]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:32.572]                   envs[common]]
[15:32:32.572]                 NAMES <- toupper(changed)
[15:32:32.572]                 args <- list()
[15:32:32.572]                 for (kk in seq_along(NAMES)) {
[15:32:32.572]                   name <- changed[[kk]]
[15:32:32.572]                   NAME <- NAMES[[kk]]
[15:32:32.572]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:32.572]                     next
[15:32:32.572]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:32.572]                 }
[15:32:32.572]                 NAMES <- toupper(added)
[15:32:32.572]                 for (kk in seq_along(NAMES)) {
[15:32:32.572]                   name <- added[[kk]]
[15:32:32.572]                   NAME <- NAMES[[kk]]
[15:32:32.572]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:32.572]                     next
[15:32:32.572]                   args[[name]] <- ""
[15:32:32.572]                 }
[15:32:32.572]                 NAMES <- toupper(removed)
[15:32:32.572]                 for (kk in seq_along(NAMES)) {
[15:32:32.572]                   name <- removed[[kk]]
[15:32:32.572]                   NAME <- NAMES[[kk]]
[15:32:32.572]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:32.572]                     next
[15:32:32.572]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:32.572]                 }
[15:32:32.572]                 if (length(args) > 0) 
[15:32:32.572]                   base::do.call(base::Sys.setenv, args = args)
[15:32:32.572]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:32.572]             }
[15:32:32.572]             else {
[15:32:32.572]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:32.572]             }
[15:32:32.572]             {
[15:32:32.572]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:32.572]                   0L) {
[15:32:32.572]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:32.572]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:32.572]                   base::options(opts)
[15:32:32.572]                 }
[15:32:32.572]                 {
[15:32:32.572]                   {
[15:32:32.572]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:32.572]                     NULL
[15:32:32.572]                   }
[15:32:32.572]                   options(future.plan = NULL)
[15:32:32.572]                   if (is.na(NA_character_)) 
[15:32:32.572]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:32.572]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:32.572]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:32.572]                     .init = FALSE)
[15:32:32.572]                 }
[15:32:32.572]             }
[15:32:32.572]         }
[15:32:32.572]     })
[15:32:32.572]     if (TRUE) {
[15:32:32.572]         base::sink(type = "output", split = FALSE)
[15:32:32.572]         if (TRUE) {
[15:32:32.572]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:32.572]         }
[15:32:32.572]         else {
[15:32:32.572]             ...future.result["stdout"] <- base::list(NULL)
[15:32:32.572]         }
[15:32:32.572]         base::close(...future.stdout)
[15:32:32.572]         ...future.stdout <- NULL
[15:32:32.572]     }
[15:32:32.572]     ...future.result$conditions <- ...future.conditions
[15:32:32.572]     ...future.result$finished <- base::Sys.time()
[15:32:32.572]     ...future.result
[15:32:32.572] }
[15:32:32.580] Exporting 5 global objects (1.22 KiB) to cluster node #1 ...
[15:32:32.580] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ...
[15:32:32.581] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ... DONE
[15:32:32.581] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:32.582] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:32.582] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ...
[15:32:32.582] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ... DONE
[15:32:32.583] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:32.583] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:32.583] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:32.584] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:32.584] Exporting 5 global objects (1.22 KiB) to cluster node #1 ... DONE
[15:32:32.585] MultisessionFuture started
[15:32:32.585] - Launch lazy future ... done
[15:32:32.585] run() for 'MultisessionFuture' ... done
[15:32:32.586] Created future:
[15:32:32.612] receiveMessageFromWorker() for ClusterFuture ...
[15:32:32.612] - Validating connection of MultisessionFuture
[15:32:32.613] - received message: FutureResult
[15:32:32.613] - Received FutureResult
[15:32:32.613] - Erased future from FutureRegistry
[15:32:32.614] result() for ClusterFuture ...
[15:32:32.614] - result already collected: FutureResult
[15:32:32.614] result() for ClusterFuture ... done
[15:32:32.615] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:32.586] MultisessionFuture:
[15:32:32.586] Label: 'future_sapply-1'
[15:32:32.586] Expression:
[15:32:32.586] {
[15:32:32.586]     do.call(function(...) {
[15:32:32.586]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:32.586]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:32.586]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:32.586]             on.exit(options(oopts), add = TRUE)
[15:32:32.586]         }
[15:32:32.586]         {
[15:32:32.586]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:32.586]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:32.586]                 ...future.FUN(...future.X_jj, ...)
[15:32:32.586]             })
[15:32:32.586]         }
[15:32:32.586]     }, args = future.call.arguments)
[15:32:32.586] }
[15:32:32.586] Lazy evaluation: FALSE
[15:32:32.586] Asynchronous evaluation: TRUE
[15:32:32.586] Local evaluation: TRUE
[15:32:32.586] Environment: R_GlobalEnv
[15:32:32.586] Capture standard output: TRUE
[15:32:32.586] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:32.586] Globals: 5 objects totaling 1.38 KiB (function '...future.FUN' of 1.22 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:32.586] Packages: <none>
[15:32:32.586] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:32.586] Resolved: TRUE
[15:32:32.586] Value: <not collected>
[15:32:32.586] Conditions captured: <none>
[15:32:32.586] Early signaling: FALSE
[15:32:32.586] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:32.586] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:32.615] Chunk #1 of 2 ... DONE
[15:32:32.616] Chunk #2 of 2 ...
[15:32:32.616]  - Finding globals in 'X' for chunk #2 ...
[15:32:32.616] getGlobalsAndPackages() ...
[15:32:32.616] Searching for globals...
[15:32:32.617] 
[15:32:32.617] Searching for globals ... DONE
[15:32:32.618] - globals: [0] <none>
[15:32:32.618] getGlobalsAndPackages() ... DONE
[15:32:32.618]    + additional globals found: [n=0] 
[15:32:32.618]    + additional namespaces needed: [n=0] 
[15:32:32.619]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:32.619]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:32.619]  - seeds: <none>
[15:32:32.620]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:32.620] getGlobalsAndPackages() ...
[15:32:32.620] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:32.620] Resolving globals: FALSE
[15:32:32.621] Tweak future expression to call with '...' arguments ...
[15:32:32.621] {
[15:32:32.621]     do.call(function(...) {
[15:32:32.621]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:32.621]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:32.621]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:32.621]             on.exit(options(oopts), add = TRUE)
[15:32:32.621]         }
[15:32:32.621]         {
[15:32:32.621]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:32.621]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:32.621]                 ...future.FUN(...future.X_jj, ...)
[15:32:32.621]             })
[15:32:32.621]         }
[15:32:32.621]     }, args = future.call.arguments)
[15:32:32.621] }
[15:32:32.622] Tweak future expression to call with '...' arguments ... DONE
[15:32:32.623] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:32.623] 
[15:32:32.623] getGlobalsAndPackages() ... DONE
[15:32:32.624] run() for 'Future' ...
[15:32:32.624] - state: 'created'
[15:32:32.625] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:32.644] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:32.644] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:32.644]   - Field: 'node'
[15:32:32.645]   - Field: 'label'
[15:32:32.645]   - Field: 'local'
[15:32:32.645]   - Field: 'owner'
[15:32:32.646]   - Field: 'envir'
[15:32:32.646]   - Field: 'workers'
[15:32:32.646]   - Field: 'packages'
[15:32:32.646]   - Field: 'gc'
[15:32:32.647]   - Field: 'conditions'
[15:32:32.647]   - Field: 'persistent'
[15:32:32.647]   - Field: 'expr'
[15:32:32.648]   - Field: 'uuid'
[15:32:32.648]   - Field: 'seed'
[15:32:32.648]   - Field: 'version'
[15:32:32.648]   - Field: 'result'
[15:32:32.649]   - Field: 'asynchronous'
[15:32:32.649]   - Field: 'calls'
[15:32:32.649]   - Field: 'globals'
[15:32:32.650]   - Field: 'stdout'
[15:32:32.650]   - Field: 'earlySignal'
[15:32:32.650]   - Field: 'lazy'
[15:32:32.650]   - Field: 'state'
[15:32:32.651] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:32.651] - Launch lazy future ...
[15:32:32.651] Packages needed by the future expression (n = 0): <none>
[15:32:32.652] Packages needed by future strategies (n = 0): <none>
[15:32:32.652] {
[15:32:32.652]     {
[15:32:32.652]         {
[15:32:32.652]             ...future.startTime <- base::Sys.time()
[15:32:32.652]             {
[15:32:32.652]                 {
[15:32:32.652]                   {
[15:32:32.652]                     {
[15:32:32.652]                       base::local({
[15:32:32.652]                         has_future <- base::requireNamespace("future", 
[15:32:32.652]                           quietly = TRUE)
[15:32:32.652]                         if (has_future) {
[15:32:32.652]                           ns <- base::getNamespace("future")
[15:32:32.652]                           version <- ns[[".package"]][["version"]]
[15:32:32.652]                           if (is.null(version)) 
[15:32:32.652]                             version <- utils::packageVersion("future")
[15:32:32.652]                         }
[15:32:32.652]                         else {
[15:32:32.652]                           version <- NULL
[15:32:32.652]                         }
[15:32:32.652]                         if (!has_future || version < "1.8.0") {
[15:32:32.652]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:32.652]                             "", base::R.version$version.string), 
[15:32:32.652]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:32.652]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:32.652]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:32.652]                               "release", "version")], collapse = " "), 
[15:32:32.652]                             hostname = base::Sys.info()[["nodename"]])
[15:32:32.652]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:32.652]                             info)
[15:32:32.652]                           info <- base::paste(info, collapse = "; ")
[15:32:32.652]                           if (!has_future) {
[15:32:32.652]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:32.652]                               info)
[15:32:32.652]                           }
[15:32:32.652]                           else {
[15:32:32.652]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:32.652]                               info, version)
[15:32:32.652]                           }
[15:32:32.652]                           base::stop(msg)
[15:32:32.652]                         }
[15:32:32.652]                       })
[15:32:32.652]                     }
[15:32:32.652]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:32.652]                     base::options(mc.cores = 1L)
[15:32:32.652]                   }
[15:32:32.652]                   ...future.strategy.old <- future::plan("list")
[15:32:32.652]                   options(future.plan = NULL)
[15:32:32.652]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:32.652]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:32.652]                 }
[15:32:32.652]                 ...future.workdir <- getwd()
[15:32:32.652]             }
[15:32:32.652]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:32.652]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:32.652]         }
[15:32:32.652]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:32.652]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:32.652]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:32.652]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:32.652]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:32.652]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:32.652]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:32.652]             base::names(...future.oldOptions))
[15:32:32.652]     }
[15:32:32.652]     if (FALSE) {
[15:32:32.652]     }
[15:32:32.652]     else {
[15:32:32.652]         if (TRUE) {
[15:32:32.652]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:32.652]                 open = "w")
[15:32:32.652]         }
[15:32:32.652]         else {
[15:32:32.652]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:32.652]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:32.652]         }
[15:32:32.652]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:32.652]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:32.652]             base::sink(type = "output", split = FALSE)
[15:32:32.652]             base::close(...future.stdout)
[15:32:32.652]         }, add = TRUE)
[15:32:32.652]     }
[15:32:32.652]     ...future.frame <- base::sys.nframe()
[15:32:32.652]     ...future.conditions <- base::list()
[15:32:32.652]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:32.652]     if (FALSE) {
[15:32:32.652]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:32.652]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:32.652]     }
[15:32:32.652]     ...future.result <- base::tryCatch({
[15:32:32.652]         base::withCallingHandlers({
[15:32:32.652]             ...future.value <- base::withVisible(base::local({
[15:32:32.652]                 ...future.makeSendCondition <- base::local({
[15:32:32.652]                   sendCondition <- NULL
[15:32:32.652]                   function(frame = 1L) {
[15:32:32.652]                     if (is.function(sendCondition)) 
[15:32:32.652]                       return(sendCondition)
[15:32:32.652]                     ns <- getNamespace("parallel")
[15:32:32.652]                     if (exists("sendData", mode = "function", 
[15:32:32.652]                       envir = ns)) {
[15:32:32.652]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:32.652]                         envir = ns)
[15:32:32.652]                       envir <- sys.frame(frame)
[15:32:32.652]                       master <- NULL
[15:32:32.652]                       while (!identical(envir, .GlobalEnv) && 
[15:32:32.652]                         !identical(envir, emptyenv())) {
[15:32:32.652]                         if (exists("master", mode = "list", envir = envir, 
[15:32:32.652]                           inherits = FALSE)) {
[15:32:32.652]                           master <- get("master", mode = "list", 
[15:32:32.652]                             envir = envir, inherits = FALSE)
[15:32:32.652]                           if (inherits(master, c("SOCKnode", 
[15:32:32.652]                             "SOCK0node"))) {
[15:32:32.652]                             sendCondition <<- function(cond) {
[15:32:32.652]                               data <- list(type = "VALUE", value = cond, 
[15:32:32.652]                                 success = TRUE)
[15:32:32.652]                               parallel_sendData(master, data)
[15:32:32.652]                             }
[15:32:32.652]                             return(sendCondition)
[15:32:32.652]                           }
[15:32:32.652]                         }
[15:32:32.652]                         frame <- frame + 1L
[15:32:32.652]                         envir <- sys.frame(frame)
[15:32:32.652]                       }
[15:32:32.652]                     }
[15:32:32.652]                     sendCondition <<- function(cond) NULL
[15:32:32.652]                   }
[15:32:32.652]                 })
[15:32:32.652]                 withCallingHandlers({
[15:32:32.652]                   {
[15:32:32.652]                     do.call(function(...) {
[15:32:32.652]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:32.652]                       if (!identical(...future.globals.maxSize.org, 
[15:32:32.652]                         ...future.globals.maxSize)) {
[15:32:32.652]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:32.652]                         on.exit(options(oopts), add = TRUE)
[15:32:32.652]                       }
[15:32:32.652]                       {
[15:32:32.652]                         lapply(seq_along(...future.elements_ii), 
[15:32:32.652]                           FUN = function(jj) {
[15:32:32.652]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:32.652]                             ...future.FUN(...future.X_jj, ...)
[15:32:32.652]                           })
[15:32:32.652]                       }
[15:32:32.652]                     }, args = future.call.arguments)
[15:32:32.652]                   }
[15:32:32.652]                 }, immediateCondition = function(cond) {
[15:32:32.652]                   sendCondition <- ...future.makeSendCondition()
[15:32:32.652]                   sendCondition(cond)
[15:32:32.652]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:32.652]                   {
[15:32:32.652]                     inherits <- base::inherits
[15:32:32.652]                     invokeRestart <- base::invokeRestart
[15:32:32.652]                     is.null <- base::is.null
[15:32:32.652]                     muffled <- FALSE
[15:32:32.652]                     if (inherits(cond, "message")) {
[15:32:32.652]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:32.652]                       if (muffled) 
[15:32:32.652]                         invokeRestart("muffleMessage")
[15:32:32.652]                     }
[15:32:32.652]                     else if (inherits(cond, "warning")) {
[15:32:32.652]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:32.652]                       if (muffled) 
[15:32:32.652]                         invokeRestart("muffleWarning")
[15:32:32.652]                     }
[15:32:32.652]                     else if (inherits(cond, "condition")) {
[15:32:32.652]                       if (!is.null(pattern)) {
[15:32:32.652]                         computeRestarts <- base::computeRestarts
[15:32:32.652]                         grepl <- base::grepl
[15:32:32.652]                         restarts <- computeRestarts(cond)
[15:32:32.652]                         for (restart in restarts) {
[15:32:32.652]                           name <- restart$name
[15:32:32.652]                           if (is.null(name)) 
[15:32:32.652]                             next
[15:32:32.652]                           if (!grepl(pattern, name)) 
[15:32:32.652]                             next
[15:32:32.652]                           invokeRestart(restart)
[15:32:32.652]                           muffled <- TRUE
[15:32:32.652]                           break
[15:32:32.652]                         }
[15:32:32.652]                       }
[15:32:32.652]                     }
[15:32:32.652]                     invisible(muffled)
[15:32:32.652]                   }
[15:32:32.652]                   muffleCondition(cond)
[15:32:32.652]                 })
[15:32:32.652]             }))
[15:32:32.652]             future::FutureResult(value = ...future.value$value, 
[15:32:32.652]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:32.652]                   ...future.rng), globalenv = if (FALSE) 
[15:32:32.652]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:32.652]                     ...future.globalenv.names))
[15:32:32.652]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:32.652]         }, condition = base::local({
[15:32:32.652]             c <- base::c
[15:32:32.652]             inherits <- base::inherits
[15:32:32.652]             invokeRestart <- base::invokeRestart
[15:32:32.652]             length <- base::length
[15:32:32.652]             list <- base::list
[15:32:32.652]             seq.int <- base::seq.int
[15:32:32.652]             signalCondition <- base::signalCondition
[15:32:32.652]             sys.calls <- base::sys.calls
[15:32:32.652]             `[[` <- base::`[[`
[15:32:32.652]             `+` <- base::`+`
[15:32:32.652]             `<<-` <- base::`<<-`
[15:32:32.652]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:32.652]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:32.652]                   3L)]
[15:32:32.652]             }
[15:32:32.652]             function(cond) {
[15:32:32.652]                 is_error <- inherits(cond, "error")
[15:32:32.652]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:32.652]                   NULL)
[15:32:32.652]                 if (is_error) {
[15:32:32.652]                   sessionInformation <- function() {
[15:32:32.652]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:32.652]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:32.652]                       search = base::search(), system = base::Sys.info())
[15:32:32.652]                   }
[15:32:32.652]                   ...future.conditions[[length(...future.conditions) + 
[15:32:32.652]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:32.652]                     cond$call), session = sessionInformation(), 
[15:32:32.652]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:32.652]                   signalCondition(cond)
[15:32:32.652]                 }
[15:32:32.652]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:32.652]                 "immediateCondition"))) {
[15:32:32.652]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:32.652]                   ...future.conditions[[length(...future.conditions) + 
[15:32:32.652]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:32.652]                   if (TRUE && !signal) {
[15:32:32.652]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:32.652]                     {
[15:32:32.652]                       inherits <- base::inherits
[15:32:32.652]                       invokeRestart <- base::invokeRestart
[15:32:32.652]                       is.null <- base::is.null
[15:32:32.652]                       muffled <- FALSE
[15:32:32.652]                       if (inherits(cond, "message")) {
[15:32:32.652]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:32.652]                         if (muffled) 
[15:32:32.652]                           invokeRestart("muffleMessage")
[15:32:32.652]                       }
[15:32:32.652]                       else if (inherits(cond, "warning")) {
[15:32:32.652]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:32.652]                         if (muffled) 
[15:32:32.652]                           invokeRestart("muffleWarning")
[15:32:32.652]                       }
[15:32:32.652]                       else if (inherits(cond, "condition")) {
[15:32:32.652]                         if (!is.null(pattern)) {
[15:32:32.652]                           computeRestarts <- base::computeRestarts
[15:32:32.652]                           grepl <- base::grepl
[15:32:32.652]                           restarts <- computeRestarts(cond)
[15:32:32.652]                           for (restart in restarts) {
[15:32:32.652]                             name <- restart$name
[15:32:32.652]                             if (is.null(name)) 
[15:32:32.652]                               next
[15:32:32.652]                             if (!grepl(pattern, name)) 
[15:32:32.652]                               next
[15:32:32.652]                             invokeRestart(restart)
[15:32:32.652]                             muffled <- TRUE
[15:32:32.652]                             break
[15:32:32.652]                           }
[15:32:32.652]                         }
[15:32:32.652]                       }
[15:32:32.652]                       invisible(muffled)
[15:32:32.652]                     }
[15:32:32.652]                     muffleCondition(cond, pattern = "^muffle")
[15:32:32.652]                   }
[15:32:32.652]                 }
[15:32:32.652]                 else {
[15:32:32.652]                   if (TRUE) {
[15:32:32.652]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:32.652]                     {
[15:32:32.652]                       inherits <- base::inherits
[15:32:32.652]                       invokeRestart <- base::invokeRestart
[15:32:32.652]                       is.null <- base::is.null
[15:32:32.652]                       muffled <- FALSE
[15:32:32.652]                       if (inherits(cond, "message")) {
[15:32:32.652]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:32.652]                         if (muffled) 
[15:32:32.652]                           invokeRestart("muffleMessage")
[15:32:32.652]                       }
[15:32:32.652]                       else if (inherits(cond, "warning")) {
[15:32:32.652]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:32.652]                         if (muffled) 
[15:32:32.652]                           invokeRestart("muffleWarning")
[15:32:32.652]                       }
[15:32:32.652]                       else if (inherits(cond, "condition")) {
[15:32:32.652]                         if (!is.null(pattern)) {
[15:32:32.652]                           computeRestarts <- base::computeRestarts
[15:32:32.652]                           grepl <- base::grepl
[15:32:32.652]                           restarts <- computeRestarts(cond)
[15:32:32.652]                           for (restart in restarts) {
[15:32:32.652]                             name <- restart$name
[15:32:32.652]                             if (is.null(name)) 
[15:32:32.652]                               next
[15:32:32.652]                             if (!grepl(pattern, name)) 
[15:32:32.652]                               next
[15:32:32.652]                             invokeRestart(restart)
[15:32:32.652]                             muffled <- TRUE
[15:32:32.652]                             break
[15:32:32.652]                           }
[15:32:32.652]                         }
[15:32:32.652]                       }
[15:32:32.652]                       invisible(muffled)
[15:32:32.652]                     }
[15:32:32.652]                     muffleCondition(cond, pattern = "^muffle")
[15:32:32.652]                   }
[15:32:32.652]                 }
[15:32:32.652]             }
[15:32:32.652]         }))
[15:32:32.652]     }, error = function(ex) {
[15:32:32.652]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:32.652]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:32.652]                 ...future.rng), started = ...future.startTime, 
[15:32:32.652]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:32.652]             version = "1.8"), class = "FutureResult")
[15:32:32.652]     }, finally = {
[15:32:32.652]         if (!identical(...future.workdir, getwd())) 
[15:32:32.652]             setwd(...future.workdir)
[15:32:32.652]         {
[15:32:32.652]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:32.652]                 ...future.oldOptions$nwarnings <- NULL
[15:32:32.652]             }
[15:32:32.652]             base::options(...future.oldOptions)
[15:32:32.652]             if (.Platform$OS.type == "windows") {
[15:32:32.652]                 old_names <- names(...future.oldEnvVars)
[15:32:32.652]                 envs <- base::Sys.getenv()
[15:32:32.652]                 names <- names(envs)
[15:32:32.652]                 common <- intersect(names, old_names)
[15:32:32.652]                 added <- setdiff(names, old_names)
[15:32:32.652]                 removed <- setdiff(old_names, names)
[15:32:32.652]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:32.652]                   envs[common]]
[15:32:32.652]                 NAMES <- toupper(changed)
[15:32:32.652]                 args <- list()
[15:32:32.652]                 for (kk in seq_along(NAMES)) {
[15:32:32.652]                   name <- changed[[kk]]
[15:32:32.652]                   NAME <- NAMES[[kk]]
[15:32:32.652]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:32.652]                     next
[15:32:32.652]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:32.652]                 }
[15:32:32.652]                 NAMES <- toupper(added)
[15:32:32.652]                 for (kk in seq_along(NAMES)) {
[15:32:32.652]                   name <- added[[kk]]
[15:32:32.652]                   NAME <- NAMES[[kk]]
[15:32:32.652]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:32.652]                     next
[15:32:32.652]                   args[[name]] <- ""
[15:32:32.652]                 }
[15:32:32.652]                 NAMES <- toupper(removed)
[15:32:32.652]                 for (kk in seq_along(NAMES)) {
[15:32:32.652]                   name <- removed[[kk]]
[15:32:32.652]                   NAME <- NAMES[[kk]]
[15:32:32.652]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:32.652]                     next
[15:32:32.652]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:32.652]                 }
[15:32:32.652]                 if (length(args) > 0) 
[15:32:32.652]                   base::do.call(base::Sys.setenv, args = args)
[15:32:32.652]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:32.652]             }
[15:32:32.652]             else {
[15:32:32.652]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:32.652]             }
[15:32:32.652]             {
[15:32:32.652]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:32.652]                   0L) {
[15:32:32.652]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:32.652]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:32.652]                   base::options(opts)
[15:32:32.652]                 }
[15:32:32.652]                 {
[15:32:32.652]                   {
[15:32:32.652]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:32.652]                     NULL
[15:32:32.652]                   }
[15:32:32.652]                   options(future.plan = NULL)
[15:32:32.652]                   if (is.na(NA_character_)) 
[15:32:32.652]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:32.652]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:32.652]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:32.652]                     .init = FALSE)
[15:32:32.652]                 }
[15:32:32.652]             }
[15:32:32.652]         }
[15:32:32.652]     })
[15:32:32.652]     if (TRUE) {
[15:32:32.652]         base::sink(type = "output", split = FALSE)
[15:32:32.652]         if (TRUE) {
[15:32:32.652]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:32.652]         }
[15:32:32.652]         else {
[15:32:32.652]             ...future.result["stdout"] <- base::list(NULL)
[15:32:32.652]         }
[15:32:32.652]         base::close(...future.stdout)
[15:32:32.652]         ...future.stdout <- NULL
[15:32:32.652]     }
[15:32:32.652]     ...future.result$conditions <- ...future.conditions
[15:32:32.652]     ...future.result$finished <- base::Sys.time()
[15:32:32.652]     ...future.result
[15:32:32.652] }
[15:32:32.660] Exporting 5 global objects (1.22 KiB) to cluster node #1 ...
[15:32:32.660] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ...
[15:32:32.661] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ... DONE
[15:32:32.662] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:32.662] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:32.663] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ...
[15:32:32.663] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ... DONE
[15:32:32.663] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:32.664] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:32.665] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:32.666] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:32.666] Exporting 5 global objects (1.22 KiB) to cluster node #1 ... DONE
[15:32:32.668] MultisessionFuture started
[15:32:32.668] - Launch lazy future ... done
[15:32:32.668] run() for 'MultisessionFuture' ... done
[15:32:32.669] Created future:
[15:32:32.694] receiveMessageFromWorker() for ClusterFuture ...
[15:32:32.694] - Validating connection of MultisessionFuture
[15:32:32.695] - received message: FutureResult
[15:32:32.695] - Received FutureResult
[15:32:32.696] - Erased future from FutureRegistry
[15:32:32.696] result() for ClusterFuture ...
[15:32:32.696] - result already collected: FutureResult
[15:32:32.696] result() for ClusterFuture ... done
[15:32:32.697] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:32.669] MultisessionFuture:
[15:32:32.669] Label: 'future_sapply-2'
[15:32:32.669] Expression:
[15:32:32.669] {
[15:32:32.669]     do.call(function(...) {
[15:32:32.669]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:32.669]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:32.669]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:32.669]             on.exit(options(oopts), add = TRUE)
[15:32:32.669]         }
[15:32:32.669]         {
[15:32:32.669]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:32.669]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:32.669]                 ...future.FUN(...future.X_jj, ...)
[15:32:32.669]             })
[15:32:32.669]         }
[15:32:32.669]     }, args = future.call.arguments)
[15:32:32.669] }
[15:32:32.669] Lazy evaluation: FALSE
[15:32:32.669] Asynchronous evaluation: TRUE
[15:32:32.669] Local evaluation: TRUE
[15:32:32.669] Environment: R_GlobalEnv
[15:32:32.669] Capture standard output: TRUE
[15:32:32.669] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:32.669] Globals: 5 objects totaling 1.38 KiB (function '...future.FUN' of 1.22 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:32.669] Packages: <none>
[15:32:32.669] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:32.669] Resolved: TRUE
[15:32:32.669] Value: <not collected>
[15:32:32.669] Conditions captured: <none>
[15:32:32.669] Early signaling: FALSE
[15:32:32.669] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:32.669] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:32.697] Chunk #2 of 2 ... DONE
[15:32:32.698] Launching 2 futures (chunks) ... DONE
[15:32:32.698] Resolving 2 futures (chunks) ...
[15:32:32.698] resolve() on list ...
[15:32:32.698]  recursive: 0
[15:32:32.698]  length: 2
[15:32:32.699] 
[15:32:32.699] Future #1
[15:32:32.699] result() for ClusterFuture ...
[15:32:32.699] - result already collected: FutureResult
[15:32:32.700] result() for ClusterFuture ... done
[15:32:32.700] result() for ClusterFuture ...
[15:32:32.700] - result already collected: FutureResult
[15:32:32.700] result() for ClusterFuture ... done
[15:32:32.700] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:32.701] - nx: 2
[15:32:32.701] - relay: TRUE
[15:32:32.701] - stdout: TRUE
[15:32:32.701] - signal: TRUE
[15:32:32.701] - resignal: FALSE
[15:32:32.702] - force: TRUE
[15:32:32.702] - relayed: [n=2] FALSE, FALSE
[15:32:32.702] - queued futures: [n=2] FALSE, FALSE
[15:32:32.702]  - until=1
[15:32:32.703]  - relaying element #1
[15:32:32.703] result() for ClusterFuture ...
[15:32:32.703] - result already collected: FutureResult
[15:32:32.703] result() for ClusterFuture ... done
[15:32:32.703] result() for ClusterFuture ...
[15:32:32.704] - result already collected: FutureResult
[15:32:32.704] result() for ClusterFuture ... done
[15:32:32.704] result() for ClusterFuture ...
[15:32:32.704] - result already collected: FutureResult
[15:32:32.705] result() for ClusterFuture ... done
[15:32:32.705] result() for ClusterFuture ...
[15:32:32.705] - result already collected: FutureResult
[15:32:32.705] result() for ClusterFuture ... done
[15:32:32.705] - relayed: [n=2] TRUE, FALSE
[15:32:32.706] - queued futures: [n=2] TRUE, FALSE
[15:32:32.706] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:32.706]  length: 1 (resolved future 1)
[15:32:32.706] Future #2
[15:32:32.707] result() for ClusterFuture ...
[15:32:32.707] - result already collected: FutureResult
[15:32:32.707] result() for ClusterFuture ... done
[15:32:32.707] result() for ClusterFuture ...
[15:32:32.707] - result already collected: FutureResult
[15:32:32.708] result() for ClusterFuture ... done
[15:32:32.708] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:32.708] - nx: 2
[15:32:32.708] - relay: TRUE
[15:32:32.708] - stdout: TRUE
[15:32:32.709] - signal: TRUE
[15:32:32.709] - resignal: FALSE
[15:32:32.709] - force: TRUE
[15:32:32.709] - relayed: [n=2] TRUE, FALSE
[15:32:32.709] - queued futures: [n=2] TRUE, FALSE
[15:32:32.710]  - until=2
[15:32:32.710]  - relaying element #2
[15:32:32.710] result() for ClusterFuture ...
[15:32:32.710] - result already collected: FutureResult
[15:32:32.711] result() for ClusterFuture ... done
[15:32:32.711] result() for ClusterFuture ...
[15:32:32.711] - result already collected: FutureResult
[15:32:32.711] result() for ClusterFuture ... done
[15:32:32.712] result() for ClusterFuture ...
[15:32:32.712] - result already collected: FutureResult
[15:32:32.712] result() for ClusterFuture ... done
[15:32:32.712] result() for ClusterFuture ...
[15:32:32.712] - result already collected: FutureResult
[15:32:32.713] result() for ClusterFuture ... done
[15:32:32.713] - relayed: [n=2] TRUE, TRUE
[15:32:32.713] - queued futures: [n=2] TRUE, TRUE
[15:32:32.713] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:32.713]  length: 0 (resolved future 2)
[15:32:32.714] Relaying remaining futures
[15:32:32.714] signalConditionsASAP(NULL, pos=0) ...
[15:32:32.714] - nx: 2
[15:32:32.714] - relay: TRUE
[15:32:32.714] - stdout: TRUE
[15:32:32.715] - signal: TRUE
[15:32:32.715] - resignal: FALSE
[15:32:32.715] - force: TRUE
[15:32:32.715] - relayed: [n=2] TRUE, TRUE
[15:32:32.715] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:32.716] - relayed: [n=2] TRUE, TRUE
[15:32:32.716] - queued futures: [n=2] TRUE, TRUE
[15:32:32.716] signalConditionsASAP(NULL, pos=0) ... done
[15:32:32.716] resolve() on list ... DONE
[15:32:32.717] result() for ClusterFuture ...
[15:32:32.717] - result already collected: FutureResult
[15:32:32.717] result() for ClusterFuture ... done
[15:32:32.717] result() for ClusterFuture ...
[15:32:32.718] - result already collected: FutureResult
[15:32:32.718] result() for ClusterFuture ... done
[15:32:32.718] result() for ClusterFuture ...
[15:32:32.718] - result already collected: FutureResult
[15:32:32.718] result() for ClusterFuture ... done
[15:32:32.719] result() for ClusterFuture ...
[15:32:32.719] - result already collected: FutureResult
[15:32:32.719] result() for ClusterFuture ... done
[15:32:32.719]  - Number of value chunks collected: 2
[15:32:32.720] Resolving 2 futures (chunks) ... DONE
[15:32:32.720] Reducing values from 2 chunks ...
[15:32:32.720]  - Number of values collected after concatenation: 6
[15:32:32.720]  - Number of values expected: 6
[15:32:32.721] Reducing values from 2 chunks ... DONE
[15:32:32.721] future_lapply() ... DONE
List of 2
 $ y0: Named int [1:6] 1 2 2 3 3 4
  ..- attr(*, "names")= chr [1:6] "a1" "a2" "b1" "b2" ...
 $ y1: Named int [1:6] 1 2 2 3 3 4
  ..- attr(*, "names")= chr [1:6] "a1" "a2" "b1" "b2" ...
[15:32:32.724] future_lapply() ...
[15:32:32.729] Number of chunks: 2
[15:32:32.729] getGlobalsAndPackagesXApply() ...
[15:32:32.729]  - future.globals: TRUE
[15:32:32.729] getGlobalsAndPackages() ...
[15:32:32.730] Searching for globals...
[15:32:32.732] - globals found: [5] 'FUN', '*', ':', 'outer', 'rep'
[15:32:32.732] Searching for globals ... DONE
[15:32:32.733] Resolving globals: FALSE
[15:32:32.733] The total size of the 1 globals is 4.62 KiB (4728 bytes)
[15:32:32.734] The total size of the 1 globals exported for future expression ('FUN()') is 4.62 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.62 KiB of class 'function')
[15:32:32.734] - globals: [1] 'FUN'
[15:32:32.734] 
[15:32:32.735] getGlobalsAndPackages() ... DONE
[15:32:32.735]  - globals found/used: [n=1] 'FUN'
[15:32:32.735]  - needed namespaces: [n=0] 
[15:32:32.735] Finding globals ... DONE
[15:32:32.736]  - use_args: TRUE
[15:32:32.736]  - Getting '...' globals ...
[15:32:32.736] resolve() on list ...
[15:32:32.737]  recursive: 0
[15:32:32.737]  length: 1
[15:32:32.737]  elements: '...'
[15:32:32.737]  length: 0 (resolved future 1)
[15:32:32.738] resolve() on list ... DONE
[15:32:32.738]    - '...' content: [n=0] 
[15:32:32.738] List of 1
[15:32:32.738]  $ ...: list()
[15:32:32.738]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:32.738]  - attr(*, "where")=List of 1
[15:32:32.738]   ..$ ...:<environment: 0x00000276e5b0b1b0> 
[15:32:32.738]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:32.738]  - attr(*, "resolved")= logi TRUE
[15:32:32.738]  - attr(*, "total_size")= num NA
[15:32:32.742]  - Getting '...' globals ... DONE
[15:32:32.743] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:32.743] List of 2
[15:32:32.743]  $ ...future.FUN:function (x, y = 2 * 1:5)  
[15:32:32.743]  $ ...          : list()
[15:32:32.743]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:32.743]  - attr(*, "where")=List of 2
[15:32:32.743]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:32.743]   ..$ ...          :<environment: 0x00000276e5b0b1b0> 
[15:32:32.743]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:32.743]  - attr(*, "resolved")= logi FALSE
[15:32:32.743]  - attr(*, "total_size")= num 4728
[15:32:32.747] Packages to be attached in all futures: [n=0] 
[15:32:32.748] getGlobalsAndPackagesXApply() ... DONE
[15:32:32.748] Number of futures (= number of chunks): 2
[15:32:32.748] Launching 2 futures (chunks) ...
[15:32:32.748] Chunk #1 of 2 ...
[15:32:32.749]  - Finding globals in 'X' for chunk #1 ...
[15:32:32.749] getGlobalsAndPackages() ...
[15:32:32.749] Searching for globals...
[15:32:32.750] 
[15:32:32.750] Searching for globals ... DONE
[15:32:32.750] - globals: [0] <none>
[15:32:32.751] getGlobalsAndPackages() ... DONE
[15:32:32.751]    + additional globals found: [n=0] 
[15:32:32.751]    + additional namespaces needed: [n=0] 
[15:32:32.752]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:32.752]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:32.752]  - seeds: <none>
[15:32:32.752]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:32.753] getGlobalsAndPackages() ...
[15:32:32.753] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:32.753] Resolving globals: FALSE
[15:32:32.753] Tweak future expression to call with '...' arguments ...
[15:32:32.754] {
[15:32:32.754]     do.call(function(...) {
[15:32:32.754]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:32.754]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:32.754]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:32.754]             on.exit(options(oopts), add = TRUE)
[15:32:32.754]         }
[15:32:32.754]         {
[15:32:32.754]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:32.754]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:32.754]                 ...future.FUN(...future.X_jj, ...)
[15:32:32.754]             })
[15:32:32.754]         }
[15:32:32.754]     }, args = future.call.arguments)
[15:32:32.754] }
[15:32:32.754] Tweak future expression to call with '...' arguments ... DONE
[15:32:32.755] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:32.755] 
[15:32:32.756] getGlobalsAndPackages() ... DONE
[15:32:32.756] run() for 'Future' ...
[15:32:32.757] - state: 'created'
[15:32:32.757] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:32.774] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:32.774] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:32.774]   - Field: 'node'
[15:32:32.774]   - Field: 'label'
[15:32:32.775]   - Field: 'local'
[15:32:32.775]   - Field: 'owner'
[15:32:32.775]   - Field: 'envir'
[15:32:32.775]   - Field: 'workers'
[15:32:32.775]   - Field: 'packages'
[15:32:32.775]   - Field: 'gc'
[15:32:32.776]   - Field: 'conditions'
[15:32:32.776]   - Field: 'persistent'
[15:32:32.776]   - Field: 'expr'
[15:32:32.776]   - Field: 'uuid'
[15:32:32.776]   - Field: 'seed'
[15:32:32.777]   - Field: 'version'
[15:32:32.777]   - Field: 'result'
[15:32:32.777]   - Field: 'asynchronous'
[15:32:32.777]   - Field: 'calls'
[15:32:32.777]   - Field: 'globals'
[15:32:32.777]   - Field: 'stdout'
[15:32:32.778]   - Field: 'earlySignal'
[15:32:32.778]   - Field: 'lazy'
[15:32:32.778]   - Field: 'state'
[15:32:32.778] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:32.778] - Launch lazy future ...
[15:32:32.779] Packages needed by the future expression (n = 0): <none>
[15:32:32.779] Packages needed by future strategies (n = 0): <none>
[15:32:32.780] {
[15:32:32.780]     {
[15:32:32.780]         {
[15:32:32.780]             ...future.startTime <- base::Sys.time()
[15:32:32.780]             {
[15:32:32.780]                 {
[15:32:32.780]                   {
[15:32:32.780]                     {
[15:32:32.780]                       base::local({
[15:32:32.780]                         has_future <- base::requireNamespace("future", 
[15:32:32.780]                           quietly = TRUE)
[15:32:32.780]                         if (has_future) {
[15:32:32.780]                           ns <- base::getNamespace("future")
[15:32:32.780]                           version <- ns[[".package"]][["version"]]
[15:32:32.780]                           if (is.null(version)) 
[15:32:32.780]                             version <- utils::packageVersion("future")
[15:32:32.780]                         }
[15:32:32.780]                         else {
[15:32:32.780]                           version <- NULL
[15:32:32.780]                         }
[15:32:32.780]                         if (!has_future || version < "1.8.0") {
[15:32:32.780]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:32.780]                             "", base::R.version$version.string), 
[15:32:32.780]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:32.780]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:32.780]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:32.780]                               "release", "version")], collapse = " "), 
[15:32:32.780]                             hostname = base::Sys.info()[["nodename"]])
[15:32:32.780]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:32.780]                             info)
[15:32:32.780]                           info <- base::paste(info, collapse = "; ")
[15:32:32.780]                           if (!has_future) {
[15:32:32.780]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:32.780]                               info)
[15:32:32.780]                           }
[15:32:32.780]                           else {
[15:32:32.780]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:32.780]                               info, version)
[15:32:32.780]                           }
[15:32:32.780]                           base::stop(msg)
[15:32:32.780]                         }
[15:32:32.780]                       })
[15:32:32.780]                     }
[15:32:32.780]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:32.780]                     base::options(mc.cores = 1L)
[15:32:32.780]                   }
[15:32:32.780]                   ...future.strategy.old <- future::plan("list")
[15:32:32.780]                   options(future.plan = NULL)
[15:32:32.780]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:32.780]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:32.780]                 }
[15:32:32.780]                 ...future.workdir <- getwd()
[15:32:32.780]             }
[15:32:32.780]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:32.780]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:32.780]         }
[15:32:32.780]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:32.780]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:32.780]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:32.780]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:32.780]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:32.780]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:32.780]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:32.780]             base::names(...future.oldOptions))
[15:32:32.780]     }
[15:32:32.780]     if (FALSE) {
[15:32:32.780]     }
[15:32:32.780]     else {
[15:32:32.780]         if (TRUE) {
[15:32:32.780]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:32.780]                 open = "w")
[15:32:32.780]         }
[15:32:32.780]         else {
[15:32:32.780]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:32.780]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:32.780]         }
[15:32:32.780]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:32.780]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:32.780]             base::sink(type = "output", split = FALSE)
[15:32:32.780]             base::close(...future.stdout)
[15:32:32.780]         }, add = TRUE)
[15:32:32.780]     }
[15:32:32.780]     ...future.frame <- base::sys.nframe()
[15:32:32.780]     ...future.conditions <- base::list()
[15:32:32.780]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:32.780]     if (FALSE) {
[15:32:32.780]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:32.780]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:32.780]     }
[15:32:32.780]     ...future.result <- base::tryCatch({
[15:32:32.780]         base::withCallingHandlers({
[15:32:32.780]             ...future.value <- base::withVisible(base::local({
[15:32:32.780]                 ...future.makeSendCondition <- base::local({
[15:32:32.780]                   sendCondition <- NULL
[15:32:32.780]                   function(frame = 1L) {
[15:32:32.780]                     if (is.function(sendCondition)) 
[15:32:32.780]                       return(sendCondition)
[15:32:32.780]                     ns <- getNamespace("parallel")
[15:32:32.780]                     if (exists("sendData", mode = "function", 
[15:32:32.780]                       envir = ns)) {
[15:32:32.780]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:32.780]                         envir = ns)
[15:32:32.780]                       envir <- sys.frame(frame)
[15:32:32.780]                       master <- NULL
[15:32:32.780]                       while (!identical(envir, .GlobalEnv) && 
[15:32:32.780]                         !identical(envir, emptyenv())) {
[15:32:32.780]                         if (exists("master", mode = "list", envir = envir, 
[15:32:32.780]                           inherits = FALSE)) {
[15:32:32.780]                           master <- get("master", mode = "list", 
[15:32:32.780]                             envir = envir, inherits = FALSE)
[15:32:32.780]                           if (inherits(master, c("SOCKnode", 
[15:32:32.780]                             "SOCK0node"))) {
[15:32:32.780]                             sendCondition <<- function(cond) {
[15:32:32.780]                               data <- list(type = "VALUE", value = cond, 
[15:32:32.780]                                 success = TRUE)
[15:32:32.780]                               parallel_sendData(master, data)
[15:32:32.780]                             }
[15:32:32.780]                             return(sendCondition)
[15:32:32.780]                           }
[15:32:32.780]                         }
[15:32:32.780]                         frame <- frame + 1L
[15:32:32.780]                         envir <- sys.frame(frame)
[15:32:32.780]                       }
[15:32:32.780]                     }
[15:32:32.780]                     sendCondition <<- function(cond) NULL
[15:32:32.780]                   }
[15:32:32.780]                 })
[15:32:32.780]                 withCallingHandlers({
[15:32:32.780]                   {
[15:32:32.780]                     do.call(function(...) {
[15:32:32.780]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:32.780]                       if (!identical(...future.globals.maxSize.org, 
[15:32:32.780]                         ...future.globals.maxSize)) {
[15:32:32.780]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:32.780]                         on.exit(options(oopts), add = TRUE)
[15:32:32.780]                       }
[15:32:32.780]                       {
[15:32:32.780]                         lapply(seq_along(...future.elements_ii), 
[15:32:32.780]                           FUN = function(jj) {
[15:32:32.780]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:32.780]                             ...future.FUN(...future.X_jj, ...)
[15:32:32.780]                           })
[15:32:32.780]                       }
[15:32:32.780]                     }, args = future.call.arguments)
[15:32:32.780]                   }
[15:32:32.780]                 }, immediateCondition = function(cond) {
[15:32:32.780]                   sendCondition <- ...future.makeSendCondition()
[15:32:32.780]                   sendCondition(cond)
[15:32:32.780]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:32.780]                   {
[15:32:32.780]                     inherits <- base::inherits
[15:32:32.780]                     invokeRestart <- base::invokeRestart
[15:32:32.780]                     is.null <- base::is.null
[15:32:32.780]                     muffled <- FALSE
[15:32:32.780]                     if (inherits(cond, "message")) {
[15:32:32.780]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:32.780]                       if (muffled) 
[15:32:32.780]                         invokeRestart("muffleMessage")
[15:32:32.780]                     }
[15:32:32.780]                     else if (inherits(cond, "warning")) {
[15:32:32.780]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:32.780]                       if (muffled) 
[15:32:32.780]                         invokeRestart("muffleWarning")
[15:32:32.780]                     }
[15:32:32.780]                     else if (inherits(cond, "condition")) {
[15:32:32.780]                       if (!is.null(pattern)) {
[15:32:32.780]                         computeRestarts <- base::computeRestarts
[15:32:32.780]                         grepl <- base::grepl
[15:32:32.780]                         restarts <- computeRestarts(cond)
[15:32:32.780]                         for (restart in restarts) {
[15:32:32.780]                           name <- restart$name
[15:32:32.780]                           if (is.null(name)) 
[15:32:32.780]                             next
[15:32:32.780]                           if (!grepl(pattern, name)) 
[15:32:32.780]                             next
[15:32:32.780]                           invokeRestart(restart)
[15:32:32.780]                           muffled <- TRUE
[15:32:32.780]                           break
[15:32:32.780]                         }
[15:32:32.780]                       }
[15:32:32.780]                     }
[15:32:32.780]                     invisible(muffled)
[15:32:32.780]                   }
[15:32:32.780]                   muffleCondition(cond)
[15:32:32.780]                 })
[15:32:32.780]             }))
[15:32:32.780]             future::FutureResult(value = ...future.value$value, 
[15:32:32.780]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:32.780]                   ...future.rng), globalenv = if (FALSE) 
[15:32:32.780]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:32.780]                     ...future.globalenv.names))
[15:32:32.780]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:32.780]         }, condition = base::local({
[15:32:32.780]             c <- base::c
[15:32:32.780]             inherits <- base::inherits
[15:32:32.780]             invokeRestart <- base::invokeRestart
[15:32:32.780]             length <- base::length
[15:32:32.780]             list <- base::list
[15:32:32.780]             seq.int <- base::seq.int
[15:32:32.780]             signalCondition <- base::signalCondition
[15:32:32.780]             sys.calls <- base::sys.calls
[15:32:32.780]             `[[` <- base::`[[`
[15:32:32.780]             `+` <- base::`+`
[15:32:32.780]             `<<-` <- base::`<<-`
[15:32:32.780]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:32.780]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:32.780]                   3L)]
[15:32:32.780]             }
[15:32:32.780]             function(cond) {
[15:32:32.780]                 is_error <- inherits(cond, "error")
[15:32:32.780]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:32.780]                   NULL)
[15:32:32.780]                 if (is_error) {
[15:32:32.780]                   sessionInformation <- function() {
[15:32:32.780]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:32.780]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:32.780]                       search = base::search(), system = base::Sys.info())
[15:32:32.780]                   }
[15:32:32.780]                   ...future.conditions[[length(...future.conditions) + 
[15:32:32.780]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:32.780]                     cond$call), session = sessionInformation(), 
[15:32:32.780]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:32.780]                   signalCondition(cond)
[15:32:32.780]                 }
[15:32:32.780]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:32.780]                 "immediateCondition"))) {
[15:32:32.780]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:32.780]                   ...future.conditions[[length(...future.conditions) + 
[15:32:32.780]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:32.780]                   if (TRUE && !signal) {
[15:32:32.780]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:32.780]                     {
[15:32:32.780]                       inherits <- base::inherits
[15:32:32.780]                       invokeRestart <- base::invokeRestart
[15:32:32.780]                       is.null <- base::is.null
[15:32:32.780]                       muffled <- FALSE
[15:32:32.780]                       if (inherits(cond, "message")) {
[15:32:32.780]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:32.780]                         if (muffled) 
[15:32:32.780]                           invokeRestart("muffleMessage")
[15:32:32.780]                       }
[15:32:32.780]                       else if (inherits(cond, "warning")) {
[15:32:32.780]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:32.780]                         if (muffled) 
[15:32:32.780]                           invokeRestart("muffleWarning")
[15:32:32.780]                       }
[15:32:32.780]                       else if (inherits(cond, "condition")) {
[15:32:32.780]                         if (!is.null(pattern)) {
[15:32:32.780]                           computeRestarts <- base::computeRestarts
[15:32:32.780]                           grepl <- base::grepl
[15:32:32.780]                           restarts <- computeRestarts(cond)
[15:32:32.780]                           for (restart in restarts) {
[15:32:32.780]                             name <- restart$name
[15:32:32.780]                             if (is.null(name)) 
[15:32:32.780]                               next
[15:32:32.780]                             if (!grepl(pattern, name)) 
[15:32:32.780]                               next
[15:32:32.780]                             invokeRestart(restart)
[15:32:32.780]                             muffled <- TRUE
[15:32:32.780]                             break
[15:32:32.780]                           }
[15:32:32.780]                         }
[15:32:32.780]                       }
[15:32:32.780]                       invisible(muffled)
[15:32:32.780]                     }
[15:32:32.780]                     muffleCondition(cond, pattern = "^muffle")
[15:32:32.780]                   }
[15:32:32.780]                 }
[15:32:32.780]                 else {
[15:32:32.780]                   if (TRUE) {
[15:32:32.780]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:32.780]                     {
[15:32:32.780]                       inherits <- base::inherits
[15:32:32.780]                       invokeRestart <- base::invokeRestart
[15:32:32.780]                       is.null <- base::is.null
[15:32:32.780]                       muffled <- FALSE
[15:32:32.780]                       if (inherits(cond, "message")) {
[15:32:32.780]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:32.780]                         if (muffled) 
[15:32:32.780]                           invokeRestart("muffleMessage")
[15:32:32.780]                       }
[15:32:32.780]                       else if (inherits(cond, "warning")) {
[15:32:32.780]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:32.780]                         if (muffled) 
[15:32:32.780]                           invokeRestart("muffleWarning")
[15:32:32.780]                       }
[15:32:32.780]                       else if (inherits(cond, "condition")) {
[15:32:32.780]                         if (!is.null(pattern)) {
[15:32:32.780]                           computeRestarts <- base::computeRestarts
[15:32:32.780]                           grepl <- base::grepl
[15:32:32.780]                           restarts <- computeRestarts(cond)
[15:32:32.780]                           for (restart in restarts) {
[15:32:32.780]                             name <- restart$name
[15:32:32.780]                             if (is.null(name)) 
[15:32:32.780]                               next
[15:32:32.780]                             if (!grepl(pattern, name)) 
[15:32:32.780]                               next
[15:32:32.780]                             invokeRestart(restart)
[15:32:32.780]                             muffled <- TRUE
[15:32:32.780]                             break
[15:32:32.780]                           }
[15:32:32.780]                         }
[15:32:32.780]                       }
[15:32:32.780]                       invisible(muffled)
[15:32:32.780]                     }
[15:32:32.780]                     muffleCondition(cond, pattern = "^muffle")
[15:32:32.780]                   }
[15:32:32.780]                 }
[15:32:32.780]             }
[15:32:32.780]         }))
[15:32:32.780]     }, error = function(ex) {
[15:32:32.780]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:32.780]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:32.780]                 ...future.rng), started = ...future.startTime, 
[15:32:32.780]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:32.780]             version = "1.8"), class = "FutureResult")
[15:32:32.780]     }, finally = {
[15:32:32.780]         if (!identical(...future.workdir, getwd())) 
[15:32:32.780]             setwd(...future.workdir)
[15:32:32.780]         {
[15:32:32.780]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:32.780]                 ...future.oldOptions$nwarnings <- NULL
[15:32:32.780]             }
[15:32:32.780]             base::options(...future.oldOptions)
[15:32:32.780]             if (.Platform$OS.type == "windows") {
[15:32:32.780]                 old_names <- names(...future.oldEnvVars)
[15:32:32.780]                 envs <- base::Sys.getenv()
[15:32:32.780]                 names <- names(envs)
[15:32:32.780]                 common <- intersect(names, old_names)
[15:32:32.780]                 added <- setdiff(names, old_names)
[15:32:32.780]                 removed <- setdiff(old_names, names)
[15:32:32.780]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:32.780]                   envs[common]]
[15:32:32.780]                 NAMES <- toupper(changed)
[15:32:32.780]                 args <- list()
[15:32:32.780]                 for (kk in seq_along(NAMES)) {
[15:32:32.780]                   name <- changed[[kk]]
[15:32:32.780]                   NAME <- NAMES[[kk]]
[15:32:32.780]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:32.780]                     next
[15:32:32.780]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:32.780]                 }
[15:32:32.780]                 NAMES <- toupper(added)
[15:32:32.780]                 for (kk in seq_along(NAMES)) {
[15:32:32.780]                   name <- added[[kk]]
[15:32:32.780]                   NAME <- NAMES[[kk]]
[15:32:32.780]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:32.780]                     next
[15:32:32.780]                   args[[name]] <- ""
[15:32:32.780]                 }
[15:32:32.780]                 NAMES <- toupper(removed)
[15:32:32.780]                 for (kk in seq_along(NAMES)) {
[15:32:32.780]                   name <- removed[[kk]]
[15:32:32.780]                   NAME <- NAMES[[kk]]
[15:32:32.780]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:32.780]                     next
[15:32:32.780]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:32.780]                 }
[15:32:32.780]                 if (length(args) > 0) 
[15:32:32.780]                   base::do.call(base::Sys.setenv, args = args)
[15:32:32.780]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:32.780]             }
[15:32:32.780]             else {
[15:32:32.780]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:32.780]             }
[15:32:32.780]             {
[15:32:32.780]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:32.780]                   0L) {
[15:32:32.780]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:32.780]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:32.780]                   base::options(opts)
[15:32:32.780]                 }
[15:32:32.780]                 {
[15:32:32.780]                   {
[15:32:32.780]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:32.780]                     NULL
[15:32:32.780]                   }
[15:32:32.780]                   options(future.plan = NULL)
[15:32:32.780]                   if (is.na(NA_character_)) 
[15:32:32.780]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:32.780]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:32.780]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:32.780]                     .init = FALSE)
[15:32:32.780]                 }
[15:32:32.780]             }
[15:32:32.780]         }
[15:32:32.780]     })
[15:32:32.780]     if (TRUE) {
[15:32:32.780]         base::sink(type = "output", split = FALSE)
[15:32:32.780]         if (TRUE) {
[15:32:32.780]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:32.780]         }
[15:32:32.780]         else {
[15:32:32.780]             ...future.result["stdout"] <- base::list(NULL)
[15:32:32.780]         }
[15:32:32.780]         base::close(...future.stdout)
[15:32:32.780]         ...future.stdout <- NULL
[15:32:32.780]     }
[15:32:32.780]     ...future.result$conditions <- ...future.conditions
[15:32:32.780]     ...future.result$finished <- base::Sys.time()
[15:32:32.780]     ...future.result
[15:32:32.780] }
[15:32:32.786] Exporting 5 global objects (4.62 KiB) to cluster node #1 ...
[15:32:32.786] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ...
[15:32:32.787] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ... DONE
[15:32:32.787] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:32.788] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:32.788] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ...
[15:32:32.789] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ... DONE
[15:32:32.789] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:32.790] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:32.790] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:32.790] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:32.791] Exporting 5 global objects (4.62 KiB) to cluster node #1 ... DONE
[15:32:32.791] MultisessionFuture started
[15:32:32.792] - Launch lazy future ... done
[15:32:32.792] run() for 'MultisessionFuture' ... done
[15:32:32.792] Created future:
[15:32:32.808] receiveMessageFromWorker() for ClusterFuture ...
[15:32:32.808] - Validating connection of MultisessionFuture
[15:32:32.808] - received message: FutureResult
[15:32:32.808] - Received FutureResult
[15:32:32.808] - Erased future from FutureRegistry
[15:32:32.809] result() for ClusterFuture ...
[15:32:32.809] - result already collected: FutureResult
[15:32:32.809] result() for ClusterFuture ... done
[15:32:32.809] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:32.792] MultisessionFuture:
[15:32:32.792] Label: 'future_sapply-1'
[15:32:32.792] Expression:
[15:32:32.792] {
[15:32:32.792]     do.call(function(...) {
[15:32:32.792]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:32.792]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:32.792]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:32.792]             on.exit(options(oopts), add = TRUE)
[15:32:32.792]         }
[15:32:32.792]         {
[15:32:32.792]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:32.792]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:32.792]                 ...future.FUN(...future.X_jj, ...)
[15:32:32.792]             })
[15:32:32.792]         }
[15:32:32.792]     }, args = future.call.arguments)
[15:32:32.792] }
[15:32:32.792] Lazy evaluation: FALSE
[15:32:32.792] Asynchronous evaluation: TRUE
[15:32:32.792] Local evaluation: TRUE
[15:32:32.792] Environment: R_GlobalEnv
[15:32:32.792] Capture standard output: TRUE
[15:32:32.792] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:32.792] Globals: 5 objects totaling 4.78 KiB (function '...future.FUN' of 4.62 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:32.792] Packages: <none>
[15:32:32.792] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:32.792] Resolved: TRUE
[15:32:32.792] Value: <not collected>
[15:32:32.792] Conditions captured: <none>
[15:32:32.792] Early signaling: FALSE
[15:32:32.792] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:32.792] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:32.810] Chunk #1 of 2 ... DONE
[15:32:32.810] Chunk #2 of 2 ...
[15:32:32.810]  - Finding globals in 'X' for chunk #2 ...
[15:32:32.810] getGlobalsAndPackages() ...
[15:32:32.810] Searching for globals...
[15:32:32.811] 
[15:32:32.811] Searching for globals ... DONE
[15:32:32.811] - globals: [0] <none>
[15:32:32.811] getGlobalsAndPackages() ... DONE
[15:32:32.811]    + additional globals found: [n=0] 
[15:32:32.812]    + additional namespaces needed: [n=0] 
[15:32:32.812]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:32.812]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:32.813]  - seeds: <none>
[15:32:32.813]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:32.813] getGlobalsAndPackages() ...
[15:32:32.813] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:32.814] Resolving globals: FALSE
[15:32:32.814] Tweak future expression to call with '...' arguments ...
[15:32:32.814] {
[15:32:32.814]     do.call(function(...) {
[15:32:32.814]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:32.814]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:32.814]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:32.814]             on.exit(options(oopts), add = TRUE)
[15:32:32.814]         }
[15:32:32.814]         {
[15:32:32.814]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:32.814]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:32.814]                 ...future.FUN(...future.X_jj, ...)
[15:32:32.814]             })
[15:32:32.814]         }
[15:32:32.814]     }, args = future.call.arguments)
[15:32:32.814] }
[15:32:32.815] Tweak future expression to call with '...' arguments ... DONE
[15:32:32.816] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:32.816] 
[15:32:32.816] getGlobalsAndPackages() ... DONE
[15:32:32.817] run() for 'Future' ...
[15:32:32.817] - state: 'created'
[15:32:32.817] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:32.848] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:32.848] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:32.849]   - Field: 'node'
[15:32:32.849]   - Field: 'label'
[15:32:32.849]   - Field: 'local'
[15:32:32.849]   - Field: 'owner'
[15:32:32.850]   - Field: 'envir'
[15:32:32.850]   - Field: 'workers'
[15:32:32.850]   - Field: 'packages'
[15:32:32.851]   - Field: 'gc'
[15:32:32.851]   - Field: 'conditions'
[15:32:32.851]   - Field: 'persistent'
[15:32:32.851]   - Field: 'expr'
[15:32:32.852]   - Field: 'uuid'
[15:32:32.852]   - Field: 'seed'
[15:32:32.852]   - Field: 'version'
[15:32:32.853]   - Field: 'result'
[15:32:32.853]   - Field: 'asynchronous'
[15:32:32.853]   - Field: 'calls'
[15:32:32.853]   - Field: 'globals'
[15:32:32.854]   - Field: 'stdout'
[15:32:32.854]   - Field: 'earlySignal'
[15:32:32.854]   - Field: 'lazy'
[15:32:32.854]   - Field: 'state'
[15:32:32.855] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:32.855] - Launch lazy future ...
[15:32:32.856] Packages needed by the future expression (n = 0): <none>
[15:32:32.856] Packages needed by future strategies (n = 0): <none>
[15:32:32.857] {
[15:32:32.857]     {
[15:32:32.857]         {
[15:32:32.857]             ...future.startTime <- base::Sys.time()
[15:32:32.857]             {
[15:32:32.857]                 {
[15:32:32.857]                   {
[15:32:32.857]                     {
[15:32:32.857]                       base::local({
[15:32:32.857]                         has_future <- base::requireNamespace("future", 
[15:32:32.857]                           quietly = TRUE)
[15:32:32.857]                         if (has_future) {
[15:32:32.857]                           ns <- base::getNamespace("future")
[15:32:32.857]                           version <- ns[[".package"]][["version"]]
[15:32:32.857]                           if (is.null(version)) 
[15:32:32.857]                             version <- utils::packageVersion("future")
[15:32:32.857]                         }
[15:32:32.857]                         else {
[15:32:32.857]                           version <- NULL
[15:32:32.857]                         }
[15:32:32.857]                         if (!has_future || version < "1.8.0") {
[15:32:32.857]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:32.857]                             "", base::R.version$version.string), 
[15:32:32.857]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:32.857]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:32.857]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:32.857]                               "release", "version")], collapse = " "), 
[15:32:32.857]                             hostname = base::Sys.info()[["nodename"]])
[15:32:32.857]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:32.857]                             info)
[15:32:32.857]                           info <- base::paste(info, collapse = "; ")
[15:32:32.857]                           if (!has_future) {
[15:32:32.857]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:32.857]                               info)
[15:32:32.857]                           }
[15:32:32.857]                           else {
[15:32:32.857]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:32.857]                               info, version)
[15:32:32.857]                           }
[15:32:32.857]                           base::stop(msg)
[15:32:32.857]                         }
[15:32:32.857]                       })
[15:32:32.857]                     }
[15:32:32.857]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:32.857]                     base::options(mc.cores = 1L)
[15:32:32.857]                   }
[15:32:32.857]                   ...future.strategy.old <- future::plan("list")
[15:32:32.857]                   options(future.plan = NULL)
[15:32:32.857]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:32.857]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:32.857]                 }
[15:32:32.857]                 ...future.workdir <- getwd()
[15:32:32.857]             }
[15:32:32.857]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:32.857]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:32.857]         }
[15:32:32.857]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:32.857]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:32.857]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:32.857]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:32.857]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:32.857]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:32.857]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:32.857]             base::names(...future.oldOptions))
[15:32:32.857]     }
[15:32:32.857]     if (FALSE) {
[15:32:32.857]     }
[15:32:32.857]     else {
[15:32:32.857]         if (TRUE) {
[15:32:32.857]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:32.857]                 open = "w")
[15:32:32.857]         }
[15:32:32.857]         else {
[15:32:32.857]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:32.857]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:32.857]         }
[15:32:32.857]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:32.857]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:32.857]             base::sink(type = "output", split = FALSE)
[15:32:32.857]             base::close(...future.stdout)
[15:32:32.857]         }, add = TRUE)
[15:32:32.857]     }
[15:32:32.857]     ...future.frame <- base::sys.nframe()
[15:32:32.857]     ...future.conditions <- base::list()
[15:32:32.857]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:32.857]     if (FALSE) {
[15:32:32.857]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:32.857]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:32.857]     }
[15:32:32.857]     ...future.result <- base::tryCatch({
[15:32:32.857]         base::withCallingHandlers({
[15:32:32.857]             ...future.value <- base::withVisible(base::local({
[15:32:32.857]                 ...future.makeSendCondition <- base::local({
[15:32:32.857]                   sendCondition <- NULL
[15:32:32.857]                   function(frame = 1L) {
[15:32:32.857]                     if (is.function(sendCondition)) 
[15:32:32.857]                       return(sendCondition)
[15:32:32.857]                     ns <- getNamespace("parallel")
[15:32:32.857]                     if (exists("sendData", mode = "function", 
[15:32:32.857]                       envir = ns)) {
[15:32:32.857]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:32.857]                         envir = ns)
[15:32:32.857]                       envir <- sys.frame(frame)
[15:32:32.857]                       master <- NULL
[15:32:32.857]                       while (!identical(envir, .GlobalEnv) && 
[15:32:32.857]                         !identical(envir, emptyenv())) {
[15:32:32.857]                         if (exists("master", mode = "list", envir = envir, 
[15:32:32.857]                           inherits = FALSE)) {
[15:32:32.857]                           master <- get("master", mode = "list", 
[15:32:32.857]                             envir = envir, inherits = FALSE)
[15:32:32.857]                           if (inherits(master, c("SOCKnode", 
[15:32:32.857]                             "SOCK0node"))) {
[15:32:32.857]                             sendCondition <<- function(cond) {
[15:32:32.857]                               data <- list(type = "VALUE", value = cond, 
[15:32:32.857]                                 success = TRUE)
[15:32:32.857]                               parallel_sendData(master, data)
[15:32:32.857]                             }
[15:32:32.857]                             return(sendCondition)
[15:32:32.857]                           }
[15:32:32.857]                         }
[15:32:32.857]                         frame <- frame + 1L
[15:32:32.857]                         envir <- sys.frame(frame)
[15:32:32.857]                       }
[15:32:32.857]                     }
[15:32:32.857]                     sendCondition <<- function(cond) NULL
[15:32:32.857]                   }
[15:32:32.857]                 })
[15:32:32.857]                 withCallingHandlers({
[15:32:32.857]                   {
[15:32:32.857]                     do.call(function(...) {
[15:32:32.857]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:32.857]                       if (!identical(...future.globals.maxSize.org, 
[15:32:32.857]                         ...future.globals.maxSize)) {
[15:32:32.857]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:32.857]                         on.exit(options(oopts), add = TRUE)
[15:32:32.857]                       }
[15:32:32.857]                       {
[15:32:32.857]                         lapply(seq_along(...future.elements_ii), 
[15:32:32.857]                           FUN = function(jj) {
[15:32:32.857]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:32.857]                             ...future.FUN(...future.X_jj, ...)
[15:32:32.857]                           })
[15:32:32.857]                       }
[15:32:32.857]                     }, args = future.call.arguments)
[15:32:32.857]                   }
[15:32:32.857]                 }, immediateCondition = function(cond) {
[15:32:32.857]                   sendCondition <- ...future.makeSendCondition()
[15:32:32.857]                   sendCondition(cond)
[15:32:32.857]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:32.857]                   {
[15:32:32.857]                     inherits <- base::inherits
[15:32:32.857]                     invokeRestart <- base::invokeRestart
[15:32:32.857]                     is.null <- base::is.null
[15:32:32.857]                     muffled <- FALSE
[15:32:32.857]                     if (inherits(cond, "message")) {
[15:32:32.857]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:32.857]                       if (muffled) 
[15:32:32.857]                         invokeRestart("muffleMessage")
[15:32:32.857]                     }
[15:32:32.857]                     else if (inherits(cond, "warning")) {
[15:32:32.857]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:32.857]                       if (muffled) 
[15:32:32.857]                         invokeRestart("muffleWarning")
[15:32:32.857]                     }
[15:32:32.857]                     else if (inherits(cond, "condition")) {
[15:32:32.857]                       if (!is.null(pattern)) {
[15:32:32.857]                         computeRestarts <- base::computeRestarts
[15:32:32.857]                         grepl <- base::grepl
[15:32:32.857]                         restarts <- computeRestarts(cond)
[15:32:32.857]                         for (restart in restarts) {
[15:32:32.857]                           name <- restart$name
[15:32:32.857]                           if (is.null(name)) 
[15:32:32.857]                             next
[15:32:32.857]                           if (!grepl(pattern, name)) 
[15:32:32.857]                             next
[15:32:32.857]                           invokeRestart(restart)
[15:32:32.857]                           muffled <- TRUE
[15:32:32.857]                           break
[15:32:32.857]                         }
[15:32:32.857]                       }
[15:32:32.857]                     }
[15:32:32.857]                     invisible(muffled)
[15:32:32.857]                   }
[15:32:32.857]                   muffleCondition(cond)
[15:32:32.857]                 })
[15:32:32.857]             }))
[15:32:32.857]             future::FutureResult(value = ...future.value$value, 
[15:32:32.857]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:32.857]                   ...future.rng), globalenv = if (FALSE) 
[15:32:32.857]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:32.857]                     ...future.globalenv.names))
[15:32:32.857]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:32.857]         }, condition = base::local({
[15:32:32.857]             c <- base::c
[15:32:32.857]             inherits <- base::inherits
[15:32:32.857]             invokeRestart <- base::invokeRestart
[15:32:32.857]             length <- base::length
[15:32:32.857]             list <- base::list
[15:32:32.857]             seq.int <- base::seq.int
[15:32:32.857]             signalCondition <- base::signalCondition
[15:32:32.857]             sys.calls <- base::sys.calls
[15:32:32.857]             `[[` <- base::`[[`
[15:32:32.857]             `+` <- base::`+`
[15:32:32.857]             `<<-` <- base::`<<-`
[15:32:32.857]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:32.857]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:32.857]                   3L)]
[15:32:32.857]             }
[15:32:32.857]             function(cond) {
[15:32:32.857]                 is_error <- inherits(cond, "error")
[15:32:32.857]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:32.857]                   NULL)
[15:32:32.857]                 if (is_error) {
[15:32:32.857]                   sessionInformation <- function() {
[15:32:32.857]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:32.857]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:32.857]                       search = base::search(), system = base::Sys.info())
[15:32:32.857]                   }
[15:32:32.857]                   ...future.conditions[[length(...future.conditions) + 
[15:32:32.857]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:32.857]                     cond$call), session = sessionInformation(), 
[15:32:32.857]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:32.857]                   signalCondition(cond)
[15:32:32.857]                 }
[15:32:32.857]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:32.857]                 "immediateCondition"))) {
[15:32:32.857]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:32.857]                   ...future.conditions[[length(...future.conditions) + 
[15:32:32.857]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:32.857]                   if (TRUE && !signal) {
[15:32:32.857]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:32.857]                     {
[15:32:32.857]                       inherits <- base::inherits
[15:32:32.857]                       invokeRestart <- base::invokeRestart
[15:32:32.857]                       is.null <- base::is.null
[15:32:32.857]                       muffled <- FALSE
[15:32:32.857]                       if (inherits(cond, "message")) {
[15:32:32.857]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:32.857]                         if (muffled) 
[15:32:32.857]                           invokeRestart("muffleMessage")
[15:32:32.857]                       }
[15:32:32.857]                       else if (inherits(cond, "warning")) {
[15:32:32.857]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:32.857]                         if (muffled) 
[15:32:32.857]                           invokeRestart("muffleWarning")
[15:32:32.857]                       }
[15:32:32.857]                       else if (inherits(cond, "condition")) {
[15:32:32.857]                         if (!is.null(pattern)) {
[15:32:32.857]                           computeRestarts <- base::computeRestarts
[15:32:32.857]                           grepl <- base::grepl
[15:32:32.857]                           restarts <- computeRestarts(cond)
[15:32:32.857]                           for (restart in restarts) {
[15:32:32.857]                             name <- restart$name
[15:32:32.857]                             if (is.null(name)) 
[15:32:32.857]                               next
[15:32:32.857]                             if (!grepl(pattern, name)) 
[15:32:32.857]                               next
[15:32:32.857]                             invokeRestart(restart)
[15:32:32.857]                             muffled <- TRUE
[15:32:32.857]                             break
[15:32:32.857]                           }
[15:32:32.857]                         }
[15:32:32.857]                       }
[15:32:32.857]                       invisible(muffled)
[15:32:32.857]                     }
[15:32:32.857]                     muffleCondition(cond, pattern = "^muffle")
[15:32:32.857]                   }
[15:32:32.857]                 }
[15:32:32.857]                 else {
[15:32:32.857]                   if (TRUE) {
[15:32:32.857]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:32.857]                     {
[15:32:32.857]                       inherits <- base::inherits
[15:32:32.857]                       invokeRestart <- base::invokeRestart
[15:32:32.857]                       is.null <- base::is.null
[15:32:32.857]                       muffled <- FALSE
[15:32:32.857]                       if (inherits(cond, "message")) {
[15:32:32.857]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:32.857]                         if (muffled) 
[15:32:32.857]                           invokeRestart("muffleMessage")
[15:32:32.857]                       }
[15:32:32.857]                       else if (inherits(cond, "warning")) {
[15:32:32.857]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:32.857]                         if (muffled) 
[15:32:32.857]                           invokeRestart("muffleWarning")
[15:32:32.857]                       }
[15:32:32.857]                       else if (inherits(cond, "condition")) {
[15:32:32.857]                         if (!is.null(pattern)) {
[15:32:32.857]                           computeRestarts <- base::computeRestarts
[15:32:32.857]                           grepl <- base::grepl
[15:32:32.857]                           restarts <- computeRestarts(cond)
[15:32:32.857]                           for (restart in restarts) {
[15:32:32.857]                             name <- restart$name
[15:32:32.857]                             if (is.null(name)) 
[15:32:32.857]                               next
[15:32:32.857]                             if (!grepl(pattern, name)) 
[15:32:32.857]                               next
[15:32:32.857]                             invokeRestart(restart)
[15:32:32.857]                             muffled <- TRUE
[15:32:32.857]                             break
[15:32:32.857]                           }
[15:32:32.857]                         }
[15:32:32.857]                       }
[15:32:32.857]                       invisible(muffled)
[15:32:32.857]                     }
[15:32:32.857]                     muffleCondition(cond, pattern = "^muffle")
[15:32:32.857]                   }
[15:32:32.857]                 }
[15:32:32.857]             }
[15:32:32.857]         }))
[15:32:32.857]     }, error = function(ex) {
[15:32:32.857]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:32.857]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:32.857]                 ...future.rng), started = ...future.startTime, 
[15:32:32.857]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:32.857]             version = "1.8"), class = "FutureResult")
[15:32:32.857]     }, finally = {
[15:32:32.857]         if (!identical(...future.workdir, getwd())) 
[15:32:32.857]             setwd(...future.workdir)
[15:32:32.857]         {
[15:32:32.857]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:32.857]                 ...future.oldOptions$nwarnings <- NULL
[15:32:32.857]             }
[15:32:32.857]             base::options(...future.oldOptions)
[15:32:32.857]             if (.Platform$OS.type == "windows") {
[15:32:32.857]                 old_names <- names(...future.oldEnvVars)
[15:32:32.857]                 envs <- base::Sys.getenv()
[15:32:32.857]                 names <- names(envs)
[15:32:32.857]                 common <- intersect(names, old_names)
[15:32:32.857]                 added <- setdiff(names, old_names)
[15:32:32.857]                 removed <- setdiff(old_names, names)
[15:32:32.857]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:32.857]                   envs[common]]
[15:32:32.857]                 NAMES <- toupper(changed)
[15:32:32.857]                 args <- list()
[15:32:32.857]                 for (kk in seq_along(NAMES)) {
[15:32:32.857]                   name <- changed[[kk]]
[15:32:32.857]                   NAME <- NAMES[[kk]]
[15:32:32.857]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:32.857]                     next
[15:32:32.857]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:32.857]                 }
[15:32:32.857]                 NAMES <- toupper(added)
[15:32:32.857]                 for (kk in seq_along(NAMES)) {
[15:32:32.857]                   name <- added[[kk]]
[15:32:32.857]                   NAME <- NAMES[[kk]]
[15:32:32.857]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:32.857]                     next
[15:32:32.857]                   args[[name]] <- ""
[15:32:32.857]                 }
[15:32:32.857]                 NAMES <- toupper(removed)
[15:32:32.857]                 for (kk in seq_along(NAMES)) {
[15:32:32.857]                   name <- removed[[kk]]
[15:32:32.857]                   NAME <- NAMES[[kk]]
[15:32:32.857]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:32.857]                     next
[15:32:32.857]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:32.857]                 }
[15:32:32.857]                 if (length(args) > 0) 
[15:32:32.857]                   base::do.call(base::Sys.setenv, args = args)
[15:32:32.857]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:32.857]             }
[15:32:32.857]             else {
[15:32:32.857]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:32.857]             }
[15:32:32.857]             {
[15:32:32.857]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:32.857]                   0L) {
[15:32:32.857]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:32.857]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:32.857]                   base::options(opts)
[15:32:32.857]                 }
[15:32:32.857]                 {
[15:32:32.857]                   {
[15:32:32.857]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:32.857]                     NULL
[15:32:32.857]                   }
[15:32:32.857]                   options(future.plan = NULL)
[15:32:32.857]                   if (is.na(NA_character_)) 
[15:32:32.857]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:32.857]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:32.857]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:32.857]                     .init = FALSE)
[15:32:32.857]                 }
[15:32:32.857]             }
[15:32:32.857]         }
[15:32:32.857]     })
[15:32:32.857]     if (TRUE) {
[15:32:32.857]         base::sink(type = "output", split = FALSE)
[15:32:32.857]         if (TRUE) {
[15:32:32.857]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:32.857]         }
[15:32:32.857]         else {
[15:32:32.857]             ...future.result["stdout"] <- base::list(NULL)
[15:32:32.857]         }
[15:32:32.857]         base::close(...future.stdout)
[15:32:32.857]         ...future.stdout <- NULL
[15:32:32.857]     }
[15:32:32.857]     ...future.result$conditions <- ...future.conditions
[15:32:32.857]     ...future.result$finished <- base::Sys.time()
[15:32:32.857]     ...future.result
[15:32:32.857] }
[15:32:32.866] Exporting 5 global objects (4.62 KiB) to cluster node #1 ...
[15:32:32.867] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ...
[15:32:32.868] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ... DONE
[15:32:32.868] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:32.869] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:32.869] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ...
[15:32:32.870] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ... DONE
[15:32:32.870] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:32.871] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:32.871] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:32.872] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:32.872] Exporting 5 global objects (4.62 KiB) to cluster node #1 ... DONE
[15:32:32.873] MultisessionFuture started
[15:32:32.873] - Launch lazy future ... done
[15:32:32.874] run() for 'MultisessionFuture' ... done
[15:32:32.874] Created future:
[15:32:32.903] receiveMessageFromWorker() for ClusterFuture ...
[15:32:32.903] - Validating connection of MultisessionFuture
[15:32:32.904] - received message: FutureResult
[15:32:32.904] - Received FutureResult
[15:32:32.904] - Erased future from FutureRegistry
[15:32:32.905] result() for ClusterFuture ...
[15:32:32.905] - result already collected: FutureResult
[15:32:32.905] result() for ClusterFuture ... done
[15:32:32.906] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:32.874] MultisessionFuture:
[15:32:32.874] Label: 'future_sapply-2'
[15:32:32.874] Expression:
[15:32:32.874] {
[15:32:32.874]     do.call(function(...) {
[15:32:32.874]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:32.874]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:32.874]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:32.874]             on.exit(options(oopts), add = TRUE)
[15:32:32.874]         }
[15:32:32.874]         {
[15:32:32.874]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:32.874]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:32.874]                 ...future.FUN(...future.X_jj, ...)
[15:32:32.874]             })
[15:32:32.874]         }
[15:32:32.874]     }, args = future.call.arguments)
[15:32:32.874] }
[15:32:32.874] Lazy evaluation: FALSE
[15:32:32.874] Asynchronous evaluation: TRUE
[15:32:32.874] Local evaluation: TRUE
[15:32:32.874] Environment: R_GlobalEnv
[15:32:32.874] Capture standard output: TRUE
[15:32:32.874] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:32.874] Globals: 5 objects totaling 4.78 KiB (function '...future.FUN' of 4.62 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:32.874] Packages: <none>
[15:32:32.874] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:32.874] Resolved: TRUE
[15:32:32.874] Value: <not collected>
[15:32:32.874] Conditions captured: <none>
[15:32:32.874] Early signaling: FALSE
[15:32:32.874] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:32.874] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:32.906] Chunk #2 of 2 ... DONE
[15:32:32.907] Launching 2 futures (chunks) ... DONE
[15:32:32.907] Resolving 2 futures (chunks) ...
[15:32:32.907] resolve() on list ...
[15:32:32.908]  recursive: 0
[15:32:32.908]  length: 2
[15:32:32.908] 
[15:32:32.908] Future #1
[15:32:32.909] result() for ClusterFuture ...
[15:32:32.909] - result already collected: FutureResult
[15:32:32.909] result() for ClusterFuture ... done
[15:32:32.910] result() for ClusterFuture ...
[15:32:32.910] - result already collected: FutureResult
[15:32:32.910] result() for ClusterFuture ... done
[15:32:32.910] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:32.911] - nx: 2
[15:32:32.911] - relay: TRUE
[15:32:32.911] - stdout: TRUE
[15:32:32.912] - signal: TRUE
[15:32:32.912] - resignal: FALSE
[15:32:32.912] - force: TRUE
[15:32:32.912] - relayed: [n=2] FALSE, FALSE
[15:32:32.913] - queued futures: [n=2] FALSE, FALSE
[15:32:32.913]  - until=1
[15:32:32.913]  - relaying element #1
[15:32:32.913] result() for ClusterFuture ...
[15:32:32.914] - result already collected: FutureResult
[15:32:32.914] result() for ClusterFuture ... done
[15:32:32.914] result() for ClusterFuture ...
[15:32:32.915] - result already collected: FutureResult
[15:32:32.915] result() for ClusterFuture ... done
[15:32:32.915] result() for ClusterFuture ...
[15:32:32.915] - result already collected: FutureResult
[15:32:32.916] result() for ClusterFuture ... done
[15:32:32.916] result() for ClusterFuture ...
[15:32:32.916] - result already collected: FutureResult
[15:32:32.917] result() for ClusterFuture ... done
[15:32:32.917] - relayed: [n=2] TRUE, FALSE
[15:32:32.917] - queued futures: [n=2] TRUE, FALSE
[15:32:32.917] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:32.918]  length: 1 (resolved future 1)
[15:32:32.918] Future #2
[15:32:32.918] result() for ClusterFuture ...
[15:32:32.919] - result already collected: FutureResult
[15:32:32.919] result() for ClusterFuture ... done
[15:32:32.919] result() for ClusterFuture ...
[15:32:32.919] - result already collected: FutureResult
[15:32:32.920] result() for ClusterFuture ... done
[15:32:32.920] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:32.920] - nx: 2
[15:32:32.921] - relay: TRUE
[15:32:32.921] - stdout: TRUE
[15:32:32.921] - signal: TRUE
[15:32:32.921] - resignal: FALSE
[15:32:32.922] - force: TRUE
[15:32:32.922] - relayed: [n=2] TRUE, FALSE
[15:32:32.922] - queued futures: [n=2] TRUE, FALSE
[15:32:32.923]  - until=2
[15:32:32.923]  - relaying element #2
[15:32:32.923] result() for ClusterFuture ...
[15:32:32.923] - result already collected: FutureResult
[15:32:32.924] result() for ClusterFuture ... done
[15:32:32.924] result() for ClusterFuture ...
[15:32:32.924] - result already collected: FutureResult
[15:32:32.925] result() for ClusterFuture ... done
[15:32:32.925] result() for ClusterFuture ...
[15:32:32.925] - result already collected: FutureResult
[15:32:32.925] result() for ClusterFuture ... done
[15:32:32.926] result() for ClusterFuture ...
[15:32:32.926] - result already collected: FutureResult
[15:32:32.926] result() for ClusterFuture ... done
[15:32:32.927] - relayed: [n=2] TRUE, TRUE
[15:32:32.927] - queued futures: [n=2] TRUE, TRUE
[15:32:32.927] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:32.927]  length: 0 (resolved future 2)
[15:32:32.928] Relaying remaining futures
[15:32:32.928] signalConditionsASAP(NULL, pos=0) ...
[15:32:32.928] - nx: 2
[15:32:32.929] - relay: TRUE
[15:32:32.929] - stdout: TRUE
[15:32:32.929] - signal: TRUE
[15:32:32.929] - resignal: FALSE
[15:32:32.930] - force: TRUE
[15:32:32.930] - relayed: [n=2] TRUE, TRUE
[15:32:32.930] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:32.931] - relayed: [n=2] TRUE, TRUE
[15:32:32.931] - queued futures: [n=2] TRUE, TRUE
[15:32:32.931] signalConditionsASAP(NULL, pos=0) ... done
[15:32:32.931] resolve() on list ... DONE
[15:32:32.932] result() for ClusterFuture ...
[15:32:32.932] - result already collected: FutureResult
[15:32:32.932] result() for ClusterFuture ... done
[15:32:32.932] result() for ClusterFuture ...
[15:32:32.933] - result already collected: FutureResult
[15:32:32.933] result() for ClusterFuture ... done
[15:32:32.933] result() for ClusterFuture ...
[15:32:32.934] - result already collected: FutureResult
[15:32:32.934] result() for ClusterFuture ... done
[15:32:32.934] result() for ClusterFuture ...
[15:32:32.934] - result already collected: FutureResult
[15:32:32.935] result() for ClusterFuture ... done
[15:32:32.935]  - Number of value chunks collected: 2
[15:32:32.935] Resolving 2 futures (chunks) ... DONE
[15:32:32.936] Reducing values from 2 chunks ...
[15:32:32.936]  - Number of values collected after concatenation: 6
[15:32:32.936]  - Number of values expected: 6
[15:32:32.936] Reducing values from 2 chunks ... DONE
[15:32:32.937] future_lapply() ... DONE
List of 2
 $ y0: num [1:3, 1:5, 1:6] 2 2 2 4 4 4 6 6 6 8 ...
  ..- attr(*, "dimnames")=List of 3
  .. ..$ : NULL
  .. ..$ : NULL
  .. ..$ : chr [1:6] "a1" "a2" "b1" "b2" ...
 $ y1: num [1:3, 1:5, 1:6] 2 2 2 4 4 4 6 6 6 8 ...
  ..- attr(*, "dimnames")=List of 3
  .. ..$ : NULL
  .. ..$ : NULL
  .. ..$ : chr [1:6] "a1" "a2" "b1" "b2" ...
[15:32:32.943] future_lapply() ...
[15:32:32.948] Number of chunks: 2
[15:32:32.948] getGlobalsAndPackagesXApply() ...
[15:32:32.949]  - future.globals: TRUE
[15:32:32.949] getGlobalsAndPackages() ...
[15:32:32.949] Searching for globals...
[15:32:32.951] - globals found: [1] 'FUN'
[15:32:32.951] Searching for globals ... DONE
[15:32:32.952] Resolving globals: FALSE
[15:32:32.952] The total size of the 1 globals is 848 bytes (848 bytes)
[15:32:32.953] The total size of the 1 globals exported for future expression ('FUN()') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:32:32.953] - globals: [1] 'FUN'
[15:32:32.954] 
[15:32:32.954] getGlobalsAndPackages() ... DONE
[15:32:32.954]  - globals found/used: [n=1] 'FUN'
[15:32:32.955]  - needed namespaces: [n=0] 
[15:32:32.955] Finding globals ... DONE
[15:32:32.955]  - use_args: TRUE
[15:32:32.955]  - Getting '...' globals ...
[15:32:32.956] resolve() on list ...
[15:32:32.956]  recursive: 0
[15:32:32.957]  length: 1
[15:32:32.957]  elements: '...'
[15:32:32.957]  length: 0 (resolved future 1)
[15:32:32.958] resolve() on list ... DONE
[15:32:32.958]    - '...' content: [n=0] 
[15:32:32.958] List of 1
[15:32:32.958]  $ ...: list()
[15:32:32.958]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:32.958]  - attr(*, "where")=List of 1
[15:32:32.958]   ..$ ...:<environment: 0x00000276e0aa7b50> 
[15:32:32.958]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:32.958]  - attr(*, "resolved")= logi TRUE
[15:32:32.958]  - attr(*, "total_size")= num NA
[15:32:32.963]  - Getting '...' globals ... DONE
[15:32:32.964] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:32.964] List of 2
[15:32:32.964]  $ ...future.FUN:function (x)  
[15:32:32.964]  $ ...          : list()
[15:32:32.964]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:32.964]  - attr(*, "where")=List of 2
[15:32:32.964]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:32.964]   ..$ ...          :<environment: 0x00000276e0aa7b50> 
[15:32:32.964]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:32.964]  - attr(*, "resolved")= logi FALSE
[15:32:32.964]  - attr(*, "total_size")= num 848
[15:32:32.969] Packages to be attached in all futures: [n=0] 
[15:32:32.970] getGlobalsAndPackagesXApply() ... DONE
[15:32:32.970] Number of futures (= number of chunks): 2
[15:32:32.971] Launching 2 futures (chunks) ...
[15:32:32.971] Chunk #1 of 2 ...
[15:32:32.971]  - Finding globals in 'X' for chunk #1 ...
[15:32:32.971] getGlobalsAndPackages() ...
[15:32:32.972] Searching for globals...
[15:32:32.972] 
[15:32:32.973] Searching for globals ... DONE
[15:32:32.973] - globals: [0] <none>
[15:32:32.973] getGlobalsAndPackages() ... DONE
[15:32:32.973]    + additional globals found: [n=0] 
[15:32:32.974]    + additional namespaces needed: [n=0] 
[15:32:32.974]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:32.974]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:32.975]  - seeds: <none>
[15:32:32.975]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:32.975] getGlobalsAndPackages() ...
[15:32:32.975] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:32.976] Resolving globals: FALSE
[15:32:32.976] Tweak future expression to call with '...' arguments ...
[15:32:32.976] {
[15:32:32.976]     do.call(function(...) {
[15:32:32.976]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:32.976]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:32.976]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:32.976]             on.exit(options(oopts), add = TRUE)
[15:32:32.976]         }
[15:32:32.976]         {
[15:32:32.976]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:32.976]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:32.976]                 ...future.FUN(...future.X_jj, ...)
[15:32:32.976]             })
[15:32:32.976]         }
[15:32:32.976]     }, args = future.call.arguments)
[15:32:32.976] }
[15:32:32.977] Tweak future expression to call with '...' arguments ... DONE
[15:32:32.978] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:32.978] 
[15:32:32.979] getGlobalsAndPackages() ... DONE
[15:32:32.979] run() for 'Future' ...
[15:32:32.979] - state: 'created'
[15:32:32.980] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:32.999] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:33.000] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:33.000]   - Field: 'node'
[15:32:33.000]   - Field: 'label'
[15:32:33.001]   - Field: 'local'
[15:32:33.001]   - Field: 'owner'
[15:32:33.001]   - Field: 'envir'
[15:32:33.002]   - Field: 'workers'
[15:32:33.002]   - Field: 'packages'
[15:32:33.002]   - Field: 'gc'
[15:32:33.002]   - Field: 'conditions'
[15:32:33.003]   - Field: 'persistent'
[15:32:33.003]   - Field: 'expr'
[15:32:33.003]   - Field: 'uuid'
[15:32:33.004]   - Field: 'seed'
[15:32:33.004]   - Field: 'version'
[15:32:33.004]   - Field: 'result'
[15:32:33.005]   - Field: 'asynchronous'
[15:32:33.005]   - Field: 'calls'
[15:32:33.005]   - Field: 'globals'
[15:32:33.006]   - Field: 'stdout'
[15:32:33.006]   - Field: 'earlySignal'
[15:32:33.006]   - Field: 'lazy'
[15:32:33.007]   - Field: 'state'
[15:32:33.007] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:33.007] - Launch lazy future ...
[15:32:33.008] Packages needed by the future expression (n = 0): <none>
[15:32:33.008] Packages needed by future strategies (n = 0): <none>
[15:32:33.009] {
[15:32:33.009]     {
[15:32:33.009]         {
[15:32:33.009]             ...future.startTime <- base::Sys.time()
[15:32:33.009]             {
[15:32:33.009]                 {
[15:32:33.009]                   {
[15:32:33.009]                     {
[15:32:33.009]                       base::local({
[15:32:33.009]                         has_future <- base::requireNamespace("future", 
[15:32:33.009]                           quietly = TRUE)
[15:32:33.009]                         if (has_future) {
[15:32:33.009]                           ns <- base::getNamespace("future")
[15:32:33.009]                           version <- ns[[".package"]][["version"]]
[15:32:33.009]                           if (is.null(version)) 
[15:32:33.009]                             version <- utils::packageVersion("future")
[15:32:33.009]                         }
[15:32:33.009]                         else {
[15:32:33.009]                           version <- NULL
[15:32:33.009]                         }
[15:32:33.009]                         if (!has_future || version < "1.8.0") {
[15:32:33.009]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:33.009]                             "", base::R.version$version.string), 
[15:32:33.009]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:33.009]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:33.009]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:33.009]                               "release", "version")], collapse = " "), 
[15:32:33.009]                             hostname = base::Sys.info()[["nodename"]])
[15:32:33.009]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:33.009]                             info)
[15:32:33.009]                           info <- base::paste(info, collapse = "; ")
[15:32:33.009]                           if (!has_future) {
[15:32:33.009]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:33.009]                               info)
[15:32:33.009]                           }
[15:32:33.009]                           else {
[15:32:33.009]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:33.009]                               info, version)
[15:32:33.009]                           }
[15:32:33.009]                           base::stop(msg)
[15:32:33.009]                         }
[15:32:33.009]                       })
[15:32:33.009]                     }
[15:32:33.009]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:33.009]                     base::options(mc.cores = 1L)
[15:32:33.009]                   }
[15:32:33.009]                   ...future.strategy.old <- future::plan("list")
[15:32:33.009]                   options(future.plan = NULL)
[15:32:33.009]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:33.009]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:33.009]                 }
[15:32:33.009]                 ...future.workdir <- getwd()
[15:32:33.009]             }
[15:32:33.009]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:33.009]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:33.009]         }
[15:32:33.009]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:33.009]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:33.009]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:33.009]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:33.009]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:33.009]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:33.009]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:33.009]             base::names(...future.oldOptions))
[15:32:33.009]     }
[15:32:33.009]     if (FALSE) {
[15:32:33.009]     }
[15:32:33.009]     else {
[15:32:33.009]         if (TRUE) {
[15:32:33.009]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:33.009]                 open = "w")
[15:32:33.009]         }
[15:32:33.009]         else {
[15:32:33.009]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:33.009]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:33.009]         }
[15:32:33.009]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:33.009]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:33.009]             base::sink(type = "output", split = FALSE)
[15:32:33.009]             base::close(...future.stdout)
[15:32:33.009]         }, add = TRUE)
[15:32:33.009]     }
[15:32:33.009]     ...future.frame <- base::sys.nframe()
[15:32:33.009]     ...future.conditions <- base::list()
[15:32:33.009]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:33.009]     if (FALSE) {
[15:32:33.009]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:33.009]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:33.009]     }
[15:32:33.009]     ...future.result <- base::tryCatch({
[15:32:33.009]         base::withCallingHandlers({
[15:32:33.009]             ...future.value <- base::withVisible(base::local({
[15:32:33.009]                 ...future.makeSendCondition <- base::local({
[15:32:33.009]                   sendCondition <- NULL
[15:32:33.009]                   function(frame = 1L) {
[15:32:33.009]                     if (is.function(sendCondition)) 
[15:32:33.009]                       return(sendCondition)
[15:32:33.009]                     ns <- getNamespace("parallel")
[15:32:33.009]                     if (exists("sendData", mode = "function", 
[15:32:33.009]                       envir = ns)) {
[15:32:33.009]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:33.009]                         envir = ns)
[15:32:33.009]                       envir <- sys.frame(frame)
[15:32:33.009]                       master <- NULL
[15:32:33.009]                       while (!identical(envir, .GlobalEnv) && 
[15:32:33.009]                         !identical(envir, emptyenv())) {
[15:32:33.009]                         if (exists("master", mode = "list", envir = envir, 
[15:32:33.009]                           inherits = FALSE)) {
[15:32:33.009]                           master <- get("master", mode = "list", 
[15:32:33.009]                             envir = envir, inherits = FALSE)
[15:32:33.009]                           if (inherits(master, c("SOCKnode", 
[15:32:33.009]                             "SOCK0node"))) {
[15:32:33.009]                             sendCondition <<- function(cond) {
[15:32:33.009]                               data <- list(type = "VALUE", value = cond, 
[15:32:33.009]                                 success = TRUE)
[15:32:33.009]                               parallel_sendData(master, data)
[15:32:33.009]                             }
[15:32:33.009]                             return(sendCondition)
[15:32:33.009]                           }
[15:32:33.009]                         }
[15:32:33.009]                         frame <- frame + 1L
[15:32:33.009]                         envir <- sys.frame(frame)
[15:32:33.009]                       }
[15:32:33.009]                     }
[15:32:33.009]                     sendCondition <<- function(cond) NULL
[15:32:33.009]                   }
[15:32:33.009]                 })
[15:32:33.009]                 withCallingHandlers({
[15:32:33.009]                   {
[15:32:33.009]                     do.call(function(...) {
[15:32:33.009]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:33.009]                       if (!identical(...future.globals.maxSize.org, 
[15:32:33.009]                         ...future.globals.maxSize)) {
[15:32:33.009]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:33.009]                         on.exit(options(oopts), add = TRUE)
[15:32:33.009]                       }
[15:32:33.009]                       {
[15:32:33.009]                         lapply(seq_along(...future.elements_ii), 
[15:32:33.009]                           FUN = function(jj) {
[15:32:33.009]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:33.009]                             ...future.FUN(...future.X_jj, ...)
[15:32:33.009]                           })
[15:32:33.009]                       }
[15:32:33.009]                     }, args = future.call.arguments)
[15:32:33.009]                   }
[15:32:33.009]                 }, immediateCondition = function(cond) {
[15:32:33.009]                   sendCondition <- ...future.makeSendCondition()
[15:32:33.009]                   sendCondition(cond)
[15:32:33.009]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:33.009]                   {
[15:32:33.009]                     inherits <- base::inherits
[15:32:33.009]                     invokeRestart <- base::invokeRestart
[15:32:33.009]                     is.null <- base::is.null
[15:32:33.009]                     muffled <- FALSE
[15:32:33.009]                     if (inherits(cond, "message")) {
[15:32:33.009]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:33.009]                       if (muffled) 
[15:32:33.009]                         invokeRestart("muffleMessage")
[15:32:33.009]                     }
[15:32:33.009]                     else if (inherits(cond, "warning")) {
[15:32:33.009]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:33.009]                       if (muffled) 
[15:32:33.009]                         invokeRestart("muffleWarning")
[15:32:33.009]                     }
[15:32:33.009]                     else if (inherits(cond, "condition")) {
[15:32:33.009]                       if (!is.null(pattern)) {
[15:32:33.009]                         computeRestarts <- base::computeRestarts
[15:32:33.009]                         grepl <- base::grepl
[15:32:33.009]                         restarts <- computeRestarts(cond)
[15:32:33.009]                         for (restart in restarts) {
[15:32:33.009]                           name <- restart$name
[15:32:33.009]                           if (is.null(name)) 
[15:32:33.009]                             next
[15:32:33.009]                           if (!grepl(pattern, name)) 
[15:32:33.009]                             next
[15:32:33.009]                           invokeRestart(restart)
[15:32:33.009]                           muffled <- TRUE
[15:32:33.009]                           break
[15:32:33.009]                         }
[15:32:33.009]                       }
[15:32:33.009]                     }
[15:32:33.009]                     invisible(muffled)
[15:32:33.009]                   }
[15:32:33.009]                   muffleCondition(cond)
[15:32:33.009]                 })
[15:32:33.009]             }))
[15:32:33.009]             future::FutureResult(value = ...future.value$value, 
[15:32:33.009]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:33.009]                   ...future.rng), globalenv = if (FALSE) 
[15:32:33.009]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:33.009]                     ...future.globalenv.names))
[15:32:33.009]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:33.009]         }, condition = base::local({
[15:32:33.009]             c <- base::c
[15:32:33.009]             inherits <- base::inherits
[15:32:33.009]             invokeRestart <- base::invokeRestart
[15:32:33.009]             length <- base::length
[15:32:33.009]             list <- base::list
[15:32:33.009]             seq.int <- base::seq.int
[15:32:33.009]             signalCondition <- base::signalCondition
[15:32:33.009]             sys.calls <- base::sys.calls
[15:32:33.009]             `[[` <- base::`[[`
[15:32:33.009]             `+` <- base::`+`
[15:32:33.009]             `<<-` <- base::`<<-`
[15:32:33.009]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:33.009]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:33.009]                   3L)]
[15:32:33.009]             }
[15:32:33.009]             function(cond) {
[15:32:33.009]                 is_error <- inherits(cond, "error")
[15:32:33.009]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:33.009]                   NULL)
[15:32:33.009]                 if (is_error) {
[15:32:33.009]                   sessionInformation <- function() {
[15:32:33.009]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:33.009]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:33.009]                       search = base::search(), system = base::Sys.info())
[15:32:33.009]                   }
[15:32:33.009]                   ...future.conditions[[length(...future.conditions) + 
[15:32:33.009]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:33.009]                     cond$call), session = sessionInformation(), 
[15:32:33.009]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:33.009]                   signalCondition(cond)
[15:32:33.009]                 }
[15:32:33.009]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:33.009]                 "immediateCondition"))) {
[15:32:33.009]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:33.009]                   ...future.conditions[[length(...future.conditions) + 
[15:32:33.009]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:33.009]                   if (TRUE && !signal) {
[15:32:33.009]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:33.009]                     {
[15:32:33.009]                       inherits <- base::inherits
[15:32:33.009]                       invokeRestart <- base::invokeRestart
[15:32:33.009]                       is.null <- base::is.null
[15:32:33.009]                       muffled <- FALSE
[15:32:33.009]                       if (inherits(cond, "message")) {
[15:32:33.009]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:33.009]                         if (muffled) 
[15:32:33.009]                           invokeRestart("muffleMessage")
[15:32:33.009]                       }
[15:32:33.009]                       else if (inherits(cond, "warning")) {
[15:32:33.009]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:33.009]                         if (muffled) 
[15:32:33.009]                           invokeRestart("muffleWarning")
[15:32:33.009]                       }
[15:32:33.009]                       else if (inherits(cond, "condition")) {
[15:32:33.009]                         if (!is.null(pattern)) {
[15:32:33.009]                           computeRestarts <- base::computeRestarts
[15:32:33.009]                           grepl <- base::grepl
[15:32:33.009]                           restarts <- computeRestarts(cond)
[15:32:33.009]                           for (restart in restarts) {
[15:32:33.009]                             name <- restart$name
[15:32:33.009]                             if (is.null(name)) 
[15:32:33.009]                               next
[15:32:33.009]                             if (!grepl(pattern, name)) 
[15:32:33.009]                               next
[15:32:33.009]                             invokeRestart(restart)
[15:32:33.009]                             muffled <- TRUE
[15:32:33.009]                             break
[15:32:33.009]                           }
[15:32:33.009]                         }
[15:32:33.009]                       }
[15:32:33.009]                       invisible(muffled)
[15:32:33.009]                     }
[15:32:33.009]                     muffleCondition(cond, pattern = "^muffle")
[15:32:33.009]                   }
[15:32:33.009]                 }
[15:32:33.009]                 else {
[15:32:33.009]                   if (TRUE) {
[15:32:33.009]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:33.009]                     {
[15:32:33.009]                       inherits <- base::inherits
[15:32:33.009]                       invokeRestart <- base::invokeRestart
[15:32:33.009]                       is.null <- base::is.null
[15:32:33.009]                       muffled <- FALSE
[15:32:33.009]                       if (inherits(cond, "message")) {
[15:32:33.009]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:33.009]                         if (muffled) 
[15:32:33.009]                           invokeRestart("muffleMessage")
[15:32:33.009]                       }
[15:32:33.009]                       else if (inherits(cond, "warning")) {
[15:32:33.009]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:33.009]                         if (muffled) 
[15:32:33.009]                           invokeRestart("muffleWarning")
[15:32:33.009]                       }
[15:32:33.009]                       else if (inherits(cond, "condition")) {
[15:32:33.009]                         if (!is.null(pattern)) {
[15:32:33.009]                           computeRestarts <- base::computeRestarts
[15:32:33.009]                           grepl <- base::grepl
[15:32:33.009]                           restarts <- computeRestarts(cond)
[15:32:33.009]                           for (restart in restarts) {
[15:32:33.009]                             name <- restart$name
[15:32:33.009]                             if (is.null(name)) 
[15:32:33.009]                               next
[15:32:33.009]                             if (!grepl(pattern, name)) 
[15:32:33.009]                               next
[15:32:33.009]                             invokeRestart(restart)
[15:32:33.009]                             muffled <- TRUE
[15:32:33.009]                             break
[15:32:33.009]                           }
[15:32:33.009]                         }
[15:32:33.009]                       }
[15:32:33.009]                       invisible(muffled)
[15:32:33.009]                     }
[15:32:33.009]                     muffleCondition(cond, pattern = "^muffle")
[15:32:33.009]                   }
[15:32:33.009]                 }
[15:32:33.009]             }
[15:32:33.009]         }))
[15:32:33.009]     }, error = function(ex) {
[15:32:33.009]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:33.009]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:33.009]                 ...future.rng), started = ...future.startTime, 
[15:32:33.009]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:33.009]             version = "1.8"), class = "FutureResult")
[15:32:33.009]     }, finally = {
[15:32:33.009]         if (!identical(...future.workdir, getwd())) 
[15:32:33.009]             setwd(...future.workdir)
[15:32:33.009]         {
[15:32:33.009]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:33.009]                 ...future.oldOptions$nwarnings <- NULL
[15:32:33.009]             }
[15:32:33.009]             base::options(...future.oldOptions)
[15:32:33.009]             if (.Platform$OS.type == "windows") {
[15:32:33.009]                 old_names <- names(...future.oldEnvVars)
[15:32:33.009]                 envs <- base::Sys.getenv()
[15:32:33.009]                 names <- names(envs)
[15:32:33.009]                 common <- intersect(names, old_names)
[15:32:33.009]                 added <- setdiff(names, old_names)
[15:32:33.009]                 removed <- setdiff(old_names, names)
[15:32:33.009]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:33.009]                   envs[common]]
[15:32:33.009]                 NAMES <- toupper(changed)
[15:32:33.009]                 args <- list()
[15:32:33.009]                 for (kk in seq_along(NAMES)) {
[15:32:33.009]                   name <- changed[[kk]]
[15:32:33.009]                   NAME <- NAMES[[kk]]
[15:32:33.009]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:33.009]                     next
[15:32:33.009]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:33.009]                 }
[15:32:33.009]                 NAMES <- toupper(added)
[15:32:33.009]                 for (kk in seq_along(NAMES)) {
[15:32:33.009]                   name <- added[[kk]]
[15:32:33.009]                   NAME <- NAMES[[kk]]
[15:32:33.009]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:33.009]                     next
[15:32:33.009]                   args[[name]] <- ""
[15:32:33.009]                 }
[15:32:33.009]                 NAMES <- toupper(removed)
[15:32:33.009]                 for (kk in seq_along(NAMES)) {
[15:32:33.009]                   name <- removed[[kk]]
[15:32:33.009]                   NAME <- NAMES[[kk]]
[15:32:33.009]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:33.009]                     next
[15:32:33.009]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:33.009]                 }
[15:32:33.009]                 if (length(args) > 0) 
[15:32:33.009]                   base::do.call(base::Sys.setenv, args = args)
[15:32:33.009]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:33.009]             }
[15:32:33.009]             else {
[15:32:33.009]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:33.009]             }
[15:32:33.009]             {
[15:32:33.009]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:33.009]                   0L) {
[15:32:33.009]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:33.009]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:33.009]                   base::options(opts)
[15:32:33.009]                 }
[15:32:33.009]                 {
[15:32:33.009]                   {
[15:32:33.009]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:33.009]                     NULL
[15:32:33.009]                   }
[15:32:33.009]                   options(future.plan = NULL)
[15:32:33.009]                   if (is.na(NA_character_)) 
[15:32:33.009]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:33.009]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:33.009]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:33.009]                     .init = FALSE)
[15:32:33.009]                 }
[15:32:33.009]             }
[15:32:33.009]         }
[15:32:33.009]     })
[15:32:33.009]     if (TRUE) {
[15:32:33.009]         base::sink(type = "output", split = FALSE)
[15:32:33.009]         if (TRUE) {
[15:32:33.009]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:33.009]         }
[15:32:33.009]         else {
[15:32:33.009]             ...future.result["stdout"] <- base::list(NULL)
[15:32:33.009]         }
[15:32:33.009]         base::close(...future.stdout)
[15:32:33.009]         ...future.stdout <- NULL
[15:32:33.009]     }
[15:32:33.009]     ...future.result$conditions <- ...future.conditions
[15:32:33.009]     ...future.result$finished <- base::Sys.time()
[15:32:33.009]     ...future.result
[15:32:33.009] }
[15:32:33.019] Exporting 5 global objects (848 bytes) to cluster node #1 ...
[15:32:33.020] Exporting '...future.FUN' (848 bytes) to cluster node #1 ...
[15:32:33.021] Exporting '...future.FUN' (848 bytes) to cluster node #1 ... DONE
[15:32:33.021] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:33.022] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:33.022] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ...
[15:32:33.023] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ... DONE
[15:32:33.023] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:33.024] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:33.024] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:33.025] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:33.025] Exporting 5 global objects (848 bytes) to cluster node #1 ... DONE
[15:32:33.026] MultisessionFuture started
[15:32:33.027] - Launch lazy future ... done
[15:32:33.027] run() for 'MultisessionFuture' ... done
[15:32:33.027] Created future:
[15:32:33.054] receiveMessageFromWorker() for ClusterFuture ...
[15:32:33.055] - Validating connection of MultisessionFuture
[15:32:33.056] - received message: FutureResult
[15:32:33.056] - Received FutureResult
[15:32:33.056] - Erased future from FutureRegistry
[15:32:33.057] result() for ClusterFuture ...
[15:32:33.057] - result already collected: FutureResult
[15:32:33.057] result() for ClusterFuture ... done
[15:32:33.057] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:33.028] MultisessionFuture:
[15:32:33.028] Label: 'future_sapply-1'
[15:32:33.028] Expression:
[15:32:33.028] {
[15:32:33.028]     do.call(function(...) {
[15:32:33.028]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:33.028]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:33.028]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:33.028]             on.exit(options(oopts), add = TRUE)
[15:32:33.028]         }
[15:32:33.028]         {
[15:32:33.028]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:33.028]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:33.028]                 ...future.FUN(...future.X_jj, ...)
[15:32:33.028]             })
[15:32:33.028]         }
[15:32:33.028]     }, args = future.call.arguments)
[15:32:33.028] }
[15:32:33.028] Lazy evaluation: FALSE
[15:32:33.028] Asynchronous evaluation: TRUE
[15:32:33.028] Local evaluation: TRUE
[15:32:33.028] Environment: R_GlobalEnv
[15:32:33.028] Capture standard output: TRUE
[15:32:33.028] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:33.028] Globals: 5 objects totaling 0.99 KiB (function '...future.FUN' of 848 bytes, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:33.028] Packages: <none>
[15:32:33.028] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:33.028] Resolved: TRUE
[15:32:33.028] Value: <not collected>
[15:32:33.028] Conditions captured: <none>
[15:32:33.028] Early signaling: FALSE
[15:32:33.028] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:33.028] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:33.058] Chunk #1 of 2 ... DONE
[15:32:33.058] Chunk #2 of 2 ...
[15:32:33.059]  - Finding globals in 'X' for chunk #2 ...
[15:32:33.059] getGlobalsAndPackages() ...
[15:32:33.059] Searching for globals...
[15:32:33.060] 
[15:32:33.060] Searching for globals ... DONE
[15:32:33.061] - globals: [0] <none>
[15:32:33.061] getGlobalsAndPackages() ... DONE
[15:32:33.061]    + additional globals found: [n=0] 
[15:32:33.061]    + additional namespaces needed: [n=0] 
[15:32:33.062]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:33.062]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:33.062]  - seeds: <none>
[15:32:33.063]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:33.063] getGlobalsAndPackages() ...
[15:32:33.063] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:33.064] Resolving globals: FALSE
[15:32:33.064] Tweak future expression to call with '...' arguments ...
[15:32:33.064] {
[15:32:33.064]     do.call(function(...) {
[15:32:33.064]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:33.064]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:33.064]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:33.064]             on.exit(options(oopts), add = TRUE)
[15:32:33.064]         }
[15:32:33.064]         {
[15:32:33.064]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:33.064]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:33.064]                 ...future.FUN(...future.X_jj, ...)
[15:32:33.064]             })
[15:32:33.064]         }
[15:32:33.064]     }, args = future.call.arguments)
[15:32:33.064] }
[15:32:33.065] Tweak future expression to call with '...' arguments ... DONE
[15:32:33.066] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:33.066] 
[15:32:33.066] getGlobalsAndPackages() ... DONE
[15:32:33.067] run() for 'Future' ...
[15:32:33.067] - state: 'created'
[15:32:33.068] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:33.088] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:33.088] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:33.088]   - Field: 'node'
[15:32:33.089]   - Field: 'label'
[15:32:33.089]   - Field: 'local'
[15:32:33.089]   - Field: 'owner'
[15:32:33.090]   - Field: 'envir'
[15:32:33.090]   - Field: 'workers'
[15:32:33.090]   - Field: 'packages'
[15:32:33.091]   - Field: 'gc'
[15:32:33.091]   - Field: 'conditions'
[15:32:33.091]   - Field: 'persistent'
[15:32:33.092]   - Field: 'expr'
[15:32:33.092]   - Field: 'uuid'
[15:32:33.092]   - Field: 'seed'
[15:32:33.093]   - Field: 'version'
[15:32:33.093]   - Field: 'result'
[15:32:33.093]   - Field: 'asynchronous'
[15:32:33.094]   - Field: 'calls'
[15:32:33.094]   - Field: 'globals'
[15:32:33.094]   - Field: 'stdout'
[15:32:33.095]   - Field: 'earlySignal'
[15:32:33.095]   - Field: 'lazy'
[15:32:33.095]   - Field: 'state'
[15:32:33.095] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:33.096] - Launch lazy future ...
[15:32:33.096] Packages needed by the future expression (n = 0): <none>
[15:32:33.097] Packages needed by future strategies (n = 0): <none>
[15:32:33.098] {
[15:32:33.098]     {
[15:32:33.098]         {
[15:32:33.098]             ...future.startTime <- base::Sys.time()
[15:32:33.098]             {
[15:32:33.098]                 {
[15:32:33.098]                   {
[15:32:33.098]                     {
[15:32:33.098]                       base::local({
[15:32:33.098]                         has_future <- base::requireNamespace("future", 
[15:32:33.098]                           quietly = TRUE)
[15:32:33.098]                         if (has_future) {
[15:32:33.098]                           ns <- base::getNamespace("future")
[15:32:33.098]                           version <- ns[[".package"]][["version"]]
[15:32:33.098]                           if (is.null(version)) 
[15:32:33.098]                             version <- utils::packageVersion("future")
[15:32:33.098]                         }
[15:32:33.098]                         else {
[15:32:33.098]                           version <- NULL
[15:32:33.098]                         }
[15:32:33.098]                         if (!has_future || version < "1.8.0") {
[15:32:33.098]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:33.098]                             "", base::R.version$version.string), 
[15:32:33.098]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:33.098]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:33.098]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:33.098]                               "release", "version")], collapse = " "), 
[15:32:33.098]                             hostname = base::Sys.info()[["nodename"]])
[15:32:33.098]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:33.098]                             info)
[15:32:33.098]                           info <- base::paste(info, collapse = "; ")
[15:32:33.098]                           if (!has_future) {
[15:32:33.098]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:33.098]                               info)
[15:32:33.098]                           }
[15:32:33.098]                           else {
[15:32:33.098]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:33.098]                               info, version)
[15:32:33.098]                           }
[15:32:33.098]                           base::stop(msg)
[15:32:33.098]                         }
[15:32:33.098]                       })
[15:32:33.098]                     }
[15:32:33.098]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:33.098]                     base::options(mc.cores = 1L)
[15:32:33.098]                   }
[15:32:33.098]                   ...future.strategy.old <- future::plan("list")
[15:32:33.098]                   options(future.plan = NULL)
[15:32:33.098]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:33.098]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:33.098]                 }
[15:32:33.098]                 ...future.workdir <- getwd()
[15:32:33.098]             }
[15:32:33.098]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:33.098]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:33.098]         }
[15:32:33.098]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:33.098]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:33.098]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:33.098]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:33.098]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:33.098]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:33.098]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:33.098]             base::names(...future.oldOptions))
[15:32:33.098]     }
[15:32:33.098]     if (FALSE) {
[15:32:33.098]     }
[15:32:33.098]     else {
[15:32:33.098]         if (TRUE) {
[15:32:33.098]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:33.098]                 open = "w")
[15:32:33.098]         }
[15:32:33.098]         else {
[15:32:33.098]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:33.098]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:33.098]         }
[15:32:33.098]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:33.098]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:33.098]             base::sink(type = "output", split = FALSE)
[15:32:33.098]             base::close(...future.stdout)
[15:32:33.098]         }, add = TRUE)
[15:32:33.098]     }
[15:32:33.098]     ...future.frame <- base::sys.nframe()
[15:32:33.098]     ...future.conditions <- base::list()
[15:32:33.098]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:33.098]     if (FALSE) {
[15:32:33.098]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:33.098]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:33.098]     }
[15:32:33.098]     ...future.result <- base::tryCatch({
[15:32:33.098]         base::withCallingHandlers({
[15:32:33.098]             ...future.value <- base::withVisible(base::local({
[15:32:33.098]                 ...future.makeSendCondition <- base::local({
[15:32:33.098]                   sendCondition <- NULL
[15:32:33.098]                   function(frame = 1L) {
[15:32:33.098]                     if (is.function(sendCondition)) 
[15:32:33.098]                       return(sendCondition)
[15:32:33.098]                     ns <- getNamespace("parallel")
[15:32:33.098]                     if (exists("sendData", mode = "function", 
[15:32:33.098]                       envir = ns)) {
[15:32:33.098]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:33.098]                         envir = ns)
[15:32:33.098]                       envir <- sys.frame(frame)
[15:32:33.098]                       master <- NULL
[15:32:33.098]                       while (!identical(envir, .GlobalEnv) && 
[15:32:33.098]                         !identical(envir, emptyenv())) {
[15:32:33.098]                         if (exists("master", mode = "list", envir = envir, 
[15:32:33.098]                           inherits = FALSE)) {
[15:32:33.098]                           master <- get("master", mode = "list", 
[15:32:33.098]                             envir = envir, inherits = FALSE)
[15:32:33.098]                           if (inherits(master, c("SOCKnode", 
[15:32:33.098]                             "SOCK0node"))) {
[15:32:33.098]                             sendCondition <<- function(cond) {
[15:32:33.098]                               data <- list(type = "VALUE", value = cond, 
[15:32:33.098]                                 success = TRUE)
[15:32:33.098]                               parallel_sendData(master, data)
[15:32:33.098]                             }
[15:32:33.098]                             return(sendCondition)
[15:32:33.098]                           }
[15:32:33.098]                         }
[15:32:33.098]                         frame <- frame + 1L
[15:32:33.098]                         envir <- sys.frame(frame)
[15:32:33.098]                       }
[15:32:33.098]                     }
[15:32:33.098]                     sendCondition <<- function(cond) NULL
[15:32:33.098]                   }
[15:32:33.098]                 })
[15:32:33.098]                 withCallingHandlers({
[15:32:33.098]                   {
[15:32:33.098]                     do.call(function(...) {
[15:32:33.098]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:33.098]                       if (!identical(...future.globals.maxSize.org, 
[15:32:33.098]                         ...future.globals.maxSize)) {
[15:32:33.098]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:33.098]                         on.exit(options(oopts), add = TRUE)
[15:32:33.098]                       }
[15:32:33.098]                       {
[15:32:33.098]                         lapply(seq_along(...future.elements_ii), 
[15:32:33.098]                           FUN = function(jj) {
[15:32:33.098]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:33.098]                             ...future.FUN(...future.X_jj, ...)
[15:32:33.098]                           })
[15:32:33.098]                       }
[15:32:33.098]                     }, args = future.call.arguments)
[15:32:33.098]                   }
[15:32:33.098]                 }, immediateCondition = function(cond) {
[15:32:33.098]                   sendCondition <- ...future.makeSendCondition()
[15:32:33.098]                   sendCondition(cond)
[15:32:33.098]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:33.098]                   {
[15:32:33.098]                     inherits <- base::inherits
[15:32:33.098]                     invokeRestart <- base::invokeRestart
[15:32:33.098]                     is.null <- base::is.null
[15:32:33.098]                     muffled <- FALSE
[15:32:33.098]                     if (inherits(cond, "message")) {
[15:32:33.098]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:33.098]                       if (muffled) 
[15:32:33.098]                         invokeRestart("muffleMessage")
[15:32:33.098]                     }
[15:32:33.098]                     else if (inherits(cond, "warning")) {
[15:32:33.098]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:33.098]                       if (muffled) 
[15:32:33.098]                         invokeRestart("muffleWarning")
[15:32:33.098]                     }
[15:32:33.098]                     else if (inherits(cond, "condition")) {
[15:32:33.098]                       if (!is.null(pattern)) {
[15:32:33.098]                         computeRestarts <- base::computeRestarts
[15:32:33.098]                         grepl <- base::grepl
[15:32:33.098]                         restarts <- computeRestarts(cond)
[15:32:33.098]                         for (restart in restarts) {
[15:32:33.098]                           name <- restart$name
[15:32:33.098]                           if (is.null(name)) 
[15:32:33.098]                             next
[15:32:33.098]                           if (!grepl(pattern, name)) 
[15:32:33.098]                             next
[15:32:33.098]                           invokeRestart(restart)
[15:32:33.098]                           muffled <- TRUE
[15:32:33.098]                           break
[15:32:33.098]                         }
[15:32:33.098]                       }
[15:32:33.098]                     }
[15:32:33.098]                     invisible(muffled)
[15:32:33.098]                   }
[15:32:33.098]                   muffleCondition(cond)
[15:32:33.098]                 })
[15:32:33.098]             }))
[15:32:33.098]             future::FutureResult(value = ...future.value$value, 
[15:32:33.098]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:33.098]                   ...future.rng), globalenv = if (FALSE) 
[15:32:33.098]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:33.098]                     ...future.globalenv.names))
[15:32:33.098]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:33.098]         }, condition = base::local({
[15:32:33.098]             c <- base::c
[15:32:33.098]             inherits <- base::inherits
[15:32:33.098]             invokeRestart <- base::invokeRestart
[15:32:33.098]             length <- base::length
[15:32:33.098]             list <- base::list
[15:32:33.098]             seq.int <- base::seq.int
[15:32:33.098]             signalCondition <- base::signalCondition
[15:32:33.098]             sys.calls <- base::sys.calls
[15:32:33.098]             `[[` <- base::`[[`
[15:32:33.098]             `+` <- base::`+`
[15:32:33.098]             `<<-` <- base::`<<-`
[15:32:33.098]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:33.098]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:33.098]                   3L)]
[15:32:33.098]             }
[15:32:33.098]             function(cond) {
[15:32:33.098]                 is_error <- inherits(cond, "error")
[15:32:33.098]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:33.098]                   NULL)
[15:32:33.098]                 if (is_error) {
[15:32:33.098]                   sessionInformation <- function() {
[15:32:33.098]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:33.098]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:33.098]                       search = base::search(), system = base::Sys.info())
[15:32:33.098]                   }
[15:32:33.098]                   ...future.conditions[[length(...future.conditions) + 
[15:32:33.098]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:33.098]                     cond$call), session = sessionInformation(), 
[15:32:33.098]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:33.098]                   signalCondition(cond)
[15:32:33.098]                 }
[15:32:33.098]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:33.098]                 "immediateCondition"))) {
[15:32:33.098]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:33.098]                   ...future.conditions[[length(...future.conditions) + 
[15:32:33.098]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:33.098]                   if (TRUE && !signal) {
[15:32:33.098]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:33.098]                     {
[15:32:33.098]                       inherits <- base::inherits
[15:32:33.098]                       invokeRestart <- base::invokeRestart
[15:32:33.098]                       is.null <- base::is.null
[15:32:33.098]                       muffled <- FALSE
[15:32:33.098]                       if (inherits(cond, "message")) {
[15:32:33.098]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:33.098]                         if (muffled) 
[15:32:33.098]                           invokeRestart("muffleMessage")
[15:32:33.098]                       }
[15:32:33.098]                       else if (inherits(cond, "warning")) {
[15:32:33.098]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:33.098]                         if (muffled) 
[15:32:33.098]                           invokeRestart("muffleWarning")
[15:32:33.098]                       }
[15:32:33.098]                       else if (inherits(cond, "condition")) {
[15:32:33.098]                         if (!is.null(pattern)) {
[15:32:33.098]                           computeRestarts <- base::computeRestarts
[15:32:33.098]                           grepl <- base::grepl
[15:32:33.098]                           restarts <- computeRestarts(cond)
[15:32:33.098]                           for (restart in restarts) {
[15:32:33.098]                             name <- restart$name
[15:32:33.098]                             if (is.null(name)) 
[15:32:33.098]                               next
[15:32:33.098]                             if (!grepl(pattern, name)) 
[15:32:33.098]                               next
[15:32:33.098]                             invokeRestart(restart)
[15:32:33.098]                             muffled <- TRUE
[15:32:33.098]                             break
[15:32:33.098]                           }
[15:32:33.098]                         }
[15:32:33.098]                       }
[15:32:33.098]                       invisible(muffled)
[15:32:33.098]                     }
[15:32:33.098]                     muffleCondition(cond, pattern = "^muffle")
[15:32:33.098]                   }
[15:32:33.098]                 }
[15:32:33.098]                 else {
[15:32:33.098]                   if (TRUE) {
[15:32:33.098]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:33.098]                     {
[15:32:33.098]                       inherits <- base::inherits
[15:32:33.098]                       invokeRestart <- base::invokeRestart
[15:32:33.098]                       is.null <- base::is.null
[15:32:33.098]                       muffled <- FALSE
[15:32:33.098]                       if (inherits(cond, "message")) {
[15:32:33.098]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:33.098]                         if (muffled) 
[15:32:33.098]                           invokeRestart("muffleMessage")
[15:32:33.098]                       }
[15:32:33.098]                       else if (inherits(cond, "warning")) {
[15:32:33.098]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:33.098]                         if (muffled) 
[15:32:33.098]                           invokeRestart("muffleWarning")
[15:32:33.098]                       }
[15:32:33.098]                       else if (inherits(cond, "condition")) {
[15:32:33.098]                         if (!is.null(pattern)) {
[15:32:33.098]                           computeRestarts <- base::computeRestarts
[15:32:33.098]                           grepl <- base::grepl
[15:32:33.098]                           restarts <- computeRestarts(cond)
[15:32:33.098]                           for (restart in restarts) {
[15:32:33.098]                             name <- restart$name
[15:32:33.098]                             if (is.null(name)) 
[15:32:33.098]                               next
[15:32:33.098]                             if (!grepl(pattern, name)) 
[15:32:33.098]                               next
[15:32:33.098]                             invokeRestart(restart)
[15:32:33.098]                             muffled <- TRUE
[15:32:33.098]                             break
[15:32:33.098]                           }
[15:32:33.098]                         }
[15:32:33.098]                       }
[15:32:33.098]                       invisible(muffled)
[15:32:33.098]                     }
[15:32:33.098]                     muffleCondition(cond, pattern = "^muffle")
[15:32:33.098]                   }
[15:32:33.098]                 }
[15:32:33.098]             }
[15:32:33.098]         }))
[15:32:33.098]     }, error = function(ex) {
[15:32:33.098]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:33.098]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:33.098]                 ...future.rng), started = ...future.startTime, 
[15:32:33.098]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:33.098]             version = "1.8"), class = "FutureResult")
[15:32:33.098]     }, finally = {
[15:32:33.098]         if (!identical(...future.workdir, getwd())) 
[15:32:33.098]             setwd(...future.workdir)
[15:32:33.098]         {
[15:32:33.098]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:33.098]                 ...future.oldOptions$nwarnings <- NULL
[15:32:33.098]             }
[15:32:33.098]             base::options(...future.oldOptions)
[15:32:33.098]             if (.Platform$OS.type == "windows") {
[15:32:33.098]                 old_names <- names(...future.oldEnvVars)
[15:32:33.098]                 envs <- base::Sys.getenv()
[15:32:33.098]                 names <- names(envs)
[15:32:33.098]                 common <- intersect(names, old_names)
[15:32:33.098]                 added <- setdiff(names, old_names)
[15:32:33.098]                 removed <- setdiff(old_names, names)
[15:32:33.098]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:33.098]                   envs[common]]
[15:32:33.098]                 NAMES <- toupper(changed)
[15:32:33.098]                 args <- list()
[15:32:33.098]                 for (kk in seq_along(NAMES)) {
[15:32:33.098]                   name <- changed[[kk]]
[15:32:33.098]                   NAME <- NAMES[[kk]]
[15:32:33.098]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:33.098]                     next
[15:32:33.098]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:33.098]                 }
[15:32:33.098]                 NAMES <- toupper(added)
[15:32:33.098]                 for (kk in seq_along(NAMES)) {
[15:32:33.098]                   name <- added[[kk]]
[15:32:33.098]                   NAME <- NAMES[[kk]]
[15:32:33.098]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:33.098]                     next
[15:32:33.098]                   args[[name]] <- ""
[15:32:33.098]                 }
[15:32:33.098]                 NAMES <- toupper(removed)
[15:32:33.098]                 for (kk in seq_along(NAMES)) {
[15:32:33.098]                   name <- removed[[kk]]
[15:32:33.098]                   NAME <- NAMES[[kk]]
[15:32:33.098]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:33.098]                     next
[15:32:33.098]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:33.098]                 }
[15:32:33.098]                 if (length(args) > 0) 
[15:32:33.098]                   base::do.call(base::Sys.setenv, args = args)
[15:32:33.098]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:33.098]             }
[15:32:33.098]             else {
[15:32:33.098]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:33.098]             }
[15:32:33.098]             {
[15:32:33.098]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:33.098]                   0L) {
[15:32:33.098]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:33.098]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:33.098]                   base::options(opts)
[15:32:33.098]                 }
[15:32:33.098]                 {
[15:32:33.098]                   {
[15:32:33.098]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:33.098]                     NULL
[15:32:33.098]                   }
[15:32:33.098]                   options(future.plan = NULL)
[15:32:33.098]                   if (is.na(NA_character_)) 
[15:32:33.098]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:33.098]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:33.098]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:33.098]                     .init = FALSE)
[15:32:33.098]                 }
[15:32:33.098]             }
[15:32:33.098]         }
[15:32:33.098]     })
[15:32:33.098]     if (TRUE) {
[15:32:33.098]         base::sink(type = "output", split = FALSE)
[15:32:33.098]         if (TRUE) {
[15:32:33.098]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:33.098]         }
[15:32:33.098]         else {
[15:32:33.098]             ...future.result["stdout"] <- base::list(NULL)
[15:32:33.098]         }
[15:32:33.098]         base::close(...future.stdout)
[15:32:33.098]         ...future.stdout <- NULL
[15:32:33.098]     }
[15:32:33.098]     ...future.result$conditions <- ...future.conditions
[15:32:33.098]     ...future.result$finished <- base::Sys.time()
[15:32:33.098]     ...future.result
[15:32:33.098] }
[15:32:33.108] Exporting 5 global objects (848 bytes) to cluster node #1 ...
[15:32:33.108] Exporting '...future.FUN' (848 bytes) to cluster node #1 ...
[15:32:33.109] Exporting '...future.FUN' (848 bytes) to cluster node #1 ... DONE
[15:32:33.109] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:33.110] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:33.110] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ...
[15:32:33.111] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ... DONE
[15:32:33.111] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:33.112] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:33.112] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:33.113] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:33.113] Exporting 5 global objects (848 bytes) to cluster node #1 ... DONE
[15:32:33.115] MultisessionFuture started
[15:32:33.115] - Launch lazy future ... done
[15:32:33.115] run() for 'MultisessionFuture' ... done
[15:32:33.116] Created future:
[15:32:33.134] receiveMessageFromWorker() for ClusterFuture ...
[15:32:33.134] - Validating connection of MultisessionFuture
[15:32:33.135] - received message: FutureResult
[15:32:33.135] - Received FutureResult
[15:32:33.135] - Erased future from FutureRegistry
[15:32:33.135] result() for ClusterFuture ...
[15:32:33.136] - result already collected: FutureResult
[15:32:33.136] result() for ClusterFuture ... done
[15:32:33.136] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:33.116] MultisessionFuture:
[15:32:33.116] Label: 'future_sapply-2'
[15:32:33.116] Expression:
[15:32:33.116] {
[15:32:33.116]     do.call(function(...) {
[15:32:33.116]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:33.116]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:33.116]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:33.116]             on.exit(options(oopts), add = TRUE)
[15:32:33.116]         }
[15:32:33.116]         {
[15:32:33.116]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:33.116]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:33.116]                 ...future.FUN(...future.X_jj, ...)
[15:32:33.116]             })
[15:32:33.116]         }
[15:32:33.116]     }, args = future.call.arguments)
[15:32:33.116] }
[15:32:33.116] Lazy evaluation: FALSE
[15:32:33.116] Asynchronous evaluation: TRUE
[15:32:33.116] Local evaluation: TRUE
[15:32:33.116] Environment: R_GlobalEnv
[15:32:33.116] Capture standard output: TRUE
[15:32:33.116] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:33.116] Globals: 5 objects totaling 0.99 KiB (function '...future.FUN' of 848 bytes, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:33.116] Packages: <none>
[15:32:33.116] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:33.116] Resolved: TRUE
[15:32:33.116] Value: <not collected>
[15:32:33.116] Conditions captured: <none>
[15:32:33.116] Early signaling: FALSE
[15:32:33.116] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:33.116] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:33.139] Chunk #2 of 2 ... DONE
[15:32:33.140] Launching 2 futures (chunks) ... DONE
[15:32:33.140] Resolving 2 futures (chunks) ...
[15:32:33.140] resolve() on list ...
[15:32:33.140]  recursive: 0
[15:32:33.140]  length: 2
[15:32:33.141] 
[15:32:33.141] Future #1
[15:32:33.141] result() for ClusterFuture ...
[15:32:33.141] - result already collected: FutureResult
[15:32:33.141] result() for ClusterFuture ... done
[15:32:33.142] result() for ClusterFuture ...
[15:32:33.142] - result already collected: FutureResult
[15:32:33.142] result() for ClusterFuture ... done
[15:32:33.142] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:33.143] - nx: 2
[15:32:33.143] - relay: TRUE
[15:32:33.143] - stdout: TRUE
[15:32:33.143] - signal: TRUE
[15:32:33.143] - resignal: FALSE
[15:32:33.144] - force: TRUE
[15:32:33.144] - relayed: [n=2] FALSE, FALSE
[15:32:33.144] - queued futures: [n=2] FALSE, FALSE
[15:32:33.144]  - until=1
[15:32:33.144]  - relaying element #1
[15:32:33.144] result() for ClusterFuture ...
[15:32:33.145] - result already collected: FutureResult
[15:32:33.145] result() for ClusterFuture ... done
[15:32:33.145] result() for ClusterFuture ...
[15:32:33.145] - result already collected: FutureResult
[15:32:33.145] result() for ClusterFuture ... done
[15:32:33.145] result() for ClusterFuture ...
[15:32:33.146] - result already collected: FutureResult
[15:32:33.146] result() for ClusterFuture ... done
[15:32:33.146] result() for ClusterFuture ...
[15:32:33.146] - result already collected: FutureResult
[15:32:33.146] result() for ClusterFuture ... done
[15:32:33.146] - relayed: [n=2] TRUE, FALSE
[15:32:33.147] - queued futures: [n=2] TRUE, FALSE
[15:32:33.147] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:33.147]  length: 1 (resolved future 1)
[15:32:33.147] Future #2
[15:32:33.147] result() for ClusterFuture ...
[15:32:33.148] - result already collected: FutureResult
[15:32:33.148] result() for ClusterFuture ... done
[15:32:33.148] result() for ClusterFuture ...
[15:32:33.148] - result already collected: FutureResult
[15:32:33.148] result() for ClusterFuture ... done
[15:32:33.148] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:33.149] - nx: 2
[15:32:33.149] - relay: TRUE
[15:32:33.149] - stdout: TRUE
[15:32:33.149] - signal: TRUE
[15:32:33.149] - resignal: FALSE
[15:32:33.149] - force: TRUE
[15:32:33.150] - relayed: [n=2] TRUE, FALSE
[15:32:33.150] - queued futures: [n=2] TRUE, FALSE
[15:32:33.150]  - until=2
[15:32:33.150]  - relaying element #2
[15:32:33.150] result() for ClusterFuture ...
[15:32:33.150] - result already collected: FutureResult
[15:32:33.151] result() for ClusterFuture ... done
[15:32:33.151] result() for ClusterFuture ...
[15:32:33.151] - result already collected: FutureResult
[15:32:33.151] result() for ClusterFuture ... done
[15:32:33.151] result() for ClusterFuture ...
[15:32:33.151] - result already collected: FutureResult
[15:32:33.152] result() for ClusterFuture ... done
[15:32:33.152] result() for ClusterFuture ...
[15:32:33.152] - result already collected: FutureResult
[15:32:33.152] result() for ClusterFuture ... done
[15:32:33.152] - relayed: [n=2] TRUE, TRUE
[15:32:33.152] - queued futures: [n=2] TRUE, TRUE
[15:32:33.153] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:33.153]  length: 0 (resolved future 2)
[15:32:33.153] Relaying remaining futures
[15:32:33.153] signalConditionsASAP(NULL, pos=0) ...
[15:32:33.153] - nx: 2
[15:32:33.153] - relay: TRUE
[15:32:33.154] - stdout: TRUE
[15:32:33.154] - signal: TRUE
[15:32:33.154] - resignal: FALSE
[15:32:33.154] - force: TRUE
[15:32:33.154] - relayed: [n=2] TRUE, TRUE
[15:32:33.154] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:33.155] - relayed: [n=2] TRUE, TRUE
[15:32:33.155] - queued futures: [n=2] TRUE, TRUE
[15:32:33.155] signalConditionsASAP(NULL, pos=0) ... done
[15:32:33.155] resolve() on list ... DONE
[15:32:33.155] result() for ClusterFuture ...
[15:32:33.155] - result already collected: FutureResult
[15:32:33.156] result() for ClusterFuture ... done
[15:32:33.156] result() for ClusterFuture ...
[15:32:33.156] - result already collected: FutureResult
[15:32:33.156] result() for ClusterFuture ... done
[15:32:33.156] result() for ClusterFuture ...
[15:32:33.156] - result already collected: FutureResult
[15:32:33.157] result() for ClusterFuture ... done
[15:32:33.157] result() for ClusterFuture ...
[15:32:33.157] - result already collected: FutureResult
[15:32:33.157] result() for ClusterFuture ... done
[15:32:33.157]  - Number of value chunks collected: 2
[15:32:33.157] Resolving 2 futures (chunks) ... DONE
[15:32:33.158] Reducing values from 2 chunks ...
[15:32:33.158]  - Number of values collected after concatenation: 6
[15:32:33.158]  - Number of values expected: 6
[15:32:33.158] Reducing values from 2 chunks ... DONE
[15:32:33.158] future_lapply() ... DONE
List of 2
 $ y0:List of 6
  ..$ a1: int 1
  ..$ a2: int 2
  ..$ b1: int 2
  ..$ b2: int 3
  ..$ c1: int 3
  ..$ c2: int 4
 $ y1:List of 6
  ..$ a1: int 1
  ..$ a2: int 2
  ..$ b1: int 2
  ..$ b2: int 3
  ..$ c1: int 3
  ..$ c2: int 4
List of 2
 $ y0:List of 6
  ..$ a1: int 1
  ..$ a2: int 2
  ..$ b1: int 2
  ..$ b2: int 3
  ..$ c1: int 3
  ..$ c2: int 4
 $ y2:List of 6
  ..$ a1: int 1
  ..$ a2: int 2
  ..$ b1: int 2
  ..$ b2: int 3
  ..$ c1: int 3
  ..$ c2: int 4
[15:32:33.170] future_lapply() ...
[15:32:33.173] Number of chunks: 2
[15:32:33.174] getGlobalsAndPackagesXApply() ...
[15:32:33.174]  - future.globals: TRUE
[15:32:33.174] getGlobalsAndPackages() ...
[15:32:33.175] Searching for globals...
[15:32:33.177] - globals found: [2] 'FUN', 'UseMethod'
[15:32:33.177] Searching for globals ... DONE
[15:32:33.177] Resolving globals: FALSE
[15:32:33.178] The total size of the 1 globals is 1.22 KiB (1248 bytes)
[15:32:33.179] The total size of the 1 globals exported for future expression ('FUN()') is 1.22 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.22 KiB of class 'function')
[15:32:33.179] - globals: [1] 'FUN'
[15:32:33.179] 
[15:32:33.180] getGlobalsAndPackages() ... DONE
[15:32:33.180]  - globals found/used: [n=1] 'FUN'
[15:32:33.180]  - needed namespaces: [n=0] 
[15:32:33.181] Finding globals ... DONE
[15:32:33.181]  - use_args: TRUE
[15:32:33.181]  - Getting '...' globals ...
[15:32:33.182] resolve() on list ...
[15:32:33.182]  recursive: 0
[15:32:33.182]  length: 1
[15:32:33.183]  elements: '...'
[15:32:33.183]  length: 0 (resolved future 1)
[15:32:33.183] resolve() on list ... DONE
[15:32:33.183]    - '...' content: [n=0] 
[15:32:33.184] List of 1
[15:32:33.184]  $ ...: list()
[15:32:33.184]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:33.184]  - attr(*, "where")=List of 1
[15:32:33.184]   ..$ ...:<environment: 0x00000276e0774530> 
[15:32:33.184]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:33.184]  - attr(*, "resolved")= logi TRUE
[15:32:33.184]  - attr(*, "total_size")= num NA
[15:32:33.188]  - Getting '...' globals ... DONE
[15:32:33.189] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:33.189] List of 2
[15:32:33.189]  $ ...future.FUN:function (x, ...)  
[15:32:33.189]  $ ...          : list()
[15:32:33.189]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:33.189]  - attr(*, "where")=List of 2
[15:32:33.189]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:33.189]   ..$ ...          :<environment: 0x00000276e0774530> 
[15:32:33.189]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:33.189]  - attr(*, "resolved")= logi FALSE
[15:32:33.189]  - attr(*, "total_size")= num 1248
[15:32:33.194] Packages to be attached in all futures: [n=0] 
[15:32:33.195] getGlobalsAndPackagesXApply() ... DONE
[15:32:33.195] Number of futures (= number of chunks): 2
[15:32:33.195] Launching 2 futures (chunks) ...
[15:32:33.196] Chunk #1 of 2 ...
[15:32:33.196]  - Finding globals in 'X' for chunk #1 ...
[15:32:33.196] getGlobalsAndPackages() ...
[15:32:33.197] Searching for globals...
[15:32:33.197] 
[15:32:33.197] Searching for globals ... DONE
[15:32:33.198] - globals: [0] <none>
[15:32:33.198] getGlobalsAndPackages() ... DONE
[15:32:33.198]    + additional globals found: [n=0] 
[15:32:33.199]    + additional namespaces needed: [n=0] 
[15:32:33.199]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:33.199]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:33.199]  - seeds: <none>
[15:32:33.200]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:33.200] getGlobalsAndPackages() ...
[15:32:33.200] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:33.201] Resolving globals: FALSE
[15:32:33.201] Tweak future expression to call with '...' arguments ...
[15:32:33.201] {
[15:32:33.201]     do.call(function(...) {
[15:32:33.201]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:33.201]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:33.201]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:33.201]             on.exit(options(oopts), add = TRUE)
[15:32:33.201]         }
[15:32:33.201]         {
[15:32:33.201]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:33.201]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:33.201]                 ...future.FUN(...future.X_jj, ...)
[15:32:33.201]             })
[15:32:33.201]         }
[15:32:33.201]     }, args = future.call.arguments)
[15:32:33.201] }
[15:32:33.202] Tweak future expression to call with '...' arguments ... DONE
[15:32:33.203] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:33.203] 
[15:32:33.203] getGlobalsAndPackages() ... DONE
[15:32:33.203] run() for 'Future' ...
[15:32:33.204] - state: 'created'
[15:32:33.204] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:33.220] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:33.220] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:33.221]   - Field: 'node'
[15:32:33.221]   - Field: 'label'
[15:32:33.221]   - Field: 'local'
[15:32:33.222]   - Field: 'owner'
[15:32:33.222]   - Field: 'envir'
[15:32:33.222]   - Field: 'workers'
[15:32:33.223]   - Field: 'packages'
[15:32:33.223]   - Field: 'gc'
[15:32:33.223]   - Field: 'conditions'
[15:32:33.223]   - Field: 'persistent'
[15:32:33.224]   - Field: 'expr'
[15:32:33.224]   - Field: 'uuid'
[15:32:33.224]   - Field: 'seed'
[15:32:33.225]   - Field: 'version'
[15:32:33.225]   - Field: 'result'
[15:32:33.225]   - Field: 'asynchronous'
[15:32:33.225]   - Field: 'calls'
[15:32:33.226]   - Field: 'globals'
[15:32:33.226]   - Field: 'stdout'
[15:32:33.226]   - Field: 'earlySignal'
[15:32:33.227]   - Field: 'lazy'
[15:32:33.227]   - Field: 'state'
[15:32:33.227] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:33.228] - Launch lazy future ...
[15:32:33.228] Packages needed by the future expression (n = 0): <none>
[15:32:33.229] Packages needed by future strategies (n = 0): <none>
[15:32:33.230] {
[15:32:33.230]     {
[15:32:33.230]         {
[15:32:33.230]             ...future.startTime <- base::Sys.time()
[15:32:33.230]             {
[15:32:33.230]                 {
[15:32:33.230]                   {
[15:32:33.230]                     {
[15:32:33.230]                       base::local({
[15:32:33.230]                         has_future <- base::requireNamespace("future", 
[15:32:33.230]                           quietly = TRUE)
[15:32:33.230]                         if (has_future) {
[15:32:33.230]                           ns <- base::getNamespace("future")
[15:32:33.230]                           version <- ns[[".package"]][["version"]]
[15:32:33.230]                           if (is.null(version)) 
[15:32:33.230]                             version <- utils::packageVersion("future")
[15:32:33.230]                         }
[15:32:33.230]                         else {
[15:32:33.230]                           version <- NULL
[15:32:33.230]                         }
[15:32:33.230]                         if (!has_future || version < "1.8.0") {
[15:32:33.230]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:33.230]                             "", base::R.version$version.string), 
[15:32:33.230]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:33.230]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:33.230]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:33.230]                               "release", "version")], collapse = " "), 
[15:32:33.230]                             hostname = base::Sys.info()[["nodename"]])
[15:32:33.230]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:33.230]                             info)
[15:32:33.230]                           info <- base::paste(info, collapse = "; ")
[15:32:33.230]                           if (!has_future) {
[15:32:33.230]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:33.230]                               info)
[15:32:33.230]                           }
[15:32:33.230]                           else {
[15:32:33.230]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:33.230]                               info, version)
[15:32:33.230]                           }
[15:32:33.230]                           base::stop(msg)
[15:32:33.230]                         }
[15:32:33.230]                       })
[15:32:33.230]                     }
[15:32:33.230]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:33.230]                     base::options(mc.cores = 1L)
[15:32:33.230]                   }
[15:32:33.230]                   ...future.strategy.old <- future::plan("list")
[15:32:33.230]                   options(future.plan = NULL)
[15:32:33.230]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:33.230]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:33.230]                 }
[15:32:33.230]                 ...future.workdir <- getwd()
[15:32:33.230]             }
[15:32:33.230]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:33.230]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:33.230]         }
[15:32:33.230]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:33.230]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:33.230]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:33.230]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:33.230]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:33.230]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:33.230]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:33.230]             base::names(...future.oldOptions))
[15:32:33.230]     }
[15:32:33.230]     if (FALSE) {
[15:32:33.230]     }
[15:32:33.230]     else {
[15:32:33.230]         if (TRUE) {
[15:32:33.230]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:33.230]                 open = "w")
[15:32:33.230]         }
[15:32:33.230]         else {
[15:32:33.230]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:33.230]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:33.230]         }
[15:32:33.230]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:33.230]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:33.230]             base::sink(type = "output", split = FALSE)
[15:32:33.230]             base::close(...future.stdout)
[15:32:33.230]         }, add = TRUE)
[15:32:33.230]     }
[15:32:33.230]     ...future.frame <- base::sys.nframe()
[15:32:33.230]     ...future.conditions <- base::list()
[15:32:33.230]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:33.230]     if (FALSE) {
[15:32:33.230]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:33.230]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:33.230]     }
[15:32:33.230]     ...future.result <- base::tryCatch({
[15:32:33.230]         base::withCallingHandlers({
[15:32:33.230]             ...future.value <- base::withVisible(base::local({
[15:32:33.230]                 ...future.makeSendCondition <- base::local({
[15:32:33.230]                   sendCondition <- NULL
[15:32:33.230]                   function(frame = 1L) {
[15:32:33.230]                     if (is.function(sendCondition)) 
[15:32:33.230]                       return(sendCondition)
[15:32:33.230]                     ns <- getNamespace("parallel")
[15:32:33.230]                     if (exists("sendData", mode = "function", 
[15:32:33.230]                       envir = ns)) {
[15:32:33.230]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:33.230]                         envir = ns)
[15:32:33.230]                       envir <- sys.frame(frame)
[15:32:33.230]                       master <- NULL
[15:32:33.230]                       while (!identical(envir, .GlobalEnv) && 
[15:32:33.230]                         !identical(envir, emptyenv())) {
[15:32:33.230]                         if (exists("master", mode = "list", envir = envir, 
[15:32:33.230]                           inherits = FALSE)) {
[15:32:33.230]                           master <- get("master", mode = "list", 
[15:32:33.230]                             envir = envir, inherits = FALSE)
[15:32:33.230]                           if (inherits(master, c("SOCKnode", 
[15:32:33.230]                             "SOCK0node"))) {
[15:32:33.230]                             sendCondition <<- function(cond) {
[15:32:33.230]                               data <- list(type = "VALUE", value = cond, 
[15:32:33.230]                                 success = TRUE)
[15:32:33.230]                               parallel_sendData(master, data)
[15:32:33.230]                             }
[15:32:33.230]                             return(sendCondition)
[15:32:33.230]                           }
[15:32:33.230]                         }
[15:32:33.230]                         frame <- frame + 1L
[15:32:33.230]                         envir <- sys.frame(frame)
[15:32:33.230]                       }
[15:32:33.230]                     }
[15:32:33.230]                     sendCondition <<- function(cond) NULL
[15:32:33.230]                   }
[15:32:33.230]                 })
[15:32:33.230]                 withCallingHandlers({
[15:32:33.230]                   {
[15:32:33.230]                     do.call(function(...) {
[15:32:33.230]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:33.230]                       if (!identical(...future.globals.maxSize.org, 
[15:32:33.230]                         ...future.globals.maxSize)) {
[15:32:33.230]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:33.230]                         on.exit(options(oopts), add = TRUE)
[15:32:33.230]                       }
[15:32:33.230]                       {
[15:32:33.230]                         lapply(seq_along(...future.elements_ii), 
[15:32:33.230]                           FUN = function(jj) {
[15:32:33.230]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:33.230]                             ...future.FUN(...future.X_jj, ...)
[15:32:33.230]                           })
[15:32:33.230]                       }
[15:32:33.230]                     }, args = future.call.arguments)
[15:32:33.230]                   }
[15:32:33.230]                 }, immediateCondition = function(cond) {
[15:32:33.230]                   sendCondition <- ...future.makeSendCondition()
[15:32:33.230]                   sendCondition(cond)
[15:32:33.230]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:33.230]                   {
[15:32:33.230]                     inherits <- base::inherits
[15:32:33.230]                     invokeRestart <- base::invokeRestart
[15:32:33.230]                     is.null <- base::is.null
[15:32:33.230]                     muffled <- FALSE
[15:32:33.230]                     if (inherits(cond, "message")) {
[15:32:33.230]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:33.230]                       if (muffled) 
[15:32:33.230]                         invokeRestart("muffleMessage")
[15:32:33.230]                     }
[15:32:33.230]                     else if (inherits(cond, "warning")) {
[15:32:33.230]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:33.230]                       if (muffled) 
[15:32:33.230]                         invokeRestart("muffleWarning")
[15:32:33.230]                     }
[15:32:33.230]                     else if (inherits(cond, "condition")) {
[15:32:33.230]                       if (!is.null(pattern)) {
[15:32:33.230]                         computeRestarts <- base::computeRestarts
[15:32:33.230]                         grepl <- base::grepl
[15:32:33.230]                         restarts <- computeRestarts(cond)
[15:32:33.230]                         for (restart in restarts) {
[15:32:33.230]                           name <- restart$name
[15:32:33.230]                           if (is.null(name)) 
[15:32:33.230]                             next
[15:32:33.230]                           if (!grepl(pattern, name)) 
[15:32:33.230]                             next
[15:32:33.230]                           invokeRestart(restart)
[15:32:33.230]                           muffled <- TRUE
[15:32:33.230]                           break
[15:32:33.230]                         }
[15:32:33.230]                       }
[15:32:33.230]                     }
[15:32:33.230]                     invisible(muffled)
[15:32:33.230]                   }
[15:32:33.230]                   muffleCondition(cond)
[15:32:33.230]                 })
[15:32:33.230]             }))
[15:32:33.230]             future::FutureResult(value = ...future.value$value, 
[15:32:33.230]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:33.230]                   ...future.rng), globalenv = if (FALSE) 
[15:32:33.230]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:33.230]                     ...future.globalenv.names))
[15:32:33.230]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:33.230]         }, condition = base::local({
[15:32:33.230]             c <- base::c
[15:32:33.230]             inherits <- base::inherits
[15:32:33.230]             invokeRestart <- base::invokeRestart
[15:32:33.230]             length <- base::length
[15:32:33.230]             list <- base::list
[15:32:33.230]             seq.int <- base::seq.int
[15:32:33.230]             signalCondition <- base::signalCondition
[15:32:33.230]             sys.calls <- base::sys.calls
[15:32:33.230]             `[[` <- base::`[[`
[15:32:33.230]             `+` <- base::`+`
[15:32:33.230]             `<<-` <- base::`<<-`
[15:32:33.230]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:33.230]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:33.230]                   3L)]
[15:32:33.230]             }
[15:32:33.230]             function(cond) {
[15:32:33.230]                 is_error <- inherits(cond, "error")
[15:32:33.230]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:33.230]                   NULL)
[15:32:33.230]                 if (is_error) {
[15:32:33.230]                   sessionInformation <- function() {
[15:32:33.230]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:33.230]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:33.230]                       search = base::search(), system = base::Sys.info())
[15:32:33.230]                   }
[15:32:33.230]                   ...future.conditions[[length(...future.conditions) + 
[15:32:33.230]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:33.230]                     cond$call), session = sessionInformation(), 
[15:32:33.230]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:33.230]                   signalCondition(cond)
[15:32:33.230]                 }
[15:32:33.230]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:33.230]                 "immediateCondition"))) {
[15:32:33.230]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:33.230]                   ...future.conditions[[length(...future.conditions) + 
[15:32:33.230]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:33.230]                   if (TRUE && !signal) {
[15:32:33.230]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:33.230]                     {
[15:32:33.230]                       inherits <- base::inherits
[15:32:33.230]                       invokeRestart <- base::invokeRestart
[15:32:33.230]                       is.null <- base::is.null
[15:32:33.230]                       muffled <- FALSE
[15:32:33.230]                       if (inherits(cond, "message")) {
[15:32:33.230]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:33.230]                         if (muffled) 
[15:32:33.230]                           invokeRestart("muffleMessage")
[15:32:33.230]                       }
[15:32:33.230]                       else if (inherits(cond, "warning")) {
[15:32:33.230]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:33.230]                         if (muffled) 
[15:32:33.230]                           invokeRestart("muffleWarning")
[15:32:33.230]                       }
[15:32:33.230]                       else if (inherits(cond, "condition")) {
[15:32:33.230]                         if (!is.null(pattern)) {
[15:32:33.230]                           computeRestarts <- base::computeRestarts
[15:32:33.230]                           grepl <- base::grepl
[15:32:33.230]                           restarts <- computeRestarts(cond)
[15:32:33.230]                           for (restart in restarts) {
[15:32:33.230]                             name <- restart$name
[15:32:33.230]                             if (is.null(name)) 
[15:32:33.230]                               next
[15:32:33.230]                             if (!grepl(pattern, name)) 
[15:32:33.230]                               next
[15:32:33.230]                             invokeRestart(restart)
[15:32:33.230]                             muffled <- TRUE
[15:32:33.230]                             break
[15:32:33.230]                           }
[15:32:33.230]                         }
[15:32:33.230]                       }
[15:32:33.230]                       invisible(muffled)
[15:32:33.230]                     }
[15:32:33.230]                     muffleCondition(cond, pattern = "^muffle")
[15:32:33.230]                   }
[15:32:33.230]                 }
[15:32:33.230]                 else {
[15:32:33.230]                   if (TRUE) {
[15:32:33.230]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:33.230]                     {
[15:32:33.230]                       inherits <- base::inherits
[15:32:33.230]                       invokeRestart <- base::invokeRestart
[15:32:33.230]                       is.null <- base::is.null
[15:32:33.230]                       muffled <- FALSE
[15:32:33.230]                       if (inherits(cond, "message")) {
[15:32:33.230]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:33.230]                         if (muffled) 
[15:32:33.230]                           invokeRestart("muffleMessage")
[15:32:33.230]                       }
[15:32:33.230]                       else if (inherits(cond, "warning")) {
[15:32:33.230]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:33.230]                         if (muffled) 
[15:32:33.230]                           invokeRestart("muffleWarning")
[15:32:33.230]                       }
[15:32:33.230]                       else if (inherits(cond, "condition")) {
[15:32:33.230]                         if (!is.null(pattern)) {
[15:32:33.230]                           computeRestarts <- base::computeRestarts
[15:32:33.230]                           grepl <- base::grepl
[15:32:33.230]                           restarts <- computeRestarts(cond)
[15:32:33.230]                           for (restart in restarts) {
[15:32:33.230]                             name <- restart$name
[15:32:33.230]                             if (is.null(name)) 
[15:32:33.230]                               next
[15:32:33.230]                             if (!grepl(pattern, name)) 
[15:32:33.230]                               next
[15:32:33.230]                             invokeRestart(restart)
[15:32:33.230]                             muffled <- TRUE
[15:32:33.230]                             break
[15:32:33.230]                           }
[15:32:33.230]                         }
[15:32:33.230]                       }
[15:32:33.230]                       invisible(muffled)
[15:32:33.230]                     }
[15:32:33.230]                     muffleCondition(cond, pattern = "^muffle")
[15:32:33.230]                   }
[15:32:33.230]                 }
[15:32:33.230]             }
[15:32:33.230]         }))
[15:32:33.230]     }, error = function(ex) {
[15:32:33.230]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:33.230]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:33.230]                 ...future.rng), started = ...future.startTime, 
[15:32:33.230]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:33.230]             version = "1.8"), class = "FutureResult")
[15:32:33.230]     }, finally = {
[15:32:33.230]         if (!identical(...future.workdir, getwd())) 
[15:32:33.230]             setwd(...future.workdir)
[15:32:33.230]         {
[15:32:33.230]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:33.230]                 ...future.oldOptions$nwarnings <- NULL
[15:32:33.230]             }
[15:32:33.230]             base::options(...future.oldOptions)
[15:32:33.230]             if (.Platform$OS.type == "windows") {
[15:32:33.230]                 old_names <- names(...future.oldEnvVars)
[15:32:33.230]                 envs <- base::Sys.getenv()
[15:32:33.230]                 names <- names(envs)
[15:32:33.230]                 common <- intersect(names, old_names)
[15:32:33.230]                 added <- setdiff(names, old_names)
[15:32:33.230]                 removed <- setdiff(old_names, names)
[15:32:33.230]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:33.230]                   envs[common]]
[15:32:33.230]                 NAMES <- toupper(changed)
[15:32:33.230]                 args <- list()
[15:32:33.230]                 for (kk in seq_along(NAMES)) {
[15:32:33.230]                   name <- changed[[kk]]
[15:32:33.230]                   NAME <- NAMES[[kk]]
[15:32:33.230]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:33.230]                     next
[15:32:33.230]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:33.230]                 }
[15:32:33.230]                 NAMES <- toupper(added)
[15:32:33.230]                 for (kk in seq_along(NAMES)) {
[15:32:33.230]                   name <- added[[kk]]
[15:32:33.230]                   NAME <- NAMES[[kk]]
[15:32:33.230]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:33.230]                     next
[15:32:33.230]                   args[[name]] <- ""
[15:32:33.230]                 }
[15:32:33.230]                 NAMES <- toupper(removed)
[15:32:33.230]                 for (kk in seq_along(NAMES)) {
[15:32:33.230]                   name <- removed[[kk]]
[15:32:33.230]                   NAME <- NAMES[[kk]]
[15:32:33.230]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:33.230]                     next
[15:32:33.230]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:33.230]                 }
[15:32:33.230]                 if (length(args) > 0) 
[15:32:33.230]                   base::do.call(base::Sys.setenv, args = args)
[15:32:33.230]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:33.230]             }
[15:32:33.230]             else {
[15:32:33.230]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:33.230]             }
[15:32:33.230]             {
[15:32:33.230]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:33.230]                   0L) {
[15:32:33.230]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:33.230]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:33.230]                   base::options(opts)
[15:32:33.230]                 }
[15:32:33.230]                 {
[15:32:33.230]                   {
[15:32:33.230]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:33.230]                     NULL
[15:32:33.230]                   }
[15:32:33.230]                   options(future.plan = NULL)
[15:32:33.230]                   if (is.na(NA_character_)) 
[15:32:33.230]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:33.230]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:33.230]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:33.230]                     .init = FALSE)
[15:32:33.230]                 }
[15:32:33.230]             }
[15:32:33.230]         }
[15:32:33.230]     })
[15:32:33.230]     if (TRUE) {
[15:32:33.230]         base::sink(type = "output", split = FALSE)
[15:32:33.230]         if (TRUE) {
[15:32:33.230]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:33.230]         }
[15:32:33.230]         else {
[15:32:33.230]             ...future.result["stdout"] <- base::list(NULL)
[15:32:33.230]         }
[15:32:33.230]         base::close(...future.stdout)
[15:32:33.230]         ...future.stdout <- NULL
[15:32:33.230]     }
[15:32:33.230]     ...future.result$conditions <- ...future.conditions
[15:32:33.230]     ...future.result$finished <- base::Sys.time()
[15:32:33.230]     ...future.result
[15:32:33.230] }
[15:32:33.239] Exporting 5 global objects (1.22 KiB) to cluster node #1 ...
[15:32:33.239] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ...
[15:32:33.240] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ... DONE
[15:32:33.240] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:33.241] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:33.241] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ...
[15:32:33.242] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ... DONE
[15:32:33.242] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:33.243] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:33.243] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:33.244] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:33.244] Exporting 5 global objects (1.22 KiB) to cluster node #1 ... DONE
[15:32:33.245] MultisessionFuture started
[15:32:33.245] - Launch lazy future ... done
[15:32:33.245] run() for 'MultisessionFuture' ... done
[15:32:33.246] Created future:
[15:32:33.273] receiveMessageFromWorker() for ClusterFuture ...
[15:32:33.273] - Validating connection of MultisessionFuture
[15:32:33.274] - received message: FutureResult
[15:32:33.274] - Received FutureResult
[15:32:33.275] - Erased future from FutureRegistry
[15:32:33.275] result() for ClusterFuture ...
[15:32:33.275] - result already collected: FutureResult
[15:32:33.275] result() for ClusterFuture ... done
[15:32:33.276] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:33.246] MultisessionFuture:
[15:32:33.246] Label: 'future_sapply-1'
[15:32:33.246] Expression:
[15:32:33.246] {
[15:32:33.246]     do.call(function(...) {
[15:32:33.246]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:33.246]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:33.246]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:33.246]             on.exit(options(oopts), add = TRUE)
[15:32:33.246]         }
[15:32:33.246]         {
[15:32:33.246]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:33.246]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:33.246]                 ...future.FUN(...future.X_jj, ...)
[15:32:33.246]             })
[15:32:33.246]         }
[15:32:33.246]     }, args = future.call.arguments)
[15:32:33.246] }
[15:32:33.246] Lazy evaluation: FALSE
[15:32:33.246] Asynchronous evaluation: TRUE
[15:32:33.246] Local evaluation: TRUE
[15:32:33.246] Environment: R_GlobalEnv
[15:32:33.246] Capture standard output: TRUE
[15:32:33.246] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:33.246] Globals: 5 objects totaling 1.38 KiB (function '...future.FUN' of 1.22 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:33.246] Packages: <none>
[15:32:33.246] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:33.246] Resolved: TRUE
[15:32:33.246] Value: <not collected>
[15:32:33.246] Conditions captured: <none>
[15:32:33.246] Early signaling: FALSE
[15:32:33.246] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:33.246] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:33.277] Chunk #1 of 2 ... DONE
[15:32:33.277] Chunk #2 of 2 ...
[15:32:33.277]  - Finding globals in 'X' for chunk #2 ...
[15:32:33.277] getGlobalsAndPackages() ...
[15:32:33.278] Searching for globals...
[15:32:33.278] 
[15:32:33.278] Searching for globals ... DONE
[15:32:33.279] - globals: [0] <none>
[15:32:33.279] getGlobalsAndPackages() ... DONE
[15:32:33.279]    + additional globals found: [n=0] 
[15:32:33.279]    + additional namespaces needed: [n=0] 
[15:32:33.280]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:33.280]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:33.280]  - seeds: <none>
[15:32:33.280]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:33.281] getGlobalsAndPackages() ...
[15:32:33.281] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:33.281] Resolving globals: FALSE
[15:32:33.282] Tweak future expression to call with '...' arguments ...
[15:32:33.282] {
[15:32:33.282]     do.call(function(...) {
[15:32:33.282]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:33.282]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:33.282]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:33.282]             on.exit(options(oopts), add = TRUE)
[15:32:33.282]         }
[15:32:33.282]         {
[15:32:33.282]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:33.282]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:33.282]                 ...future.FUN(...future.X_jj, ...)
[15:32:33.282]             })
[15:32:33.282]         }
[15:32:33.282]     }, args = future.call.arguments)
[15:32:33.282] }
[15:32:33.283] Tweak future expression to call with '...' arguments ... DONE
[15:32:33.283] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:33.283] 
[15:32:33.284] getGlobalsAndPackages() ... DONE
[15:32:33.284] run() for 'Future' ...
[15:32:33.285] - state: 'created'
[15:32:33.285] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:33.302] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:33.303] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:33.303]   - Field: 'node'
[15:32:33.303]   - Field: 'label'
[15:32:33.304]   - Field: 'local'
[15:32:33.304]   - Field: 'owner'
[15:32:33.304]   - Field: 'envir'
[15:32:33.305]   - Field: 'workers'
[15:32:33.305]   - Field: 'packages'
[15:32:33.305]   - Field: 'gc'
[15:32:33.306]   - Field: 'conditions'
[15:32:33.306]   - Field: 'persistent'
[15:32:33.306]   - Field: 'expr'
[15:32:33.307]   - Field: 'uuid'
[15:32:33.307]   - Field: 'seed'
[15:32:33.307]   - Field: 'version'
[15:32:33.308]   - Field: 'result'
[15:32:33.308]   - Field: 'asynchronous'
[15:32:33.308]   - Field: 'calls'
[15:32:33.309]   - Field: 'globals'
[15:32:33.309]   - Field: 'stdout'
[15:32:33.309]   - Field: 'earlySignal'
[15:32:33.310]   - Field: 'lazy'
[15:32:33.310]   - Field: 'state'
[15:32:33.310] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:33.310] - Launch lazy future ...
[15:32:33.311] Packages needed by the future expression (n = 0): <none>
[15:32:33.311] Packages needed by future strategies (n = 0): <none>
[15:32:33.312] {
[15:32:33.312]     {
[15:32:33.312]         {
[15:32:33.312]             ...future.startTime <- base::Sys.time()
[15:32:33.312]             {
[15:32:33.312]                 {
[15:32:33.312]                   {
[15:32:33.312]                     {
[15:32:33.312]                       base::local({
[15:32:33.312]                         has_future <- base::requireNamespace("future", 
[15:32:33.312]                           quietly = TRUE)
[15:32:33.312]                         if (has_future) {
[15:32:33.312]                           ns <- base::getNamespace("future")
[15:32:33.312]                           version <- ns[[".package"]][["version"]]
[15:32:33.312]                           if (is.null(version)) 
[15:32:33.312]                             version <- utils::packageVersion("future")
[15:32:33.312]                         }
[15:32:33.312]                         else {
[15:32:33.312]                           version <- NULL
[15:32:33.312]                         }
[15:32:33.312]                         if (!has_future || version < "1.8.0") {
[15:32:33.312]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:33.312]                             "", base::R.version$version.string), 
[15:32:33.312]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:33.312]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:33.312]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:33.312]                               "release", "version")], collapse = " "), 
[15:32:33.312]                             hostname = base::Sys.info()[["nodename"]])
[15:32:33.312]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:33.312]                             info)
[15:32:33.312]                           info <- base::paste(info, collapse = "; ")
[15:32:33.312]                           if (!has_future) {
[15:32:33.312]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:33.312]                               info)
[15:32:33.312]                           }
[15:32:33.312]                           else {
[15:32:33.312]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:33.312]                               info, version)
[15:32:33.312]                           }
[15:32:33.312]                           base::stop(msg)
[15:32:33.312]                         }
[15:32:33.312]                       })
[15:32:33.312]                     }
[15:32:33.312]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:33.312]                     base::options(mc.cores = 1L)
[15:32:33.312]                   }
[15:32:33.312]                   ...future.strategy.old <- future::plan("list")
[15:32:33.312]                   options(future.plan = NULL)
[15:32:33.312]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:33.312]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:33.312]                 }
[15:32:33.312]                 ...future.workdir <- getwd()
[15:32:33.312]             }
[15:32:33.312]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:33.312]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:33.312]         }
[15:32:33.312]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:33.312]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:33.312]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:33.312]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:33.312]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:33.312]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:33.312]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:33.312]             base::names(...future.oldOptions))
[15:32:33.312]     }
[15:32:33.312]     if (FALSE) {
[15:32:33.312]     }
[15:32:33.312]     else {
[15:32:33.312]         if (TRUE) {
[15:32:33.312]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:33.312]                 open = "w")
[15:32:33.312]         }
[15:32:33.312]         else {
[15:32:33.312]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:33.312]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:33.312]         }
[15:32:33.312]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:33.312]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:33.312]             base::sink(type = "output", split = FALSE)
[15:32:33.312]             base::close(...future.stdout)
[15:32:33.312]         }, add = TRUE)
[15:32:33.312]     }
[15:32:33.312]     ...future.frame <- base::sys.nframe()
[15:32:33.312]     ...future.conditions <- base::list()
[15:32:33.312]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:33.312]     if (FALSE) {
[15:32:33.312]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:33.312]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:33.312]     }
[15:32:33.312]     ...future.result <- base::tryCatch({
[15:32:33.312]         base::withCallingHandlers({
[15:32:33.312]             ...future.value <- base::withVisible(base::local({
[15:32:33.312]                 ...future.makeSendCondition <- base::local({
[15:32:33.312]                   sendCondition <- NULL
[15:32:33.312]                   function(frame = 1L) {
[15:32:33.312]                     if (is.function(sendCondition)) 
[15:32:33.312]                       return(sendCondition)
[15:32:33.312]                     ns <- getNamespace("parallel")
[15:32:33.312]                     if (exists("sendData", mode = "function", 
[15:32:33.312]                       envir = ns)) {
[15:32:33.312]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:33.312]                         envir = ns)
[15:32:33.312]                       envir <- sys.frame(frame)
[15:32:33.312]                       master <- NULL
[15:32:33.312]                       while (!identical(envir, .GlobalEnv) && 
[15:32:33.312]                         !identical(envir, emptyenv())) {
[15:32:33.312]                         if (exists("master", mode = "list", envir = envir, 
[15:32:33.312]                           inherits = FALSE)) {
[15:32:33.312]                           master <- get("master", mode = "list", 
[15:32:33.312]                             envir = envir, inherits = FALSE)
[15:32:33.312]                           if (inherits(master, c("SOCKnode", 
[15:32:33.312]                             "SOCK0node"))) {
[15:32:33.312]                             sendCondition <<- function(cond) {
[15:32:33.312]                               data <- list(type = "VALUE", value = cond, 
[15:32:33.312]                                 success = TRUE)
[15:32:33.312]                               parallel_sendData(master, data)
[15:32:33.312]                             }
[15:32:33.312]                             return(sendCondition)
[15:32:33.312]                           }
[15:32:33.312]                         }
[15:32:33.312]                         frame <- frame + 1L
[15:32:33.312]                         envir <- sys.frame(frame)
[15:32:33.312]                       }
[15:32:33.312]                     }
[15:32:33.312]                     sendCondition <<- function(cond) NULL
[15:32:33.312]                   }
[15:32:33.312]                 })
[15:32:33.312]                 withCallingHandlers({
[15:32:33.312]                   {
[15:32:33.312]                     do.call(function(...) {
[15:32:33.312]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:33.312]                       if (!identical(...future.globals.maxSize.org, 
[15:32:33.312]                         ...future.globals.maxSize)) {
[15:32:33.312]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:33.312]                         on.exit(options(oopts), add = TRUE)
[15:32:33.312]                       }
[15:32:33.312]                       {
[15:32:33.312]                         lapply(seq_along(...future.elements_ii), 
[15:32:33.312]                           FUN = function(jj) {
[15:32:33.312]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:33.312]                             ...future.FUN(...future.X_jj, ...)
[15:32:33.312]                           })
[15:32:33.312]                       }
[15:32:33.312]                     }, args = future.call.arguments)
[15:32:33.312]                   }
[15:32:33.312]                 }, immediateCondition = function(cond) {
[15:32:33.312]                   sendCondition <- ...future.makeSendCondition()
[15:32:33.312]                   sendCondition(cond)
[15:32:33.312]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:33.312]                   {
[15:32:33.312]                     inherits <- base::inherits
[15:32:33.312]                     invokeRestart <- base::invokeRestart
[15:32:33.312]                     is.null <- base::is.null
[15:32:33.312]                     muffled <- FALSE
[15:32:33.312]                     if (inherits(cond, "message")) {
[15:32:33.312]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:33.312]                       if (muffled) 
[15:32:33.312]                         invokeRestart("muffleMessage")
[15:32:33.312]                     }
[15:32:33.312]                     else if (inherits(cond, "warning")) {
[15:32:33.312]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:33.312]                       if (muffled) 
[15:32:33.312]                         invokeRestart("muffleWarning")
[15:32:33.312]                     }
[15:32:33.312]                     else if (inherits(cond, "condition")) {
[15:32:33.312]                       if (!is.null(pattern)) {
[15:32:33.312]                         computeRestarts <- base::computeRestarts
[15:32:33.312]                         grepl <- base::grepl
[15:32:33.312]                         restarts <- computeRestarts(cond)
[15:32:33.312]                         for (restart in restarts) {
[15:32:33.312]                           name <- restart$name
[15:32:33.312]                           if (is.null(name)) 
[15:32:33.312]                             next
[15:32:33.312]                           if (!grepl(pattern, name)) 
[15:32:33.312]                             next
[15:32:33.312]                           invokeRestart(restart)
[15:32:33.312]                           muffled <- TRUE
[15:32:33.312]                           break
[15:32:33.312]                         }
[15:32:33.312]                       }
[15:32:33.312]                     }
[15:32:33.312]                     invisible(muffled)
[15:32:33.312]                   }
[15:32:33.312]                   muffleCondition(cond)
[15:32:33.312]                 })
[15:32:33.312]             }))
[15:32:33.312]             future::FutureResult(value = ...future.value$value, 
[15:32:33.312]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:33.312]                   ...future.rng), globalenv = if (FALSE) 
[15:32:33.312]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:33.312]                     ...future.globalenv.names))
[15:32:33.312]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:33.312]         }, condition = base::local({
[15:32:33.312]             c <- base::c
[15:32:33.312]             inherits <- base::inherits
[15:32:33.312]             invokeRestart <- base::invokeRestart
[15:32:33.312]             length <- base::length
[15:32:33.312]             list <- base::list
[15:32:33.312]             seq.int <- base::seq.int
[15:32:33.312]             signalCondition <- base::signalCondition
[15:32:33.312]             sys.calls <- base::sys.calls
[15:32:33.312]             `[[` <- base::`[[`
[15:32:33.312]             `+` <- base::`+`
[15:32:33.312]             `<<-` <- base::`<<-`
[15:32:33.312]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:33.312]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:33.312]                   3L)]
[15:32:33.312]             }
[15:32:33.312]             function(cond) {
[15:32:33.312]                 is_error <- inherits(cond, "error")
[15:32:33.312]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:33.312]                   NULL)
[15:32:33.312]                 if (is_error) {
[15:32:33.312]                   sessionInformation <- function() {
[15:32:33.312]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:33.312]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:33.312]                       search = base::search(), system = base::Sys.info())
[15:32:33.312]                   }
[15:32:33.312]                   ...future.conditions[[length(...future.conditions) + 
[15:32:33.312]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:33.312]                     cond$call), session = sessionInformation(), 
[15:32:33.312]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:33.312]                   signalCondition(cond)
[15:32:33.312]                 }
[15:32:33.312]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:33.312]                 "immediateCondition"))) {
[15:32:33.312]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:33.312]                   ...future.conditions[[length(...future.conditions) + 
[15:32:33.312]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:33.312]                   if (TRUE && !signal) {
[15:32:33.312]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:33.312]                     {
[15:32:33.312]                       inherits <- base::inherits
[15:32:33.312]                       invokeRestart <- base::invokeRestart
[15:32:33.312]                       is.null <- base::is.null
[15:32:33.312]                       muffled <- FALSE
[15:32:33.312]                       if (inherits(cond, "message")) {
[15:32:33.312]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:33.312]                         if (muffled) 
[15:32:33.312]                           invokeRestart("muffleMessage")
[15:32:33.312]                       }
[15:32:33.312]                       else if (inherits(cond, "warning")) {
[15:32:33.312]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:33.312]                         if (muffled) 
[15:32:33.312]                           invokeRestart("muffleWarning")
[15:32:33.312]                       }
[15:32:33.312]                       else if (inherits(cond, "condition")) {
[15:32:33.312]                         if (!is.null(pattern)) {
[15:32:33.312]                           computeRestarts <- base::computeRestarts
[15:32:33.312]                           grepl <- base::grepl
[15:32:33.312]                           restarts <- computeRestarts(cond)
[15:32:33.312]                           for (restart in restarts) {
[15:32:33.312]                             name <- restart$name
[15:32:33.312]                             if (is.null(name)) 
[15:32:33.312]                               next
[15:32:33.312]                             if (!grepl(pattern, name)) 
[15:32:33.312]                               next
[15:32:33.312]                             invokeRestart(restart)
[15:32:33.312]                             muffled <- TRUE
[15:32:33.312]                             break
[15:32:33.312]                           }
[15:32:33.312]                         }
[15:32:33.312]                       }
[15:32:33.312]                       invisible(muffled)
[15:32:33.312]                     }
[15:32:33.312]                     muffleCondition(cond, pattern = "^muffle")
[15:32:33.312]                   }
[15:32:33.312]                 }
[15:32:33.312]                 else {
[15:32:33.312]                   if (TRUE) {
[15:32:33.312]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:33.312]                     {
[15:32:33.312]                       inherits <- base::inherits
[15:32:33.312]                       invokeRestart <- base::invokeRestart
[15:32:33.312]                       is.null <- base::is.null
[15:32:33.312]                       muffled <- FALSE
[15:32:33.312]                       if (inherits(cond, "message")) {
[15:32:33.312]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:33.312]                         if (muffled) 
[15:32:33.312]                           invokeRestart("muffleMessage")
[15:32:33.312]                       }
[15:32:33.312]                       else if (inherits(cond, "warning")) {
[15:32:33.312]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:33.312]                         if (muffled) 
[15:32:33.312]                           invokeRestart("muffleWarning")
[15:32:33.312]                       }
[15:32:33.312]                       else if (inherits(cond, "condition")) {
[15:32:33.312]                         if (!is.null(pattern)) {
[15:32:33.312]                           computeRestarts <- base::computeRestarts
[15:32:33.312]                           grepl <- base::grepl
[15:32:33.312]                           restarts <- computeRestarts(cond)
[15:32:33.312]                           for (restart in restarts) {
[15:32:33.312]                             name <- restart$name
[15:32:33.312]                             if (is.null(name)) 
[15:32:33.312]                               next
[15:32:33.312]                             if (!grepl(pattern, name)) 
[15:32:33.312]                               next
[15:32:33.312]                             invokeRestart(restart)
[15:32:33.312]                             muffled <- TRUE
[15:32:33.312]                             break
[15:32:33.312]                           }
[15:32:33.312]                         }
[15:32:33.312]                       }
[15:32:33.312]                       invisible(muffled)
[15:32:33.312]                     }
[15:32:33.312]                     muffleCondition(cond, pattern = "^muffle")
[15:32:33.312]                   }
[15:32:33.312]                 }
[15:32:33.312]             }
[15:32:33.312]         }))
[15:32:33.312]     }, error = function(ex) {
[15:32:33.312]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:33.312]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:33.312]                 ...future.rng), started = ...future.startTime, 
[15:32:33.312]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:33.312]             version = "1.8"), class = "FutureResult")
[15:32:33.312]     }, finally = {
[15:32:33.312]         if (!identical(...future.workdir, getwd())) 
[15:32:33.312]             setwd(...future.workdir)
[15:32:33.312]         {
[15:32:33.312]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:33.312]                 ...future.oldOptions$nwarnings <- NULL
[15:32:33.312]             }
[15:32:33.312]             base::options(...future.oldOptions)
[15:32:33.312]             if (.Platform$OS.type == "windows") {
[15:32:33.312]                 old_names <- names(...future.oldEnvVars)
[15:32:33.312]                 envs <- base::Sys.getenv()
[15:32:33.312]                 names <- names(envs)
[15:32:33.312]                 common <- intersect(names, old_names)
[15:32:33.312]                 added <- setdiff(names, old_names)
[15:32:33.312]                 removed <- setdiff(old_names, names)
[15:32:33.312]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:33.312]                   envs[common]]
[15:32:33.312]                 NAMES <- toupper(changed)
[15:32:33.312]                 args <- list()
[15:32:33.312]                 for (kk in seq_along(NAMES)) {
[15:32:33.312]                   name <- changed[[kk]]
[15:32:33.312]                   NAME <- NAMES[[kk]]
[15:32:33.312]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:33.312]                     next
[15:32:33.312]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:33.312]                 }
[15:32:33.312]                 NAMES <- toupper(added)
[15:32:33.312]                 for (kk in seq_along(NAMES)) {
[15:32:33.312]                   name <- added[[kk]]
[15:32:33.312]                   NAME <- NAMES[[kk]]
[15:32:33.312]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:33.312]                     next
[15:32:33.312]                   args[[name]] <- ""
[15:32:33.312]                 }
[15:32:33.312]                 NAMES <- toupper(removed)
[15:32:33.312]                 for (kk in seq_along(NAMES)) {
[15:32:33.312]                   name <- removed[[kk]]
[15:32:33.312]                   NAME <- NAMES[[kk]]
[15:32:33.312]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:33.312]                     next
[15:32:33.312]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:33.312]                 }
[15:32:33.312]                 if (length(args) > 0) 
[15:32:33.312]                   base::do.call(base::Sys.setenv, args = args)
[15:32:33.312]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:33.312]             }
[15:32:33.312]             else {
[15:32:33.312]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:33.312]             }
[15:32:33.312]             {
[15:32:33.312]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:33.312]                   0L) {
[15:32:33.312]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:33.312]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:33.312]                   base::options(opts)
[15:32:33.312]                 }
[15:32:33.312]                 {
[15:32:33.312]                   {
[15:32:33.312]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:33.312]                     NULL
[15:32:33.312]                   }
[15:32:33.312]                   options(future.plan = NULL)
[15:32:33.312]                   if (is.na(NA_character_)) 
[15:32:33.312]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:33.312]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:33.312]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:33.312]                     .init = FALSE)
[15:32:33.312]                 }
[15:32:33.312]             }
[15:32:33.312]         }
[15:32:33.312]     })
[15:32:33.312]     if (TRUE) {
[15:32:33.312]         base::sink(type = "output", split = FALSE)
[15:32:33.312]         if (TRUE) {
[15:32:33.312]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:33.312]         }
[15:32:33.312]         else {
[15:32:33.312]             ...future.result["stdout"] <- base::list(NULL)
[15:32:33.312]         }
[15:32:33.312]         base::close(...future.stdout)
[15:32:33.312]         ...future.stdout <- NULL
[15:32:33.312]     }
[15:32:33.312]     ...future.result$conditions <- ...future.conditions
[15:32:33.312]     ...future.result$finished <- base::Sys.time()
[15:32:33.312]     ...future.result
[15:32:33.312] }
[15:32:33.318] Exporting 5 global objects (1.22 KiB) to cluster node #1 ...
[15:32:33.319] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ...
[15:32:33.319] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ... DONE
[15:32:33.320] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:33.321] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:33.321] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ...
[15:32:33.322] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ... DONE
[15:32:33.322] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:33.323] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:33.323] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:33.323] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:33.324] Exporting 5 global objects (1.22 KiB) to cluster node #1 ... DONE
[15:32:33.325] MultisessionFuture started
[15:32:33.325] - Launch lazy future ... done
[15:32:33.325] run() for 'MultisessionFuture' ... done
[15:32:33.325] Created future:
[15:32:33.348] receiveMessageFromWorker() for ClusterFuture ...
[15:32:33.348] - Validating connection of MultisessionFuture
[15:32:33.348] - received message: FutureResult
[15:32:33.349] - Received FutureResult
[15:32:33.349] - Erased future from FutureRegistry
[15:32:33.349] result() for ClusterFuture ...
[15:32:33.349] - result already collected: FutureResult
[15:32:33.349] result() for ClusterFuture ... done
[15:32:33.349] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:33.326] MultisessionFuture:
[15:32:33.326] Label: 'future_sapply-2'
[15:32:33.326] Expression:
[15:32:33.326] {
[15:32:33.326]     do.call(function(...) {
[15:32:33.326]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:33.326]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:33.326]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:33.326]             on.exit(options(oopts), add = TRUE)
[15:32:33.326]         }
[15:32:33.326]         {
[15:32:33.326]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:33.326]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:33.326]                 ...future.FUN(...future.X_jj, ...)
[15:32:33.326]             })
[15:32:33.326]         }
[15:32:33.326]     }, args = future.call.arguments)
[15:32:33.326] }
[15:32:33.326] Lazy evaluation: FALSE
[15:32:33.326] Asynchronous evaluation: TRUE
[15:32:33.326] Local evaluation: TRUE
[15:32:33.326] Environment: R_GlobalEnv
[15:32:33.326] Capture standard output: TRUE
[15:32:33.326] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:33.326] Globals: 5 objects totaling 1.38 KiB (function '...future.FUN' of 1.22 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:33.326] Packages: <none>
[15:32:33.326] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:33.326] Resolved: TRUE
[15:32:33.326] Value: <not collected>
[15:32:33.326] Conditions captured: <none>
[15:32:33.326] Early signaling: FALSE
[15:32:33.326] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:33.326] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:33.350] Chunk #2 of 2 ... DONE
[15:32:33.350] Launching 2 futures (chunks) ... DONE
[15:32:33.351] Resolving 2 futures (chunks) ...
[15:32:33.351] resolve() on list ...
[15:32:33.351]  recursive: 0
[15:32:33.351]  length: 2
[15:32:33.351] 
[15:32:33.351] Future #1
[15:32:33.352] result() for ClusterFuture ...
[15:32:33.352] - result already collected: FutureResult
[15:32:33.352] result() for ClusterFuture ... done
[15:32:33.352] result() for ClusterFuture ...
[15:32:33.352] - result already collected: FutureResult
[15:32:33.352] result() for ClusterFuture ... done
[15:32:33.352] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:33.353] - nx: 2
[15:32:33.353] - relay: TRUE
[15:32:33.353] - stdout: TRUE
[15:32:33.353] - signal: TRUE
[15:32:33.353] - resignal: FALSE
[15:32:33.353] - force: TRUE
[15:32:33.354] - relayed: [n=2] FALSE, FALSE
[15:32:33.354] - queued futures: [n=2] FALSE, FALSE
[15:32:33.354]  - until=1
[15:32:33.354]  - relaying element #1
[15:32:33.354] result() for ClusterFuture ...
[15:32:33.358] - result already collected: FutureResult
[15:32:33.359] result() for ClusterFuture ... done
[15:32:33.359] result() for ClusterFuture ...
[15:32:33.359] - result already collected: FutureResult
[15:32:33.359] result() for ClusterFuture ... done
[15:32:33.360] result() for ClusterFuture ...
[15:32:33.360] - result already collected: FutureResult
[15:32:33.360] result() for ClusterFuture ... done
[15:32:33.361] result() for ClusterFuture ...
[15:32:33.361] - result already collected: FutureResult
[15:32:33.361] result() for ClusterFuture ... done
[15:32:33.362] - relayed: [n=2] TRUE, FALSE
[15:32:33.362] - queued futures: [n=2] TRUE, FALSE
[15:32:33.362] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:33.362]  length: 1 (resolved future 1)
[15:32:33.363] Future #2
[15:32:33.363] result() for ClusterFuture ...
[15:32:33.363] - result already collected: FutureResult
[15:32:33.364] result() for ClusterFuture ... done
[15:32:33.364] result() for ClusterFuture ...
[15:32:33.364] - result already collected: FutureResult
[15:32:33.365] result() for ClusterFuture ... done
[15:32:33.365] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:33.365] - nx: 2
[15:32:33.365] - relay: TRUE
[15:32:33.366] - stdout: TRUE
[15:32:33.366] - signal: TRUE
[15:32:33.366] - resignal: FALSE
[15:32:33.366] - force: TRUE
[15:32:33.366] - relayed: [n=2] TRUE, FALSE
[15:32:33.366] - queued futures: [n=2] TRUE, FALSE
[15:32:33.367]  - until=2
[15:32:33.367]  - relaying element #2
[15:32:33.367] result() for ClusterFuture ...
[15:32:33.367] - result already collected: FutureResult
[15:32:33.367] result() for ClusterFuture ... done
[15:32:33.367] result() for ClusterFuture ...
[15:32:33.367] - result already collected: FutureResult
[15:32:33.368] result() for ClusterFuture ... done
[15:32:33.368] result() for ClusterFuture ...
[15:32:33.368] - result already collected: FutureResult
[15:32:33.368] result() for ClusterFuture ... done
[15:32:33.368] result() for ClusterFuture ...
[15:32:33.368] - result already collected: FutureResult
[15:32:33.369] result() for ClusterFuture ... done
[15:32:33.369] - relayed: [n=2] TRUE, TRUE
[15:32:33.369] - queued futures: [n=2] TRUE, TRUE
[15:32:33.369] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:33.369]  length: 0 (resolved future 2)
[15:32:33.369] Relaying remaining futures
[15:32:33.369] signalConditionsASAP(NULL, pos=0) ...
[15:32:33.370] - nx: 2
[15:32:33.370] - relay: TRUE
[15:32:33.370] - stdout: TRUE
[15:32:33.370] - signal: TRUE
[15:32:33.370] - resignal: FALSE
[15:32:33.370] - force: TRUE
[15:32:33.370] - relayed: [n=2] TRUE, TRUE
[15:32:33.371] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:33.371] - relayed: [n=2] TRUE, TRUE
[15:32:33.371] - queued futures: [n=2] TRUE, TRUE
[15:32:33.371] signalConditionsASAP(NULL, pos=0) ... done
[15:32:33.371] resolve() on list ... DONE
[15:32:33.371] result() for ClusterFuture ...
[15:32:33.372] - result already collected: FutureResult
[15:32:33.372] result() for ClusterFuture ... done
[15:32:33.372] result() for ClusterFuture ...
[15:32:33.372] - result already collected: FutureResult
[15:32:33.372] result() for ClusterFuture ... done
[15:32:33.372] result() for ClusterFuture ...
[15:32:33.373] - result already collected: FutureResult
[15:32:33.373] result() for ClusterFuture ... done
[15:32:33.373] result() for ClusterFuture ...
[15:32:33.373] - result already collected: FutureResult
[15:32:33.373] result() for ClusterFuture ... done
[15:32:33.373]  - Number of value chunks collected: 2
[15:32:33.373] Resolving 2 futures (chunks) ... DONE
[15:32:33.374] Reducing values from 2 chunks ...
[15:32:33.374]  - Number of values collected after concatenation: 6
[15:32:33.374]  - Number of values expected: 6
[15:32:33.374] Reducing values from 2 chunks ... DONE
[15:32:33.374] future_lapply() ... DONE
List of 2
 $ y0:List of 6
  ..$ a1: int [1, 1] 1
  ..$ a2: int [1, 1] 2
  ..$ b1: int [1, 1] 2
  ..$ b2: int [1, 1] 3
  ..$ c1: int [1, 1] 3
  ..$ c2: int [1, 1] 4
 $ y1:List of 6
  ..$ a1: int [1, 1] 1
  ..$ a2: int [1, 1] 2
  ..$ b1: int [1, 1] 2
  ..$ b2: int [1, 1] 3
  ..$ c1: int [1, 1] 3
  ..$ c2: int [1, 1] 4
List of 2
 $ y0:List of 6
  ..$ a1: int [1, 1] 1
  ..$ a2: int [1, 1] 2
  ..$ b1: int [1, 1] 2
  ..$ b2: int [1, 1] 3
  ..$ c1: int [1, 1] 3
  ..$ c2: int [1, 1] 4
 $ y2:List of 6
  ..$ a1: int [1, 1] 1
  ..$ a2: int [1, 1] 2
  ..$ b1: int [1, 1] 2
  ..$ b2: int [1, 1] 3
  ..$ c1: int [1, 1] 3
  ..$ c2: int [1, 1] 4
[15:32:33.387] future_lapply() ...
[15:32:33.393] Number of chunks: 2
[15:32:33.393] getGlobalsAndPackagesXApply() ...
[15:32:33.393]  - future.globals: TRUE
[15:32:33.393] getGlobalsAndPackages() ...
[15:32:33.394] Searching for globals...
[15:32:33.397] - globals found: [5] 'FUN', '*', ':', 'outer', 'rep'
[15:32:33.397] Searching for globals ... DONE
[15:32:33.397] Resolving globals: FALSE
[15:32:33.398] The total size of the 1 globals is 4.62 KiB (4728 bytes)
[15:32:33.399] The total size of the 1 globals exported for future expression ('FUN()') is 4.62 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.62 KiB of class 'function')
[15:32:33.399] - globals: [1] 'FUN'
[15:32:33.400] 
[15:32:33.400] getGlobalsAndPackages() ... DONE
[15:32:33.400]  - globals found/used: [n=1] 'FUN'
[15:32:33.400]  - needed namespaces: [n=0] 
[15:32:33.401] Finding globals ... DONE
[15:32:33.401]  - use_args: TRUE
[15:32:33.401]  - Getting '...' globals ...
[15:32:33.402] resolve() on list ...
[15:32:33.402]  recursive: 0
[15:32:33.402]  length: 1
[15:32:33.403]  elements: '...'
[15:32:33.403]  length: 0 (resolved future 1)
[15:32:33.403] resolve() on list ... DONE
[15:32:33.404]    - '...' content: [n=0] 
[15:32:33.404] List of 1
[15:32:33.404]  $ ...: list()
[15:32:33.404]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:33.404]  - attr(*, "where")=List of 1
[15:32:33.404]   ..$ ...:<environment: 0x00000276e1993338> 
[15:32:33.404]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:33.404]  - attr(*, "resolved")= logi TRUE
[15:32:33.404]  - attr(*, "total_size")= num NA
[15:32:33.409]  - Getting '...' globals ... DONE
[15:32:33.409] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:33.410] List of 2
[15:32:33.410]  $ ...future.FUN:function (x, y = 2 * 1:5)  
[15:32:33.410]  $ ...          : list()
[15:32:33.410]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:33.410]  - attr(*, "where")=List of 2
[15:32:33.410]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:33.410]   ..$ ...          :<environment: 0x00000276e1993338> 
[15:32:33.410]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:33.410]  - attr(*, "resolved")= logi FALSE
[15:32:33.410]  - attr(*, "total_size")= num 4728
[15:32:33.415] Packages to be attached in all futures: [n=0] 
[15:32:33.415] getGlobalsAndPackagesXApply() ... DONE
[15:32:33.415] Number of futures (= number of chunks): 2
[15:32:33.416] Launching 2 futures (chunks) ...
[15:32:33.416] Chunk #1 of 2 ...
[15:32:33.416]  - Finding globals in 'X' for chunk #1 ...
[15:32:33.416] getGlobalsAndPackages() ...
[15:32:33.417] Searching for globals...
[15:32:33.417] 
[15:32:33.418] Searching for globals ... DONE
[15:32:33.418] - globals: [0] <none>
[15:32:33.418] getGlobalsAndPackages() ... DONE
[15:32:33.418]    + additional globals found: [n=0] 
[15:32:33.419]    + additional namespaces needed: [n=0] 
[15:32:33.419]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:33.419]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:33.420]  - seeds: <none>
[15:32:33.420]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:33.420] getGlobalsAndPackages() ...
[15:32:33.420] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:33.421] Resolving globals: FALSE
[15:32:33.421] Tweak future expression to call with '...' arguments ...
[15:32:33.421] {
[15:32:33.421]     do.call(function(...) {
[15:32:33.421]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:33.421]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:33.421]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:33.421]             on.exit(options(oopts), add = TRUE)
[15:32:33.421]         }
[15:32:33.421]         {
[15:32:33.421]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:33.421]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:33.421]                 ...future.FUN(...future.X_jj, ...)
[15:32:33.421]             })
[15:32:33.421]         }
[15:32:33.421]     }, args = future.call.arguments)
[15:32:33.421] }
[15:32:33.422] Tweak future expression to call with '...' arguments ... DONE
[15:32:33.423] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:33.423] 
[15:32:33.423] getGlobalsAndPackages() ... DONE
[15:32:33.424] run() for 'Future' ...
[15:32:33.424] - state: 'created'
[15:32:33.425] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:33.441] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:33.442] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:33.442]   - Field: 'node'
[15:32:33.442]   - Field: 'label'
[15:32:33.442]   - Field: 'local'
[15:32:33.443]   - Field: 'owner'
[15:32:33.443]   - Field: 'envir'
[15:32:33.443]   - Field: 'workers'
[15:32:33.444]   - Field: 'packages'
[15:32:33.444]   - Field: 'gc'
[15:32:33.444]   - Field: 'conditions'
[15:32:33.444]   - Field: 'persistent'
[15:32:33.445]   - Field: 'expr'
[15:32:33.445]   - Field: 'uuid'
[15:32:33.445]   - Field: 'seed'
[15:32:33.445]   - Field: 'version'
[15:32:33.445]   - Field: 'result'
[15:32:33.445]   - Field: 'asynchronous'
[15:32:33.446]   - Field: 'calls'
[15:32:33.446]   - Field: 'globals'
[15:32:33.446]   - Field: 'stdout'
[15:32:33.446]   - Field: 'earlySignal'
[15:32:33.446]   - Field: 'lazy'
[15:32:33.446]   - Field: 'state'
[15:32:33.447] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:33.447] - Launch lazy future ...
[15:32:33.447] Packages needed by the future expression (n = 0): <none>
[15:32:33.447] Packages needed by future strategies (n = 0): <none>
[15:32:33.448] {
[15:32:33.448]     {
[15:32:33.448]         {
[15:32:33.448]             ...future.startTime <- base::Sys.time()
[15:32:33.448]             {
[15:32:33.448]                 {
[15:32:33.448]                   {
[15:32:33.448]                     {
[15:32:33.448]                       base::local({
[15:32:33.448]                         has_future <- base::requireNamespace("future", 
[15:32:33.448]                           quietly = TRUE)
[15:32:33.448]                         if (has_future) {
[15:32:33.448]                           ns <- base::getNamespace("future")
[15:32:33.448]                           version <- ns[[".package"]][["version"]]
[15:32:33.448]                           if (is.null(version)) 
[15:32:33.448]                             version <- utils::packageVersion("future")
[15:32:33.448]                         }
[15:32:33.448]                         else {
[15:32:33.448]                           version <- NULL
[15:32:33.448]                         }
[15:32:33.448]                         if (!has_future || version < "1.8.0") {
[15:32:33.448]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:33.448]                             "", base::R.version$version.string), 
[15:32:33.448]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:33.448]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:33.448]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:33.448]                               "release", "version")], collapse = " "), 
[15:32:33.448]                             hostname = base::Sys.info()[["nodename"]])
[15:32:33.448]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:33.448]                             info)
[15:32:33.448]                           info <- base::paste(info, collapse = "; ")
[15:32:33.448]                           if (!has_future) {
[15:32:33.448]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:33.448]                               info)
[15:32:33.448]                           }
[15:32:33.448]                           else {
[15:32:33.448]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:33.448]                               info, version)
[15:32:33.448]                           }
[15:32:33.448]                           base::stop(msg)
[15:32:33.448]                         }
[15:32:33.448]                       })
[15:32:33.448]                     }
[15:32:33.448]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:33.448]                     base::options(mc.cores = 1L)
[15:32:33.448]                   }
[15:32:33.448]                   ...future.strategy.old <- future::plan("list")
[15:32:33.448]                   options(future.plan = NULL)
[15:32:33.448]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:33.448]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:33.448]                 }
[15:32:33.448]                 ...future.workdir <- getwd()
[15:32:33.448]             }
[15:32:33.448]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:33.448]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:33.448]         }
[15:32:33.448]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:33.448]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:33.448]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:33.448]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:33.448]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:33.448]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:33.448]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:33.448]             base::names(...future.oldOptions))
[15:32:33.448]     }
[15:32:33.448]     if (FALSE) {
[15:32:33.448]     }
[15:32:33.448]     else {
[15:32:33.448]         if (TRUE) {
[15:32:33.448]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:33.448]                 open = "w")
[15:32:33.448]         }
[15:32:33.448]         else {
[15:32:33.448]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:33.448]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:33.448]         }
[15:32:33.448]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:33.448]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:33.448]             base::sink(type = "output", split = FALSE)
[15:32:33.448]             base::close(...future.stdout)
[15:32:33.448]         }, add = TRUE)
[15:32:33.448]     }
[15:32:33.448]     ...future.frame <- base::sys.nframe()
[15:32:33.448]     ...future.conditions <- base::list()
[15:32:33.448]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:33.448]     if (FALSE) {
[15:32:33.448]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:33.448]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:33.448]     }
[15:32:33.448]     ...future.result <- base::tryCatch({
[15:32:33.448]         base::withCallingHandlers({
[15:32:33.448]             ...future.value <- base::withVisible(base::local({
[15:32:33.448]                 ...future.makeSendCondition <- base::local({
[15:32:33.448]                   sendCondition <- NULL
[15:32:33.448]                   function(frame = 1L) {
[15:32:33.448]                     if (is.function(sendCondition)) 
[15:32:33.448]                       return(sendCondition)
[15:32:33.448]                     ns <- getNamespace("parallel")
[15:32:33.448]                     if (exists("sendData", mode = "function", 
[15:32:33.448]                       envir = ns)) {
[15:32:33.448]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:33.448]                         envir = ns)
[15:32:33.448]                       envir <- sys.frame(frame)
[15:32:33.448]                       master <- NULL
[15:32:33.448]                       while (!identical(envir, .GlobalEnv) && 
[15:32:33.448]                         !identical(envir, emptyenv())) {
[15:32:33.448]                         if (exists("master", mode = "list", envir = envir, 
[15:32:33.448]                           inherits = FALSE)) {
[15:32:33.448]                           master <- get("master", mode = "list", 
[15:32:33.448]                             envir = envir, inherits = FALSE)
[15:32:33.448]                           if (inherits(master, c("SOCKnode", 
[15:32:33.448]                             "SOCK0node"))) {
[15:32:33.448]                             sendCondition <<- function(cond) {
[15:32:33.448]                               data <- list(type = "VALUE", value = cond, 
[15:32:33.448]                                 success = TRUE)
[15:32:33.448]                               parallel_sendData(master, data)
[15:32:33.448]                             }
[15:32:33.448]                             return(sendCondition)
[15:32:33.448]                           }
[15:32:33.448]                         }
[15:32:33.448]                         frame <- frame + 1L
[15:32:33.448]                         envir <- sys.frame(frame)
[15:32:33.448]                       }
[15:32:33.448]                     }
[15:32:33.448]                     sendCondition <<- function(cond) NULL
[15:32:33.448]                   }
[15:32:33.448]                 })
[15:32:33.448]                 withCallingHandlers({
[15:32:33.448]                   {
[15:32:33.448]                     do.call(function(...) {
[15:32:33.448]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:33.448]                       if (!identical(...future.globals.maxSize.org, 
[15:32:33.448]                         ...future.globals.maxSize)) {
[15:32:33.448]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:33.448]                         on.exit(options(oopts), add = TRUE)
[15:32:33.448]                       }
[15:32:33.448]                       {
[15:32:33.448]                         lapply(seq_along(...future.elements_ii), 
[15:32:33.448]                           FUN = function(jj) {
[15:32:33.448]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:33.448]                             ...future.FUN(...future.X_jj, ...)
[15:32:33.448]                           })
[15:32:33.448]                       }
[15:32:33.448]                     }, args = future.call.arguments)
[15:32:33.448]                   }
[15:32:33.448]                 }, immediateCondition = function(cond) {
[15:32:33.448]                   sendCondition <- ...future.makeSendCondition()
[15:32:33.448]                   sendCondition(cond)
[15:32:33.448]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:33.448]                   {
[15:32:33.448]                     inherits <- base::inherits
[15:32:33.448]                     invokeRestart <- base::invokeRestart
[15:32:33.448]                     is.null <- base::is.null
[15:32:33.448]                     muffled <- FALSE
[15:32:33.448]                     if (inherits(cond, "message")) {
[15:32:33.448]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:33.448]                       if (muffled) 
[15:32:33.448]                         invokeRestart("muffleMessage")
[15:32:33.448]                     }
[15:32:33.448]                     else if (inherits(cond, "warning")) {
[15:32:33.448]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:33.448]                       if (muffled) 
[15:32:33.448]                         invokeRestart("muffleWarning")
[15:32:33.448]                     }
[15:32:33.448]                     else if (inherits(cond, "condition")) {
[15:32:33.448]                       if (!is.null(pattern)) {
[15:32:33.448]                         computeRestarts <- base::computeRestarts
[15:32:33.448]                         grepl <- base::grepl
[15:32:33.448]                         restarts <- computeRestarts(cond)
[15:32:33.448]                         for (restart in restarts) {
[15:32:33.448]                           name <- restart$name
[15:32:33.448]                           if (is.null(name)) 
[15:32:33.448]                             next
[15:32:33.448]                           if (!grepl(pattern, name)) 
[15:32:33.448]                             next
[15:32:33.448]                           invokeRestart(restart)
[15:32:33.448]                           muffled <- TRUE
[15:32:33.448]                           break
[15:32:33.448]                         }
[15:32:33.448]                       }
[15:32:33.448]                     }
[15:32:33.448]                     invisible(muffled)
[15:32:33.448]                   }
[15:32:33.448]                   muffleCondition(cond)
[15:32:33.448]                 })
[15:32:33.448]             }))
[15:32:33.448]             future::FutureResult(value = ...future.value$value, 
[15:32:33.448]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:33.448]                   ...future.rng), globalenv = if (FALSE) 
[15:32:33.448]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:33.448]                     ...future.globalenv.names))
[15:32:33.448]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:33.448]         }, condition = base::local({
[15:32:33.448]             c <- base::c
[15:32:33.448]             inherits <- base::inherits
[15:32:33.448]             invokeRestart <- base::invokeRestart
[15:32:33.448]             length <- base::length
[15:32:33.448]             list <- base::list
[15:32:33.448]             seq.int <- base::seq.int
[15:32:33.448]             signalCondition <- base::signalCondition
[15:32:33.448]             sys.calls <- base::sys.calls
[15:32:33.448]             `[[` <- base::`[[`
[15:32:33.448]             `+` <- base::`+`
[15:32:33.448]             `<<-` <- base::`<<-`
[15:32:33.448]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:33.448]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:33.448]                   3L)]
[15:32:33.448]             }
[15:32:33.448]             function(cond) {
[15:32:33.448]                 is_error <- inherits(cond, "error")
[15:32:33.448]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:33.448]                   NULL)
[15:32:33.448]                 if (is_error) {
[15:32:33.448]                   sessionInformation <- function() {
[15:32:33.448]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:33.448]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:33.448]                       search = base::search(), system = base::Sys.info())
[15:32:33.448]                   }
[15:32:33.448]                   ...future.conditions[[length(...future.conditions) + 
[15:32:33.448]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:33.448]                     cond$call), session = sessionInformation(), 
[15:32:33.448]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:33.448]                   signalCondition(cond)
[15:32:33.448]                 }
[15:32:33.448]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:33.448]                 "immediateCondition"))) {
[15:32:33.448]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:33.448]                   ...future.conditions[[length(...future.conditions) + 
[15:32:33.448]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:33.448]                   if (TRUE && !signal) {
[15:32:33.448]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:33.448]                     {
[15:32:33.448]                       inherits <- base::inherits
[15:32:33.448]                       invokeRestart <- base::invokeRestart
[15:32:33.448]                       is.null <- base::is.null
[15:32:33.448]                       muffled <- FALSE
[15:32:33.448]                       if (inherits(cond, "message")) {
[15:32:33.448]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:33.448]                         if (muffled) 
[15:32:33.448]                           invokeRestart("muffleMessage")
[15:32:33.448]                       }
[15:32:33.448]                       else if (inherits(cond, "warning")) {
[15:32:33.448]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:33.448]                         if (muffled) 
[15:32:33.448]                           invokeRestart("muffleWarning")
[15:32:33.448]                       }
[15:32:33.448]                       else if (inherits(cond, "condition")) {
[15:32:33.448]                         if (!is.null(pattern)) {
[15:32:33.448]                           computeRestarts <- base::computeRestarts
[15:32:33.448]                           grepl <- base::grepl
[15:32:33.448]                           restarts <- computeRestarts(cond)
[15:32:33.448]                           for (restart in restarts) {
[15:32:33.448]                             name <- restart$name
[15:32:33.448]                             if (is.null(name)) 
[15:32:33.448]                               next
[15:32:33.448]                             if (!grepl(pattern, name)) 
[15:32:33.448]                               next
[15:32:33.448]                             invokeRestart(restart)
[15:32:33.448]                             muffled <- TRUE
[15:32:33.448]                             break
[15:32:33.448]                           }
[15:32:33.448]                         }
[15:32:33.448]                       }
[15:32:33.448]                       invisible(muffled)
[15:32:33.448]                     }
[15:32:33.448]                     muffleCondition(cond, pattern = "^muffle")
[15:32:33.448]                   }
[15:32:33.448]                 }
[15:32:33.448]                 else {
[15:32:33.448]                   if (TRUE) {
[15:32:33.448]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:33.448]                     {
[15:32:33.448]                       inherits <- base::inherits
[15:32:33.448]                       invokeRestart <- base::invokeRestart
[15:32:33.448]                       is.null <- base::is.null
[15:32:33.448]                       muffled <- FALSE
[15:32:33.448]                       if (inherits(cond, "message")) {
[15:32:33.448]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:33.448]                         if (muffled) 
[15:32:33.448]                           invokeRestart("muffleMessage")
[15:32:33.448]                       }
[15:32:33.448]                       else if (inherits(cond, "warning")) {
[15:32:33.448]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:33.448]                         if (muffled) 
[15:32:33.448]                           invokeRestart("muffleWarning")
[15:32:33.448]                       }
[15:32:33.448]                       else if (inherits(cond, "condition")) {
[15:32:33.448]                         if (!is.null(pattern)) {
[15:32:33.448]                           computeRestarts <- base::computeRestarts
[15:32:33.448]                           grepl <- base::grepl
[15:32:33.448]                           restarts <- computeRestarts(cond)
[15:32:33.448]                           for (restart in restarts) {
[15:32:33.448]                             name <- restart$name
[15:32:33.448]                             if (is.null(name)) 
[15:32:33.448]                               next
[15:32:33.448]                             if (!grepl(pattern, name)) 
[15:32:33.448]                               next
[15:32:33.448]                             invokeRestart(restart)
[15:32:33.448]                             muffled <- TRUE
[15:32:33.448]                             break
[15:32:33.448]                           }
[15:32:33.448]                         }
[15:32:33.448]                       }
[15:32:33.448]                       invisible(muffled)
[15:32:33.448]                     }
[15:32:33.448]                     muffleCondition(cond, pattern = "^muffle")
[15:32:33.448]                   }
[15:32:33.448]                 }
[15:32:33.448]             }
[15:32:33.448]         }))
[15:32:33.448]     }, error = function(ex) {
[15:32:33.448]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:33.448]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:33.448]                 ...future.rng), started = ...future.startTime, 
[15:32:33.448]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:33.448]             version = "1.8"), class = "FutureResult")
[15:32:33.448]     }, finally = {
[15:32:33.448]         if (!identical(...future.workdir, getwd())) 
[15:32:33.448]             setwd(...future.workdir)
[15:32:33.448]         {
[15:32:33.448]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:33.448]                 ...future.oldOptions$nwarnings <- NULL
[15:32:33.448]             }
[15:32:33.448]             base::options(...future.oldOptions)
[15:32:33.448]             if (.Platform$OS.type == "windows") {
[15:32:33.448]                 old_names <- names(...future.oldEnvVars)
[15:32:33.448]                 envs <- base::Sys.getenv()
[15:32:33.448]                 names <- names(envs)
[15:32:33.448]                 common <- intersect(names, old_names)
[15:32:33.448]                 added <- setdiff(names, old_names)
[15:32:33.448]                 removed <- setdiff(old_names, names)
[15:32:33.448]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:33.448]                   envs[common]]
[15:32:33.448]                 NAMES <- toupper(changed)
[15:32:33.448]                 args <- list()
[15:32:33.448]                 for (kk in seq_along(NAMES)) {
[15:32:33.448]                   name <- changed[[kk]]
[15:32:33.448]                   NAME <- NAMES[[kk]]
[15:32:33.448]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:33.448]                     next
[15:32:33.448]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:33.448]                 }
[15:32:33.448]                 NAMES <- toupper(added)
[15:32:33.448]                 for (kk in seq_along(NAMES)) {
[15:32:33.448]                   name <- added[[kk]]
[15:32:33.448]                   NAME <- NAMES[[kk]]
[15:32:33.448]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:33.448]                     next
[15:32:33.448]                   args[[name]] <- ""
[15:32:33.448]                 }
[15:32:33.448]                 NAMES <- toupper(removed)
[15:32:33.448]                 for (kk in seq_along(NAMES)) {
[15:32:33.448]                   name <- removed[[kk]]
[15:32:33.448]                   NAME <- NAMES[[kk]]
[15:32:33.448]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:33.448]                     next
[15:32:33.448]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:33.448]                 }
[15:32:33.448]                 if (length(args) > 0) 
[15:32:33.448]                   base::do.call(base::Sys.setenv, args = args)
[15:32:33.448]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:33.448]             }
[15:32:33.448]             else {
[15:32:33.448]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:33.448]             }
[15:32:33.448]             {
[15:32:33.448]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:33.448]                   0L) {
[15:32:33.448]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:33.448]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:33.448]                   base::options(opts)
[15:32:33.448]                 }
[15:32:33.448]                 {
[15:32:33.448]                   {
[15:32:33.448]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:33.448]                     NULL
[15:32:33.448]                   }
[15:32:33.448]                   options(future.plan = NULL)
[15:32:33.448]                   if (is.na(NA_character_)) 
[15:32:33.448]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:33.448]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:33.448]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:33.448]                     .init = FALSE)
[15:32:33.448]                 }
[15:32:33.448]             }
[15:32:33.448]         }
[15:32:33.448]     })
[15:32:33.448]     if (TRUE) {
[15:32:33.448]         base::sink(type = "output", split = FALSE)
[15:32:33.448]         if (TRUE) {
[15:32:33.448]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:33.448]         }
[15:32:33.448]         else {
[15:32:33.448]             ...future.result["stdout"] <- base::list(NULL)
[15:32:33.448]         }
[15:32:33.448]         base::close(...future.stdout)
[15:32:33.448]         ...future.stdout <- NULL
[15:32:33.448]     }
[15:32:33.448]     ...future.result$conditions <- ...future.conditions
[15:32:33.448]     ...future.result$finished <- base::Sys.time()
[15:32:33.448]     ...future.result
[15:32:33.448] }
[15:32:33.454] Exporting 5 global objects (4.62 KiB) to cluster node #1 ...
[15:32:33.454] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ...
[15:32:33.455] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ... DONE
[15:32:33.455] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:33.455] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:33.456] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ...
[15:32:33.456] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ... DONE
[15:32:33.456] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:33.457] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:33.457] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:33.457] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:33.458] Exporting 5 global objects (4.62 KiB) to cluster node #1 ... DONE
[15:32:33.458] MultisessionFuture started
[15:32:33.458] - Launch lazy future ... done
[15:32:33.458] run() for 'MultisessionFuture' ... done
[15:32:33.459] Created future:
[15:32:33.487] receiveMessageFromWorker() for ClusterFuture ...
[15:32:33.487] - Validating connection of MultisessionFuture
[15:32:33.488] - received message: FutureResult
[15:32:33.488] - Received FutureResult
[15:32:33.488] - Erased future from FutureRegistry
[15:32:33.488] result() for ClusterFuture ...
[15:32:33.488] - result already collected: FutureResult
[15:32:33.489] result() for ClusterFuture ... done
[15:32:33.489] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:33.459] MultisessionFuture:
[15:32:33.459] Label: 'future_sapply-1'
[15:32:33.459] Expression:
[15:32:33.459] {
[15:32:33.459]     do.call(function(...) {
[15:32:33.459]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:33.459]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:33.459]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:33.459]             on.exit(options(oopts), add = TRUE)
[15:32:33.459]         }
[15:32:33.459]         {
[15:32:33.459]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:33.459]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:33.459]                 ...future.FUN(...future.X_jj, ...)
[15:32:33.459]             })
[15:32:33.459]         }
[15:32:33.459]     }, args = future.call.arguments)
[15:32:33.459] }
[15:32:33.459] Lazy evaluation: FALSE
[15:32:33.459] Asynchronous evaluation: TRUE
[15:32:33.459] Local evaluation: TRUE
[15:32:33.459] Environment: R_GlobalEnv
[15:32:33.459] Capture standard output: TRUE
[15:32:33.459] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:33.459] Globals: 5 objects totaling 4.78 KiB (function '...future.FUN' of 4.62 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:33.459] Packages: <none>
[15:32:33.459] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:33.459] Resolved: TRUE
[15:32:33.459] Value: <not collected>
[15:32:33.459] Conditions captured: <none>
[15:32:33.459] Early signaling: FALSE
[15:32:33.459] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:33.459] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:33.489] Chunk #1 of 2 ... DONE
[15:32:33.489] Chunk #2 of 2 ...
[15:32:33.490]  - Finding globals in 'X' for chunk #2 ...
[15:32:33.490] getGlobalsAndPackages() ...
[15:32:33.490] Searching for globals...
[15:32:33.490] 
[15:32:33.491] Searching for globals ... DONE
[15:32:33.491] - globals: [0] <none>
[15:32:33.491] getGlobalsAndPackages() ... DONE
[15:32:33.491]    + additional globals found: [n=0] 
[15:32:33.491]    + additional namespaces needed: [n=0] 
[15:32:33.491]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:33.492]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:33.492]  - seeds: <none>
[15:32:33.492]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:33.492] getGlobalsAndPackages() ...
[15:32:33.492] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:33.492] Resolving globals: FALSE
[15:32:33.493] Tweak future expression to call with '...' arguments ...
[15:32:33.493] {
[15:32:33.493]     do.call(function(...) {
[15:32:33.493]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:33.493]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:33.493]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:33.493]             on.exit(options(oopts), add = TRUE)
[15:32:33.493]         }
[15:32:33.493]         {
[15:32:33.493]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:33.493]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:33.493]                 ...future.FUN(...future.X_jj, ...)
[15:32:33.493]             })
[15:32:33.493]         }
[15:32:33.493]     }, args = future.call.arguments)
[15:32:33.493] }
[15:32:33.493] Tweak future expression to call with '...' arguments ... DONE
[15:32:33.494] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:33.494] 
[15:32:33.494] getGlobalsAndPackages() ... DONE
[15:32:33.495] run() for 'Future' ...
[15:32:33.495] - state: 'created'
[15:32:33.495] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:33.510] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:33.511] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:33.511]   - Field: 'node'
[15:32:33.511]   - Field: 'label'
[15:32:33.512]   - Field: 'local'
[15:32:33.512]   - Field: 'owner'
[15:32:33.512]   - Field: 'envir'
[15:32:33.513]   - Field: 'workers'
[15:32:33.513]   - Field: 'packages'
[15:32:33.513]   - Field: 'gc'
[15:32:33.513]   - Field: 'conditions'
[15:32:33.514]   - Field: 'persistent'
[15:32:33.514]   - Field: 'expr'
[15:32:33.514]   - Field: 'uuid'
[15:32:33.515]   - Field: 'seed'
[15:32:33.515]   - Field: 'version'
[15:32:33.515]   - Field: 'result'
[15:32:33.515]   - Field: 'asynchronous'
[15:32:33.515]   - Field: 'calls'
[15:32:33.516]   - Field: 'globals'
[15:32:33.516]   - Field: 'stdout'
[15:32:33.516]   - Field: 'earlySignal'
[15:32:33.516]   - Field: 'lazy'
[15:32:33.516]   - Field: 'state'
[15:32:33.516] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:33.517] - Launch lazy future ...
[15:32:33.517] Packages needed by the future expression (n = 0): <none>
[15:32:33.517] Packages needed by future strategies (n = 0): <none>
[15:32:33.518] {
[15:32:33.518]     {
[15:32:33.518]         {
[15:32:33.518]             ...future.startTime <- base::Sys.time()
[15:32:33.518]             {
[15:32:33.518]                 {
[15:32:33.518]                   {
[15:32:33.518]                     {
[15:32:33.518]                       base::local({
[15:32:33.518]                         has_future <- base::requireNamespace("future", 
[15:32:33.518]                           quietly = TRUE)
[15:32:33.518]                         if (has_future) {
[15:32:33.518]                           ns <- base::getNamespace("future")
[15:32:33.518]                           version <- ns[[".package"]][["version"]]
[15:32:33.518]                           if (is.null(version)) 
[15:32:33.518]                             version <- utils::packageVersion("future")
[15:32:33.518]                         }
[15:32:33.518]                         else {
[15:32:33.518]                           version <- NULL
[15:32:33.518]                         }
[15:32:33.518]                         if (!has_future || version < "1.8.0") {
[15:32:33.518]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:33.518]                             "", base::R.version$version.string), 
[15:32:33.518]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:33.518]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:33.518]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:33.518]                               "release", "version")], collapse = " "), 
[15:32:33.518]                             hostname = base::Sys.info()[["nodename"]])
[15:32:33.518]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:33.518]                             info)
[15:32:33.518]                           info <- base::paste(info, collapse = "; ")
[15:32:33.518]                           if (!has_future) {
[15:32:33.518]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:33.518]                               info)
[15:32:33.518]                           }
[15:32:33.518]                           else {
[15:32:33.518]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:33.518]                               info, version)
[15:32:33.518]                           }
[15:32:33.518]                           base::stop(msg)
[15:32:33.518]                         }
[15:32:33.518]                       })
[15:32:33.518]                     }
[15:32:33.518]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:33.518]                     base::options(mc.cores = 1L)
[15:32:33.518]                   }
[15:32:33.518]                   ...future.strategy.old <- future::plan("list")
[15:32:33.518]                   options(future.plan = NULL)
[15:32:33.518]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:33.518]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:33.518]                 }
[15:32:33.518]                 ...future.workdir <- getwd()
[15:32:33.518]             }
[15:32:33.518]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:33.518]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:33.518]         }
[15:32:33.518]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:33.518]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:33.518]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:33.518]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:33.518]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:33.518]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:33.518]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:33.518]             base::names(...future.oldOptions))
[15:32:33.518]     }
[15:32:33.518]     if (FALSE) {
[15:32:33.518]     }
[15:32:33.518]     else {
[15:32:33.518]         if (TRUE) {
[15:32:33.518]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:33.518]                 open = "w")
[15:32:33.518]         }
[15:32:33.518]         else {
[15:32:33.518]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:33.518]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:33.518]         }
[15:32:33.518]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:33.518]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:33.518]             base::sink(type = "output", split = FALSE)
[15:32:33.518]             base::close(...future.stdout)
[15:32:33.518]         }, add = TRUE)
[15:32:33.518]     }
[15:32:33.518]     ...future.frame <- base::sys.nframe()
[15:32:33.518]     ...future.conditions <- base::list()
[15:32:33.518]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:33.518]     if (FALSE) {
[15:32:33.518]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:33.518]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:33.518]     }
[15:32:33.518]     ...future.result <- base::tryCatch({
[15:32:33.518]         base::withCallingHandlers({
[15:32:33.518]             ...future.value <- base::withVisible(base::local({
[15:32:33.518]                 ...future.makeSendCondition <- base::local({
[15:32:33.518]                   sendCondition <- NULL
[15:32:33.518]                   function(frame = 1L) {
[15:32:33.518]                     if (is.function(sendCondition)) 
[15:32:33.518]                       return(sendCondition)
[15:32:33.518]                     ns <- getNamespace("parallel")
[15:32:33.518]                     if (exists("sendData", mode = "function", 
[15:32:33.518]                       envir = ns)) {
[15:32:33.518]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:33.518]                         envir = ns)
[15:32:33.518]                       envir <- sys.frame(frame)
[15:32:33.518]                       master <- NULL
[15:32:33.518]                       while (!identical(envir, .GlobalEnv) && 
[15:32:33.518]                         !identical(envir, emptyenv())) {
[15:32:33.518]                         if (exists("master", mode = "list", envir = envir, 
[15:32:33.518]                           inherits = FALSE)) {
[15:32:33.518]                           master <- get("master", mode = "list", 
[15:32:33.518]                             envir = envir, inherits = FALSE)
[15:32:33.518]                           if (inherits(master, c("SOCKnode", 
[15:32:33.518]                             "SOCK0node"))) {
[15:32:33.518]                             sendCondition <<- function(cond) {
[15:32:33.518]                               data <- list(type = "VALUE", value = cond, 
[15:32:33.518]                                 success = TRUE)
[15:32:33.518]                               parallel_sendData(master, data)
[15:32:33.518]                             }
[15:32:33.518]                             return(sendCondition)
[15:32:33.518]                           }
[15:32:33.518]                         }
[15:32:33.518]                         frame <- frame + 1L
[15:32:33.518]                         envir <- sys.frame(frame)
[15:32:33.518]                       }
[15:32:33.518]                     }
[15:32:33.518]                     sendCondition <<- function(cond) NULL
[15:32:33.518]                   }
[15:32:33.518]                 })
[15:32:33.518]                 withCallingHandlers({
[15:32:33.518]                   {
[15:32:33.518]                     do.call(function(...) {
[15:32:33.518]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:33.518]                       if (!identical(...future.globals.maxSize.org, 
[15:32:33.518]                         ...future.globals.maxSize)) {
[15:32:33.518]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:33.518]                         on.exit(options(oopts), add = TRUE)
[15:32:33.518]                       }
[15:32:33.518]                       {
[15:32:33.518]                         lapply(seq_along(...future.elements_ii), 
[15:32:33.518]                           FUN = function(jj) {
[15:32:33.518]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:33.518]                             ...future.FUN(...future.X_jj, ...)
[15:32:33.518]                           })
[15:32:33.518]                       }
[15:32:33.518]                     }, args = future.call.arguments)
[15:32:33.518]                   }
[15:32:33.518]                 }, immediateCondition = function(cond) {
[15:32:33.518]                   sendCondition <- ...future.makeSendCondition()
[15:32:33.518]                   sendCondition(cond)
[15:32:33.518]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:33.518]                   {
[15:32:33.518]                     inherits <- base::inherits
[15:32:33.518]                     invokeRestart <- base::invokeRestart
[15:32:33.518]                     is.null <- base::is.null
[15:32:33.518]                     muffled <- FALSE
[15:32:33.518]                     if (inherits(cond, "message")) {
[15:32:33.518]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:33.518]                       if (muffled) 
[15:32:33.518]                         invokeRestart("muffleMessage")
[15:32:33.518]                     }
[15:32:33.518]                     else if (inherits(cond, "warning")) {
[15:32:33.518]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:33.518]                       if (muffled) 
[15:32:33.518]                         invokeRestart("muffleWarning")
[15:32:33.518]                     }
[15:32:33.518]                     else if (inherits(cond, "condition")) {
[15:32:33.518]                       if (!is.null(pattern)) {
[15:32:33.518]                         computeRestarts <- base::computeRestarts
[15:32:33.518]                         grepl <- base::grepl
[15:32:33.518]                         restarts <- computeRestarts(cond)
[15:32:33.518]                         for (restart in restarts) {
[15:32:33.518]                           name <- restart$name
[15:32:33.518]                           if (is.null(name)) 
[15:32:33.518]                             next
[15:32:33.518]                           if (!grepl(pattern, name)) 
[15:32:33.518]                             next
[15:32:33.518]                           invokeRestart(restart)
[15:32:33.518]                           muffled <- TRUE
[15:32:33.518]                           break
[15:32:33.518]                         }
[15:32:33.518]                       }
[15:32:33.518]                     }
[15:32:33.518]                     invisible(muffled)
[15:32:33.518]                   }
[15:32:33.518]                   muffleCondition(cond)
[15:32:33.518]                 })
[15:32:33.518]             }))
[15:32:33.518]             future::FutureResult(value = ...future.value$value, 
[15:32:33.518]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:33.518]                   ...future.rng), globalenv = if (FALSE) 
[15:32:33.518]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:33.518]                     ...future.globalenv.names))
[15:32:33.518]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:33.518]         }, condition = base::local({
[15:32:33.518]             c <- base::c
[15:32:33.518]             inherits <- base::inherits
[15:32:33.518]             invokeRestart <- base::invokeRestart
[15:32:33.518]             length <- base::length
[15:32:33.518]             list <- base::list
[15:32:33.518]             seq.int <- base::seq.int
[15:32:33.518]             signalCondition <- base::signalCondition
[15:32:33.518]             sys.calls <- base::sys.calls
[15:32:33.518]             `[[` <- base::`[[`
[15:32:33.518]             `+` <- base::`+`
[15:32:33.518]             `<<-` <- base::`<<-`
[15:32:33.518]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:33.518]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:33.518]                   3L)]
[15:32:33.518]             }
[15:32:33.518]             function(cond) {
[15:32:33.518]                 is_error <- inherits(cond, "error")
[15:32:33.518]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:33.518]                   NULL)
[15:32:33.518]                 if (is_error) {
[15:32:33.518]                   sessionInformation <- function() {
[15:32:33.518]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:33.518]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:33.518]                       search = base::search(), system = base::Sys.info())
[15:32:33.518]                   }
[15:32:33.518]                   ...future.conditions[[length(...future.conditions) + 
[15:32:33.518]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:33.518]                     cond$call), session = sessionInformation(), 
[15:32:33.518]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:33.518]                   signalCondition(cond)
[15:32:33.518]                 }
[15:32:33.518]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:33.518]                 "immediateCondition"))) {
[15:32:33.518]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:33.518]                   ...future.conditions[[length(...future.conditions) + 
[15:32:33.518]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:33.518]                   if (TRUE && !signal) {
[15:32:33.518]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:33.518]                     {
[15:32:33.518]                       inherits <- base::inherits
[15:32:33.518]                       invokeRestart <- base::invokeRestart
[15:32:33.518]                       is.null <- base::is.null
[15:32:33.518]                       muffled <- FALSE
[15:32:33.518]                       if (inherits(cond, "message")) {
[15:32:33.518]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:33.518]                         if (muffled) 
[15:32:33.518]                           invokeRestart("muffleMessage")
[15:32:33.518]                       }
[15:32:33.518]                       else if (inherits(cond, "warning")) {
[15:32:33.518]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:33.518]                         if (muffled) 
[15:32:33.518]                           invokeRestart("muffleWarning")
[15:32:33.518]                       }
[15:32:33.518]                       else if (inherits(cond, "condition")) {
[15:32:33.518]                         if (!is.null(pattern)) {
[15:32:33.518]                           computeRestarts <- base::computeRestarts
[15:32:33.518]                           grepl <- base::grepl
[15:32:33.518]                           restarts <- computeRestarts(cond)
[15:32:33.518]                           for (restart in restarts) {
[15:32:33.518]                             name <- restart$name
[15:32:33.518]                             if (is.null(name)) 
[15:32:33.518]                               next
[15:32:33.518]                             if (!grepl(pattern, name)) 
[15:32:33.518]                               next
[15:32:33.518]                             invokeRestart(restart)
[15:32:33.518]                             muffled <- TRUE
[15:32:33.518]                             break
[15:32:33.518]                           }
[15:32:33.518]                         }
[15:32:33.518]                       }
[15:32:33.518]                       invisible(muffled)
[15:32:33.518]                     }
[15:32:33.518]                     muffleCondition(cond, pattern = "^muffle")
[15:32:33.518]                   }
[15:32:33.518]                 }
[15:32:33.518]                 else {
[15:32:33.518]                   if (TRUE) {
[15:32:33.518]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:33.518]                     {
[15:32:33.518]                       inherits <- base::inherits
[15:32:33.518]                       invokeRestart <- base::invokeRestart
[15:32:33.518]                       is.null <- base::is.null
[15:32:33.518]                       muffled <- FALSE
[15:32:33.518]                       if (inherits(cond, "message")) {
[15:32:33.518]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:33.518]                         if (muffled) 
[15:32:33.518]                           invokeRestart("muffleMessage")
[15:32:33.518]                       }
[15:32:33.518]                       else if (inherits(cond, "warning")) {
[15:32:33.518]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:33.518]                         if (muffled) 
[15:32:33.518]                           invokeRestart("muffleWarning")
[15:32:33.518]                       }
[15:32:33.518]                       else if (inherits(cond, "condition")) {
[15:32:33.518]                         if (!is.null(pattern)) {
[15:32:33.518]                           computeRestarts <- base::computeRestarts
[15:32:33.518]                           grepl <- base::grepl
[15:32:33.518]                           restarts <- computeRestarts(cond)
[15:32:33.518]                           for (restart in restarts) {
[15:32:33.518]                             name <- restart$name
[15:32:33.518]                             if (is.null(name)) 
[15:32:33.518]                               next
[15:32:33.518]                             if (!grepl(pattern, name)) 
[15:32:33.518]                               next
[15:32:33.518]                             invokeRestart(restart)
[15:32:33.518]                             muffled <- TRUE
[15:32:33.518]                             break
[15:32:33.518]                           }
[15:32:33.518]                         }
[15:32:33.518]                       }
[15:32:33.518]                       invisible(muffled)
[15:32:33.518]                     }
[15:32:33.518]                     muffleCondition(cond, pattern = "^muffle")
[15:32:33.518]                   }
[15:32:33.518]                 }
[15:32:33.518]             }
[15:32:33.518]         }))
[15:32:33.518]     }, error = function(ex) {
[15:32:33.518]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:33.518]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:33.518]                 ...future.rng), started = ...future.startTime, 
[15:32:33.518]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:33.518]             version = "1.8"), class = "FutureResult")
[15:32:33.518]     }, finally = {
[15:32:33.518]         if (!identical(...future.workdir, getwd())) 
[15:32:33.518]             setwd(...future.workdir)
[15:32:33.518]         {
[15:32:33.518]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:33.518]                 ...future.oldOptions$nwarnings <- NULL
[15:32:33.518]             }
[15:32:33.518]             base::options(...future.oldOptions)
[15:32:33.518]             if (.Platform$OS.type == "windows") {
[15:32:33.518]                 old_names <- names(...future.oldEnvVars)
[15:32:33.518]                 envs <- base::Sys.getenv()
[15:32:33.518]                 names <- names(envs)
[15:32:33.518]                 common <- intersect(names, old_names)
[15:32:33.518]                 added <- setdiff(names, old_names)
[15:32:33.518]                 removed <- setdiff(old_names, names)
[15:32:33.518]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:33.518]                   envs[common]]
[15:32:33.518]                 NAMES <- toupper(changed)
[15:32:33.518]                 args <- list()
[15:32:33.518]                 for (kk in seq_along(NAMES)) {
[15:32:33.518]                   name <- changed[[kk]]
[15:32:33.518]                   NAME <- NAMES[[kk]]
[15:32:33.518]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:33.518]                     next
[15:32:33.518]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:33.518]                 }
[15:32:33.518]                 NAMES <- toupper(added)
[15:32:33.518]                 for (kk in seq_along(NAMES)) {
[15:32:33.518]                   name <- added[[kk]]
[15:32:33.518]                   NAME <- NAMES[[kk]]
[15:32:33.518]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:33.518]                     next
[15:32:33.518]                   args[[name]] <- ""
[15:32:33.518]                 }
[15:32:33.518]                 NAMES <- toupper(removed)
[15:32:33.518]                 for (kk in seq_along(NAMES)) {
[15:32:33.518]                   name <- removed[[kk]]
[15:32:33.518]                   NAME <- NAMES[[kk]]
[15:32:33.518]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:33.518]                     next
[15:32:33.518]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:33.518]                 }
[15:32:33.518]                 if (length(args) > 0) 
[15:32:33.518]                   base::do.call(base::Sys.setenv, args = args)
[15:32:33.518]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:33.518]             }
[15:32:33.518]             else {
[15:32:33.518]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:33.518]             }
[15:32:33.518]             {
[15:32:33.518]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:33.518]                   0L) {
[15:32:33.518]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:33.518]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:33.518]                   base::options(opts)
[15:32:33.518]                 }
[15:32:33.518]                 {
[15:32:33.518]                   {
[15:32:33.518]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:33.518]                     NULL
[15:32:33.518]                   }
[15:32:33.518]                   options(future.plan = NULL)
[15:32:33.518]                   if (is.na(NA_character_)) 
[15:32:33.518]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:33.518]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:33.518]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:33.518]                     .init = FALSE)
[15:32:33.518]                 }
[15:32:33.518]             }
[15:32:33.518]         }
[15:32:33.518]     })
[15:32:33.518]     if (TRUE) {
[15:32:33.518]         base::sink(type = "output", split = FALSE)
[15:32:33.518]         if (TRUE) {
[15:32:33.518]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:33.518]         }
[15:32:33.518]         else {
[15:32:33.518]             ...future.result["stdout"] <- base::list(NULL)
[15:32:33.518]         }
[15:32:33.518]         base::close(...future.stdout)
[15:32:33.518]         ...future.stdout <- NULL
[15:32:33.518]     }
[15:32:33.518]     ...future.result$conditions <- ...future.conditions
[15:32:33.518]     ...future.result$finished <- base::Sys.time()
[15:32:33.518]     ...future.result
[15:32:33.518] }
[15:32:33.525] Exporting 5 global objects (4.62 KiB) to cluster node #1 ...
[15:32:33.526] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ...
[15:32:33.527] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ... DONE
[15:32:33.527] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:33.528] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:33.528] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ...
[15:32:33.529] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ... DONE
[15:32:33.529] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:33.530] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:33.530] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:33.530] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:33.531] Exporting 5 global objects (4.62 KiB) to cluster node #1 ... DONE
[15:32:33.532] MultisessionFuture started
[15:32:33.532] - Launch lazy future ... done
[15:32:33.532] run() for 'MultisessionFuture' ... done
[15:32:33.533] Created future:
[15:32:33.558] receiveMessageFromWorker() for ClusterFuture ...
[15:32:33.559] - Validating connection of MultisessionFuture
[15:32:33.559] - received message: FutureResult
[15:32:33.559] - Received FutureResult
[15:32:33.559] - Erased future from FutureRegistry
[15:32:33.560] result() for ClusterFuture ...
[15:32:33.560] - result already collected: FutureResult
[15:32:33.560] result() for ClusterFuture ... done
[15:32:33.560] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:33.533] MultisessionFuture:
[15:32:33.533] Label: 'future_sapply-2'
[15:32:33.533] Expression:
[15:32:33.533] {
[15:32:33.533]     do.call(function(...) {
[15:32:33.533]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:33.533]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:33.533]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:33.533]             on.exit(options(oopts), add = TRUE)
[15:32:33.533]         }
[15:32:33.533]         {
[15:32:33.533]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:33.533]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:33.533]                 ...future.FUN(...future.X_jj, ...)
[15:32:33.533]             })
[15:32:33.533]         }
[15:32:33.533]     }, args = future.call.arguments)
[15:32:33.533] }
[15:32:33.533] Lazy evaluation: FALSE
[15:32:33.533] Asynchronous evaluation: TRUE
[15:32:33.533] Local evaluation: TRUE
[15:32:33.533] Environment: R_GlobalEnv
[15:32:33.533] Capture standard output: TRUE
[15:32:33.533] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:33.533] Globals: 5 objects totaling 4.78 KiB (function '...future.FUN' of 4.62 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:33.533] Packages: <none>
[15:32:33.533] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:33.533] Resolved: TRUE
[15:32:33.533] Value: <not collected>
[15:32:33.533] Conditions captured: <none>
[15:32:33.533] Early signaling: FALSE
[15:32:33.533] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:33.533] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:33.561] Chunk #2 of 2 ... DONE
[15:32:33.561] Launching 2 futures (chunks) ... DONE
[15:32:33.562] Resolving 2 futures (chunks) ...
[15:32:33.562] resolve() on list ...
[15:32:33.562]  recursive: 0
[15:32:33.563]  length: 2
[15:32:33.563] 
[15:32:33.563] Future #1
[15:32:33.563] result() for ClusterFuture ...
[15:32:33.564] - result already collected: FutureResult
[15:32:33.564] result() for ClusterFuture ... done
[15:32:33.564] result() for ClusterFuture ...
[15:32:33.564] - result already collected: FutureResult
[15:32:33.565] result() for ClusterFuture ... done
[15:32:33.565] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:33.565] - nx: 2
[15:32:33.565] - relay: TRUE
[15:32:33.566] - stdout: TRUE
[15:32:33.566] - signal: TRUE
[15:32:33.566] - resignal: FALSE
[15:32:33.566] - force: TRUE
[15:32:33.567] - relayed: [n=2] FALSE, FALSE
[15:32:33.567] - queued futures: [n=2] FALSE, FALSE
[15:32:33.567]  - until=1
[15:32:33.568]  - relaying element #1
[15:32:33.568] result() for ClusterFuture ...
[15:32:33.568] - result already collected: FutureResult
[15:32:33.568] result() for ClusterFuture ... done
[15:32:33.569] result() for ClusterFuture ...
[15:32:33.569] - result already collected: FutureResult
[15:32:33.569] result() for ClusterFuture ... done
[15:32:33.574] result() for ClusterFuture ...
[15:32:33.574] - result already collected: FutureResult
[15:32:33.574] result() for ClusterFuture ... done
[15:32:33.575] result() for ClusterFuture ...
[15:32:33.575] - result already collected: FutureResult
[15:32:33.575] result() for ClusterFuture ... done
[15:32:33.575] - relayed: [n=2] TRUE, FALSE
[15:32:33.576] - queued futures: [n=2] TRUE, FALSE
[15:32:33.576] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:33.576]  length: 1 (resolved future 1)
[15:32:33.577] Future #2
[15:32:33.577] result() for ClusterFuture ...
[15:32:33.577] - result already collected: FutureResult
[15:32:33.578] result() for ClusterFuture ... done
[15:32:33.578] result() for ClusterFuture ...
[15:32:33.578] - result already collected: FutureResult
[15:32:33.578] result() for ClusterFuture ... done
[15:32:33.579] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:33.579] - nx: 2
[15:32:33.579] - relay: TRUE
[15:32:33.580] - stdout: TRUE
[15:32:33.580] - signal: TRUE
[15:32:33.580] - resignal: FALSE
[15:32:33.580] - force: TRUE
[15:32:33.581] - relayed: [n=2] TRUE, FALSE
[15:32:33.581] - queued futures: [n=2] TRUE, FALSE
[15:32:33.581]  - until=2
[15:32:33.581]  - relaying element #2
[15:32:33.582] result() for ClusterFuture ...
[15:32:33.582] - result already collected: FutureResult
[15:32:33.582] result() for ClusterFuture ... done
[15:32:33.582] result() for ClusterFuture ...
[15:32:33.583] - result already collected: FutureResult
[15:32:33.583] result() for ClusterFuture ... done
[15:32:33.583] result() for ClusterFuture ...
[15:32:33.584] - result already collected: FutureResult
[15:32:33.584] result() for ClusterFuture ... done
[15:32:33.584] result() for ClusterFuture ...
[15:32:33.584] - result already collected: FutureResult
[15:32:33.585] result() for ClusterFuture ... done
[15:32:33.585] - relayed: [n=2] TRUE, TRUE
[15:32:33.585] - queued futures: [n=2] TRUE, TRUE
[15:32:33.585] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:33.586]  length: 0 (resolved future 2)
[15:32:33.586] Relaying remaining futures
[15:32:33.586] signalConditionsASAP(NULL, pos=0) ...
[15:32:33.586] - nx: 2
[15:32:33.587] - relay: TRUE
[15:32:33.587] - stdout: TRUE
[15:32:33.587] - signal: TRUE
[15:32:33.587] - resignal: FALSE
[15:32:33.588] - force: TRUE
[15:32:33.588] - relayed: [n=2] TRUE, TRUE
[15:32:33.588] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:33.588] - relayed: [n=2] TRUE, TRUE
[15:32:33.589] - queued futures: [n=2] TRUE, TRUE
[15:32:33.589] signalConditionsASAP(NULL, pos=0) ... done
[15:32:33.589] resolve() on list ... DONE
[15:32:33.589] result() for ClusterFuture ...
[15:32:33.590] - result already collected: FutureResult
[15:32:33.590] result() for ClusterFuture ... done
[15:32:33.590] result() for ClusterFuture ...
[15:32:33.591] - result already collected: FutureResult
[15:32:33.591] result() for ClusterFuture ... done
[15:32:33.591] result() for ClusterFuture ...
[15:32:33.591] - result already collected: FutureResult
[15:32:33.592] result() for ClusterFuture ... done
[15:32:33.592] result() for ClusterFuture ...
[15:32:33.592] - result already collected: FutureResult
[15:32:33.592] result() for ClusterFuture ... done
[15:32:33.593]  - Number of value chunks collected: 2
[15:32:33.593] Resolving 2 futures (chunks) ... DONE
[15:32:33.593] Reducing values from 2 chunks ...
[15:32:33.593]  - Number of values collected after concatenation: 6
[15:32:33.594]  - Number of values expected: 6
[15:32:33.594] Reducing values from 2 chunks ... DONE
[15:32:33.594] future_lapply() ... DONE
List of 2
 $ y0:List of 6
  ..$ a1: num [1:3, 1:5] 2 2 2 4 4 4 6 6 6 8 ...
  ..$ a2: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
  ..$ b1: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
  ..$ b2: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
  ..$ c1: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
  ..$ c2: num [1:3, 1:5] 8 8 8 16 16 16 24 24 24 32 ...
 $ y1:List of 6
  ..$ a1: num [1:3, 1:5] 2 2 2 4 4 4 6 6 6 8 ...
  ..$ a2: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
  ..$ b1: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
  ..$ b2: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
  ..$ c1: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
  ..$ c2: num [1:3, 1:5] 8 8 8 16 16 16 24 24 24 32 ...
List of 2
 $ y0:List of 6
  ..$ a1: num [1:3, 1:5] 2 2 2 4 4 4 6 6 6 8 ...
  ..$ a2: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
  ..$ b1: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
  ..$ b2: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
  ..$ c1: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
  ..$ c2: num [1:3, 1:5] 8 8 8 16 16 16 24 24 24 32 ...
 $ y2:List of 6
  ..$ a1: num [1:3, 1:5] 2 2 2 4 4 4 6 6 6 8 ...
  ..$ a2: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
  ..$ b1: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
  ..$ b2: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
  ..$ c1: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
  ..$ c2: num [1:3, 1:5] 8 8 8 16 16 16 24 24 24 32 ...
[15:32:33.614] future_lapply() ...
[15:32:33.619] Number of chunks: 2
[15:32:33.619] getGlobalsAndPackagesXApply() ...
[15:32:33.619]  - future.globals: TRUE
[15:32:33.620] getGlobalsAndPackages() ...
[15:32:33.620] Searching for globals...
[15:32:33.622] - globals found: [1] 'FUN'
[15:32:33.622] Searching for globals ... DONE
[15:32:33.622] Resolving globals: FALSE
[15:32:33.623] The total size of the 1 globals is 848 bytes (848 bytes)
[15:32:33.623] The total size of the 1 globals exported for future expression ('FUN()') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:32:33.624] - globals: [1] 'FUN'
[15:32:33.624] 
[15:32:33.624] getGlobalsAndPackages() ... DONE
[15:32:33.624]  - globals found/used: [n=1] 'FUN'
[15:32:33.625]  - needed namespaces: [n=0] 
[15:32:33.625] Finding globals ... DONE
[15:32:33.625]  - use_args: TRUE
[15:32:33.626]  - Getting '...' globals ...
[15:32:33.626] resolve() on list ...
[15:32:33.626]  recursive: 0
[15:32:33.627]  length: 1
[15:32:33.627]  elements: '...'
[15:32:33.627]  length: 0 (resolved future 1)
[15:32:33.628] resolve() on list ... DONE
[15:32:33.628]    - '...' content: [n=0] 
[15:32:33.628] List of 1
[15:32:33.628]  $ ...: list()
[15:32:33.628]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:33.628]  - attr(*, "where")=List of 1
[15:32:33.628]   ..$ ...:<environment: 0x00000276e19b67a0> 
[15:32:33.628]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:33.628]  - attr(*, "resolved")= logi TRUE
[15:32:33.628]  - attr(*, "total_size")= num NA
[15:32:33.633]  - Getting '...' globals ... DONE
[15:32:33.633] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:33.633] List of 2
[15:32:33.633]  $ ...future.FUN:function (x)  
[15:32:33.633]  $ ...          : list()
[15:32:33.633]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:33.633]  - attr(*, "where")=List of 2
[15:32:33.633]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:33.633]   ..$ ...          :<environment: 0x00000276e19b67a0> 
[15:32:33.633]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:33.633]  - attr(*, "resolved")= logi FALSE
[15:32:33.633]  - attr(*, "total_size")= num 848
[15:32:33.638] Packages to be attached in all futures: [n=0] 
[15:32:33.638] getGlobalsAndPackagesXApply() ... DONE
[15:32:33.639] Number of futures (= number of chunks): 2
[15:32:33.639] Launching 2 futures (chunks) ...
[15:32:33.639] Chunk #1 of 2 ...
[15:32:33.640]  - Finding globals in 'X' for chunk #1 ...
[15:32:33.640] getGlobalsAndPackages() ...
[15:32:33.640] Searching for globals...
[15:32:33.641] 
[15:32:33.641] Searching for globals ... DONE
[15:32:33.641] - globals: [0] <none>
[15:32:33.641] getGlobalsAndPackages() ... DONE
[15:32:33.642]    + additional globals found: [n=0] 
[15:32:33.642]    + additional namespaces needed: [n=0] 
[15:32:33.642]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:33.643]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:33.643]  - seeds: <none>
[15:32:33.643]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:33.643] getGlobalsAndPackages() ...
[15:32:33.644] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:33.644] Resolving globals: FALSE
[15:32:33.644] Tweak future expression to call with '...' arguments ...
[15:32:33.644] {
[15:32:33.644]     do.call(function(...) {
[15:32:33.644]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:33.644]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:33.644]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:33.644]             on.exit(options(oopts), add = TRUE)
[15:32:33.644]         }
[15:32:33.644]         {
[15:32:33.644]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:33.644]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:33.644]                 ...future.FUN(...future.X_jj, ...)
[15:32:33.644]             })
[15:32:33.644]         }
[15:32:33.644]     }, args = future.call.arguments)
[15:32:33.644] }
[15:32:33.645] Tweak future expression to call with '...' arguments ... DONE
[15:32:33.646] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:33.646] 
[15:32:33.646] getGlobalsAndPackages() ... DONE
[15:32:33.647] run() for 'Future' ...
[15:32:33.647] - state: 'created'
[15:32:33.648] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:33.665] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:33.665] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:33.665]   - Field: 'node'
[15:32:33.666]   - Field: 'label'
[15:32:33.666]   - Field: 'local'
[15:32:33.666]   - Field: 'owner'
[15:32:33.666]   - Field: 'envir'
[15:32:33.667]   - Field: 'workers'
[15:32:33.667]   - Field: 'packages'
[15:32:33.667]   - Field: 'gc'
[15:32:33.668]   - Field: 'conditions'
[15:32:33.668]   - Field: 'persistent'
[15:32:33.668]   - Field: 'expr'
[15:32:33.668]   - Field: 'uuid'
[15:32:33.669]   - Field: 'seed'
[15:32:33.669]   - Field: 'version'
[15:32:33.669]   - Field: 'result'
[15:32:33.670]   - Field: 'asynchronous'
[15:32:33.670]   - Field: 'calls'
[15:32:33.670]   - Field: 'globals'
[15:32:33.670]   - Field: 'stdout'
[15:32:33.671]   - Field: 'earlySignal'
[15:32:33.671]   - Field: 'lazy'
[15:32:33.671]   - Field: 'state'
[15:32:33.671] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:33.672] - Launch lazy future ...
[15:32:33.672] Packages needed by the future expression (n = 0): <none>
[15:32:33.673] Packages needed by future strategies (n = 0): <none>
[15:32:33.674] {
[15:32:33.674]     {
[15:32:33.674]         {
[15:32:33.674]             ...future.startTime <- base::Sys.time()
[15:32:33.674]             {
[15:32:33.674]                 {
[15:32:33.674]                   {
[15:32:33.674]                     {
[15:32:33.674]                       base::local({
[15:32:33.674]                         has_future <- base::requireNamespace("future", 
[15:32:33.674]                           quietly = TRUE)
[15:32:33.674]                         if (has_future) {
[15:32:33.674]                           ns <- base::getNamespace("future")
[15:32:33.674]                           version <- ns[[".package"]][["version"]]
[15:32:33.674]                           if (is.null(version)) 
[15:32:33.674]                             version <- utils::packageVersion("future")
[15:32:33.674]                         }
[15:32:33.674]                         else {
[15:32:33.674]                           version <- NULL
[15:32:33.674]                         }
[15:32:33.674]                         if (!has_future || version < "1.8.0") {
[15:32:33.674]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:33.674]                             "", base::R.version$version.string), 
[15:32:33.674]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:33.674]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:33.674]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:33.674]                               "release", "version")], collapse = " "), 
[15:32:33.674]                             hostname = base::Sys.info()[["nodename"]])
[15:32:33.674]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:33.674]                             info)
[15:32:33.674]                           info <- base::paste(info, collapse = "; ")
[15:32:33.674]                           if (!has_future) {
[15:32:33.674]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:33.674]                               info)
[15:32:33.674]                           }
[15:32:33.674]                           else {
[15:32:33.674]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:33.674]                               info, version)
[15:32:33.674]                           }
[15:32:33.674]                           base::stop(msg)
[15:32:33.674]                         }
[15:32:33.674]                       })
[15:32:33.674]                     }
[15:32:33.674]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:33.674]                     base::options(mc.cores = 1L)
[15:32:33.674]                   }
[15:32:33.674]                   ...future.strategy.old <- future::plan("list")
[15:32:33.674]                   options(future.plan = NULL)
[15:32:33.674]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:33.674]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:33.674]                 }
[15:32:33.674]                 ...future.workdir <- getwd()
[15:32:33.674]             }
[15:32:33.674]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:33.674]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:33.674]         }
[15:32:33.674]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:33.674]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:33.674]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:33.674]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:33.674]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:33.674]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:33.674]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:33.674]             base::names(...future.oldOptions))
[15:32:33.674]     }
[15:32:33.674]     if (FALSE) {
[15:32:33.674]     }
[15:32:33.674]     else {
[15:32:33.674]         if (TRUE) {
[15:32:33.674]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:33.674]                 open = "w")
[15:32:33.674]         }
[15:32:33.674]         else {
[15:32:33.674]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:33.674]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:33.674]         }
[15:32:33.674]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:33.674]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:33.674]             base::sink(type = "output", split = FALSE)
[15:32:33.674]             base::close(...future.stdout)
[15:32:33.674]         }, add = TRUE)
[15:32:33.674]     }
[15:32:33.674]     ...future.frame <- base::sys.nframe()
[15:32:33.674]     ...future.conditions <- base::list()
[15:32:33.674]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:33.674]     if (FALSE) {
[15:32:33.674]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:33.674]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:33.674]     }
[15:32:33.674]     ...future.result <- base::tryCatch({
[15:32:33.674]         base::withCallingHandlers({
[15:32:33.674]             ...future.value <- base::withVisible(base::local({
[15:32:33.674]                 ...future.makeSendCondition <- base::local({
[15:32:33.674]                   sendCondition <- NULL
[15:32:33.674]                   function(frame = 1L) {
[15:32:33.674]                     if (is.function(sendCondition)) 
[15:32:33.674]                       return(sendCondition)
[15:32:33.674]                     ns <- getNamespace("parallel")
[15:32:33.674]                     if (exists("sendData", mode = "function", 
[15:32:33.674]                       envir = ns)) {
[15:32:33.674]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:33.674]                         envir = ns)
[15:32:33.674]                       envir <- sys.frame(frame)
[15:32:33.674]                       master <- NULL
[15:32:33.674]                       while (!identical(envir, .GlobalEnv) && 
[15:32:33.674]                         !identical(envir, emptyenv())) {
[15:32:33.674]                         if (exists("master", mode = "list", envir = envir, 
[15:32:33.674]                           inherits = FALSE)) {
[15:32:33.674]                           master <- get("master", mode = "list", 
[15:32:33.674]                             envir = envir, inherits = FALSE)
[15:32:33.674]                           if (inherits(master, c("SOCKnode", 
[15:32:33.674]                             "SOCK0node"))) {
[15:32:33.674]                             sendCondition <<- function(cond) {
[15:32:33.674]                               data <- list(type = "VALUE", value = cond, 
[15:32:33.674]                                 success = TRUE)
[15:32:33.674]                               parallel_sendData(master, data)
[15:32:33.674]                             }
[15:32:33.674]                             return(sendCondition)
[15:32:33.674]                           }
[15:32:33.674]                         }
[15:32:33.674]                         frame <- frame + 1L
[15:32:33.674]                         envir <- sys.frame(frame)
[15:32:33.674]                       }
[15:32:33.674]                     }
[15:32:33.674]                     sendCondition <<- function(cond) NULL
[15:32:33.674]                   }
[15:32:33.674]                 })
[15:32:33.674]                 withCallingHandlers({
[15:32:33.674]                   {
[15:32:33.674]                     do.call(function(...) {
[15:32:33.674]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:33.674]                       if (!identical(...future.globals.maxSize.org, 
[15:32:33.674]                         ...future.globals.maxSize)) {
[15:32:33.674]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:33.674]                         on.exit(options(oopts), add = TRUE)
[15:32:33.674]                       }
[15:32:33.674]                       {
[15:32:33.674]                         lapply(seq_along(...future.elements_ii), 
[15:32:33.674]                           FUN = function(jj) {
[15:32:33.674]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:33.674]                             ...future.FUN(...future.X_jj, ...)
[15:32:33.674]                           })
[15:32:33.674]                       }
[15:32:33.674]                     }, args = future.call.arguments)
[15:32:33.674]                   }
[15:32:33.674]                 }, immediateCondition = function(cond) {
[15:32:33.674]                   sendCondition <- ...future.makeSendCondition()
[15:32:33.674]                   sendCondition(cond)
[15:32:33.674]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:33.674]                   {
[15:32:33.674]                     inherits <- base::inherits
[15:32:33.674]                     invokeRestart <- base::invokeRestart
[15:32:33.674]                     is.null <- base::is.null
[15:32:33.674]                     muffled <- FALSE
[15:32:33.674]                     if (inherits(cond, "message")) {
[15:32:33.674]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:33.674]                       if (muffled) 
[15:32:33.674]                         invokeRestart("muffleMessage")
[15:32:33.674]                     }
[15:32:33.674]                     else if (inherits(cond, "warning")) {
[15:32:33.674]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:33.674]                       if (muffled) 
[15:32:33.674]                         invokeRestart("muffleWarning")
[15:32:33.674]                     }
[15:32:33.674]                     else if (inherits(cond, "condition")) {
[15:32:33.674]                       if (!is.null(pattern)) {
[15:32:33.674]                         computeRestarts <- base::computeRestarts
[15:32:33.674]                         grepl <- base::grepl
[15:32:33.674]                         restarts <- computeRestarts(cond)
[15:32:33.674]                         for (restart in restarts) {
[15:32:33.674]                           name <- restart$name
[15:32:33.674]                           if (is.null(name)) 
[15:32:33.674]                             next
[15:32:33.674]                           if (!grepl(pattern, name)) 
[15:32:33.674]                             next
[15:32:33.674]                           invokeRestart(restart)
[15:32:33.674]                           muffled <- TRUE
[15:32:33.674]                           break
[15:32:33.674]                         }
[15:32:33.674]                       }
[15:32:33.674]                     }
[15:32:33.674]                     invisible(muffled)
[15:32:33.674]                   }
[15:32:33.674]                   muffleCondition(cond)
[15:32:33.674]                 })
[15:32:33.674]             }))
[15:32:33.674]             future::FutureResult(value = ...future.value$value, 
[15:32:33.674]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:33.674]                   ...future.rng), globalenv = if (FALSE) 
[15:32:33.674]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:33.674]                     ...future.globalenv.names))
[15:32:33.674]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:33.674]         }, condition = base::local({
[15:32:33.674]             c <- base::c
[15:32:33.674]             inherits <- base::inherits
[15:32:33.674]             invokeRestart <- base::invokeRestart
[15:32:33.674]             length <- base::length
[15:32:33.674]             list <- base::list
[15:32:33.674]             seq.int <- base::seq.int
[15:32:33.674]             signalCondition <- base::signalCondition
[15:32:33.674]             sys.calls <- base::sys.calls
[15:32:33.674]             `[[` <- base::`[[`
[15:32:33.674]             `+` <- base::`+`
[15:32:33.674]             `<<-` <- base::`<<-`
[15:32:33.674]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:33.674]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:33.674]                   3L)]
[15:32:33.674]             }
[15:32:33.674]             function(cond) {
[15:32:33.674]                 is_error <- inherits(cond, "error")
[15:32:33.674]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:33.674]                   NULL)
[15:32:33.674]                 if (is_error) {
[15:32:33.674]                   sessionInformation <- function() {
[15:32:33.674]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:33.674]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:33.674]                       search = base::search(), system = base::Sys.info())
[15:32:33.674]                   }
[15:32:33.674]                   ...future.conditions[[length(...future.conditions) + 
[15:32:33.674]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:33.674]                     cond$call), session = sessionInformation(), 
[15:32:33.674]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:33.674]                   signalCondition(cond)
[15:32:33.674]                 }
[15:32:33.674]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:33.674]                 "immediateCondition"))) {
[15:32:33.674]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:33.674]                   ...future.conditions[[length(...future.conditions) + 
[15:32:33.674]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:33.674]                   if (TRUE && !signal) {
[15:32:33.674]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:33.674]                     {
[15:32:33.674]                       inherits <- base::inherits
[15:32:33.674]                       invokeRestart <- base::invokeRestart
[15:32:33.674]                       is.null <- base::is.null
[15:32:33.674]                       muffled <- FALSE
[15:32:33.674]                       if (inherits(cond, "message")) {
[15:32:33.674]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:33.674]                         if (muffled) 
[15:32:33.674]                           invokeRestart("muffleMessage")
[15:32:33.674]                       }
[15:32:33.674]                       else if (inherits(cond, "warning")) {
[15:32:33.674]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:33.674]                         if (muffled) 
[15:32:33.674]                           invokeRestart("muffleWarning")
[15:32:33.674]                       }
[15:32:33.674]                       else if (inherits(cond, "condition")) {
[15:32:33.674]                         if (!is.null(pattern)) {
[15:32:33.674]                           computeRestarts <- base::computeRestarts
[15:32:33.674]                           grepl <- base::grepl
[15:32:33.674]                           restarts <- computeRestarts(cond)
[15:32:33.674]                           for (restart in restarts) {
[15:32:33.674]                             name <- restart$name
[15:32:33.674]                             if (is.null(name)) 
[15:32:33.674]                               next
[15:32:33.674]                             if (!grepl(pattern, name)) 
[15:32:33.674]                               next
[15:32:33.674]                             invokeRestart(restart)
[15:32:33.674]                             muffled <- TRUE
[15:32:33.674]                             break
[15:32:33.674]                           }
[15:32:33.674]                         }
[15:32:33.674]                       }
[15:32:33.674]                       invisible(muffled)
[15:32:33.674]                     }
[15:32:33.674]                     muffleCondition(cond, pattern = "^muffle")
[15:32:33.674]                   }
[15:32:33.674]                 }
[15:32:33.674]                 else {
[15:32:33.674]                   if (TRUE) {
[15:32:33.674]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:33.674]                     {
[15:32:33.674]                       inherits <- base::inherits
[15:32:33.674]                       invokeRestart <- base::invokeRestart
[15:32:33.674]                       is.null <- base::is.null
[15:32:33.674]                       muffled <- FALSE
[15:32:33.674]                       if (inherits(cond, "message")) {
[15:32:33.674]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:33.674]                         if (muffled) 
[15:32:33.674]                           invokeRestart("muffleMessage")
[15:32:33.674]                       }
[15:32:33.674]                       else if (inherits(cond, "warning")) {
[15:32:33.674]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:33.674]                         if (muffled) 
[15:32:33.674]                           invokeRestart("muffleWarning")
[15:32:33.674]                       }
[15:32:33.674]                       else if (inherits(cond, "condition")) {
[15:32:33.674]                         if (!is.null(pattern)) {
[15:32:33.674]                           computeRestarts <- base::computeRestarts
[15:32:33.674]                           grepl <- base::grepl
[15:32:33.674]                           restarts <- computeRestarts(cond)
[15:32:33.674]                           for (restart in restarts) {
[15:32:33.674]                             name <- restart$name
[15:32:33.674]                             if (is.null(name)) 
[15:32:33.674]                               next
[15:32:33.674]                             if (!grepl(pattern, name)) 
[15:32:33.674]                               next
[15:32:33.674]                             invokeRestart(restart)
[15:32:33.674]                             muffled <- TRUE
[15:32:33.674]                             break
[15:32:33.674]                           }
[15:32:33.674]                         }
[15:32:33.674]                       }
[15:32:33.674]                       invisible(muffled)
[15:32:33.674]                     }
[15:32:33.674]                     muffleCondition(cond, pattern = "^muffle")
[15:32:33.674]                   }
[15:32:33.674]                 }
[15:32:33.674]             }
[15:32:33.674]         }))
[15:32:33.674]     }, error = function(ex) {
[15:32:33.674]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:33.674]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:33.674]                 ...future.rng), started = ...future.startTime, 
[15:32:33.674]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:33.674]             version = "1.8"), class = "FutureResult")
[15:32:33.674]     }, finally = {
[15:32:33.674]         if (!identical(...future.workdir, getwd())) 
[15:32:33.674]             setwd(...future.workdir)
[15:32:33.674]         {
[15:32:33.674]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:33.674]                 ...future.oldOptions$nwarnings <- NULL
[15:32:33.674]             }
[15:32:33.674]             base::options(...future.oldOptions)
[15:32:33.674]             if (.Platform$OS.type == "windows") {
[15:32:33.674]                 old_names <- names(...future.oldEnvVars)
[15:32:33.674]                 envs <- base::Sys.getenv()
[15:32:33.674]                 names <- names(envs)
[15:32:33.674]                 common <- intersect(names, old_names)
[15:32:33.674]                 added <- setdiff(names, old_names)
[15:32:33.674]                 removed <- setdiff(old_names, names)
[15:32:33.674]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:33.674]                   envs[common]]
[15:32:33.674]                 NAMES <- toupper(changed)
[15:32:33.674]                 args <- list()
[15:32:33.674]                 for (kk in seq_along(NAMES)) {
[15:32:33.674]                   name <- changed[[kk]]
[15:32:33.674]                   NAME <- NAMES[[kk]]
[15:32:33.674]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:33.674]                     next
[15:32:33.674]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:33.674]                 }
[15:32:33.674]                 NAMES <- toupper(added)
[15:32:33.674]                 for (kk in seq_along(NAMES)) {
[15:32:33.674]                   name <- added[[kk]]
[15:32:33.674]                   NAME <- NAMES[[kk]]
[15:32:33.674]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:33.674]                     next
[15:32:33.674]                   args[[name]] <- ""
[15:32:33.674]                 }
[15:32:33.674]                 NAMES <- toupper(removed)
[15:32:33.674]                 for (kk in seq_along(NAMES)) {
[15:32:33.674]                   name <- removed[[kk]]
[15:32:33.674]                   NAME <- NAMES[[kk]]
[15:32:33.674]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:33.674]                     next
[15:32:33.674]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:33.674]                 }
[15:32:33.674]                 if (length(args) > 0) 
[15:32:33.674]                   base::do.call(base::Sys.setenv, args = args)
[15:32:33.674]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:33.674]             }
[15:32:33.674]             else {
[15:32:33.674]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:33.674]             }
[15:32:33.674]             {
[15:32:33.674]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:33.674]                   0L) {
[15:32:33.674]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:33.674]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:33.674]                   base::options(opts)
[15:32:33.674]                 }
[15:32:33.674]                 {
[15:32:33.674]                   {
[15:32:33.674]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:33.674]                     NULL
[15:32:33.674]                   }
[15:32:33.674]                   options(future.plan = NULL)
[15:32:33.674]                   if (is.na(NA_character_)) 
[15:32:33.674]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:33.674]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:33.674]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:33.674]                     .init = FALSE)
[15:32:33.674]                 }
[15:32:33.674]             }
[15:32:33.674]         }
[15:32:33.674]     })
[15:32:33.674]     if (TRUE) {
[15:32:33.674]         base::sink(type = "output", split = FALSE)
[15:32:33.674]         if (TRUE) {
[15:32:33.674]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:33.674]         }
[15:32:33.674]         else {
[15:32:33.674]             ...future.result["stdout"] <- base::list(NULL)
[15:32:33.674]         }
[15:32:33.674]         base::close(...future.stdout)
[15:32:33.674]         ...future.stdout <- NULL
[15:32:33.674]     }
[15:32:33.674]     ...future.result$conditions <- ...future.conditions
[15:32:33.674]     ...future.result$finished <- base::Sys.time()
[15:32:33.674]     ...future.result
[15:32:33.674] }
[15:32:33.683] Exporting 5 global objects (848 bytes) to cluster node #1 ...
[15:32:33.684] Exporting '...future.FUN' (848 bytes) to cluster node #1 ...
[15:32:33.685] Exporting '...future.FUN' (848 bytes) to cluster node #1 ... DONE
[15:32:33.686] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:33.687] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:33.687] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ...
[15:32:33.688] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ... DONE
[15:32:33.688] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:33.689] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:33.689] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:33.690] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:33.690] Exporting 5 global objects (848 bytes) to cluster node #1 ... DONE
[15:32:33.691] MultisessionFuture started
[15:32:33.692] - Launch lazy future ... done
[15:32:33.692] run() for 'MultisessionFuture' ... done
[15:32:33.692] Created future:
[15:32:33.718] receiveMessageFromWorker() for ClusterFuture ...
[15:32:33.718] - Validating connection of MultisessionFuture
[15:32:33.719] - received message: FutureResult
[15:32:33.719] - Received FutureResult
[15:32:33.720] - Erased future from FutureRegistry
[15:32:33.720] result() for ClusterFuture ...
[15:32:33.720] - result already collected: FutureResult
[15:32:33.720] result() for ClusterFuture ... done
[15:32:33.720] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:33.693] MultisessionFuture:
[15:32:33.693] Label: 'future_sapply-1'
[15:32:33.693] Expression:
[15:32:33.693] {
[15:32:33.693]     do.call(function(...) {
[15:32:33.693]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:33.693]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:33.693]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:33.693]             on.exit(options(oopts), add = TRUE)
[15:32:33.693]         }
[15:32:33.693]         {
[15:32:33.693]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:33.693]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:33.693]                 ...future.FUN(...future.X_jj, ...)
[15:32:33.693]             })
[15:32:33.693]         }
[15:32:33.693]     }, args = future.call.arguments)
[15:32:33.693] }
[15:32:33.693] Lazy evaluation: FALSE
[15:32:33.693] Asynchronous evaluation: TRUE
[15:32:33.693] Local evaluation: TRUE
[15:32:33.693] Environment: R_GlobalEnv
[15:32:33.693] Capture standard output: TRUE
[15:32:33.693] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:33.693] Globals: 5 objects totaling 0.99 KiB (function '...future.FUN' of 848 bytes, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:33.693] Packages: <none>
[15:32:33.693] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:33.693] Resolved: TRUE
[15:32:33.693] Value: <not collected>
[15:32:33.693] Conditions captured: <none>
[15:32:33.693] Early signaling: FALSE
[15:32:33.693] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:33.693] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:33.721] Chunk #1 of 2 ... DONE
[15:32:33.721] Chunk #2 of 2 ...
[15:32:33.722]  - Finding globals in 'X' for chunk #2 ...
[15:32:33.722] getGlobalsAndPackages() ...
[15:32:33.722] Searching for globals...
[15:32:33.723] 
[15:32:33.723] Searching for globals ... DONE
[15:32:33.723] - globals: [0] <none>
[15:32:33.723] getGlobalsAndPackages() ... DONE
[15:32:33.724]    + additional globals found: [n=0] 
[15:32:33.724]    + additional namespaces needed: [n=0] 
[15:32:33.724]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:33.724]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:33.725]  - seeds: <none>
[15:32:33.725]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:33.725] getGlobalsAndPackages() ...
[15:32:33.725] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:33.726] Resolving globals: FALSE
[15:32:33.726] Tweak future expression to call with '...' arguments ...
[15:32:33.726] {
[15:32:33.726]     do.call(function(...) {
[15:32:33.726]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:33.726]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:33.726]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:33.726]             on.exit(options(oopts), add = TRUE)
[15:32:33.726]         }
[15:32:33.726]         {
[15:32:33.726]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:33.726]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:33.726]                 ...future.FUN(...future.X_jj, ...)
[15:32:33.726]             })
[15:32:33.726]         }
[15:32:33.726]     }, args = future.call.arguments)
[15:32:33.726] }
[15:32:33.727] Tweak future expression to call with '...' arguments ... DONE
[15:32:33.728] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:33.728] 
[15:32:33.728] getGlobalsAndPackages() ... DONE
[15:32:33.729] run() for 'Future' ...
[15:32:33.729] - state: 'created'
[15:32:33.729] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:33.745] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:33.746] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:33.746]   - Field: 'node'
[15:32:33.747]   - Field: 'label'
[15:32:33.747]   - Field: 'local'
[15:32:33.747]   - Field: 'owner'
[15:32:33.747]   - Field: 'envir'
[15:32:33.748]   - Field: 'workers'
[15:32:33.748]   - Field: 'packages'
[15:32:33.748]   - Field: 'gc'
[15:32:33.749]   - Field: 'conditions'
[15:32:33.749]   - Field: 'persistent'
[15:32:33.749]   - Field: 'expr'
[15:32:33.749]   - Field: 'uuid'
[15:32:33.750]   - Field: 'seed'
[15:32:33.750]   - Field: 'version'
[15:32:33.750]   - Field: 'result'
[15:32:33.750]   - Field: 'asynchronous'
[15:32:33.751]   - Field: 'calls'
[15:32:33.751]   - Field: 'globals'
[15:32:33.751]   - Field: 'stdout'
[15:32:33.751]   - Field: 'earlySignal'
[15:32:33.752]   - Field: 'lazy'
[15:32:33.752]   - Field: 'state'
[15:32:33.752] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:33.752] - Launch lazy future ...
[15:32:33.753] Packages needed by the future expression (n = 0): <none>
[15:32:33.753] Packages needed by future strategies (n = 0): <none>
[15:32:33.754] {
[15:32:33.754]     {
[15:32:33.754]         {
[15:32:33.754]             ...future.startTime <- base::Sys.time()
[15:32:33.754]             {
[15:32:33.754]                 {
[15:32:33.754]                   {
[15:32:33.754]                     {
[15:32:33.754]                       base::local({
[15:32:33.754]                         has_future <- base::requireNamespace("future", 
[15:32:33.754]                           quietly = TRUE)
[15:32:33.754]                         if (has_future) {
[15:32:33.754]                           ns <- base::getNamespace("future")
[15:32:33.754]                           version <- ns[[".package"]][["version"]]
[15:32:33.754]                           if (is.null(version)) 
[15:32:33.754]                             version <- utils::packageVersion("future")
[15:32:33.754]                         }
[15:32:33.754]                         else {
[15:32:33.754]                           version <- NULL
[15:32:33.754]                         }
[15:32:33.754]                         if (!has_future || version < "1.8.0") {
[15:32:33.754]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:33.754]                             "", base::R.version$version.string), 
[15:32:33.754]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:33.754]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:33.754]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:33.754]                               "release", "version")], collapse = " "), 
[15:32:33.754]                             hostname = base::Sys.info()[["nodename"]])
[15:32:33.754]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:33.754]                             info)
[15:32:33.754]                           info <- base::paste(info, collapse = "; ")
[15:32:33.754]                           if (!has_future) {
[15:32:33.754]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:33.754]                               info)
[15:32:33.754]                           }
[15:32:33.754]                           else {
[15:32:33.754]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:33.754]                               info, version)
[15:32:33.754]                           }
[15:32:33.754]                           base::stop(msg)
[15:32:33.754]                         }
[15:32:33.754]                       })
[15:32:33.754]                     }
[15:32:33.754]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:33.754]                     base::options(mc.cores = 1L)
[15:32:33.754]                   }
[15:32:33.754]                   ...future.strategy.old <- future::plan("list")
[15:32:33.754]                   options(future.plan = NULL)
[15:32:33.754]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:33.754]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:33.754]                 }
[15:32:33.754]                 ...future.workdir <- getwd()
[15:32:33.754]             }
[15:32:33.754]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:33.754]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:33.754]         }
[15:32:33.754]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:33.754]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:33.754]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:33.754]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:33.754]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:33.754]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:33.754]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:33.754]             base::names(...future.oldOptions))
[15:32:33.754]     }
[15:32:33.754]     if (FALSE) {
[15:32:33.754]     }
[15:32:33.754]     else {
[15:32:33.754]         if (TRUE) {
[15:32:33.754]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:33.754]                 open = "w")
[15:32:33.754]         }
[15:32:33.754]         else {
[15:32:33.754]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:33.754]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:33.754]         }
[15:32:33.754]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:33.754]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:33.754]             base::sink(type = "output", split = FALSE)
[15:32:33.754]             base::close(...future.stdout)
[15:32:33.754]         }, add = TRUE)
[15:32:33.754]     }
[15:32:33.754]     ...future.frame <- base::sys.nframe()
[15:32:33.754]     ...future.conditions <- base::list()
[15:32:33.754]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:33.754]     if (FALSE) {
[15:32:33.754]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:33.754]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:33.754]     }
[15:32:33.754]     ...future.result <- base::tryCatch({
[15:32:33.754]         base::withCallingHandlers({
[15:32:33.754]             ...future.value <- base::withVisible(base::local({
[15:32:33.754]                 ...future.makeSendCondition <- base::local({
[15:32:33.754]                   sendCondition <- NULL
[15:32:33.754]                   function(frame = 1L) {
[15:32:33.754]                     if (is.function(sendCondition)) 
[15:32:33.754]                       return(sendCondition)
[15:32:33.754]                     ns <- getNamespace("parallel")
[15:32:33.754]                     if (exists("sendData", mode = "function", 
[15:32:33.754]                       envir = ns)) {
[15:32:33.754]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:33.754]                         envir = ns)
[15:32:33.754]                       envir <- sys.frame(frame)
[15:32:33.754]                       master <- NULL
[15:32:33.754]                       while (!identical(envir, .GlobalEnv) && 
[15:32:33.754]                         !identical(envir, emptyenv())) {
[15:32:33.754]                         if (exists("master", mode = "list", envir = envir, 
[15:32:33.754]                           inherits = FALSE)) {
[15:32:33.754]                           master <- get("master", mode = "list", 
[15:32:33.754]                             envir = envir, inherits = FALSE)
[15:32:33.754]                           if (inherits(master, c("SOCKnode", 
[15:32:33.754]                             "SOCK0node"))) {
[15:32:33.754]                             sendCondition <<- function(cond) {
[15:32:33.754]                               data <- list(type = "VALUE", value = cond, 
[15:32:33.754]                                 success = TRUE)
[15:32:33.754]                               parallel_sendData(master, data)
[15:32:33.754]                             }
[15:32:33.754]                             return(sendCondition)
[15:32:33.754]                           }
[15:32:33.754]                         }
[15:32:33.754]                         frame <- frame + 1L
[15:32:33.754]                         envir <- sys.frame(frame)
[15:32:33.754]                       }
[15:32:33.754]                     }
[15:32:33.754]                     sendCondition <<- function(cond) NULL
[15:32:33.754]                   }
[15:32:33.754]                 })
[15:32:33.754]                 withCallingHandlers({
[15:32:33.754]                   {
[15:32:33.754]                     do.call(function(...) {
[15:32:33.754]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:33.754]                       if (!identical(...future.globals.maxSize.org, 
[15:32:33.754]                         ...future.globals.maxSize)) {
[15:32:33.754]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:33.754]                         on.exit(options(oopts), add = TRUE)
[15:32:33.754]                       }
[15:32:33.754]                       {
[15:32:33.754]                         lapply(seq_along(...future.elements_ii), 
[15:32:33.754]                           FUN = function(jj) {
[15:32:33.754]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:33.754]                             ...future.FUN(...future.X_jj, ...)
[15:32:33.754]                           })
[15:32:33.754]                       }
[15:32:33.754]                     }, args = future.call.arguments)
[15:32:33.754]                   }
[15:32:33.754]                 }, immediateCondition = function(cond) {
[15:32:33.754]                   sendCondition <- ...future.makeSendCondition()
[15:32:33.754]                   sendCondition(cond)
[15:32:33.754]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:33.754]                   {
[15:32:33.754]                     inherits <- base::inherits
[15:32:33.754]                     invokeRestart <- base::invokeRestart
[15:32:33.754]                     is.null <- base::is.null
[15:32:33.754]                     muffled <- FALSE
[15:32:33.754]                     if (inherits(cond, "message")) {
[15:32:33.754]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:33.754]                       if (muffled) 
[15:32:33.754]                         invokeRestart("muffleMessage")
[15:32:33.754]                     }
[15:32:33.754]                     else if (inherits(cond, "warning")) {
[15:32:33.754]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:33.754]                       if (muffled) 
[15:32:33.754]                         invokeRestart("muffleWarning")
[15:32:33.754]                     }
[15:32:33.754]                     else if (inherits(cond, "condition")) {
[15:32:33.754]                       if (!is.null(pattern)) {
[15:32:33.754]                         computeRestarts <- base::computeRestarts
[15:32:33.754]                         grepl <- base::grepl
[15:32:33.754]                         restarts <- computeRestarts(cond)
[15:32:33.754]                         for (restart in restarts) {
[15:32:33.754]                           name <- restart$name
[15:32:33.754]                           if (is.null(name)) 
[15:32:33.754]                             next
[15:32:33.754]                           if (!grepl(pattern, name)) 
[15:32:33.754]                             next
[15:32:33.754]                           invokeRestart(restart)
[15:32:33.754]                           muffled <- TRUE
[15:32:33.754]                           break
[15:32:33.754]                         }
[15:32:33.754]                       }
[15:32:33.754]                     }
[15:32:33.754]                     invisible(muffled)
[15:32:33.754]                   }
[15:32:33.754]                   muffleCondition(cond)
[15:32:33.754]                 })
[15:32:33.754]             }))
[15:32:33.754]             future::FutureResult(value = ...future.value$value, 
[15:32:33.754]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:33.754]                   ...future.rng), globalenv = if (FALSE) 
[15:32:33.754]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:33.754]                     ...future.globalenv.names))
[15:32:33.754]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:33.754]         }, condition = base::local({
[15:32:33.754]             c <- base::c
[15:32:33.754]             inherits <- base::inherits
[15:32:33.754]             invokeRestart <- base::invokeRestart
[15:32:33.754]             length <- base::length
[15:32:33.754]             list <- base::list
[15:32:33.754]             seq.int <- base::seq.int
[15:32:33.754]             signalCondition <- base::signalCondition
[15:32:33.754]             sys.calls <- base::sys.calls
[15:32:33.754]             `[[` <- base::`[[`
[15:32:33.754]             `+` <- base::`+`
[15:32:33.754]             `<<-` <- base::`<<-`
[15:32:33.754]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:33.754]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:33.754]                   3L)]
[15:32:33.754]             }
[15:32:33.754]             function(cond) {
[15:32:33.754]                 is_error <- inherits(cond, "error")
[15:32:33.754]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:33.754]                   NULL)
[15:32:33.754]                 if (is_error) {
[15:32:33.754]                   sessionInformation <- function() {
[15:32:33.754]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:33.754]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:33.754]                       search = base::search(), system = base::Sys.info())
[15:32:33.754]                   }
[15:32:33.754]                   ...future.conditions[[length(...future.conditions) + 
[15:32:33.754]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:33.754]                     cond$call), session = sessionInformation(), 
[15:32:33.754]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:33.754]                   signalCondition(cond)
[15:32:33.754]                 }
[15:32:33.754]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:33.754]                 "immediateCondition"))) {
[15:32:33.754]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:33.754]                   ...future.conditions[[length(...future.conditions) + 
[15:32:33.754]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:33.754]                   if (TRUE && !signal) {
[15:32:33.754]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:33.754]                     {
[15:32:33.754]                       inherits <- base::inherits
[15:32:33.754]                       invokeRestart <- base::invokeRestart
[15:32:33.754]                       is.null <- base::is.null
[15:32:33.754]                       muffled <- FALSE
[15:32:33.754]                       if (inherits(cond, "message")) {
[15:32:33.754]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:33.754]                         if (muffled) 
[15:32:33.754]                           invokeRestart("muffleMessage")
[15:32:33.754]                       }
[15:32:33.754]                       else if (inherits(cond, "warning")) {
[15:32:33.754]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:33.754]                         if (muffled) 
[15:32:33.754]                           invokeRestart("muffleWarning")
[15:32:33.754]                       }
[15:32:33.754]                       else if (inherits(cond, "condition")) {
[15:32:33.754]                         if (!is.null(pattern)) {
[15:32:33.754]                           computeRestarts <- base::computeRestarts
[15:32:33.754]                           grepl <- base::grepl
[15:32:33.754]                           restarts <- computeRestarts(cond)
[15:32:33.754]                           for (restart in restarts) {
[15:32:33.754]                             name <- restart$name
[15:32:33.754]                             if (is.null(name)) 
[15:32:33.754]                               next
[15:32:33.754]                             if (!grepl(pattern, name)) 
[15:32:33.754]                               next
[15:32:33.754]                             invokeRestart(restart)
[15:32:33.754]                             muffled <- TRUE
[15:32:33.754]                             break
[15:32:33.754]                           }
[15:32:33.754]                         }
[15:32:33.754]                       }
[15:32:33.754]                       invisible(muffled)
[15:32:33.754]                     }
[15:32:33.754]                     muffleCondition(cond, pattern = "^muffle")
[15:32:33.754]                   }
[15:32:33.754]                 }
[15:32:33.754]                 else {
[15:32:33.754]                   if (TRUE) {
[15:32:33.754]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:33.754]                     {
[15:32:33.754]                       inherits <- base::inherits
[15:32:33.754]                       invokeRestart <- base::invokeRestart
[15:32:33.754]                       is.null <- base::is.null
[15:32:33.754]                       muffled <- FALSE
[15:32:33.754]                       if (inherits(cond, "message")) {
[15:32:33.754]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:33.754]                         if (muffled) 
[15:32:33.754]                           invokeRestart("muffleMessage")
[15:32:33.754]                       }
[15:32:33.754]                       else if (inherits(cond, "warning")) {
[15:32:33.754]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:33.754]                         if (muffled) 
[15:32:33.754]                           invokeRestart("muffleWarning")
[15:32:33.754]                       }
[15:32:33.754]                       else if (inherits(cond, "condition")) {
[15:32:33.754]                         if (!is.null(pattern)) {
[15:32:33.754]                           computeRestarts <- base::computeRestarts
[15:32:33.754]                           grepl <- base::grepl
[15:32:33.754]                           restarts <- computeRestarts(cond)
[15:32:33.754]                           for (restart in restarts) {
[15:32:33.754]                             name <- restart$name
[15:32:33.754]                             if (is.null(name)) 
[15:32:33.754]                               next
[15:32:33.754]                             if (!grepl(pattern, name)) 
[15:32:33.754]                               next
[15:32:33.754]                             invokeRestart(restart)
[15:32:33.754]                             muffled <- TRUE
[15:32:33.754]                             break
[15:32:33.754]                           }
[15:32:33.754]                         }
[15:32:33.754]                       }
[15:32:33.754]                       invisible(muffled)
[15:32:33.754]                     }
[15:32:33.754]                     muffleCondition(cond, pattern = "^muffle")
[15:32:33.754]                   }
[15:32:33.754]                 }
[15:32:33.754]             }
[15:32:33.754]         }))
[15:32:33.754]     }, error = function(ex) {
[15:32:33.754]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:33.754]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:33.754]                 ...future.rng), started = ...future.startTime, 
[15:32:33.754]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:33.754]             version = "1.8"), class = "FutureResult")
[15:32:33.754]     }, finally = {
[15:32:33.754]         if (!identical(...future.workdir, getwd())) 
[15:32:33.754]             setwd(...future.workdir)
[15:32:33.754]         {
[15:32:33.754]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:33.754]                 ...future.oldOptions$nwarnings <- NULL
[15:32:33.754]             }
[15:32:33.754]             base::options(...future.oldOptions)
[15:32:33.754]             if (.Platform$OS.type == "windows") {
[15:32:33.754]                 old_names <- names(...future.oldEnvVars)
[15:32:33.754]                 envs <- base::Sys.getenv()
[15:32:33.754]                 names <- names(envs)
[15:32:33.754]                 common <- intersect(names, old_names)
[15:32:33.754]                 added <- setdiff(names, old_names)
[15:32:33.754]                 removed <- setdiff(old_names, names)
[15:32:33.754]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:33.754]                   envs[common]]
[15:32:33.754]                 NAMES <- toupper(changed)
[15:32:33.754]                 args <- list()
[15:32:33.754]                 for (kk in seq_along(NAMES)) {
[15:32:33.754]                   name <- changed[[kk]]
[15:32:33.754]                   NAME <- NAMES[[kk]]
[15:32:33.754]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:33.754]                     next
[15:32:33.754]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:33.754]                 }
[15:32:33.754]                 NAMES <- toupper(added)
[15:32:33.754]                 for (kk in seq_along(NAMES)) {
[15:32:33.754]                   name <- added[[kk]]
[15:32:33.754]                   NAME <- NAMES[[kk]]
[15:32:33.754]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:33.754]                     next
[15:32:33.754]                   args[[name]] <- ""
[15:32:33.754]                 }
[15:32:33.754]                 NAMES <- toupper(removed)
[15:32:33.754]                 for (kk in seq_along(NAMES)) {
[15:32:33.754]                   name <- removed[[kk]]
[15:32:33.754]                   NAME <- NAMES[[kk]]
[15:32:33.754]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:33.754]                     next
[15:32:33.754]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:33.754]                 }
[15:32:33.754]                 if (length(args) > 0) 
[15:32:33.754]                   base::do.call(base::Sys.setenv, args = args)
[15:32:33.754]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:33.754]             }
[15:32:33.754]             else {
[15:32:33.754]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:33.754]             }
[15:32:33.754]             {
[15:32:33.754]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:33.754]                   0L) {
[15:32:33.754]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:33.754]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:33.754]                   base::options(opts)
[15:32:33.754]                 }
[15:32:33.754]                 {
[15:32:33.754]                   {
[15:32:33.754]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:33.754]                     NULL
[15:32:33.754]                   }
[15:32:33.754]                   options(future.plan = NULL)
[15:32:33.754]                   if (is.na(NA_character_)) 
[15:32:33.754]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:33.754]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:33.754]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:33.754]                     .init = FALSE)
[15:32:33.754]                 }
[15:32:33.754]             }
[15:32:33.754]         }
[15:32:33.754]     })
[15:32:33.754]     if (TRUE) {
[15:32:33.754]         base::sink(type = "output", split = FALSE)
[15:32:33.754]         if (TRUE) {
[15:32:33.754]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:33.754]         }
[15:32:33.754]         else {
[15:32:33.754]             ...future.result["stdout"] <- base::list(NULL)
[15:32:33.754]         }
[15:32:33.754]         base::close(...future.stdout)
[15:32:33.754]         ...future.stdout <- NULL
[15:32:33.754]     }
[15:32:33.754]     ...future.result$conditions <- ...future.conditions
[15:32:33.754]     ...future.result$finished <- base::Sys.time()
[15:32:33.754]     ...future.result
[15:32:33.754] }
[15:32:33.760] Exporting 5 global objects (848 bytes) to cluster node #1 ...
[15:32:33.760] Exporting '...future.FUN' (848 bytes) to cluster node #1 ...
[15:32:33.761] Exporting '...future.FUN' (848 bytes) to cluster node #1 ... DONE
[15:32:33.761] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:33.762] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:33.762] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ...
[15:32:33.763] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ... DONE
[15:32:33.763] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:33.764] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:33.764] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:33.764] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:33.764] Exporting 5 global objects (848 bytes) to cluster node #1 ... DONE
[15:32:33.765] MultisessionFuture started
[15:32:33.765] - Launch lazy future ... done
[15:32:33.765] run() for 'MultisessionFuture' ... done
[15:32:33.766] Created future:
[15:32:33.784] receiveMessageFromWorker() for ClusterFuture ...
[15:32:33.785] - Validating connection of MultisessionFuture
[15:32:33.785] - received message: FutureResult
[15:32:33.785] - Received FutureResult
[15:32:33.786] - Erased future from FutureRegistry
[15:32:33.786] result() for ClusterFuture ...
[15:32:33.786] - result already collected: FutureResult
[15:32:33.786] result() for ClusterFuture ... done
[15:32:33.786] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:33.766] MultisessionFuture:
[15:32:33.766] Label: 'future_sapply-2'
[15:32:33.766] Expression:
[15:32:33.766] {
[15:32:33.766]     do.call(function(...) {
[15:32:33.766]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:33.766]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:33.766]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:33.766]             on.exit(options(oopts), add = TRUE)
[15:32:33.766]         }
[15:32:33.766]         {
[15:32:33.766]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:33.766]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:33.766]                 ...future.FUN(...future.X_jj, ...)
[15:32:33.766]             })
[15:32:33.766]         }
[15:32:33.766]     }, args = future.call.arguments)
[15:32:33.766] }
[15:32:33.766] Lazy evaluation: FALSE
[15:32:33.766] Asynchronous evaluation: TRUE
[15:32:33.766] Local evaluation: TRUE
[15:32:33.766] Environment: R_GlobalEnv
[15:32:33.766] Capture standard output: TRUE
[15:32:33.766] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:33.766] Globals: 5 objects totaling 0.99 KiB (function '...future.FUN' of 848 bytes, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:33.766] Packages: <none>
[15:32:33.766] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:33.766] Resolved: TRUE
[15:32:33.766] Value: <not collected>
[15:32:33.766] Conditions captured: <none>
[15:32:33.766] Early signaling: FALSE
[15:32:33.766] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:33.766] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:33.787] Chunk #2 of 2 ... DONE
[15:32:33.787] Launching 2 futures (chunks) ... DONE
[15:32:33.787] Resolving 2 futures (chunks) ...
[15:32:33.788] resolve() on list ...
[15:32:33.788]  recursive: 0
[15:32:33.788]  length: 2
[15:32:33.788] 
[15:32:33.788] Future #1
[15:32:33.789] result() for ClusterFuture ...
[15:32:33.789] - result already collected: FutureResult
[15:32:33.789] result() for ClusterFuture ... done
[15:32:33.789] result() for ClusterFuture ...
[15:32:33.789] - result already collected: FutureResult
[15:32:33.789] result() for ClusterFuture ... done
[15:32:33.790] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:33.790] - nx: 2
[15:32:33.790] - relay: TRUE
[15:32:33.790] - stdout: TRUE
[15:32:33.790] - signal: TRUE
[15:32:33.790] - resignal: FALSE
[15:32:33.791] - force: TRUE
[15:32:33.791] - relayed: [n=2] FALSE, FALSE
[15:32:33.791] - queued futures: [n=2] FALSE, FALSE
[15:32:33.791]  - until=1
[15:32:33.791]  - relaying element #1
[15:32:33.791] result() for ClusterFuture ...
[15:32:33.792] - result already collected: FutureResult
[15:32:33.792] result() for ClusterFuture ... done
[15:32:33.792] result() for ClusterFuture ...
[15:32:33.792] - result already collected: FutureResult
[15:32:33.792] result() for ClusterFuture ... done
[15:32:33.793] result() for ClusterFuture ...
[15:32:33.793] - result already collected: FutureResult
[15:32:33.793] result() for ClusterFuture ... done
[15:32:33.793] result() for ClusterFuture ...
[15:32:33.793] - result already collected: FutureResult
[15:32:33.793] result() for ClusterFuture ... done
[15:32:33.793] - relayed: [n=2] TRUE, FALSE
[15:32:33.794] - queued futures: [n=2] TRUE, FALSE
[15:32:33.794] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:33.798]  length: 1 (resolved future 1)
[15:32:33.798] Future #2
[15:32:33.798] result() for ClusterFuture ...
[15:32:33.798] - result already collected: FutureResult
[15:32:33.799] result() for ClusterFuture ... done
[15:32:33.799] result() for ClusterFuture ...
[15:32:33.799] - result already collected: FutureResult
[15:32:33.799] result() for ClusterFuture ... done
[15:32:33.800] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:33.800] - nx: 2
[15:32:33.800] - relay: TRUE
[15:32:33.800] - stdout: TRUE
[15:32:33.801] - signal: TRUE
[15:32:33.801] - resignal: FALSE
[15:32:33.801] - force: TRUE
[15:32:33.802] - relayed: [n=2] TRUE, FALSE
[15:32:33.802] - queued futures: [n=2] TRUE, FALSE
[15:32:33.802]  - until=2
[15:32:33.802]  - relaying element #2
[15:32:33.803] result() for ClusterFuture ...
[15:32:33.803] - result already collected: FutureResult
[15:32:33.803] result() for ClusterFuture ... done
[15:32:33.803] result() for ClusterFuture ...
[15:32:33.804] - result already collected: FutureResult
[15:32:33.804] result() for ClusterFuture ... done
[15:32:33.804] result() for ClusterFuture ...
[15:32:33.804] - result already collected: FutureResult
[15:32:33.805] result() for ClusterFuture ... done
[15:32:33.805] result() for ClusterFuture ...
[15:32:33.805] - result already collected: FutureResult
[15:32:33.805] result() for ClusterFuture ... done
[15:32:33.806] - relayed: [n=2] TRUE, TRUE
[15:32:33.806] - queued futures: [n=2] TRUE, TRUE
[15:32:33.806] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:33.806]  length: 0 (resolved future 2)
[15:32:33.807] Relaying remaining futures
[15:32:33.807] signalConditionsASAP(NULL, pos=0) ...
[15:32:33.807] - nx: 2
[15:32:33.807] - relay: TRUE
[15:32:33.808] - stdout: TRUE
[15:32:33.808] - signal: TRUE
[15:32:33.808] - resignal: FALSE
[15:32:33.808] - force: TRUE
[15:32:33.808] - relayed: [n=2] TRUE, TRUE
[15:32:33.809] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:33.809] - relayed: [n=2] TRUE, TRUE
[15:32:33.809] - queued futures: [n=2] TRUE, TRUE
[15:32:33.810] signalConditionsASAP(NULL, pos=0) ... done
[15:32:33.810] resolve() on list ... DONE
[15:32:33.810] result() for ClusterFuture ...
[15:32:33.810] - result already collected: FutureResult
[15:32:33.810] result() for ClusterFuture ... done
[15:32:33.811] result() for ClusterFuture ...
[15:32:33.811] - result already collected: FutureResult
[15:32:33.811] result() for ClusterFuture ... done
[15:32:33.811] result() for ClusterFuture ...
[15:32:33.812] - result already collected: FutureResult
[15:32:33.812] result() for ClusterFuture ... done
[15:32:33.812] result() for ClusterFuture ...
[15:32:33.812] - result already collected: FutureResult
[15:32:33.813] result() for ClusterFuture ... done
[15:32:33.813]  - Number of value chunks collected: 2
[15:32:33.813] Resolving 2 futures (chunks) ... DONE
[15:32:33.813] Reducing values from 2 chunks ...
[15:32:33.814]  - Number of values collected after concatenation: 6
[15:32:33.814]  - Number of values expected: 6
[15:32:33.814] Reducing values from 2 chunks ... DONE
[15:32:33.814] future_lapply() ... DONE
List of 2
 $ y0: Named int [1:6] 1 2 2 3 3 4
  ..- attr(*, "names")= chr [1:6] "a1" "a2" "b1" "b2" ...
 $ y1: Named int [1:6] 1 2 2 3 3 4
  ..- attr(*, "names")= chr [1:6] "a1" "a2" "b1" "b2" ...
[15:32:33.818] future_lapply() ...
[15:32:33.822] Number of chunks: 2
[15:32:33.823] getGlobalsAndPackagesXApply() ...
[15:32:33.823]  - future.globals: TRUE
[15:32:33.823] getGlobalsAndPackages() ...
[15:32:33.823] Searching for globals...
[15:32:33.825] - globals found: [2] 'FUN', 'UseMethod'
[15:32:33.826] Searching for globals ... DONE
[15:32:33.826] Resolving globals: FALSE
[15:32:33.827] The total size of the 1 globals is 1.22 KiB (1248 bytes)
[15:32:33.827] The total size of the 1 globals exported for future expression ('FUN()') is 1.22 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.22 KiB of class 'function')
[15:32:33.828] - globals: [1] 'FUN'
[15:32:33.828] 
[15:32:33.828] getGlobalsAndPackages() ... DONE
[15:32:33.828]  - globals found/used: [n=1] 'FUN'
[15:32:33.829]  - needed namespaces: [n=0] 
[15:32:33.829] Finding globals ... DONE
[15:32:33.829]  - use_args: TRUE
[15:32:33.829]  - Getting '...' globals ...
[15:32:33.830] resolve() on list ...
[15:32:33.830]  recursive: 0
[15:32:33.831]  length: 1
[15:32:33.831]  elements: '...'
[15:32:33.831]  length: 0 (resolved future 1)
[15:32:33.831] resolve() on list ... DONE
[15:32:33.832]    - '...' content: [n=0] 
[15:32:33.832] List of 1
[15:32:33.832]  $ ...: list()
[15:32:33.832]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:33.832]  - attr(*, "where")=List of 1
[15:32:33.832]   ..$ ...:<environment: 0x00000276e28a4ca8> 
[15:32:33.832]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:33.832]  - attr(*, "resolved")= logi TRUE
[15:32:33.832]  - attr(*, "total_size")= num NA
[15:32:33.837]  - Getting '...' globals ... DONE
[15:32:33.837] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:33.837] List of 2
[15:32:33.837]  $ ...future.FUN:function (x, ...)  
[15:32:33.837]  $ ...          : list()
[15:32:33.837]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:33.837]  - attr(*, "where")=List of 2
[15:32:33.837]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:33.837]   ..$ ...          :<environment: 0x00000276e28a4ca8> 
[15:32:33.837]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:33.837]  - attr(*, "resolved")= logi FALSE
[15:32:33.837]  - attr(*, "total_size")= num 1248
[15:32:33.843] Packages to be attached in all futures: [n=0] 
[15:32:33.843] getGlobalsAndPackagesXApply() ... DONE
[15:32:33.843] Number of futures (= number of chunks): 2
[15:32:33.844] Launching 2 futures (chunks) ...
[15:32:33.844] Chunk #1 of 2 ...
[15:32:33.844]  - Finding globals in 'X' for chunk #1 ...
[15:32:33.844] getGlobalsAndPackages() ...
[15:32:33.845] Searching for globals...
[15:32:33.845] 
[15:32:33.845] Searching for globals ... DONE
[15:32:33.846] - globals: [0] <none>
[15:32:33.846] getGlobalsAndPackages() ... DONE
[15:32:33.846]    + additional globals found: [n=0] 
[15:32:33.846]    + additional namespaces needed: [n=0] 
[15:32:33.847]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:33.847]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:33.847]  - seeds: <none>
[15:32:33.847]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:33.848] getGlobalsAndPackages() ...
[15:32:33.848] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:33.848] Resolving globals: FALSE
[15:32:33.848] Tweak future expression to call with '...' arguments ...
[15:32:33.849] {
[15:32:33.849]     do.call(function(...) {
[15:32:33.849]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:33.849]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:33.849]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:33.849]             on.exit(options(oopts), add = TRUE)
[15:32:33.849]         }
[15:32:33.849]         {
[15:32:33.849]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:33.849]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:33.849]                 ...future.FUN(...future.X_jj, ...)
[15:32:33.849]             })
[15:32:33.849]         }
[15:32:33.849]     }, args = future.call.arguments)
[15:32:33.849] }
[15:32:33.849] Tweak future expression to call with '...' arguments ... DONE
[15:32:33.850] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:33.850] 
[15:32:33.851] getGlobalsAndPackages() ... DONE
[15:32:33.851] run() for 'Future' ...
[15:32:33.851] - state: 'created'
[15:32:33.852] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:33.874] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:33.874] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:33.875]   - Field: 'node'
[15:32:33.875]   - Field: 'label'
[15:32:33.876]   - Field: 'local'
[15:32:33.876]   - Field: 'owner'
[15:32:33.876]   - Field: 'envir'
[15:32:33.877]   - Field: 'workers'
[15:32:33.877]   - Field: 'packages'
[15:32:33.877]   - Field: 'gc'
[15:32:33.878]   - Field: 'conditions'
[15:32:33.878]   - Field: 'persistent'
[15:32:33.878]   - Field: 'expr'
[15:32:33.879]   - Field: 'uuid'
[15:32:33.879]   - Field: 'seed'
[15:32:33.879]   - Field: 'version'
[15:32:33.880]   - Field: 'result'
[15:32:33.880]   - Field: 'asynchronous'
[15:32:33.880]   - Field: 'calls'
[15:32:33.881]   - Field: 'globals'
[15:32:33.881]   - Field: 'stdout'
[15:32:33.881]   - Field: 'earlySignal'
[15:32:33.882]   - Field: 'lazy'
[15:32:33.882]   - Field: 'state'
[15:32:33.882] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:33.883] - Launch lazy future ...
[15:32:33.883] Packages needed by the future expression (n = 0): <none>
[15:32:33.884] Packages needed by future strategies (n = 0): <none>
[15:32:33.885] {
[15:32:33.885]     {
[15:32:33.885]         {
[15:32:33.885]             ...future.startTime <- base::Sys.time()
[15:32:33.885]             {
[15:32:33.885]                 {
[15:32:33.885]                   {
[15:32:33.885]                     {
[15:32:33.885]                       base::local({
[15:32:33.885]                         has_future <- base::requireNamespace("future", 
[15:32:33.885]                           quietly = TRUE)
[15:32:33.885]                         if (has_future) {
[15:32:33.885]                           ns <- base::getNamespace("future")
[15:32:33.885]                           version <- ns[[".package"]][["version"]]
[15:32:33.885]                           if (is.null(version)) 
[15:32:33.885]                             version <- utils::packageVersion("future")
[15:32:33.885]                         }
[15:32:33.885]                         else {
[15:32:33.885]                           version <- NULL
[15:32:33.885]                         }
[15:32:33.885]                         if (!has_future || version < "1.8.0") {
[15:32:33.885]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:33.885]                             "", base::R.version$version.string), 
[15:32:33.885]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:33.885]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:33.885]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:33.885]                               "release", "version")], collapse = " "), 
[15:32:33.885]                             hostname = base::Sys.info()[["nodename"]])
[15:32:33.885]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:33.885]                             info)
[15:32:33.885]                           info <- base::paste(info, collapse = "; ")
[15:32:33.885]                           if (!has_future) {
[15:32:33.885]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:33.885]                               info)
[15:32:33.885]                           }
[15:32:33.885]                           else {
[15:32:33.885]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:33.885]                               info, version)
[15:32:33.885]                           }
[15:32:33.885]                           base::stop(msg)
[15:32:33.885]                         }
[15:32:33.885]                       })
[15:32:33.885]                     }
[15:32:33.885]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:33.885]                     base::options(mc.cores = 1L)
[15:32:33.885]                   }
[15:32:33.885]                   ...future.strategy.old <- future::plan("list")
[15:32:33.885]                   options(future.plan = NULL)
[15:32:33.885]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:33.885]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:33.885]                 }
[15:32:33.885]                 ...future.workdir <- getwd()
[15:32:33.885]             }
[15:32:33.885]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:33.885]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:33.885]         }
[15:32:33.885]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:33.885]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:33.885]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:33.885]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:33.885]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:33.885]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:33.885]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:33.885]             base::names(...future.oldOptions))
[15:32:33.885]     }
[15:32:33.885]     if (FALSE) {
[15:32:33.885]     }
[15:32:33.885]     else {
[15:32:33.885]         if (TRUE) {
[15:32:33.885]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:33.885]                 open = "w")
[15:32:33.885]         }
[15:32:33.885]         else {
[15:32:33.885]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:33.885]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:33.885]         }
[15:32:33.885]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:33.885]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:33.885]             base::sink(type = "output", split = FALSE)
[15:32:33.885]             base::close(...future.stdout)
[15:32:33.885]         }, add = TRUE)
[15:32:33.885]     }
[15:32:33.885]     ...future.frame <- base::sys.nframe()
[15:32:33.885]     ...future.conditions <- base::list()
[15:32:33.885]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:33.885]     if (FALSE) {
[15:32:33.885]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:33.885]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:33.885]     }
[15:32:33.885]     ...future.result <- base::tryCatch({
[15:32:33.885]         base::withCallingHandlers({
[15:32:33.885]             ...future.value <- base::withVisible(base::local({
[15:32:33.885]                 ...future.makeSendCondition <- base::local({
[15:32:33.885]                   sendCondition <- NULL
[15:32:33.885]                   function(frame = 1L) {
[15:32:33.885]                     if (is.function(sendCondition)) 
[15:32:33.885]                       return(sendCondition)
[15:32:33.885]                     ns <- getNamespace("parallel")
[15:32:33.885]                     if (exists("sendData", mode = "function", 
[15:32:33.885]                       envir = ns)) {
[15:32:33.885]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:33.885]                         envir = ns)
[15:32:33.885]                       envir <- sys.frame(frame)
[15:32:33.885]                       master <- NULL
[15:32:33.885]                       while (!identical(envir, .GlobalEnv) && 
[15:32:33.885]                         !identical(envir, emptyenv())) {
[15:32:33.885]                         if (exists("master", mode = "list", envir = envir, 
[15:32:33.885]                           inherits = FALSE)) {
[15:32:33.885]                           master <- get("master", mode = "list", 
[15:32:33.885]                             envir = envir, inherits = FALSE)
[15:32:33.885]                           if (inherits(master, c("SOCKnode", 
[15:32:33.885]                             "SOCK0node"))) {
[15:32:33.885]                             sendCondition <<- function(cond) {
[15:32:33.885]                               data <- list(type = "VALUE", value = cond, 
[15:32:33.885]                                 success = TRUE)
[15:32:33.885]                               parallel_sendData(master, data)
[15:32:33.885]                             }
[15:32:33.885]                             return(sendCondition)
[15:32:33.885]                           }
[15:32:33.885]                         }
[15:32:33.885]                         frame <- frame + 1L
[15:32:33.885]                         envir <- sys.frame(frame)
[15:32:33.885]                       }
[15:32:33.885]                     }
[15:32:33.885]                     sendCondition <<- function(cond) NULL
[15:32:33.885]                   }
[15:32:33.885]                 })
[15:32:33.885]                 withCallingHandlers({
[15:32:33.885]                   {
[15:32:33.885]                     do.call(function(...) {
[15:32:33.885]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:33.885]                       if (!identical(...future.globals.maxSize.org, 
[15:32:33.885]                         ...future.globals.maxSize)) {
[15:32:33.885]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:33.885]                         on.exit(options(oopts), add = TRUE)
[15:32:33.885]                       }
[15:32:33.885]                       {
[15:32:33.885]                         lapply(seq_along(...future.elements_ii), 
[15:32:33.885]                           FUN = function(jj) {
[15:32:33.885]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:33.885]                             ...future.FUN(...future.X_jj, ...)
[15:32:33.885]                           })
[15:32:33.885]                       }
[15:32:33.885]                     }, args = future.call.arguments)
[15:32:33.885]                   }
[15:32:33.885]                 }, immediateCondition = function(cond) {
[15:32:33.885]                   sendCondition <- ...future.makeSendCondition()
[15:32:33.885]                   sendCondition(cond)
[15:32:33.885]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:33.885]                   {
[15:32:33.885]                     inherits <- base::inherits
[15:32:33.885]                     invokeRestart <- base::invokeRestart
[15:32:33.885]                     is.null <- base::is.null
[15:32:33.885]                     muffled <- FALSE
[15:32:33.885]                     if (inherits(cond, "message")) {
[15:32:33.885]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:33.885]                       if (muffled) 
[15:32:33.885]                         invokeRestart("muffleMessage")
[15:32:33.885]                     }
[15:32:33.885]                     else if (inherits(cond, "warning")) {
[15:32:33.885]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:33.885]                       if (muffled) 
[15:32:33.885]                         invokeRestart("muffleWarning")
[15:32:33.885]                     }
[15:32:33.885]                     else if (inherits(cond, "condition")) {
[15:32:33.885]                       if (!is.null(pattern)) {
[15:32:33.885]                         computeRestarts <- base::computeRestarts
[15:32:33.885]                         grepl <- base::grepl
[15:32:33.885]                         restarts <- computeRestarts(cond)
[15:32:33.885]                         for (restart in restarts) {
[15:32:33.885]                           name <- restart$name
[15:32:33.885]                           if (is.null(name)) 
[15:32:33.885]                             next
[15:32:33.885]                           if (!grepl(pattern, name)) 
[15:32:33.885]                             next
[15:32:33.885]                           invokeRestart(restart)
[15:32:33.885]                           muffled <- TRUE
[15:32:33.885]                           break
[15:32:33.885]                         }
[15:32:33.885]                       }
[15:32:33.885]                     }
[15:32:33.885]                     invisible(muffled)
[15:32:33.885]                   }
[15:32:33.885]                   muffleCondition(cond)
[15:32:33.885]                 })
[15:32:33.885]             }))
[15:32:33.885]             future::FutureResult(value = ...future.value$value, 
[15:32:33.885]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:33.885]                   ...future.rng), globalenv = if (FALSE) 
[15:32:33.885]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:33.885]                     ...future.globalenv.names))
[15:32:33.885]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:33.885]         }, condition = base::local({
[15:32:33.885]             c <- base::c
[15:32:33.885]             inherits <- base::inherits
[15:32:33.885]             invokeRestart <- base::invokeRestart
[15:32:33.885]             length <- base::length
[15:32:33.885]             list <- base::list
[15:32:33.885]             seq.int <- base::seq.int
[15:32:33.885]             signalCondition <- base::signalCondition
[15:32:33.885]             sys.calls <- base::sys.calls
[15:32:33.885]             `[[` <- base::`[[`
[15:32:33.885]             `+` <- base::`+`
[15:32:33.885]             `<<-` <- base::`<<-`
[15:32:33.885]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:33.885]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:33.885]                   3L)]
[15:32:33.885]             }
[15:32:33.885]             function(cond) {
[15:32:33.885]                 is_error <- inherits(cond, "error")
[15:32:33.885]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:33.885]                   NULL)
[15:32:33.885]                 if (is_error) {
[15:32:33.885]                   sessionInformation <- function() {
[15:32:33.885]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:33.885]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:33.885]                       search = base::search(), system = base::Sys.info())
[15:32:33.885]                   }
[15:32:33.885]                   ...future.conditions[[length(...future.conditions) + 
[15:32:33.885]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:33.885]                     cond$call), session = sessionInformation(), 
[15:32:33.885]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:33.885]                   signalCondition(cond)
[15:32:33.885]                 }
[15:32:33.885]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:33.885]                 "immediateCondition"))) {
[15:32:33.885]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:33.885]                   ...future.conditions[[length(...future.conditions) + 
[15:32:33.885]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:33.885]                   if (TRUE && !signal) {
[15:32:33.885]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:33.885]                     {
[15:32:33.885]                       inherits <- base::inherits
[15:32:33.885]                       invokeRestart <- base::invokeRestart
[15:32:33.885]                       is.null <- base::is.null
[15:32:33.885]                       muffled <- FALSE
[15:32:33.885]                       if (inherits(cond, "message")) {
[15:32:33.885]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:33.885]                         if (muffled) 
[15:32:33.885]                           invokeRestart("muffleMessage")
[15:32:33.885]                       }
[15:32:33.885]                       else if (inherits(cond, "warning")) {
[15:32:33.885]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:33.885]                         if (muffled) 
[15:32:33.885]                           invokeRestart("muffleWarning")
[15:32:33.885]                       }
[15:32:33.885]                       else if (inherits(cond, "condition")) {
[15:32:33.885]                         if (!is.null(pattern)) {
[15:32:33.885]                           computeRestarts <- base::computeRestarts
[15:32:33.885]                           grepl <- base::grepl
[15:32:33.885]                           restarts <- computeRestarts(cond)
[15:32:33.885]                           for (restart in restarts) {
[15:32:33.885]                             name <- restart$name
[15:32:33.885]                             if (is.null(name)) 
[15:32:33.885]                               next
[15:32:33.885]                             if (!grepl(pattern, name)) 
[15:32:33.885]                               next
[15:32:33.885]                             invokeRestart(restart)
[15:32:33.885]                             muffled <- TRUE
[15:32:33.885]                             break
[15:32:33.885]                           }
[15:32:33.885]                         }
[15:32:33.885]                       }
[15:32:33.885]                       invisible(muffled)
[15:32:33.885]                     }
[15:32:33.885]                     muffleCondition(cond, pattern = "^muffle")
[15:32:33.885]                   }
[15:32:33.885]                 }
[15:32:33.885]                 else {
[15:32:33.885]                   if (TRUE) {
[15:32:33.885]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:33.885]                     {
[15:32:33.885]                       inherits <- base::inherits
[15:32:33.885]                       invokeRestart <- base::invokeRestart
[15:32:33.885]                       is.null <- base::is.null
[15:32:33.885]                       muffled <- FALSE
[15:32:33.885]                       if (inherits(cond, "message")) {
[15:32:33.885]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:33.885]                         if (muffled) 
[15:32:33.885]                           invokeRestart("muffleMessage")
[15:32:33.885]                       }
[15:32:33.885]                       else if (inherits(cond, "warning")) {
[15:32:33.885]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:33.885]                         if (muffled) 
[15:32:33.885]                           invokeRestart("muffleWarning")
[15:32:33.885]                       }
[15:32:33.885]                       else if (inherits(cond, "condition")) {
[15:32:33.885]                         if (!is.null(pattern)) {
[15:32:33.885]                           computeRestarts <- base::computeRestarts
[15:32:33.885]                           grepl <- base::grepl
[15:32:33.885]                           restarts <- computeRestarts(cond)
[15:32:33.885]                           for (restart in restarts) {
[15:32:33.885]                             name <- restart$name
[15:32:33.885]                             if (is.null(name)) 
[15:32:33.885]                               next
[15:32:33.885]                             if (!grepl(pattern, name)) 
[15:32:33.885]                               next
[15:32:33.885]                             invokeRestart(restart)
[15:32:33.885]                             muffled <- TRUE
[15:32:33.885]                             break
[15:32:33.885]                           }
[15:32:33.885]                         }
[15:32:33.885]                       }
[15:32:33.885]                       invisible(muffled)
[15:32:33.885]                     }
[15:32:33.885]                     muffleCondition(cond, pattern = "^muffle")
[15:32:33.885]                   }
[15:32:33.885]                 }
[15:32:33.885]             }
[15:32:33.885]         }))
[15:32:33.885]     }, error = function(ex) {
[15:32:33.885]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:33.885]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:33.885]                 ...future.rng), started = ...future.startTime, 
[15:32:33.885]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:33.885]             version = "1.8"), class = "FutureResult")
[15:32:33.885]     }, finally = {
[15:32:33.885]         if (!identical(...future.workdir, getwd())) 
[15:32:33.885]             setwd(...future.workdir)
[15:32:33.885]         {
[15:32:33.885]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:33.885]                 ...future.oldOptions$nwarnings <- NULL
[15:32:33.885]             }
[15:32:33.885]             base::options(...future.oldOptions)
[15:32:33.885]             if (.Platform$OS.type == "windows") {
[15:32:33.885]                 old_names <- names(...future.oldEnvVars)
[15:32:33.885]                 envs <- base::Sys.getenv()
[15:32:33.885]                 names <- names(envs)
[15:32:33.885]                 common <- intersect(names, old_names)
[15:32:33.885]                 added <- setdiff(names, old_names)
[15:32:33.885]                 removed <- setdiff(old_names, names)
[15:32:33.885]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:33.885]                   envs[common]]
[15:32:33.885]                 NAMES <- toupper(changed)
[15:32:33.885]                 args <- list()
[15:32:33.885]                 for (kk in seq_along(NAMES)) {
[15:32:33.885]                   name <- changed[[kk]]
[15:32:33.885]                   NAME <- NAMES[[kk]]
[15:32:33.885]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:33.885]                     next
[15:32:33.885]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:33.885]                 }
[15:32:33.885]                 NAMES <- toupper(added)
[15:32:33.885]                 for (kk in seq_along(NAMES)) {
[15:32:33.885]                   name <- added[[kk]]
[15:32:33.885]                   NAME <- NAMES[[kk]]
[15:32:33.885]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:33.885]                     next
[15:32:33.885]                   args[[name]] <- ""
[15:32:33.885]                 }
[15:32:33.885]                 NAMES <- toupper(removed)
[15:32:33.885]                 for (kk in seq_along(NAMES)) {
[15:32:33.885]                   name <- removed[[kk]]
[15:32:33.885]                   NAME <- NAMES[[kk]]
[15:32:33.885]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:33.885]                     next
[15:32:33.885]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:33.885]                 }
[15:32:33.885]                 if (length(args) > 0) 
[15:32:33.885]                   base::do.call(base::Sys.setenv, args = args)
[15:32:33.885]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:33.885]             }
[15:32:33.885]             else {
[15:32:33.885]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:33.885]             }
[15:32:33.885]             {
[15:32:33.885]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:33.885]                   0L) {
[15:32:33.885]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:33.885]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:33.885]                   base::options(opts)
[15:32:33.885]                 }
[15:32:33.885]                 {
[15:32:33.885]                   {
[15:32:33.885]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:33.885]                     NULL
[15:32:33.885]                   }
[15:32:33.885]                   options(future.plan = NULL)
[15:32:33.885]                   if (is.na(NA_character_)) 
[15:32:33.885]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:33.885]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:33.885]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:33.885]                     .init = FALSE)
[15:32:33.885]                 }
[15:32:33.885]             }
[15:32:33.885]         }
[15:32:33.885]     })
[15:32:33.885]     if (TRUE) {
[15:32:33.885]         base::sink(type = "output", split = FALSE)
[15:32:33.885]         if (TRUE) {
[15:32:33.885]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:33.885]         }
[15:32:33.885]         else {
[15:32:33.885]             ...future.result["stdout"] <- base::list(NULL)
[15:32:33.885]         }
[15:32:33.885]         base::close(...future.stdout)
[15:32:33.885]         ...future.stdout <- NULL
[15:32:33.885]     }
[15:32:33.885]     ...future.result$conditions <- ...future.conditions
[15:32:33.885]     ...future.result$finished <- base::Sys.time()
[15:32:33.885]     ...future.result
[15:32:33.885] }
[15:32:33.895] Exporting 5 global objects (1.22 KiB) to cluster node #1 ...
[15:32:33.896] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ...
[15:32:33.897] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ... DONE
[15:32:33.898] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:33.899] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:33.899] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ...
[15:32:33.900] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ... DONE
[15:32:33.900] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:33.901] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:33.902] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:33.903] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:33.903] Exporting 5 global objects (1.22 KiB) to cluster node #1 ... DONE
[15:32:33.904] MultisessionFuture started
[15:32:33.904] - Launch lazy future ... done
[15:32:33.904] run() for 'MultisessionFuture' ... done
[15:32:33.905] Created future:
[15:32:33.931] receiveMessageFromWorker() for ClusterFuture ...
[15:32:33.932] - Validating connection of MultisessionFuture
[15:32:33.932] - received message: FutureResult
[15:32:33.932] - Received FutureResult
[15:32:33.933] - Erased future from FutureRegistry
[15:32:33.933] result() for ClusterFuture ...
[15:32:33.933] - result already collected: FutureResult
[15:32:33.933] result() for ClusterFuture ... done
[15:32:33.933] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:33.905] MultisessionFuture:
[15:32:33.905] Label: 'future_sapply-1'
[15:32:33.905] Expression:
[15:32:33.905] {
[15:32:33.905]     do.call(function(...) {
[15:32:33.905]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:33.905]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:33.905]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:33.905]             on.exit(options(oopts), add = TRUE)
[15:32:33.905]         }
[15:32:33.905]         {
[15:32:33.905]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:33.905]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:33.905]                 ...future.FUN(...future.X_jj, ...)
[15:32:33.905]             })
[15:32:33.905]         }
[15:32:33.905]     }, args = future.call.arguments)
[15:32:33.905] }
[15:32:33.905] Lazy evaluation: FALSE
[15:32:33.905] Asynchronous evaluation: TRUE
[15:32:33.905] Local evaluation: TRUE
[15:32:33.905] Environment: R_GlobalEnv
[15:32:33.905] Capture standard output: TRUE
[15:32:33.905] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:33.905] Globals: 5 objects totaling 1.38 KiB (function '...future.FUN' of 1.22 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:33.905] Packages: <none>
[15:32:33.905] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:33.905] Resolved: TRUE
[15:32:33.905] Value: <not collected>
[15:32:33.905] Conditions captured: <none>
[15:32:33.905] Early signaling: FALSE
[15:32:33.905] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:33.905] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:33.934] Chunk #1 of 2 ... DONE
[15:32:33.934] Chunk #2 of 2 ...
[15:32:33.934]  - Finding globals in 'X' for chunk #2 ...
[15:32:33.934] getGlobalsAndPackages() ...
[15:32:33.934] Searching for globals...
[15:32:33.935] 
[15:32:33.935] Searching for globals ... DONE
[15:32:33.935] - globals: [0] <none>
[15:32:33.935] getGlobalsAndPackages() ... DONE
[15:32:33.935]    + additional globals found: [n=0] 
[15:32:33.936]    + additional namespaces needed: [n=0] 
[15:32:33.936]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:33.936]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:33.936]  - seeds: <none>
[15:32:33.936]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:33.936] getGlobalsAndPackages() ...
[15:32:33.937] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:33.937] Resolving globals: FALSE
[15:32:33.937] Tweak future expression to call with '...' arguments ...
[15:32:33.937] {
[15:32:33.937]     do.call(function(...) {
[15:32:33.937]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:33.937]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:33.937]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:33.937]             on.exit(options(oopts), add = TRUE)
[15:32:33.937]         }
[15:32:33.937]         {
[15:32:33.937]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:33.937]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:33.937]                 ...future.FUN(...future.X_jj, ...)
[15:32:33.937]             })
[15:32:33.937]         }
[15:32:33.937]     }, args = future.call.arguments)
[15:32:33.937] }
[15:32:33.938] Tweak future expression to call with '...' arguments ... DONE
[15:32:33.939] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:33.939] 
[15:32:33.939] getGlobalsAndPackages() ... DONE
[15:32:33.939] run() for 'Future' ...
[15:32:33.940] - state: 'created'
[15:32:33.940] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:33.954] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:33.954] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:33.954]   - Field: 'node'
[15:32:33.955]   - Field: 'label'
[15:32:33.955]   - Field: 'local'
[15:32:33.955]   - Field: 'owner'
[15:32:33.955]   - Field: 'envir'
[15:32:33.955]   - Field: 'workers'
[15:32:33.955]   - Field: 'packages'
[15:32:33.956]   - Field: 'gc'
[15:32:33.956]   - Field: 'conditions'
[15:32:33.956]   - Field: 'persistent'
[15:32:33.956]   - Field: 'expr'
[15:32:33.956]   - Field: 'uuid'
[15:32:33.956]   - Field: 'seed'
[15:32:33.957]   - Field: 'version'
[15:32:33.957]   - Field: 'result'
[15:32:33.957]   - Field: 'asynchronous'
[15:32:33.957]   - Field: 'calls'
[15:32:33.957]   - Field: 'globals'
[15:32:33.957]   - Field: 'stdout'
[15:32:33.958]   - Field: 'earlySignal'
[15:32:33.958]   - Field: 'lazy'
[15:32:33.958]   - Field: 'state'
[15:32:33.958] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:33.958] - Launch lazy future ...
[15:32:33.959] Packages needed by the future expression (n = 0): <none>
[15:32:33.959] Packages needed by future strategies (n = 0): <none>
[15:32:33.960] {
[15:32:33.960]     {
[15:32:33.960]         {
[15:32:33.960]             ...future.startTime <- base::Sys.time()
[15:32:33.960]             {
[15:32:33.960]                 {
[15:32:33.960]                   {
[15:32:33.960]                     {
[15:32:33.960]                       base::local({
[15:32:33.960]                         has_future <- base::requireNamespace("future", 
[15:32:33.960]                           quietly = TRUE)
[15:32:33.960]                         if (has_future) {
[15:32:33.960]                           ns <- base::getNamespace("future")
[15:32:33.960]                           version <- ns[[".package"]][["version"]]
[15:32:33.960]                           if (is.null(version)) 
[15:32:33.960]                             version <- utils::packageVersion("future")
[15:32:33.960]                         }
[15:32:33.960]                         else {
[15:32:33.960]                           version <- NULL
[15:32:33.960]                         }
[15:32:33.960]                         if (!has_future || version < "1.8.0") {
[15:32:33.960]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:33.960]                             "", base::R.version$version.string), 
[15:32:33.960]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:33.960]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:33.960]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:33.960]                               "release", "version")], collapse = " "), 
[15:32:33.960]                             hostname = base::Sys.info()[["nodename"]])
[15:32:33.960]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:33.960]                             info)
[15:32:33.960]                           info <- base::paste(info, collapse = "; ")
[15:32:33.960]                           if (!has_future) {
[15:32:33.960]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:33.960]                               info)
[15:32:33.960]                           }
[15:32:33.960]                           else {
[15:32:33.960]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:33.960]                               info, version)
[15:32:33.960]                           }
[15:32:33.960]                           base::stop(msg)
[15:32:33.960]                         }
[15:32:33.960]                       })
[15:32:33.960]                     }
[15:32:33.960]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:33.960]                     base::options(mc.cores = 1L)
[15:32:33.960]                   }
[15:32:33.960]                   ...future.strategy.old <- future::plan("list")
[15:32:33.960]                   options(future.plan = NULL)
[15:32:33.960]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:33.960]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:33.960]                 }
[15:32:33.960]                 ...future.workdir <- getwd()
[15:32:33.960]             }
[15:32:33.960]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:33.960]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:33.960]         }
[15:32:33.960]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:33.960]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:33.960]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:33.960]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:33.960]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:33.960]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:33.960]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:33.960]             base::names(...future.oldOptions))
[15:32:33.960]     }
[15:32:33.960]     if (FALSE) {
[15:32:33.960]     }
[15:32:33.960]     else {
[15:32:33.960]         if (TRUE) {
[15:32:33.960]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:33.960]                 open = "w")
[15:32:33.960]         }
[15:32:33.960]         else {
[15:32:33.960]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:33.960]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:33.960]         }
[15:32:33.960]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:33.960]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:33.960]             base::sink(type = "output", split = FALSE)
[15:32:33.960]             base::close(...future.stdout)
[15:32:33.960]         }, add = TRUE)
[15:32:33.960]     }
[15:32:33.960]     ...future.frame <- base::sys.nframe()
[15:32:33.960]     ...future.conditions <- base::list()
[15:32:33.960]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:33.960]     if (FALSE) {
[15:32:33.960]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:33.960]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:33.960]     }
[15:32:33.960]     ...future.result <- base::tryCatch({
[15:32:33.960]         base::withCallingHandlers({
[15:32:33.960]             ...future.value <- base::withVisible(base::local({
[15:32:33.960]                 ...future.makeSendCondition <- base::local({
[15:32:33.960]                   sendCondition <- NULL
[15:32:33.960]                   function(frame = 1L) {
[15:32:33.960]                     if (is.function(sendCondition)) 
[15:32:33.960]                       return(sendCondition)
[15:32:33.960]                     ns <- getNamespace("parallel")
[15:32:33.960]                     if (exists("sendData", mode = "function", 
[15:32:33.960]                       envir = ns)) {
[15:32:33.960]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:33.960]                         envir = ns)
[15:32:33.960]                       envir <- sys.frame(frame)
[15:32:33.960]                       master <- NULL
[15:32:33.960]                       while (!identical(envir, .GlobalEnv) && 
[15:32:33.960]                         !identical(envir, emptyenv())) {
[15:32:33.960]                         if (exists("master", mode = "list", envir = envir, 
[15:32:33.960]                           inherits = FALSE)) {
[15:32:33.960]                           master <- get("master", mode = "list", 
[15:32:33.960]                             envir = envir, inherits = FALSE)
[15:32:33.960]                           if (inherits(master, c("SOCKnode", 
[15:32:33.960]                             "SOCK0node"))) {
[15:32:33.960]                             sendCondition <<- function(cond) {
[15:32:33.960]                               data <- list(type = "VALUE", value = cond, 
[15:32:33.960]                                 success = TRUE)
[15:32:33.960]                               parallel_sendData(master, data)
[15:32:33.960]                             }
[15:32:33.960]                             return(sendCondition)
[15:32:33.960]                           }
[15:32:33.960]                         }
[15:32:33.960]                         frame <- frame + 1L
[15:32:33.960]                         envir <- sys.frame(frame)
[15:32:33.960]                       }
[15:32:33.960]                     }
[15:32:33.960]                     sendCondition <<- function(cond) NULL
[15:32:33.960]                   }
[15:32:33.960]                 })
[15:32:33.960]                 withCallingHandlers({
[15:32:33.960]                   {
[15:32:33.960]                     do.call(function(...) {
[15:32:33.960]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:33.960]                       if (!identical(...future.globals.maxSize.org, 
[15:32:33.960]                         ...future.globals.maxSize)) {
[15:32:33.960]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:33.960]                         on.exit(options(oopts), add = TRUE)
[15:32:33.960]                       }
[15:32:33.960]                       {
[15:32:33.960]                         lapply(seq_along(...future.elements_ii), 
[15:32:33.960]                           FUN = function(jj) {
[15:32:33.960]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:33.960]                             ...future.FUN(...future.X_jj, ...)
[15:32:33.960]                           })
[15:32:33.960]                       }
[15:32:33.960]                     }, args = future.call.arguments)
[15:32:33.960]                   }
[15:32:33.960]                 }, immediateCondition = function(cond) {
[15:32:33.960]                   sendCondition <- ...future.makeSendCondition()
[15:32:33.960]                   sendCondition(cond)
[15:32:33.960]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:33.960]                   {
[15:32:33.960]                     inherits <- base::inherits
[15:32:33.960]                     invokeRestart <- base::invokeRestart
[15:32:33.960]                     is.null <- base::is.null
[15:32:33.960]                     muffled <- FALSE
[15:32:33.960]                     if (inherits(cond, "message")) {
[15:32:33.960]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:33.960]                       if (muffled) 
[15:32:33.960]                         invokeRestart("muffleMessage")
[15:32:33.960]                     }
[15:32:33.960]                     else if (inherits(cond, "warning")) {
[15:32:33.960]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:33.960]                       if (muffled) 
[15:32:33.960]                         invokeRestart("muffleWarning")
[15:32:33.960]                     }
[15:32:33.960]                     else if (inherits(cond, "condition")) {
[15:32:33.960]                       if (!is.null(pattern)) {
[15:32:33.960]                         computeRestarts <- base::computeRestarts
[15:32:33.960]                         grepl <- base::grepl
[15:32:33.960]                         restarts <- computeRestarts(cond)
[15:32:33.960]                         for (restart in restarts) {
[15:32:33.960]                           name <- restart$name
[15:32:33.960]                           if (is.null(name)) 
[15:32:33.960]                             next
[15:32:33.960]                           if (!grepl(pattern, name)) 
[15:32:33.960]                             next
[15:32:33.960]                           invokeRestart(restart)
[15:32:33.960]                           muffled <- TRUE
[15:32:33.960]                           break
[15:32:33.960]                         }
[15:32:33.960]                       }
[15:32:33.960]                     }
[15:32:33.960]                     invisible(muffled)
[15:32:33.960]                   }
[15:32:33.960]                   muffleCondition(cond)
[15:32:33.960]                 })
[15:32:33.960]             }))
[15:32:33.960]             future::FutureResult(value = ...future.value$value, 
[15:32:33.960]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:33.960]                   ...future.rng), globalenv = if (FALSE) 
[15:32:33.960]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:33.960]                     ...future.globalenv.names))
[15:32:33.960]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:33.960]         }, condition = base::local({
[15:32:33.960]             c <- base::c
[15:32:33.960]             inherits <- base::inherits
[15:32:33.960]             invokeRestart <- base::invokeRestart
[15:32:33.960]             length <- base::length
[15:32:33.960]             list <- base::list
[15:32:33.960]             seq.int <- base::seq.int
[15:32:33.960]             signalCondition <- base::signalCondition
[15:32:33.960]             sys.calls <- base::sys.calls
[15:32:33.960]             `[[` <- base::`[[`
[15:32:33.960]             `+` <- base::`+`
[15:32:33.960]             `<<-` <- base::`<<-`
[15:32:33.960]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:33.960]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:33.960]                   3L)]
[15:32:33.960]             }
[15:32:33.960]             function(cond) {
[15:32:33.960]                 is_error <- inherits(cond, "error")
[15:32:33.960]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:33.960]                   NULL)
[15:32:33.960]                 if (is_error) {
[15:32:33.960]                   sessionInformation <- function() {
[15:32:33.960]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:33.960]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:33.960]                       search = base::search(), system = base::Sys.info())
[15:32:33.960]                   }
[15:32:33.960]                   ...future.conditions[[length(...future.conditions) + 
[15:32:33.960]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:33.960]                     cond$call), session = sessionInformation(), 
[15:32:33.960]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:33.960]                   signalCondition(cond)
[15:32:33.960]                 }
[15:32:33.960]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:33.960]                 "immediateCondition"))) {
[15:32:33.960]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:33.960]                   ...future.conditions[[length(...future.conditions) + 
[15:32:33.960]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:33.960]                   if (TRUE && !signal) {
[15:32:33.960]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:33.960]                     {
[15:32:33.960]                       inherits <- base::inherits
[15:32:33.960]                       invokeRestart <- base::invokeRestart
[15:32:33.960]                       is.null <- base::is.null
[15:32:33.960]                       muffled <- FALSE
[15:32:33.960]                       if (inherits(cond, "message")) {
[15:32:33.960]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:33.960]                         if (muffled) 
[15:32:33.960]                           invokeRestart("muffleMessage")
[15:32:33.960]                       }
[15:32:33.960]                       else if (inherits(cond, "warning")) {
[15:32:33.960]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:33.960]                         if (muffled) 
[15:32:33.960]                           invokeRestart("muffleWarning")
[15:32:33.960]                       }
[15:32:33.960]                       else if (inherits(cond, "condition")) {
[15:32:33.960]                         if (!is.null(pattern)) {
[15:32:33.960]                           computeRestarts <- base::computeRestarts
[15:32:33.960]                           grepl <- base::grepl
[15:32:33.960]                           restarts <- computeRestarts(cond)
[15:32:33.960]                           for (restart in restarts) {
[15:32:33.960]                             name <- restart$name
[15:32:33.960]                             if (is.null(name)) 
[15:32:33.960]                               next
[15:32:33.960]                             if (!grepl(pattern, name)) 
[15:32:33.960]                               next
[15:32:33.960]                             invokeRestart(restart)
[15:32:33.960]                             muffled <- TRUE
[15:32:33.960]                             break
[15:32:33.960]                           }
[15:32:33.960]                         }
[15:32:33.960]                       }
[15:32:33.960]                       invisible(muffled)
[15:32:33.960]                     }
[15:32:33.960]                     muffleCondition(cond, pattern = "^muffle")
[15:32:33.960]                   }
[15:32:33.960]                 }
[15:32:33.960]                 else {
[15:32:33.960]                   if (TRUE) {
[15:32:33.960]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:33.960]                     {
[15:32:33.960]                       inherits <- base::inherits
[15:32:33.960]                       invokeRestart <- base::invokeRestart
[15:32:33.960]                       is.null <- base::is.null
[15:32:33.960]                       muffled <- FALSE
[15:32:33.960]                       if (inherits(cond, "message")) {
[15:32:33.960]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:33.960]                         if (muffled) 
[15:32:33.960]                           invokeRestart("muffleMessage")
[15:32:33.960]                       }
[15:32:33.960]                       else if (inherits(cond, "warning")) {
[15:32:33.960]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:33.960]                         if (muffled) 
[15:32:33.960]                           invokeRestart("muffleWarning")
[15:32:33.960]                       }
[15:32:33.960]                       else if (inherits(cond, "condition")) {
[15:32:33.960]                         if (!is.null(pattern)) {
[15:32:33.960]                           computeRestarts <- base::computeRestarts
[15:32:33.960]                           grepl <- base::grepl
[15:32:33.960]                           restarts <- computeRestarts(cond)
[15:32:33.960]                           for (restart in restarts) {
[15:32:33.960]                             name <- restart$name
[15:32:33.960]                             if (is.null(name)) 
[15:32:33.960]                               next
[15:32:33.960]                             if (!grepl(pattern, name)) 
[15:32:33.960]                               next
[15:32:33.960]                             invokeRestart(restart)
[15:32:33.960]                             muffled <- TRUE
[15:32:33.960]                             break
[15:32:33.960]                           }
[15:32:33.960]                         }
[15:32:33.960]                       }
[15:32:33.960]                       invisible(muffled)
[15:32:33.960]                     }
[15:32:33.960]                     muffleCondition(cond, pattern = "^muffle")
[15:32:33.960]                   }
[15:32:33.960]                 }
[15:32:33.960]             }
[15:32:33.960]         }))
[15:32:33.960]     }, error = function(ex) {
[15:32:33.960]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:33.960]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:33.960]                 ...future.rng), started = ...future.startTime, 
[15:32:33.960]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:33.960]             version = "1.8"), class = "FutureResult")
[15:32:33.960]     }, finally = {
[15:32:33.960]         if (!identical(...future.workdir, getwd())) 
[15:32:33.960]             setwd(...future.workdir)
[15:32:33.960]         {
[15:32:33.960]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:33.960]                 ...future.oldOptions$nwarnings <- NULL
[15:32:33.960]             }
[15:32:33.960]             base::options(...future.oldOptions)
[15:32:33.960]             if (.Platform$OS.type == "windows") {
[15:32:33.960]                 old_names <- names(...future.oldEnvVars)
[15:32:33.960]                 envs <- base::Sys.getenv()
[15:32:33.960]                 names <- names(envs)
[15:32:33.960]                 common <- intersect(names, old_names)
[15:32:33.960]                 added <- setdiff(names, old_names)
[15:32:33.960]                 removed <- setdiff(old_names, names)
[15:32:33.960]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:33.960]                   envs[common]]
[15:32:33.960]                 NAMES <- toupper(changed)
[15:32:33.960]                 args <- list()
[15:32:33.960]                 for (kk in seq_along(NAMES)) {
[15:32:33.960]                   name <- changed[[kk]]
[15:32:33.960]                   NAME <- NAMES[[kk]]
[15:32:33.960]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:33.960]                     next
[15:32:33.960]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:33.960]                 }
[15:32:33.960]                 NAMES <- toupper(added)
[15:32:33.960]                 for (kk in seq_along(NAMES)) {
[15:32:33.960]                   name <- added[[kk]]
[15:32:33.960]                   NAME <- NAMES[[kk]]
[15:32:33.960]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:33.960]                     next
[15:32:33.960]                   args[[name]] <- ""
[15:32:33.960]                 }
[15:32:33.960]                 NAMES <- toupper(removed)
[15:32:33.960]                 for (kk in seq_along(NAMES)) {
[15:32:33.960]                   name <- removed[[kk]]
[15:32:33.960]                   NAME <- NAMES[[kk]]
[15:32:33.960]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:33.960]                     next
[15:32:33.960]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:33.960]                 }
[15:32:33.960]                 if (length(args) > 0) 
[15:32:33.960]                   base::do.call(base::Sys.setenv, args = args)
[15:32:33.960]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:33.960]             }
[15:32:33.960]             else {
[15:32:33.960]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:33.960]             }
[15:32:33.960]             {
[15:32:33.960]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:33.960]                   0L) {
[15:32:33.960]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:33.960]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:33.960]                   base::options(opts)
[15:32:33.960]                 }
[15:32:33.960]                 {
[15:32:33.960]                   {
[15:32:33.960]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:33.960]                     NULL
[15:32:33.960]                   }
[15:32:33.960]                   options(future.plan = NULL)
[15:32:33.960]                   if (is.na(NA_character_)) 
[15:32:33.960]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:33.960]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:33.960]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:33.960]                     .init = FALSE)
[15:32:33.960]                 }
[15:32:33.960]             }
[15:32:33.960]         }
[15:32:33.960]     })
[15:32:33.960]     if (TRUE) {
[15:32:33.960]         base::sink(type = "output", split = FALSE)
[15:32:33.960]         if (TRUE) {
[15:32:33.960]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:33.960]         }
[15:32:33.960]         else {
[15:32:33.960]             ...future.result["stdout"] <- base::list(NULL)
[15:32:33.960]         }
[15:32:33.960]         base::close(...future.stdout)
[15:32:33.960]         ...future.stdout <- NULL
[15:32:33.960]     }
[15:32:33.960]     ...future.result$conditions <- ...future.conditions
[15:32:33.960]     ...future.result$finished <- base::Sys.time()
[15:32:33.960]     ...future.result
[15:32:33.960] }
[15:32:33.965] Exporting 5 global objects (1.22 KiB) to cluster node #1 ...
[15:32:33.965] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ...
[15:32:33.966] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ... DONE
[15:32:33.966] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:33.967] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:33.967] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ...
[15:32:33.967] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ... DONE
[15:32:33.967] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:33.968] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:33.968] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:33.968] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:33.969] Exporting 5 global objects (1.22 KiB) to cluster node #1 ... DONE
[15:32:33.969] MultisessionFuture started
[15:32:33.969] - Launch lazy future ... done
[15:32:33.970] run() for 'MultisessionFuture' ... done
[15:32:33.970] Created future:
[15:32:33.992] receiveMessageFromWorker() for ClusterFuture ...
[15:32:33.992] - Validating connection of MultisessionFuture
[15:32:33.992] - received message: FutureResult
[15:32:33.993] - Received FutureResult
[15:32:33.993] - Erased future from FutureRegistry
[15:32:33.993] result() for ClusterFuture ...
[15:32:33.993] - result already collected: FutureResult
[15:32:33.993] result() for ClusterFuture ... done
[15:32:33.994] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:33.970] MultisessionFuture:
[15:32:33.970] Label: 'future_sapply-2'
[15:32:33.970] Expression:
[15:32:33.970] {
[15:32:33.970]     do.call(function(...) {
[15:32:33.970]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:33.970]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:33.970]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:33.970]             on.exit(options(oopts), add = TRUE)
[15:32:33.970]         }
[15:32:33.970]         {
[15:32:33.970]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:33.970]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:33.970]                 ...future.FUN(...future.X_jj, ...)
[15:32:33.970]             })
[15:32:33.970]         }
[15:32:33.970]     }, args = future.call.arguments)
[15:32:33.970] }
[15:32:33.970] Lazy evaluation: FALSE
[15:32:33.970] Asynchronous evaluation: TRUE
[15:32:33.970] Local evaluation: TRUE
[15:32:33.970] Environment: R_GlobalEnv
[15:32:33.970] Capture standard output: TRUE
[15:32:33.970] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:33.970] Globals: 5 objects totaling 1.38 KiB (function '...future.FUN' of 1.22 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:33.970] Packages: <none>
[15:32:33.970] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:33.970] Resolved: TRUE
[15:32:33.970] Value: <not collected>
[15:32:33.970] Conditions captured: <none>
[15:32:33.970] Early signaling: FALSE
[15:32:33.970] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:33.970] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:33.994] Chunk #2 of 2 ... DONE
[15:32:33.994] Launching 2 futures (chunks) ... DONE
[15:32:33.995] Resolving 2 futures (chunks) ...
[15:32:33.995] resolve() on list ...
[15:32:33.995]  recursive: 0
[15:32:33.995]  length: 2
[15:32:33.995] 
[15:32:33.996] Future #1
[15:32:33.996] result() for ClusterFuture ...
[15:32:33.996] - result already collected: FutureResult
[15:32:33.996] result() for ClusterFuture ... done
[15:32:33.996] result() for ClusterFuture ...
[15:32:33.997] - result already collected: FutureResult
[15:32:33.997] result() for ClusterFuture ... done
[15:32:33.997] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:33.997] - nx: 2
[15:32:33.997] - relay: TRUE
[15:32:33.998] - stdout: TRUE
[15:32:33.998] - signal: TRUE
[15:32:33.998] - resignal: FALSE
[15:32:33.998] - force: TRUE
[15:32:33.998] - relayed: [n=2] FALSE, FALSE
[15:32:33.998] - queued futures: [n=2] FALSE, FALSE
[15:32:33.999]  - until=1
[15:32:33.999]  - relaying element #1
[15:32:33.999] result() for ClusterFuture ...
[15:32:33.999] - result already collected: FutureResult
[15:32:33.999] result() for ClusterFuture ... done
[15:32:34.000] result() for ClusterFuture ...
[15:32:34.000] - result already collected: FutureResult
[15:32:34.000] result() for ClusterFuture ... done
[15:32:34.000] result() for ClusterFuture ...
[15:32:34.000] - result already collected: FutureResult
[15:32:34.001] result() for ClusterFuture ... done
[15:32:34.001] result() for ClusterFuture ...
[15:32:34.001] - result already collected: FutureResult
[15:32:34.001] result() for ClusterFuture ... done
[15:32:34.002] - relayed: [n=2] TRUE, FALSE
[15:32:34.002] - queued futures: [n=2] TRUE, FALSE
[15:32:34.002] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:34.003]  length: 1 (resolved future 1)
[15:32:34.003] Future #2
[15:32:34.003] result() for ClusterFuture ...
[15:32:34.004] - result already collected: FutureResult
[15:32:34.004] result() for ClusterFuture ... done
[15:32:34.004] result() for ClusterFuture ...
[15:32:34.004] - result already collected: FutureResult
[15:32:34.005] result() for ClusterFuture ... done
[15:32:34.005] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:34.005] - nx: 2
[15:32:34.006] - relay: TRUE
[15:32:34.006] - stdout: TRUE
[15:32:34.006] - signal: TRUE
[15:32:34.006] - resignal: FALSE
[15:32:34.007] - force: TRUE
[15:32:34.007] - relayed: [n=2] TRUE, FALSE
[15:32:34.007] - queued futures: [n=2] TRUE, FALSE
[15:32:34.008]  - until=2
[15:32:34.008]  - relaying element #2
[15:32:34.008] result() for ClusterFuture ...
[15:32:34.008] - result already collected: FutureResult
[15:32:34.009] result() for ClusterFuture ... done
[15:32:34.009] result() for ClusterFuture ...
[15:32:34.009] - result already collected: FutureResult
[15:32:34.010] result() for ClusterFuture ... done
[15:32:34.010] result() for ClusterFuture ...
[15:32:34.010] - result already collected: FutureResult
[15:32:34.011] result() for ClusterFuture ... done
[15:32:34.011] result() for ClusterFuture ...
[15:32:34.011] - result already collected: FutureResult
[15:32:34.011] result() for ClusterFuture ... done
[15:32:34.012] - relayed: [n=2] TRUE, TRUE
[15:32:34.012] - queued futures: [n=2] TRUE, TRUE
[15:32:34.012] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:34.013]  length: 0 (resolved future 2)
[15:32:34.013] Relaying remaining futures
[15:32:34.013] signalConditionsASAP(NULL, pos=0) ...
[15:32:34.014] - nx: 2
[15:32:34.014] - relay: TRUE
[15:32:34.014] - stdout: TRUE
[15:32:34.014] - signal: TRUE
[15:32:34.015] - resignal: FALSE
[15:32:34.015] - force: TRUE
[15:32:34.015] - relayed: [n=2] TRUE, TRUE
[15:32:34.015] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:34.016] - relayed: [n=2] TRUE, TRUE
[15:32:34.016] - queued futures: [n=2] TRUE, TRUE
[15:32:34.017] signalConditionsASAP(NULL, pos=0) ... done
[15:32:34.017] resolve() on list ... DONE
[15:32:34.017] result() for ClusterFuture ...
[15:32:34.017] - result already collected: FutureResult
[15:32:34.018] result() for ClusterFuture ... done
[15:32:34.018] result() for ClusterFuture ...
[15:32:34.018] - result already collected: FutureResult
[15:32:34.019] result() for ClusterFuture ... done
[15:32:34.019] result() for ClusterFuture ...
[15:32:34.019] - result already collected: FutureResult
[15:32:34.019] result() for ClusterFuture ... done
[15:32:34.020] result() for ClusterFuture ...
[15:32:34.020] - result already collected: FutureResult
[15:32:34.020] result() for ClusterFuture ... done
[15:32:34.021]  - Number of value chunks collected: 2
[15:32:34.021] Resolving 2 futures (chunks) ... DONE
[15:32:34.021] Reducing values from 2 chunks ...
[15:32:34.022]  - Number of values collected after concatenation: 6
[15:32:34.022]  - Number of values expected: 6
[15:32:34.022] Reducing values from 2 chunks ... DONE
[15:32:34.022] future_lapply() ... DONE
List of 2
 $ y0: Named int [1:6] 1 2 2 3 3 4
  ..- attr(*, "names")= chr [1:6] "a1" "a2" "b1" "b2" ...
 $ y1: Named int [1:6] 1 2 2 3 3 4
  ..- attr(*, "names")= chr [1:6] "a1" "a2" "b1" "b2" ...
[15:32:34.026] future_lapply() ...
[15:32:34.037] Number of chunks: 2
[15:32:34.038] getGlobalsAndPackagesXApply() ...
[15:32:34.038]  - future.globals: TRUE
[15:32:34.038] getGlobalsAndPackages() ...
[15:32:34.039] Searching for globals...
[15:32:34.042] - globals found: [5] 'FUN', '*', ':', 'outer', 'rep'
[15:32:34.043] Searching for globals ... DONE
[15:32:34.043] Resolving globals: FALSE
[15:32:34.044] The total size of the 1 globals is 4.62 KiB (4728 bytes)
[15:32:34.045] The total size of the 1 globals exported for future expression ('FUN()') is 4.62 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.62 KiB of class 'function')
[15:32:34.045] - globals: [1] 'FUN'
[15:32:34.045] 
[15:32:34.046] getGlobalsAndPackages() ... DONE
[15:32:34.046]  - globals found/used: [n=1] 'FUN'
[15:32:34.046]  - needed namespaces: [n=0] 
[15:32:34.047] Finding globals ... DONE
[15:32:34.047]  - use_args: TRUE
[15:32:34.047]  - Getting '...' globals ...
[15:32:34.048] resolve() on list ...
[15:32:34.048]  recursive: 0
[15:32:34.049]  length: 1
[15:32:34.049]  elements: '...'
[15:32:34.049]  length: 0 (resolved future 1)
[15:32:34.049] resolve() on list ... DONE
[15:32:34.050]    - '...' content: [n=0] 
[15:32:34.050] List of 1
[15:32:34.050]  $ ...: list()
[15:32:34.050]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:34.050]  - attr(*, "where")=List of 1
[15:32:34.050]   ..$ ...:<environment: 0x00000276e44a9338> 
[15:32:34.050]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:34.050]  - attr(*, "resolved")= logi TRUE
[15:32:34.050]  - attr(*, "total_size")= num NA
[15:32:34.056]  - Getting '...' globals ... DONE
[15:32:34.056] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:34.056] List of 2
[15:32:34.056]  $ ...future.FUN:function (x, y = 2 * 1:5)  
[15:32:34.056]  $ ...          : list()
[15:32:34.056]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:34.056]  - attr(*, "where")=List of 2
[15:32:34.056]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:34.056]   ..$ ...          :<environment: 0x00000276e44a9338> 
[15:32:34.056]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:34.056]  - attr(*, "resolved")= logi FALSE
[15:32:34.056]  - attr(*, "total_size")= num 4728
[15:32:34.062] Packages to be attached in all futures: [n=0] 
[15:32:34.063] getGlobalsAndPackagesXApply() ... DONE
[15:32:34.063] Number of futures (= number of chunks): 2
[15:32:34.064] Launching 2 futures (chunks) ...
[15:32:34.064] Chunk #1 of 2 ...
[15:32:34.064]  - Finding globals in 'X' for chunk #1 ...
[15:32:34.064] getGlobalsAndPackages() ...
[15:32:34.065] Searching for globals...
[15:32:34.065] 
[15:32:34.065] Searching for globals ... DONE
[15:32:34.065] - globals: [0] <none>
[15:32:34.065] getGlobalsAndPackages() ... DONE
[15:32:34.066]    + additional globals found: [n=0] 
[15:32:34.066]    + additional namespaces needed: [n=0] 
[15:32:34.066]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:34.066]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:34.066]  - seeds: <none>
[15:32:34.066]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:34.067] getGlobalsAndPackages() ...
[15:32:34.067] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:34.067] Resolving globals: FALSE
[15:32:34.067] Tweak future expression to call with '...' arguments ...
[15:32:34.068] {
[15:32:34.068]     do.call(function(...) {
[15:32:34.068]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:34.068]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:34.068]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:34.068]             on.exit(options(oopts), add = TRUE)
[15:32:34.068]         }
[15:32:34.068]         {
[15:32:34.068]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:34.068]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:34.068]                 ...future.FUN(...future.X_jj, ...)
[15:32:34.068]             })
[15:32:34.068]         }
[15:32:34.068]     }, args = future.call.arguments)
[15:32:34.068] }
[15:32:34.068] Tweak future expression to call with '...' arguments ... DONE
[15:32:34.069] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:34.069] 
[15:32:34.069] getGlobalsAndPackages() ... DONE
[15:32:34.070] run() for 'Future' ...
[15:32:34.070] - state: 'created'
[15:32:34.070] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:34.087] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:34.088] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:34.088]   - Field: 'node'
[15:32:34.088]   - Field: 'label'
[15:32:34.088]   - Field: 'local'
[15:32:34.089]   - Field: 'owner'
[15:32:34.089]   - Field: 'envir'
[15:32:34.089]   - Field: 'workers'
[15:32:34.089]   - Field: 'packages'
[15:32:34.090]   - Field: 'gc'
[15:32:34.090]   - Field: 'conditions'
[15:32:34.090]   - Field: 'persistent'
[15:32:34.090]   - Field: 'expr'
[15:32:34.091]   - Field: 'uuid'
[15:32:34.091]   - Field: 'seed'
[15:32:34.091]   - Field: 'version'
[15:32:34.092]   - Field: 'result'
[15:32:34.092]   - Field: 'asynchronous'
[15:32:34.092]   - Field: 'calls'
[15:32:34.092]   - Field: 'globals'
[15:32:34.093]   - Field: 'stdout'
[15:32:34.093]   - Field: 'earlySignal'
[15:32:34.093]   - Field: 'lazy'
[15:32:34.093]   - Field: 'state'
[15:32:34.094] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:34.094] - Launch lazy future ...
[15:32:34.094] Packages needed by the future expression (n = 0): <none>
[15:32:34.095] Packages needed by future strategies (n = 0): <none>
[15:32:34.096] {
[15:32:34.096]     {
[15:32:34.096]         {
[15:32:34.096]             ...future.startTime <- base::Sys.time()
[15:32:34.096]             {
[15:32:34.096]                 {
[15:32:34.096]                   {
[15:32:34.096]                     {
[15:32:34.096]                       base::local({
[15:32:34.096]                         has_future <- base::requireNamespace("future", 
[15:32:34.096]                           quietly = TRUE)
[15:32:34.096]                         if (has_future) {
[15:32:34.096]                           ns <- base::getNamespace("future")
[15:32:34.096]                           version <- ns[[".package"]][["version"]]
[15:32:34.096]                           if (is.null(version)) 
[15:32:34.096]                             version <- utils::packageVersion("future")
[15:32:34.096]                         }
[15:32:34.096]                         else {
[15:32:34.096]                           version <- NULL
[15:32:34.096]                         }
[15:32:34.096]                         if (!has_future || version < "1.8.0") {
[15:32:34.096]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:34.096]                             "", base::R.version$version.string), 
[15:32:34.096]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:34.096]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:34.096]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:34.096]                               "release", "version")], collapse = " "), 
[15:32:34.096]                             hostname = base::Sys.info()[["nodename"]])
[15:32:34.096]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:34.096]                             info)
[15:32:34.096]                           info <- base::paste(info, collapse = "; ")
[15:32:34.096]                           if (!has_future) {
[15:32:34.096]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:34.096]                               info)
[15:32:34.096]                           }
[15:32:34.096]                           else {
[15:32:34.096]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:34.096]                               info, version)
[15:32:34.096]                           }
[15:32:34.096]                           base::stop(msg)
[15:32:34.096]                         }
[15:32:34.096]                       })
[15:32:34.096]                     }
[15:32:34.096]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:34.096]                     base::options(mc.cores = 1L)
[15:32:34.096]                   }
[15:32:34.096]                   ...future.strategy.old <- future::plan("list")
[15:32:34.096]                   options(future.plan = NULL)
[15:32:34.096]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:34.096]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:34.096]                 }
[15:32:34.096]                 ...future.workdir <- getwd()
[15:32:34.096]             }
[15:32:34.096]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:34.096]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:34.096]         }
[15:32:34.096]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:34.096]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:34.096]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:34.096]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:34.096]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:34.096]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:34.096]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:34.096]             base::names(...future.oldOptions))
[15:32:34.096]     }
[15:32:34.096]     if (FALSE) {
[15:32:34.096]     }
[15:32:34.096]     else {
[15:32:34.096]         if (TRUE) {
[15:32:34.096]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:34.096]                 open = "w")
[15:32:34.096]         }
[15:32:34.096]         else {
[15:32:34.096]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:34.096]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:34.096]         }
[15:32:34.096]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:34.096]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:34.096]             base::sink(type = "output", split = FALSE)
[15:32:34.096]             base::close(...future.stdout)
[15:32:34.096]         }, add = TRUE)
[15:32:34.096]     }
[15:32:34.096]     ...future.frame <- base::sys.nframe()
[15:32:34.096]     ...future.conditions <- base::list()
[15:32:34.096]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:34.096]     if (FALSE) {
[15:32:34.096]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:34.096]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:34.096]     }
[15:32:34.096]     ...future.result <- base::tryCatch({
[15:32:34.096]         base::withCallingHandlers({
[15:32:34.096]             ...future.value <- base::withVisible(base::local({
[15:32:34.096]                 ...future.makeSendCondition <- base::local({
[15:32:34.096]                   sendCondition <- NULL
[15:32:34.096]                   function(frame = 1L) {
[15:32:34.096]                     if (is.function(sendCondition)) 
[15:32:34.096]                       return(sendCondition)
[15:32:34.096]                     ns <- getNamespace("parallel")
[15:32:34.096]                     if (exists("sendData", mode = "function", 
[15:32:34.096]                       envir = ns)) {
[15:32:34.096]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:34.096]                         envir = ns)
[15:32:34.096]                       envir <- sys.frame(frame)
[15:32:34.096]                       master <- NULL
[15:32:34.096]                       while (!identical(envir, .GlobalEnv) && 
[15:32:34.096]                         !identical(envir, emptyenv())) {
[15:32:34.096]                         if (exists("master", mode = "list", envir = envir, 
[15:32:34.096]                           inherits = FALSE)) {
[15:32:34.096]                           master <- get("master", mode = "list", 
[15:32:34.096]                             envir = envir, inherits = FALSE)
[15:32:34.096]                           if (inherits(master, c("SOCKnode", 
[15:32:34.096]                             "SOCK0node"))) {
[15:32:34.096]                             sendCondition <<- function(cond) {
[15:32:34.096]                               data <- list(type = "VALUE", value = cond, 
[15:32:34.096]                                 success = TRUE)
[15:32:34.096]                               parallel_sendData(master, data)
[15:32:34.096]                             }
[15:32:34.096]                             return(sendCondition)
[15:32:34.096]                           }
[15:32:34.096]                         }
[15:32:34.096]                         frame <- frame + 1L
[15:32:34.096]                         envir <- sys.frame(frame)
[15:32:34.096]                       }
[15:32:34.096]                     }
[15:32:34.096]                     sendCondition <<- function(cond) NULL
[15:32:34.096]                   }
[15:32:34.096]                 })
[15:32:34.096]                 withCallingHandlers({
[15:32:34.096]                   {
[15:32:34.096]                     do.call(function(...) {
[15:32:34.096]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:34.096]                       if (!identical(...future.globals.maxSize.org, 
[15:32:34.096]                         ...future.globals.maxSize)) {
[15:32:34.096]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:34.096]                         on.exit(options(oopts), add = TRUE)
[15:32:34.096]                       }
[15:32:34.096]                       {
[15:32:34.096]                         lapply(seq_along(...future.elements_ii), 
[15:32:34.096]                           FUN = function(jj) {
[15:32:34.096]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:34.096]                             ...future.FUN(...future.X_jj, ...)
[15:32:34.096]                           })
[15:32:34.096]                       }
[15:32:34.096]                     }, args = future.call.arguments)
[15:32:34.096]                   }
[15:32:34.096]                 }, immediateCondition = function(cond) {
[15:32:34.096]                   sendCondition <- ...future.makeSendCondition()
[15:32:34.096]                   sendCondition(cond)
[15:32:34.096]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:34.096]                   {
[15:32:34.096]                     inherits <- base::inherits
[15:32:34.096]                     invokeRestart <- base::invokeRestart
[15:32:34.096]                     is.null <- base::is.null
[15:32:34.096]                     muffled <- FALSE
[15:32:34.096]                     if (inherits(cond, "message")) {
[15:32:34.096]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:34.096]                       if (muffled) 
[15:32:34.096]                         invokeRestart("muffleMessage")
[15:32:34.096]                     }
[15:32:34.096]                     else if (inherits(cond, "warning")) {
[15:32:34.096]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:34.096]                       if (muffled) 
[15:32:34.096]                         invokeRestart("muffleWarning")
[15:32:34.096]                     }
[15:32:34.096]                     else if (inherits(cond, "condition")) {
[15:32:34.096]                       if (!is.null(pattern)) {
[15:32:34.096]                         computeRestarts <- base::computeRestarts
[15:32:34.096]                         grepl <- base::grepl
[15:32:34.096]                         restarts <- computeRestarts(cond)
[15:32:34.096]                         for (restart in restarts) {
[15:32:34.096]                           name <- restart$name
[15:32:34.096]                           if (is.null(name)) 
[15:32:34.096]                             next
[15:32:34.096]                           if (!grepl(pattern, name)) 
[15:32:34.096]                             next
[15:32:34.096]                           invokeRestart(restart)
[15:32:34.096]                           muffled <- TRUE
[15:32:34.096]                           break
[15:32:34.096]                         }
[15:32:34.096]                       }
[15:32:34.096]                     }
[15:32:34.096]                     invisible(muffled)
[15:32:34.096]                   }
[15:32:34.096]                   muffleCondition(cond)
[15:32:34.096]                 })
[15:32:34.096]             }))
[15:32:34.096]             future::FutureResult(value = ...future.value$value, 
[15:32:34.096]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:34.096]                   ...future.rng), globalenv = if (FALSE) 
[15:32:34.096]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:34.096]                     ...future.globalenv.names))
[15:32:34.096]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:34.096]         }, condition = base::local({
[15:32:34.096]             c <- base::c
[15:32:34.096]             inherits <- base::inherits
[15:32:34.096]             invokeRestart <- base::invokeRestart
[15:32:34.096]             length <- base::length
[15:32:34.096]             list <- base::list
[15:32:34.096]             seq.int <- base::seq.int
[15:32:34.096]             signalCondition <- base::signalCondition
[15:32:34.096]             sys.calls <- base::sys.calls
[15:32:34.096]             `[[` <- base::`[[`
[15:32:34.096]             `+` <- base::`+`
[15:32:34.096]             `<<-` <- base::`<<-`
[15:32:34.096]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:34.096]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:34.096]                   3L)]
[15:32:34.096]             }
[15:32:34.096]             function(cond) {
[15:32:34.096]                 is_error <- inherits(cond, "error")
[15:32:34.096]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:34.096]                   NULL)
[15:32:34.096]                 if (is_error) {
[15:32:34.096]                   sessionInformation <- function() {
[15:32:34.096]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:34.096]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:34.096]                       search = base::search(), system = base::Sys.info())
[15:32:34.096]                   }
[15:32:34.096]                   ...future.conditions[[length(...future.conditions) + 
[15:32:34.096]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:34.096]                     cond$call), session = sessionInformation(), 
[15:32:34.096]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:34.096]                   signalCondition(cond)
[15:32:34.096]                 }
[15:32:34.096]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:34.096]                 "immediateCondition"))) {
[15:32:34.096]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:34.096]                   ...future.conditions[[length(...future.conditions) + 
[15:32:34.096]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:34.096]                   if (TRUE && !signal) {
[15:32:34.096]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:34.096]                     {
[15:32:34.096]                       inherits <- base::inherits
[15:32:34.096]                       invokeRestart <- base::invokeRestart
[15:32:34.096]                       is.null <- base::is.null
[15:32:34.096]                       muffled <- FALSE
[15:32:34.096]                       if (inherits(cond, "message")) {
[15:32:34.096]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:34.096]                         if (muffled) 
[15:32:34.096]                           invokeRestart("muffleMessage")
[15:32:34.096]                       }
[15:32:34.096]                       else if (inherits(cond, "warning")) {
[15:32:34.096]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:34.096]                         if (muffled) 
[15:32:34.096]                           invokeRestart("muffleWarning")
[15:32:34.096]                       }
[15:32:34.096]                       else if (inherits(cond, "condition")) {
[15:32:34.096]                         if (!is.null(pattern)) {
[15:32:34.096]                           computeRestarts <- base::computeRestarts
[15:32:34.096]                           grepl <- base::grepl
[15:32:34.096]                           restarts <- computeRestarts(cond)
[15:32:34.096]                           for (restart in restarts) {
[15:32:34.096]                             name <- restart$name
[15:32:34.096]                             if (is.null(name)) 
[15:32:34.096]                               next
[15:32:34.096]                             if (!grepl(pattern, name)) 
[15:32:34.096]                               next
[15:32:34.096]                             invokeRestart(restart)
[15:32:34.096]                             muffled <- TRUE
[15:32:34.096]                             break
[15:32:34.096]                           }
[15:32:34.096]                         }
[15:32:34.096]                       }
[15:32:34.096]                       invisible(muffled)
[15:32:34.096]                     }
[15:32:34.096]                     muffleCondition(cond, pattern = "^muffle")
[15:32:34.096]                   }
[15:32:34.096]                 }
[15:32:34.096]                 else {
[15:32:34.096]                   if (TRUE) {
[15:32:34.096]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:34.096]                     {
[15:32:34.096]                       inherits <- base::inherits
[15:32:34.096]                       invokeRestart <- base::invokeRestart
[15:32:34.096]                       is.null <- base::is.null
[15:32:34.096]                       muffled <- FALSE
[15:32:34.096]                       if (inherits(cond, "message")) {
[15:32:34.096]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:34.096]                         if (muffled) 
[15:32:34.096]                           invokeRestart("muffleMessage")
[15:32:34.096]                       }
[15:32:34.096]                       else if (inherits(cond, "warning")) {
[15:32:34.096]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:34.096]                         if (muffled) 
[15:32:34.096]                           invokeRestart("muffleWarning")
[15:32:34.096]                       }
[15:32:34.096]                       else if (inherits(cond, "condition")) {
[15:32:34.096]                         if (!is.null(pattern)) {
[15:32:34.096]                           computeRestarts <- base::computeRestarts
[15:32:34.096]                           grepl <- base::grepl
[15:32:34.096]                           restarts <- computeRestarts(cond)
[15:32:34.096]                           for (restart in restarts) {
[15:32:34.096]                             name <- restart$name
[15:32:34.096]                             if (is.null(name)) 
[15:32:34.096]                               next
[15:32:34.096]                             if (!grepl(pattern, name)) 
[15:32:34.096]                               next
[15:32:34.096]                             invokeRestart(restart)
[15:32:34.096]                             muffled <- TRUE
[15:32:34.096]                             break
[15:32:34.096]                           }
[15:32:34.096]                         }
[15:32:34.096]                       }
[15:32:34.096]                       invisible(muffled)
[15:32:34.096]                     }
[15:32:34.096]                     muffleCondition(cond, pattern = "^muffle")
[15:32:34.096]                   }
[15:32:34.096]                 }
[15:32:34.096]             }
[15:32:34.096]         }))
[15:32:34.096]     }, error = function(ex) {
[15:32:34.096]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:34.096]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:34.096]                 ...future.rng), started = ...future.startTime, 
[15:32:34.096]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:34.096]             version = "1.8"), class = "FutureResult")
[15:32:34.096]     }, finally = {
[15:32:34.096]         if (!identical(...future.workdir, getwd())) 
[15:32:34.096]             setwd(...future.workdir)
[15:32:34.096]         {
[15:32:34.096]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:34.096]                 ...future.oldOptions$nwarnings <- NULL
[15:32:34.096]             }
[15:32:34.096]             base::options(...future.oldOptions)
[15:32:34.096]             if (.Platform$OS.type == "windows") {
[15:32:34.096]                 old_names <- names(...future.oldEnvVars)
[15:32:34.096]                 envs <- base::Sys.getenv()
[15:32:34.096]                 names <- names(envs)
[15:32:34.096]                 common <- intersect(names, old_names)
[15:32:34.096]                 added <- setdiff(names, old_names)
[15:32:34.096]                 removed <- setdiff(old_names, names)
[15:32:34.096]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:34.096]                   envs[common]]
[15:32:34.096]                 NAMES <- toupper(changed)
[15:32:34.096]                 args <- list()
[15:32:34.096]                 for (kk in seq_along(NAMES)) {
[15:32:34.096]                   name <- changed[[kk]]
[15:32:34.096]                   NAME <- NAMES[[kk]]
[15:32:34.096]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:34.096]                     next
[15:32:34.096]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:34.096]                 }
[15:32:34.096]                 NAMES <- toupper(added)
[15:32:34.096]                 for (kk in seq_along(NAMES)) {
[15:32:34.096]                   name <- added[[kk]]
[15:32:34.096]                   NAME <- NAMES[[kk]]
[15:32:34.096]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:34.096]                     next
[15:32:34.096]                   args[[name]] <- ""
[15:32:34.096]                 }
[15:32:34.096]                 NAMES <- toupper(removed)
[15:32:34.096]                 for (kk in seq_along(NAMES)) {
[15:32:34.096]                   name <- removed[[kk]]
[15:32:34.096]                   NAME <- NAMES[[kk]]
[15:32:34.096]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:34.096]                     next
[15:32:34.096]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:34.096]                 }
[15:32:34.096]                 if (length(args) > 0) 
[15:32:34.096]                   base::do.call(base::Sys.setenv, args = args)
[15:32:34.096]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:34.096]             }
[15:32:34.096]             else {
[15:32:34.096]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:34.096]             }
[15:32:34.096]             {
[15:32:34.096]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:34.096]                   0L) {
[15:32:34.096]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:34.096]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:34.096]                   base::options(opts)
[15:32:34.096]                 }
[15:32:34.096]                 {
[15:32:34.096]                   {
[15:32:34.096]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:34.096]                     NULL
[15:32:34.096]                   }
[15:32:34.096]                   options(future.plan = NULL)
[15:32:34.096]                   if (is.na(NA_character_)) 
[15:32:34.096]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:34.096]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:34.096]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:34.096]                     .init = FALSE)
[15:32:34.096]                 }
[15:32:34.096]             }
[15:32:34.096]         }
[15:32:34.096]     })
[15:32:34.096]     if (TRUE) {
[15:32:34.096]         base::sink(type = "output", split = FALSE)
[15:32:34.096]         if (TRUE) {
[15:32:34.096]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:34.096]         }
[15:32:34.096]         else {
[15:32:34.096]             ...future.result["stdout"] <- base::list(NULL)
[15:32:34.096]         }
[15:32:34.096]         base::close(...future.stdout)
[15:32:34.096]         ...future.stdout <- NULL
[15:32:34.096]     }
[15:32:34.096]     ...future.result$conditions <- ...future.conditions
[15:32:34.096]     ...future.result$finished <- base::Sys.time()
[15:32:34.096]     ...future.result
[15:32:34.096] }
[15:32:34.104] Exporting 5 global objects (4.62 KiB) to cluster node #1 ...
[15:32:34.105] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ...
[15:32:34.105] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ... DONE
[15:32:34.106] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:34.107] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:34.107] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ...
[15:32:34.108] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ... DONE
[15:32:34.108] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:34.109] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:34.110] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:34.111] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:34.111] Exporting 5 global objects (4.62 KiB) to cluster node #1 ... DONE
[15:32:34.112] MultisessionFuture started
[15:32:34.113] - Launch lazy future ... done
[15:32:34.113] run() for 'MultisessionFuture' ... done
[15:32:34.113] Created future:
[15:32:34.143] receiveMessageFromWorker() for ClusterFuture ...
[15:32:34.143] - Validating connection of MultisessionFuture
[15:32:34.144] - received message: FutureResult
[15:32:34.144] - Received FutureResult
[15:32:34.145] - Erased future from FutureRegistry
[15:32:34.145] result() for ClusterFuture ...
[15:32:34.145] - result already collected: FutureResult
[15:32:34.146] result() for ClusterFuture ... done
[15:32:34.146] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:34.114] MultisessionFuture:
[15:32:34.114] Label: 'future_sapply-1'
[15:32:34.114] Expression:
[15:32:34.114] {
[15:32:34.114]     do.call(function(...) {
[15:32:34.114]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:34.114]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:34.114]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:34.114]             on.exit(options(oopts), add = TRUE)
[15:32:34.114]         }
[15:32:34.114]         {
[15:32:34.114]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:34.114]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:34.114]                 ...future.FUN(...future.X_jj, ...)
[15:32:34.114]             })
[15:32:34.114]         }
[15:32:34.114]     }, args = future.call.arguments)
[15:32:34.114] }
[15:32:34.114] Lazy evaluation: FALSE
[15:32:34.114] Asynchronous evaluation: TRUE
[15:32:34.114] Local evaluation: TRUE
[15:32:34.114] Environment: R_GlobalEnv
[15:32:34.114] Capture standard output: TRUE
[15:32:34.114] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:34.114] Globals: 5 objects totaling 4.78 KiB (function '...future.FUN' of 4.62 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:34.114] Packages: <none>
[15:32:34.114] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:34.114] Resolved: TRUE
[15:32:34.114] Value: <not collected>
[15:32:34.114] Conditions captured: <none>
[15:32:34.114] Early signaling: FALSE
[15:32:34.114] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:34.114] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:34.147] Chunk #1 of 2 ... DONE
[15:32:34.147] Chunk #2 of 2 ...
[15:32:34.148]  - Finding globals in 'X' for chunk #2 ...
[15:32:34.148] getGlobalsAndPackages() ...
[15:32:34.148] Searching for globals...
[15:32:34.149] 
[15:32:34.149] Searching for globals ... DONE
[15:32:34.150] - globals: [0] <none>
[15:32:34.150] getGlobalsAndPackages() ... DONE
[15:32:34.150]    + additional globals found: [n=0] 
[15:32:34.151]    + additional namespaces needed: [n=0] 
[15:32:34.151]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:34.151]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:34.152]  - seeds: <none>
[15:32:34.152]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:34.153] getGlobalsAndPackages() ...
[15:32:34.153] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:34.153] Resolving globals: FALSE
[15:32:34.154] Tweak future expression to call with '...' arguments ...
[15:32:34.154] {
[15:32:34.154]     do.call(function(...) {
[15:32:34.154]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:34.154]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:34.154]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:34.154]             on.exit(options(oopts), add = TRUE)
[15:32:34.154]         }
[15:32:34.154]         {
[15:32:34.154]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:34.154]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:34.154]                 ...future.FUN(...future.X_jj, ...)
[15:32:34.154]             })
[15:32:34.154]         }
[15:32:34.154]     }, args = future.call.arguments)
[15:32:34.154] }
[15:32:34.155] Tweak future expression to call with '...' arguments ... DONE
[15:32:34.156] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:34.156] 
[15:32:34.156] getGlobalsAndPackages() ... DONE
[15:32:34.157] run() for 'Future' ...
[15:32:34.157] - state: 'created'
[15:32:34.158] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:34.181] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:34.182] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:34.182]   - Field: 'node'
[15:32:34.182]   - Field: 'label'
[15:32:34.183]   - Field: 'local'
[15:32:34.183]   - Field: 'owner'
[15:32:34.184]   - Field: 'envir'
[15:32:34.184]   - Field: 'workers'
[15:32:34.185]   - Field: 'packages'
[15:32:34.185]   - Field: 'gc'
[15:32:34.185]   - Field: 'conditions'
[15:32:34.186]   - Field: 'persistent'
[15:32:34.186]   - Field: 'expr'
[15:32:34.187]   - Field: 'uuid'
[15:32:34.187]   - Field: 'seed'
[15:32:34.187]   - Field: 'version'
[15:32:34.188]   - Field: 'result'
[15:32:34.188]   - Field: 'asynchronous'
[15:32:34.189]   - Field: 'calls'
[15:32:34.189]   - Field: 'globals'
[15:32:34.189]   - Field: 'stdout'
[15:32:34.190]   - Field: 'earlySignal'
[15:32:34.190]   - Field: 'lazy'
[15:32:34.191]   - Field: 'state'
[15:32:34.191] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:34.191] - Launch lazy future ...
[15:32:34.192] Packages needed by the future expression (n = 0): <none>
[15:32:34.192] Packages needed by future strategies (n = 0): <none>
[15:32:34.193] {
[15:32:34.193]     {
[15:32:34.193]         {
[15:32:34.193]             ...future.startTime <- base::Sys.time()
[15:32:34.193]             {
[15:32:34.193]                 {
[15:32:34.193]                   {
[15:32:34.193]                     {
[15:32:34.193]                       base::local({
[15:32:34.193]                         has_future <- base::requireNamespace("future", 
[15:32:34.193]                           quietly = TRUE)
[15:32:34.193]                         if (has_future) {
[15:32:34.193]                           ns <- base::getNamespace("future")
[15:32:34.193]                           version <- ns[[".package"]][["version"]]
[15:32:34.193]                           if (is.null(version)) 
[15:32:34.193]                             version <- utils::packageVersion("future")
[15:32:34.193]                         }
[15:32:34.193]                         else {
[15:32:34.193]                           version <- NULL
[15:32:34.193]                         }
[15:32:34.193]                         if (!has_future || version < "1.8.0") {
[15:32:34.193]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:34.193]                             "", base::R.version$version.string), 
[15:32:34.193]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:34.193]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:34.193]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:34.193]                               "release", "version")], collapse = " "), 
[15:32:34.193]                             hostname = base::Sys.info()[["nodename"]])
[15:32:34.193]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:34.193]                             info)
[15:32:34.193]                           info <- base::paste(info, collapse = "; ")
[15:32:34.193]                           if (!has_future) {
[15:32:34.193]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:34.193]                               info)
[15:32:34.193]                           }
[15:32:34.193]                           else {
[15:32:34.193]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:34.193]                               info, version)
[15:32:34.193]                           }
[15:32:34.193]                           base::stop(msg)
[15:32:34.193]                         }
[15:32:34.193]                       })
[15:32:34.193]                     }
[15:32:34.193]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:34.193]                     base::options(mc.cores = 1L)
[15:32:34.193]                   }
[15:32:34.193]                   ...future.strategy.old <- future::plan("list")
[15:32:34.193]                   options(future.plan = NULL)
[15:32:34.193]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:34.193]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:34.193]                 }
[15:32:34.193]                 ...future.workdir <- getwd()
[15:32:34.193]             }
[15:32:34.193]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:34.193]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:34.193]         }
[15:32:34.193]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:34.193]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:34.193]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:34.193]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:34.193]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:34.193]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:34.193]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:34.193]             base::names(...future.oldOptions))
[15:32:34.193]     }
[15:32:34.193]     if (FALSE) {
[15:32:34.193]     }
[15:32:34.193]     else {
[15:32:34.193]         if (TRUE) {
[15:32:34.193]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:34.193]                 open = "w")
[15:32:34.193]         }
[15:32:34.193]         else {
[15:32:34.193]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:34.193]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:34.193]         }
[15:32:34.193]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:34.193]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:34.193]             base::sink(type = "output", split = FALSE)
[15:32:34.193]             base::close(...future.stdout)
[15:32:34.193]         }, add = TRUE)
[15:32:34.193]     }
[15:32:34.193]     ...future.frame <- base::sys.nframe()
[15:32:34.193]     ...future.conditions <- base::list()
[15:32:34.193]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:34.193]     if (FALSE) {
[15:32:34.193]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:34.193]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:34.193]     }
[15:32:34.193]     ...future.result <- base::tryCatch({
[15:32:34.193]         base::withCallingHandlers({
[15:32:34.193]             ...future.value <- base::withVisible(base::local({
[15:32:34.193]                 ...future.makeSendCondition <- base::local({
[15:32:34.193]                   sendCondition <- NULL
[15:32:34.193]                   function(frame = 1L) {
[15:32:34.193]                     if (is.function(sendCondition)) 
[15:32:34.193]                       return(sendCondition)
[15:32:34.193]                     ns <- getNamespace("parallel")
[15:32:34.193]                     if (exists("sendData", mode = "function", 
[15:32:34.193]                       envir = ns)) {
[15:32:34.193]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:34.193]                         envir = ns)
[15:32:34.193]                       envir <- sys.frame(frame)
[15:32:34.193]                       master <- NULL
[15:32:34.193]                       while (!identical(envir, .GlobalEnv) && 
[15:32:34.193]                         !identical(envir, emptyenv())) {
[15:32:34.193]                         if (exists("master", mode = "list", envir = envir, 
[15:32:34.193]                           inherits = FALSE)) {
[15:32:34.193]                           master <- get("master", mode = "list", 
[15:32:34.193]                             envir = envir, inherits = FALSE)
[15:32:34.193]                           if (inherits(master, c("SOCKnode", 
[15:32:34.193]                             "SOCK0node"))) {
[15:32:34.193]                             sendCondition <<- function(cond) {
[15:32:34.193]                               data <- list(type = "VALUE", value = cond, 
[15:32:34.193]                                 success = TRUE)
[15:32:34.193]                               parallel_sendData(master, data)
[15:32:34.193]                             }
[15:32:34.193]                             return(sendCondition)
[15:32:34.193]                           }
[15:32:34.193]                         }
[15:32:34.193]                         frame <- frame + 1L
[15:32:34.193]                         envir <- sys.frame(frame)
[15:32:34.193]                       }
[15:32:34.193]                     }
[15:32:34.193]                     sendCondition <<- function(cond) NULL
[15:32:34.193]                   }
[15:32:34.193]                 })
[15:32:34.193]                 withCallingHandlers({
[15:32:34.193]                   {
[15:32:34.193]                     do.call(function(...) {
[15:32:34.193]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:34.193]                       if (!identical(...future.globals.maxSize.org, 
[15:32:34.193]                         ...future.globals.maxSize)) {
[15:32:34.193]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:34.193]                         on.exit(options(oopts), add = TRUE)
[15:32:34.193]                       }
[15:32:34.193]                       {
[15:32:34.193]                         lapply(seq_along(...future.elements_ii), 
[15:32:34.193]                           FUN = function(jj) {
[15:32:34.193]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:34.193]                             ...future.FUN(...future.X_jj, ...)
[15:32:34.193]                           })
[15:32:34.193]                       }
[15:32:34.193]                     }, args = future.call.arguments)
[15:32:34.193]                   }
[15:32:34.193]                 }, immediateCondition = function(cond) {
[15:32:34.193]                   sendCondition <- ...future.makeSendCondition()
[15:32:34.193]                   sendCondition(cond)
[15:32:34.193]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:34.193]                   {
[15:32:34.193]                     inherits <- base::inherits
[15:32:34.193]                     invokeRestart <- base::invokeRestart
[15:32:34.193]                     is.null <- base::is.null
[15:32:34.193]                     muffled <- FALSE
[15:32:34.193]                     if (inherits(cond, "message")) {
[15:32:34.193]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:34.193]                       if (muffled) 
[15:32:34.193]                         invokeRestart("muffleMessage")
[15:32:34.193]                     }
[15:32:34.193]                     else if (inherits(cond, "warning")) {
[15:32:34.193]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:34.193]                       if (muffled) 
[15:32:34.193]                         invokeRestart("muffleWarning")
[15:32:34.193]                     }
[15:32:34.193]                     else if (inherits(cond, "condition")) {
[15:32:34.193]                       if (!is.null(pattern)) {
[15:32:34.193]                         computeRestarts <- base::computeRestarts
[15:32:34.193]                         grepl <- base::grepl
[15:32:34.193]                         restarts <- computeRestarts(cond)
[15:32:34.193]                         for (restart in restarts) {
[15:32:34.193]                           name <- restart$name
[15:32:34.193]                           if (is.null(name)) 
[15:32:34.193]                             next
[15:32:34.193]                           if (!grepl(pattern, name)) 
[15:32:34.193]                             next
[15:32:34.193]                           invokeRestart(restart)
[15:32:34.193]                           muffled <- TRUE
[15:32:34.193]                           break
[15:32:34.193]                         }
[15:32:34.193]                       }
[15:32:34.193]                     }
[15:32:34.193]                     invisible(muffled)
[15:32:34.193]                   }
[15:32:34.193]                   muffleCondition(cond)
[15:32:34.193]                 })
[15:32:34.193]             }))
[15:32:34.193]             future::FutureResult(value = ...future.value$value, 
[15:32:34.193]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:34.193]                   ...future.rng), globalenv = if (FALSE) 
[15:32:34.193]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:34.193]                     ...future.globalenv.names))
[15:32:34.193]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:34.193]         }, condition = base::local({
[15:32:34.193]             c <- base::c
[15:32:34.193]             inherits <- base::inherits
[15:32:34.193]             invokeRestart <- base::invokeRestart
[15:32:34.193]             length <- base::length
[15:32:34.193]             list <- base::list
[15:32:34.193]             seq.int <- base::seq.int
[15:32:34.193]             signalCondition <- base::signalCondition
[15:32:34.193]             sys.calls <- base::sys.calls
[15:32:34.193]             `[[` <- base::`[[`
[15:32:34.193]             `+` <- base::`+`
[15:32:34.193]             `<<-` <- base::`<<-`
[15:32:34.193]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:34.193]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:34.193]                   3L)]
[15:32:34.193]             }
[15:32:34.193]             function(cond) {
[15:32:34.193]                 is_error <- inherits(cond, "error")
[15:32:34.193]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:34.193]                   NULL)
[15:32:34.193]                 if (is_error) {
[15:32:34.193]                   sessionInformation <- function() {
[15:32:34.193]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:34.193]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:34.193]                       search = base::search(), system = base::Sys.info())
[15:32:34.193]                   }
[15:32:34.193]                   ...future.conditions[[length(...future.conditions) + 
[15:32:34.193]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:34.193]                     cond$call), session = sessionInformation(), 
[15:32:34.193]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:34.193]                   signalCondition(cond)
[15:32:34.193]                 }
[15:32:34.193]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:34.193]                 "immediateCondition"))) {
[15:32:34.193]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:34.193]                   ...future.conditions[[length(...future.conditions) + 
[15:32:34.193]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:34.193]                   if (TRUE && !signal) {
[15:32:34.193]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:34.193]                     {
[15:32:34.193]                       inherits <- base::inherits
[15:32:34.193]                       invokeRestart <- base::invokeRestart
[15:32:34.193]                       is.null <- base::is.null
[15:32:34.193]                       muffled <- FALSE
[15:32:34.193]                       if (inherits(cond, "message")) {
[15:32:34.193]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:34.193]                         if (muffled) 
[15:32:34.193]                           invokeRestart("muffleMessage")
[15:32:34.193]                       }
[15:32:34.193]                       else if (inherits(cond, "warning")) {
[15:32:34.193]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:34.193]                         if (muffled) 
[15:32:34.193]                           invokeRestart("muffleWarning")
[15:32:34.193]                       }
[15:32:34.193]                       else if (inherits(cond, "condition")) {
[15:32:34.193]                         if (!is.null(pattern)) {
[15:32:34.193]                           computeRestarts <- base::computeRestarts
[15:32:34.193]                           grepl <- base::grepl
[15:32:34.193]                           restarts <- computeRestarts(cond)
[15:32:34.193]                           for (restart in restarts) {
[15:32:34.193]                             name <- restart$name
[15:32:34.193]                             if (is.null(name)) 
[15:32:34.193]                               next
[15:32:34.193]                             if (!grepl(pattern, name)) 
[15:32:34.193]                               next
[15:32:34.193]                             invokeRestart(restart)
[15:32:34.193]                             muffled <- TRUE
[15:32:34.193]                             break
[15:32:34.193]                           }
[15:32:34.193]                         }
[15:32:34.193]                       }
[15:32:34.193]                       invisible(muffled)
[15:32:34.193]                     }
[15:32:34.193]                     muffleCondition(cond, pattern = "^muffle")
[15:32:34.193]                   }
[15:32:34.193]                 }
[15:32:34.193]                 else {
[15:32:34.193]                   if (TRUE) {
[15:32:34.193]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:34.193]                     {
[15:32:34.193]                       inherits <- base::inherits
[15:32:34.193]                       invokeRestart <- base::invokeRestart
[15:32:34.193]                       is.null <- base::is.null
[15:32:34.193]                       muffled <- FALSE
[15:32:34.193]                       if (inherits(cond, "message")) {
[15:32:34.193]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:34.193]                         if (muffled) 
[15:32:34.193]                           invokeRestart("muffleMessage")
[15:32:34.193]                       }
[15:32:34.193]                       else if (inherits(cond, "warning")) {
[15:32:34.193]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:34.193]                         if (muffled) 
[15:32:34.193]                           invokeRestart("muffleWarning")
[15:32:34.193]                       }
[15:32:34.193]                       else if (inherits(cond, "condition")) {
[15:32:34.193]                         if (!is.null(pattern)) {
[15:32:34.193]                           computeRestarts <- base::computeRestarts
[15:32:34.193]                           grepl <- base::grepl
[15:32:34.193]                           restarts <- computeRestarts(cond)
[15:32:34.193]                           for (restart in restarts) {
[15:32:34.193]                             name <- restart$name
[15:32:34.193]                             if (is.null(name)) 
[15:32:34.193]                               next
[15:32:34.193]                             if (!grepl(pattern, name)) 
[15:32:34.193]                               next
[15:32:34.193]                             invokeRestart(restart)
[15:32:34.193]                             muffled <- TRUE
[15:32:34.193]                             break
[15:32:34.193]                           }
[15:32:34.193]                         }
[15:32:34.193]                       }
[15:32:34.193]                       invisible(muffled)
[15:32:34.193]                     }
[15:32:34.193]                     muffleCondition(cond, pattern = "^muffle")
[15:32:34.193]                   }
[15:32:34.193]                 }
[15:32:34.193]             }
[15:32:34.193]         }))
[15:32:34.193]     }, error = function(ex) {
[15:32:34.193]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:34.193]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:34.193]                 ...future.rng), started = ...future.startTime, 
[15:32:34.193]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:34.193]             version = "1.8"), class = "FutureResult")
[15:32:34.193]     }, finally = {
[15:32:34.193]         if (!identical(...future.workdir, getwd())) 
[15:32:34.193]             setwd(...future.workdir)
[15:32:34.193]         {
[15:32:34.193]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:34.193]                 ...future.oldOptions$nwarnings <- NULL
[15:32:34.193]             }
[15:32:34.193]             base::options(...future.oldOptions)
[15:32:34.193]             if (.Platform$OS.type == "windows") {
[15:32:34.193]                 old_names <- names(...future.oldEnvVars)
[15:32:34.193]                 envs <- base::Sys.getenv()
[15:32:34.193]                 names <- names(envs)
[15:32:34.193]                 common <- intersect(names, old_names)
[15:32:34.193]                 added <- setdiff(names, old_names)
[15:32:34.193]                 removed <- setdiff(old_names, names)
[15:32:34.193]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:34.193]                   envs[common]]
[15:32:34.193]                 NAMES <- toupper(changed)
[15:32:34.193]                 args <- list()
[15:32:34.193]                 for (kk in seq_along(NAMES)) {
[15:32:34.193]                   name <- changed[[kk]]
[15:32:34.193]                   NAME <- NAMES[[kk]]
[15:32:34.193]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:34.193]                     next
[15:32:34.193]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:34.193]                 }
[15:32:34.193]                 NAMES <- toupper(added)
[15:32:34.193]                 for (kk in seq_along(NAMES)) {
[15:32:34.193]                   name <- added[[kk]]
[15:32:34.193]                   NAME <- NAMES[[kk]]
[15:32:34.193]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:34.193]                     next
[15:32:34.193]                   args[[name]] <- ""
[15:32:34.193]                 }
[15:32:34.193]                 NAMES <- toupper(removed)
[15:32:34.193]                 for (kk in seq_along(NAMES)) {
[15:32:34.193]                   name <- removed[[kk]]
[15:32:34.193]                   NAME <- NAMES[[kk]]
[15:32:34.193]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:34.193]                     next
[15:32:34.193]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:34.193]                 }
[15:32:34.193]                 if (length(args) > 0) 
[15:32:34.193]                   base::do.call(base::Sys.setenv, args = args)
[15:32:34.193]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:34.193]             }
[15:32:34.193]             else {
[15:32:34.193]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:34.193]             }
[15:32:34.193]             {
[15:32:34.193]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:34.193]                   0L) {
[15:32:34.193]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:34.193]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:34.193]                   base::options(opts)
[15:32:34.193]                 }
[15:32:34.193]                 {
[15:32:34.193]                   {
[15:32:34.193]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:34.193]                     NULL
[15:32:34.193]                   }
[15:32:34.193]                   options(future.plan = NULL)
[15:32:34.193]                   if (is.na(NA_character_)) 
[15:32:34.193]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:34.193]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:34.193]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:34.193]                     .init = FALSE)
[15:32:34.193]                 }
[15:32:34.193]             }
[15:32:34.193]         }
[15:32:34.193]     })
[15:32:34.193]     if (TRUE) {
[15:32:34.193]         base::sink(type = "output", split = FALSE)
[15:32:34.193]         if (TRUE) {
[15:32:34.193]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:34.193]         }
[15:32:34.193]         else {
[15:32:34.193]             ...future.result["stdout"] <- base::list(NULL)
[15:32:34.193]         }
[15:32:34.193]         base::close(...future.stdout)
[15:32:34.193]         ...future.stdout <- NULL
[15:32:34.193]     }
[15:32:34.193]     ...future.result$conditions <- ...future.conditions
[15:32:34.193]     ...future.result$finished <- base::Sys.time()
[15:32:34.193]     ...future.result
[15:32:34.193] }
[15:32:34.205] Exporting 5 global objects (4.62 KiB) to cluster node #1 ...
[15:32:34.206] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ...
[15:32:34.208] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ... DONE
[15:32:34.209] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:34.209] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:34.210] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ...
[15:32:34.210] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ... DONE
[15:32:34.210] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:34.211] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:34.211] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:34.212] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:34.212] Exporting 5 global objects (4.62 KiB) to cluster node #1 ... DONE
[15:32:34.213] MultisessionFuture started
[15:32:34.213] - Launch lazy future ... done
[15:32:34.213] run() for 'MultisessionFuture' ... done
[15:32:34.213] Created future:
[15:32:34.238] receiveMessageFromWorker() for ClusterFuture ...
[15:32:34.239] - Validating connection of MultisessionFuture
[15:32:34.239] - received message: FutureResult
[15:32:34.240] - Received FutureResult
[15:32:34.240] - Erased future from FutureRegistry
[15:32:34.240] result() for ClusterFuture ...
[15:32:34.241] - result already collected: FutureResult
[15:32:34.241] result() for ClusterFuture ... done
[15:32:34.241] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:34.214] MultisessionFuture:
[15:32:34.214] Label: 'future_sapply-2'
[15:32:34.214] Expression:
[15:32:34.214] {
[15:32:34.214]     do.call(function(...) {
[15:32:34.214]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:34.214]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:34.214]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:34.214]             on.exit(options(oopts), add = TRUE)
[15:32:34.214]         }
[15:32:34.214]         {
[15:32:34.214]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:34.214]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:34.214]                 ...future.FUN(...future.X_jj, ...)
[15:32:34.214]             })
[15:32:34.214]         }
[15:32:34.214]     }, args = future.call.arguments)
[15:32:34.214] }
[15:32:34.214] Lazy evaluation: FALSE
[15:32:34.214] Asynchronous evaluation: TRUE
[15:32:34.214] Local evaluation: TRUE
[15:32:34.214] Environment: R_GlobalEnv
[15:32:34.214] Capture standard output: TRUE
[15:32:34.214] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:34.214] Globals: 5 objects totaling 4.78 KiB (function '...future.FUN' of 4.62 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:34.214] Packages: <none>
[15:32:34.214] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:34.214] Resolved: TRUE
[15:32:34.214] Value: <not collected>
[15:32:34.214] Conditions captured: <none>
[15:32:34.214] Early signaling: FALSE
[15:32:34.214] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:34.214] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:34.242] Chunk #2 of 2 ... DONE
[15:32:34.242] Launching 2 futures (chunks) ... DONE
[15:32:34.243] Resolving 2 futures (chunks) ...
[15:32:34.243] resolve() on list ...
[15:32:34.243]  recursive: 0
[15:32:34.243]  length: 2
[15:32:34.244] 
[15:32:34.244] Future #1
[15:32:34.244] result() for ClusterFuture ...
[15:32:34.244] - result already collected: FutureResult
[15:32:34.245] result() for ClusterFuture ... done
[15:32:34.245] result() for ClusterFuture ...
[15:32:34.245] - result already collected: FutureResult
[15:32:34.245] result() for ClusterFuture ... done
[15:32:34.246] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:34.246] - nx: 2
[15:32:34.246] - relay: TRUE
[15:32:34.247] - stdout: TRUE
[15:32:34.247] - signal: TRUE
[15:32:34.247] - resignal: FALSE
[15:32:34.247] - force: TRUE
[15:32:34.248] - relayed: [n=2] FALSE, FALSE
[15:32:34.248] - queued futures: [n=2] FALSE, FALSE
[15:32:34.248]  - until=1
[15:32:34.248]  - relaying element #1
[15:32:34.249] result() for ClusterFuture ...
[15:32:34.249] - result already collected: FutureResult
[15:32:34.249] result() for ClusterFuture ... done
[15:32:34.249] result() for ClusterFuture ...
[15:32:34.250] - result already collected: FutureResult
[15:32:34.250] result() for ClusterFuture ... done
[15:32:34.250] result() for ClusterFuture ...
[15:32:34.251] - result already collected: FutureResult
[15:32:34.251] result() for ClusterFuture ... done
[15:32:34.251] result() for ClusterFuture ...
[15:32:34.251] - result already collected: FutureResult
[15:32:34.252] result() for ClusterFuture ... done
[15:32:34.252] - relayed: [n=2] TRUE, FALSE
[15:32:34.252] - queued futures: [n=2] TRUE, FALSE
[15:32:34.252] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:34.253]  length: 1 (resolved future 1)
[15:32:34.253] Future #2
[15:32:34.253] result() for ClusterFuture ...
[15:32:34.253] - result already collected: FutureResult
[15:32:34.254] result() for ClusterFuture ... done
[15:32:34.254] result() for ClusterFuture ...
[15:32:34.254] - result already collected: FutureResult
[15:32:34.255] result() for ClusterFuture ... done
[15:32:34.255] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:34.255] - nx: 2
[15:32:34.255] - relay: TRUE
[15:32:34.256] - stdout: TRUE
[15:32:34.256] - signal: TRUE
[15:32:34.256] - resignal: FALSE
[15:32:34.256] - force: TRUE
[15:32:34.257] - relayed: [n=2] TRUE, FALSE
[15:32:34.257] - queued futures: [n=2] TRUE, FALSE
[15:32:34.257]  - until=2
[15:32:34.257]  - relaying element #2
[15:32:34.258] result() for ClusterFuture ...
[15:32:34.258] - result already collected: FutureResult
[15:32:34.258] result() for ClusterFuture ... done
[15:32:34.258] result() for ClusterFuture ...
[15:32:34.259] - result already collected: FutureResult
[15:32:34.259] result() for ClusterFuture ... done
[15:32:34.259] result() for ClusterFuture ...
[15:32:34.259] - result already collected: FutureResult
[15:32:34.260] result() for ClusterFuture ... done
[15:32:34.260] result() for ClusterFuture ...
[15:32:34.260] - result already collected: FutureResult
[15:32:34.260] result() for ClusterFuture ... done
[15:32:34.261] - relayed: [n=2] TRUE, TRUE
[15:32:34.261] - queued futures: [n=2] TRUE, TRUE
[15:32:34.261] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:34.262]  length: 0 (resolved future 2)
[15:32:34.262] Relaying remaining futures
[15:32:34.262] signalConditionsASAP(NULL, pos=0) ...
[15:32:34.262] - nx: 2
[15:32:34.263] - relay: TRUE
[15:32:34.263] - stdout: TRUE
[15:32:34.263] - signal: TRUE
[15:32:34.263] - resignal: FALSE
[15:32:34.264] - force: TRUE
[15:32:34.264] - relayed: [n=2] TRUE, TRUE
[15:32:34.264] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:34.264] - relayed: [n=2] TRUE, TRUE
[15:32:34.265] - queued futures: [n=2] TRUE, TRUE
[15:32:34.265] signalConditionsASAP(NULL, pos=0) ... done
[15:32:34.265] resolve() on list ... DONE
[15:32:34.265] result() for ClusterFuture ...
[15:32:34.266] - result already collected: FutureResult
[15:32:34.266] result() for ClusterFuture ... done
[15:32:34.266] result() for ClusterFuture ...
[15:32:34.267] - result already collected: FutureResult
[15:32:34.267] result() for ClusterFuture ... done
[15:32:34.267] result() for ClusterFuture ...
[15:32:34.267] - result already collected: FutureResult
[15:32:34.268] result() for ClusterFuture ... done
[15:32:34.268] result() for ClusterFuture ...
[15:32:34.268] - result already collected: FutureResult
[15:32:34.268] result() for ClusterFuture ... done
[15:32:34.269]  - Number of value chunks collected: 2
[15:32:34.269] Resolving 2 futures (chunks) ... DONE
[15:32:34.269] Reducing values from 2 chunks ...
[15:32:34.270]  - Number of values collected after concatenation: 6
[15:32:34.270]  - Number of values expected: 6
[15:32:34.270] Reducing values from 2 chunks ... DONE
[15:32:34.270] future_lapply() ... DONE
List of 2
 $ y0: num [1:15, 1:6] 2 2 2 4 4 4 6 6 6 8 ...
  ..- attr(*, "dimnames")=List of 2
  .. ..$ : NULL
  .. ..$ : chr [1:6] "a1" "a2" "b1" "b2" ...
 $ y1: num [1:15, 1:6] 2 2 2 4 4 4 6 6 6 8 ...
  ..- attr(*, "dimnames")=List of 2
  .. ..$ : NULL
  .. ..$ : chr [1:6] "a1" "a2" "b1" "b2" ...
[15:32:34.276] future_lapply() ...
[15:32:34.281] Number of chunks: 2
[15:32:34.281] getGlobalsAndPackagesXApply() ...
[15:32:34.281]  - future.globals: TRUE
[15:32:34.282] getGlobalsAndPackages() ...
[15:32:34.282] Searching for globals...
[15:32:34.284] - globals found: [1] 'FUN'
[15:32:34.284] Searching for globals ... DONE
[15:32:34.285] Resolving globals: FALSE
[15:32:34.285] The total size of the 1 globals is 848 bytes (848 bytes)
[15:32:34.286] The total size of the 1 globals exported for future expression ('FUN()') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:32:34.286] - globals: [1] 'FUN'
[15:32:34.287] 
[15:32:34.287] getGlobalsAndPackages() ... DONE
[15:32:34.287]  - globals found/used: [n=1] 'FUN'
[15:32:34.287]  - needed namespaces: [n=0] 
[15:32:34.288] Finding globals ... DONE
[15:32:34.288]  - use_args: TRUE
[15:32:34.288]  - Getting '...' globals ...
[15:32:34.289] resolve() on list ...
[15:32:34.289]  recursive: 0
[15:32:34.289]  length: 1
[15:32:34.290]  elements: '...'
[15:32:34.290]  length: 0 (resolved future 1)
[15:32:34.290] resolve() on list ... DONE
[15:32:34.290]    - '...' content: [n=0] 
[15:32:34.291] List of 1
[15:32:34.291]  $ ...: list()
[15:32:34.291]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:34.291]  - attr(*, "where")=List of 1
[15:32:34.291]   ..$ ...:<environment: 0x00000276e4aa1dd0> 
[15:32:34.291]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:34.291]  - attr(*, "resolved")= logi TRUE
[15:32:34.291]  - attr(*, "total_size")= num NA
[15:32:34.296]  - Getting '...' globals ... DONE
[15:32:34.296] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:34.296] List of 2
[15:32:34.296]  $ ...future.FUN:function (x)  
[15:32:34.296]  $ ...          : list()
[15:32:34.296]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:34.296]  - attr(*, "where")=List of 2
[15:32:34.296]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:34.296]   ..$ ...          :<environment: 0x00000276e4aa1dd0> 
[15:32:34.296]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:34.296]  - attr(*, "resolved")= logi FALSE
[15:32:34.296]  - attr(*, "total_size")= num 848
[15:32:34.308] Packages to be attached in all futures: [n=0] 
[15:32:34.308] getGlobalsAndPackagesXApply() ... DONE
[15:32:34.308] Number of futures (= number of chunks): 2
[15:32:34.309] Launching 2 futures (chunks) ...
[15:32:34.309] Chunk #1 of 2 ...
[15:32:34.309]  - Finding globals in 'X' for chunk #1 ...
[15:32:34.309] getGlobalsAndPackages() ...
[15:32:34.310] Searching for globals...
[15:32:34.310] 
[15:32:34.310] Searching for globals ... DONE
[15:32:34.311] - globals: [0] <none>
[15:32:34.311] getGlobalsAndPackages() ... DONE
[15:32:34.311]    + additional globals found: [n=0] 
[15:32:34.311]    + additional namespaces needed: [n=0] 
[15:32:34.312]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:34.312]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:34.312]  - seeds: <none>
[15:32:34.312]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:34.313] getGlobalsAndPackages() ...
[15:32:34.313] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:34.313] Resolving globals: FALSE
[15:32:34.314] Tweak future expression to call with '...' arguments ...
[15:32:34.314] {
[15:32:34.314]     do.call(function(...) {
[15:32:34.314]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:34.314]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:34.314]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:34.314]             on.exit(options(oopts), add = TRUE)
[15:32:34.314]         }
[15:32:34.314]         {
[15:32:34.314]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:34.314]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:34.314]                 ...future.FUN(...future.X_jj, ...)
[15:32:34.314]             })
[15:32:34.314]         }
[15:32:34.314]     }, args = future.call.arguments)
[15:32:34.314] }
[15:32:34.315] Tweak future expression to call with '...' arguments ... DONE
[15:32:34.316] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:34.316] 
[15:32:34.316] getGlobalsAndPackages() ... DONE
[15:32:34.317] run() for 'Future' ...
[15:32:34.317] - state: 'created'
[15:32:34.318] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:34.339] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:34.339] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:34.339]   - Field: 'node'
[15:32:34.340]   - Field: 'label'
[15:32:34.340]   - Field: 'local'
[15:32:34.340]   - Field: 'owner'
[15:32:34.340]   - Field: 'envir'
[15:32:34.340]   - Field: 'workers'
[15:32:34.341]   - Field: 'packages'
[15:32:34.341]   - Field: 'gc'
[15:32:34.341]   - Field: 'conditions'
[15:32:34.341]   - Field: 'persistent'
[15:32:34.342]   - Field: 'expr'
[15:32:34.342]   - Field: 'uuid'
[15:32:34.342]   - Field: 'seed'
[15:32:34.342]   - Field: 'version'
[15:32:34.342]   - Field: 'result'
[15:32:34.343]   - Field: 'asynchronous'
[15:32:34.343]   - Field: 'calls'
[15:32:34.343]   - Field: 'globals'
[15:32:34.343]   - Field: 'stdout'
[15:32:34.344]   - Field: 'earlySignal'
[15:32:34.344]   - Field: 'lazy'
[15:32:34.344]   - Field: 'state'
[15:32:34.344] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:34.345] - Launch lazy future ...
[15:32:34.345] Packages needed by the future expression (n = 0): <none>
[15:32:34.345] Packages needed by future strategies (n = 0): <none>
[15:32:34.346] {
[15:32:34.346]     {
[15:32:34.346]         {
[15:32:34.346]             ...future.startTime <- base::Sys.time()
[15:32:34.346]             {
[15:32:34.346]                 {
[15:32:34.346]                   {
[15:32:34.346]                     {
[15:32:34.346]                       base::local({
[15:32:34.346]                         has_future <- base::requireNamespace("future", 
[15:32:34.346]                           quietly = TRUE)
[15:32:34.346]                         if (has_future) {
[15:32:34.346]                           ns <- base::getNamespace("future")
[15:32:34.346]                           version <- ns[[".package"]][["version"]]
[15:32:34.346]                           if (is.null(version)) 
[15:32:34.346]                             version <- utils::packageVersion("future")
[15:32:34.346]                         }
[15:32:34.346]                         else {
[15:32:34.346]                           version <- NULL
[15:32:34.346]                         }
[15:32:34.346]                         if (!has_future || version < "1.8.0") {
[15:32:34.346]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:34.346]                             "", base::R.version$version.string), 
[15:32:34.346]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:34.346]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:34.346]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:34.346]                               "release", "version")], collapse = " "), 
[15:32:34.346]                             hostname = base::Sys.info()[["nodename"]])
[15:32:34.346]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:34.346]                             info)
[15:32:34.346]                           info <- base::paste(info, collapse = "; ")
[15:32:34.346]                           if (!has_future) {
[15:32:34.346]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:34.346]                               info)
[15:32:34.346]                           }
[15:32:34.346]                           else {
[15:32:34.346]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:34.346]                               info, version)
[15:32:34.346]                           }
[15:32:34.346]                           base::stop(msg)
[15:32:34.346]                         }
[15:32:34.346]                       })
[15:32:34.346]                     }
[15:32:34.346]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:34.346]                     base::options(mc.cores = 1L)
[15:32:34.346]                   }
[15:32:34.346]                   ...future.strategy.old <- future::plan("list")
[15:32:34.346]                   options(future.plan = NULL)
[15:32:34.346]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:34.346]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:34.346]                 }
[15:32:34.346]                 ...future.workdir <- getwd()
[15:32:34.346]             }
[15:32:34.346]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:34.346]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:34.346]         }
[15:32:34.346]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:34.346]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:34.346]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:34.346]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:34.346]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:34.346]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:34.346]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:34.346]             base::names(...future.oldOptions))
[15:32:34.346]     }
[15:32:34.346]     if (FALSE) {
[15:32:34.346]     }
[15:32:34.346]     else {
[15:32:34.346]         if (TRUE) {
[15:32:34.346]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:34.346]                 open = "w")
[15:32:34.346]         }
[15:32:34.346]         else {
[15:32:34.346]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:34.346]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:34.346]         }
[15:32:34.346]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:34.346]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:34.346]             base::sink(type = "output", split = FALSE)
[15:32:34.346]             base::close(...future.stdout)
[15:32:34.346]         }, add = TRUE)
[15:32:34.346]     }
[15:32:34.346]     ...future.frame <- base::sys.nframe()
[15:32:34.346]     ...future.conditions <- base::list()
[15:32:34.346]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:34.346]     if (FALSE) {
[15:32:34.346]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:34.346]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:34.346]     }
[15:32:34.346]     ...future.result <- base::tryCatch({
[15:32:34.346]         base::withCallingHandlers({
[15:32:34.346]             ...future.value <- base::withVisible(base::local({
[15:32:34.346]                 ...future.makeSendCondition <- base::local({
[15:32:34.346]                   sendCondition <- NULL
[15:32:34.346]                   function(frame = 1L) {
[15:32:34.346]                     if (is.function(sendCondition)) 
[15:32:34.346]                       return(sendCondition)
[15:32:34.346]                     ns <- getNamespace("parallel")
[15:32:34.346]                     if (exists("sendData", mode = "function", 
[15:32:34.346]                       envir = ns)) {
[15:32:34.346]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:34.346]                         envir = ns)
[15:32:34.346]                       envir <- sys.frame(frame)
[15:32:34.346]                       master <- NULL
[15:32:34.346]                       while (!identical(envir, .GlobalEnv) && 
[15:32:34.346]                         !identical(envir, emptyenv())) {
[15:32:34.346]                         if (exists("master", mode = "list", envir = envir, 
[15:32:34.346]                           inherits = FALSE)) {
[15:32:34.346]                           master <- get("master", mode = "list", 
[15:32:34.346]                             envir = envir, inherits = FALSE)
[15:32:34.346]                           if (inherits(master, c("SOCKnode", 
[15:32:34.346]                             "SOCK0node"))) {
[15:32:34.346]                             sendCondition <<- function(cond) {
[15:32:34.346]                               data <- list(type = "VALUE", value = cond, 
[15:32:34.346]                                 success = TRUE)
[15:32:34.346]                               parallel_sendData(master, data)
[15:32:34.346]                             }
[15:32:34.346]                             return(sendCondition)
[15:32:34.346]                           }
[15:32:34.346]                         }
[15:32:34.346]                         frame <- frame + 1L
[15:32:34.346]                         envir <- sys.frame(frame)
[15:32:34.346]                       }
[15:32:34.346]                     }
[15:32:34.346]                     sendCondition <<- function(cond) NULL
[15:32:34.346]                   }
[15:32:34.346]                 })
[15:32:34.346]                 withCallingHandlers({
[15:32:34.346]                   {
[15:32:34.346]                     do.call(function(...) {
[15:32:34.346]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:34.346]                       if (!identical(...future.globals.maxSize.org, 
[15:32:34.346]                         ...future.globals.maxSize)) {
[15:32:34.346]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:34.346]                         on.exit(options(oopts), add = TRUE)
[15:32:34.346]                       }
[15:32:34.346]                       {
[15:32:34.346]                         lapply(seq_along(...future.elements_ii), 
[15:32:34.346]                           FUN = function(jj) {
[15:32:34.346]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:34.346]                             ...future.FUN(...future.X_jj, ...)
[15:32:34.346]                           })
[15:32:34.346]                       }
[15:32:34.346]                     }, args = future.call.arguments)
[15:32:34.346]                   }
[15:32:34.346]                 }, immediateCondition = function(cond) {
[15:32:34.346]                   sendCondition <- ...future.makeSendCondition()
[15:32:34.346]                   sendCondition(cond)
[15:32:34.346]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:34.346]                   {
[15:32:34.346]                     inherits <- base::inherits
[15:32:34.346]                     invokeRestart <- base::invokeRestart
[15:32:34.346]                     is.null <- base::is.null
[15:32:34.346]                     muffled <- FALSE
[15:32:34.346]                     if (inherits(cond, "message")) {
[15:32:34.346]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:34.346]                       if (muffled) 
[15:32:34.346]                         invokeRestart("muffleMessage")
[15:32:34.346]                     }
[15:32:34.346]                     else if (inherits(cond, "warning")) {
[15:32:34.346]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:34.346]                       if (muffled) 
[15:32:34.346]                         invokeRestart("muffleWarning")
[15:32:34.346]                     }
[15:32:34.346]                     else if (inherits(cond, "condition")) {
[15:32:34.346]                       if (!is.null(pattern)) {
[15:32:34.346]                         computeRestarts <- base::computeRestarts
[15:32:34.346]                         grepl <- base::grepl
[15:32:34.346]                         restarts <- computeRestarts(cond)
[15:32:34.346]                         for (restart in restarts) {
[15:32:34.346]                           name <- restart$name
[15:32:34.346]                           if (is.null(name)) 
[15:32:34.346]                             next
[15:32:34.346]                           if (!grepl(pattern, name)) 
[15:32:34.346]                             next
[15:32:34.346]                           invokeRestart(restart)
[15:32:34.346]                           muffled <- TRUE
[15:32:34.346]                           break
[15:32:34.346]                         }
[15:32:34.346]                       }
[15:32:34.346]                     }
[15:32:34.346]                     invisible(muffled)
[15:32:34.346]                   }
[15:32:34.346]                   muffleCondition(cond)
[15:32:34.346]                 })
[15:32:34.346]             }))
[15:32:34.346]             future::FutureResult(value = ...future.value$value, 
[15:32:34.346]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:34.346]                   ...future.rng), globalenv = if (FALSE) 
[15:32:34.346]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:34.346]                     ...future.globalenv.names))
[15:32:34.346]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:34.346]         }, condition = base::local({
[15:32:34.346]             c <- base::c
[15:32:34.346]             inherits <- base::inherits
[15:32:34.346]             invokeRestart <- base::invokeRestart
[15:32:34.346]             length <- base::length
[15:32:34.346]             list <- base::list
[15:32:34.346]             seq.int <- base::seq.int
[15:32:34.346]             signalCondition <- base::signalCondition
[15:32:34.346]             sys.calls <- base::sys.calls
[15:32:34.346]             `[[` <- base::`[[`
[15:32:34.346]             `+` <- base::`+`
[15:32:34.346]             `<<-` <- base::`<<-`
[15:32:34.346]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:34.346]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:34.346]                   3L)]
[15:32:34.346]             }
[15:32:34.346]             function(cond) {
[15:32:34.346]                 is_error <- inherits(cond, "error")
[15:32:34.346]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:34.346]                   NULL)
[15:32:34.346]                 if (is_error) {
[15:32:34.346]                   sessionInformation <- function() {
[15:32:34.346]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:34.346]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:34.346]                       search = base::search(), system = base::Sys.info())
[15:32:34.346]                   }
[15:32:34.346]                   ...future.conditions[[length(...future.conditions) + 
[15:32:34.346]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:34.346]                     cond$call), session = sessionInformation(), 
[15:32:34.346]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:34.346]                   signalCondition(cond)
[15:32:34.346]                 }
[15:32:34.346]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:34.346]                 "immediateCondition"))) {
[15:32:34.346]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:34.346]                   ...future.conditions[[length(...future.conditions) + 
[15:32:34.346]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:34.346]                   if (TRUE && !signal) {
[15:32:34.346]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:34.346]                     {
[15:32:34.346]                       inherits <- base::inherits
[15:32:34.346]                       invokeRestart <- base::invokeRestart
[15:32:34.346]                       is.null <- base::is.null
[15:32:34.346]                       muffled <- FALSE
[15:32:34.346]                       if (inherits(cond, "message")) {
[15:32:34.346]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:34.346]                         if (muffled) 
[15:32:34.346]                           invokeRestart("muffleMessage")
[15:32:34.346]                       }
[15:32:34.346]                       else if (inherits(cond, "warning")) {
[15:32:34.346]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:34.346]                         if (muffled) 
[15:32:34.346]                           invokeRestart("muffleWarning")
[15:32:34.346]                       }
[15:32:34.346]                       else if (inherits(cond, "condition")) {
[15:32:34.346]                         if (!is.null(pattern)) {
[15:32:34.346]                           computeRestarts <- base::computeRestarts
[15:32:34.346]                           grepl <- base::grepl
[15:32:34.346]                           restarts <- computeRestarts(cond)
[15:32:34.346]                           for (restart in restarts) {
[15:32:34.346]                             name <- restart$name
[15:32:34.346]                             if (is.null(name)) 
[15:32:34.346]                               next
[15:32:34.346]                             if (!grepl(pattern, name)) 
[15:32:34.346]                               next
[15:32:34.346]                             invokeRestart(restart)
[15:32:34.346]                             muffled <- TRUE
[15:32:34.346]                             break
[15:32:34.346]                           }
[15:32:34.346]                         }
[15:32:34.346]                       }
[15:32:34.346]                       invisible(muffled)
[15:32:34.346]                     }
[15:32:34.346]                     muffleCondition(cond, pattern = "^muffle")
[15:32:34.346]                   }
[15:32:34.346]                 }
[15:32:34.346]                 else {
[15:32:34.346]                   if (TRUE) {
[15:32:34.346]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:34.346]                     {
[15:32:34.346]                       inherits <- base::inherits
[15:32:34.346]                       invokeRestart <- base::invokeRestart
[15:32:34.346]                       is.null <- base::is.null
[15:32:34.346]                       muffled <- FALSE
[15:32:34.346]                       if (inherits(cond, "message")) {
[15:32:34.346]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:34.346]                         if (muffled) 
[15:32:34.346]                           invokeRestart("muffleMessage")
[15:32:34.346]                       }
[15:32:34.346]                       else if (inherits(cond, "warning")) {
[15:32:34.346]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:34.346]                         if (muffled) 
[15:32:34.346]                           invokeRestart("muffleWarning")
[15:32:34.346]                       }
[15:32:34.346]                       else if (inherits(cond, "condition")) {
[15:32:34.346]                         if (!is.null(pattern)) {
[15:32:34.346]                           computeRestarts <- base::computeRestarts
[15:32:34.346]                           grepl <- base::grepl
[15:32:34.346]                           restarts <- computeRestarts(cond)
[15:32:34.346]                           for (restart in restarts) {
[15:32:34.346]                             name <- restart$name
[15:32:34.346]                             if (is.null(name)) 
[15:32:34.346]                               next
[15:32:34.346]                             if (!grepl(pattern, name)) 
[15:32:34.346]                               next
[15:32:34.346]                             invokeRestart(restart)
[15:32:34.346]                             muffled <- TRUE
[15:32:34.346]                             break
[15:32:34.346]                           }
[15:32:34.346]                         }
[15:32:34.346]                       }
[15:32:34.346]                       invisible(muffled)
[15:32:34.346]                     }
[15:32:34.346]                     muffleCondition(cond, pattern = "^muffle")
[15:32:34.346]                   }
[15:32:34.346]                 }
[15:32:34.346]             }
[15:32:34.346]         }))
[15:32:34.346]     }, error = function(ex) {
[15:32:34.346]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:34.346]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:34.346]                 ...future.rng), started = ...future.startTime, 
[15:32:34.346]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:34.346]             version = "1.8"), class = "FutureResult")
[15:32:34.346]     }, finally = {
[15:32:34.346]         if (!identical(...future.workdir, getwd())) 
[15:32:34.346]             setwd(...future.workdir)
[15:32:34.346]         {
[15:32:34.346]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:34.346]                 ...future.oldOptions$nwarnings <- NULL
[15:32:34.346]             }
[15:32:34.346]             base::options(...future.oldOptions)
[15:32:34.346]             if (.Platform$OS.type == "windows") {
[15:32:34.346]                 old_names <- names(...future.oldEnvVars)
[15:32:34.346]                 envs <- base::Sys.getenv()
[15:32:34.346]                 names <- names(envs)
[15:32:34.346]                 common <- intersect(names, old_names)
[15:32:34.346]                 added <- setdiff(names, old_names)
[15:32:34.346]                 removed <- setdiff(old_names, names)
[15:32:34.346]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:34.346]                   envs[common]]
[15:32:34.346]                 NAMES <- toupper(changed)
[15:32:34.346]                 args <- list()
[15:32:34.346]                 for (kk in seq_along(NAMES)) {
[15:32:34.346]                   name <- changed[[kk]]
[15:32:34.346]                   NAME <- NAMES[[kk]]
[15:32:34.346]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:34.346]                     next
[15:32:34.346]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:34.346]                 }
[15:32:34.346]                 NAMES <- toupper(added)
[15:32:34.346]                 for (kk in seq_along(NAMES)) {
[15:32:34.346]                   name <- added[[kk]]
[15:32:34.346]                   NAME <- NAMES[[kk]]
[15:32:34.346]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:34.346]                     next
[15:32:34.346]                   args[[name]] <- ""
[15:32:34.346]                 }
[15:32:34.346]                 NAMES <- toupper(removed)
[15:32:34.346]                 for (kk in seq_along(NAMES)) {
[15:32:34.346]                   name <- removed[[kk]]
[15:32:34.346]                   NAME <- NAMES[[kk]]
[15:32:34.346]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:34.346]                     next
[15:32:34.346]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:34.346]                 }
[15:32:34.346]                 if (length(args) > 0) 
[15:32:34.346]                   base::do.call(base::Sys.setenv, args = args)
[15:32:34.346]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:34.346]             }
[15:32:34.346]             else {
[15:32:34.346]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:34.346]             }
[15:32:34.346]             {
[15:32:34.346]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:34.346]                   0L) {
[15:32:34.346]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:34.346]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:34.346]                   base::options(opts)
[15:32:34.346]                 }
[15:32:34.346]                 {
[15:32:34.346]                   {
[15:32:34.346]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:34.346]                     NULL
[15:32:34.346]                   }
[15:32:34.346]                   options(future.plan = NULL)
[15:32:34.346]                   if (is.na(NA_character_)) 
[15:32:34.346]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:34.346]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:34.346]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:34.346]                     .init = FALSE)
[15:32:34.346]                 }
[15:32:34.346]             }
[15:32:34.346]         }
[15:32:34.346]     })
[15:32:34.346]     if (TRUE) {
[15:32:34.346]         base::sink(type = "output", split = FALSE)
[15:32:34.346]         if (TRUE) {
[15:32:34.346]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:34.346]         }
[15:32:34.346]         else {
[15:32:34.346]             ...future.result["stdout"] <- base::list(NULL)
[15:32:34.346]         }
[15:32:34.346]         base::close(...future.stdout)
[15:32:34.346]         ...future.stdout <- NULL
[15:32:34.346]     }
[15:32:34.346]     ...future.result$conditions <- ...future.conditions
[15:32:34.346]     ...future.result$finished <- base::Sys.time()
[15:32:34.346]     ...future.result
[15:32:34.346] }
[15:32:34.353] Exporting 5 global objects (848 bytes) to cluster node #1 ...
[15:32:34.354] Exporting '...future.FUN' (848 bytes) to cluster node #1 ...
[15:32:34.354] Exporting '...future.FUN' (848 bytes) to cluster node #1 ... DONE
[15:32:34.355] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:34.355] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:34.356] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ...
[15:32:34.356] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ... DONE
[15:32:34.357] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:34.357] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:34.357] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:34.358] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:34.358] Exporting 5 global objects (848 bytes) to cluster node #1 ... DONE
[15:32:34.359] MultisessionFuture started
[15:32:34.360] - Launch lazy future ... done
[15:32:34.360] run() for 'MultisessionFuture' ... done
[15:32:34.360] Created future:
[15:32:34.391] receiveMessageFromWorker() for ClusterFuture ...
[15:32:34.392] - Validating connection of MultisessionFuture
[15:32:34.393] - received message: FutureResult
[15:32:34.393] - Received FutureResult
[15:32:34.394] - Erased future from FutureRegistry
[15:32:34.394] result() for ClusterFuture ...
[15:32:34.394] - result already collected: FutureResult
[15:32:34.395] result() for ClusterFuture ... done
[15:32:34.395] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:34.360] MultisessionFuture:
[15:32:34.360] Label: 'future_sapply-1'
[15:32:34.360] Expression:
[15:32:34.360] {
[15:32:34.360]     do.call(function(...) {
[15:32:34.360]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:34.360]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:34.360]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:34.360]             on.exit(options(oopts), add = TRUE)
[15:32:34.360]         }
[15:32:34.360]         {
[15:32:34.360]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:34.360]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:34.360]                 ...future.FUN(...future.X_jj, ...)
[15:32:34.360]             })
[15:32:34.360]         }
[15:32:34.360]     }, args = future.call.arguments)
[15:32:34.360] }
[15:32:34.360] Lazy evaluation: FALSE
[15:32:34.360] Asynchronous evaluation: TRUE
[15:32:34.360] Local evaluation: TRUE
[15:32:34.360] Environment: R_GlobalEnv
[15:32:34.360] Capture standard output: TRUE
[15:32:34.360] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:34.360] Globals: 5 objects totaling 0.99 KiB (function '...future.FUN' of 848 bytes, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:34.360] Packages: <none>
[15:32:34.360] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:34.360] Resolved: TRUE
[15:32:34.360] Value: <not collected>
[15:32:34.360] Conditions captured: <none>
[15:32:34.360] Early signaling: FALSE
[15:32:34.360] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:34.360] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:34.396] Chunk #1 of 2 ... DONE
[15:32:34.396] Chunk #2 of 2 ...
[15:32:34.397]  - Finding globals in 'X' for chunk #2 ...
[15:32:34.397] getGlobalsAndPackages() ...
[15:32:34.397] Searching for globals...
[15:32:34.398] 
[15:32:34.398] Searching for globals ... DONE
[15:32:34.399] - globals: [0] <none>
[15:32:34.399] getGlobalsAndPackages() ... DONE
[15:32:34.399]    + additional globals found: [n=0] 
[15:32:34.400]    + additional namespaces needed: [n=0] 
[15:32:34.400]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:34.400]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:34.401]  - seeds: <none>
[15:32:34.401]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:34.401] getGlobalsAndPackages() ...
[15:32:34.402] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:34.402] Resolving globals: FALSE
[15:32:34.402] Tweak future expression to call with '...' arguments ...
[15:32:34.403] {
[15:32:34.403]     do.call(function(...) {
[15:32:34.403]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:34.403]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:34.403]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:34.403]             on.exit(options(oopts), add = TRUE)
[15:32:34.403]         }
[15:32:34.403]         {
[15:32:34.403]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:34.403]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:34.403]                 ...future.FUN(...future.X_jj, ...)
[15:32:34.403]             })
[15:32:34.403]         }
[15:32:34.403]     }, args = future.call.arguments)
[15:32:34.403] }
[15:32:34.404] Tweak future expression to call with '...' arguments ... DONE
[15:32:34.404] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:34.405] 
[15:32:34.405] getGlobalsAndPackages() ... DONE
[15:32:34.406] run() for 'Future' ...
[15:32:34.406] - state: 'created'
[15:32:34.407] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:34.425] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:34.426] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:34.426]   - Field: 'node'
[15:32:34.426]   - Field: 'label'
[15:32:34.426]   - Field: 'local'
[15:32:34.427]   - Field: 'owner'
[15:32:34.427]   - Field: 'envir'
[15:32:34.428]   - Field: 'workers'
[15:32:34.428]   - Field: 'packages'
[15:32:34.428]   - Field: 'gc'
[15:32:34.428]   - Field: 'conditions'
[15:32:34.429]   - Field: 'persistent'
[15:32:34.429]   - Field: 'expr'
[15:32:34.429]   - Field: 'uuid'
[15:32:34.430]   - Field: 'seed'
[15:32:34.430]   - Field: 'version'
[15:32:34.430]   - Field: 'result'
[15:32:34.430]   - Field: 'asynchronous'
[15:32:34.431]   - Field: 'calls'
[15:32:34.431]   - Field: 'globals'
[15:32:34.431]   - Field: 'stdout'
[15:32:34.432]   - Field: 'earlySignal'
[15:32:34.432]   - Field: 'lazy'
[15:32:34.432]   - Field: 'state'
[15:32:34.432] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:34.433] - Launch lazy future ...
[15:32:34.433] Packages needed by the future expression (n = 0): <none>
[15:32:34.434] Packages needed by future strategies (n = 0): <none>
[15:32:34.435] {
[15:32:34.435]     {
[15:32:34.435]         {
[15:32:34.435]             ...future.startTime <- base::Sys.time()
[15:32:34.435]             {
[15:32:34.435]                 {
[15:32:34.435]                   {
[15:32:34.435]                     {
[15:32:34.435]                       base::local({
[15:32:34.435]                         has_future <- base::requireNamespace("future", 
[15:32:34.435]                           quietly = TRUE)
[15:32:34.435]                         if (has_future) {
[15:32:34.435]                           ns <- base::getNamespace("future")
[15:32:34.435]                           version <- ns[[".package"]][["version"]]
[15:32:34.435]                           if (is.null(version)) 
[15:32:34.435]                             version <- utils::packageVersion("future")
[15:32:34.435]                         }
[15:32:34.435]                         else {
[15:32:34.435]                           version <- NULL
[15:32:34.435]                         }
[15:32:34.435]                         if (!has_future || version < "1.8.0") {
[15:32:34.435]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:34.435]                             "", base::R.version$version.string), 
[15:32:34.435]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:34.435]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:34.435]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:34.435]                               "release", "version")], collapse = " "), 
[15:32:34.435]                             hostname = base::Sys.info()[["nodename"]])
[15:32:34.435]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:34.435]                             info)
[15:32:34.435]                           info <- base::paste(info, collapse = "; ")
[15:32:34.435]                           if (!has_future) {
[15:32:34.435]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:34.435]                               info)
[15:32:34.435]                           }
[15:32:34.435]                           else {
[15:32:34.435]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:34.435]                               info, version)
[15:32:34.435]                           }
[15:32:34.435]                           base::stop(msg)
[15:32:34.435]                         }
[15:32:34.435]                       })
[15:32:34.435]                     }
[15:32:34.435]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:34.435]                     base::options(mc.cores = 1L)
[15:32:34.435]                   }
[15:32:34.435]                   ...future.strategy.old <- future::plan("list")
[15:32:34.435]                   options(future.plan = NULL)
[15:32:34.435]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:34.435]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:34.435]                 }
[15:32:34.435]                 ...future.workdir <- getwd()
[15:32:34.435]             }
[15:32:34.435]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:34.435]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:34.435]         }
[15:32:34.435]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:34.435]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:34.435]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:34.435]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:34.435]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:34.435]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:34.435]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:34.435]             base::names(...future.oldOptions))
[15:32:34.435]     }
[15:32:34.435]     if (FALSE) {
[15:32:34.435]     }
[15:32:34.435]     else {
[15:32:34.435]         if (TRUE) {
[15:32:34.435]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:34.435]                 open = "w")
[15:32:34.435]         }
[15:32:34.435]         else {
[15:32:34.435]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:34.435]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:34.435]         }
[15:32:34.435]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:34.435]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:34.435]             base::sink(type = "output", split = FALSE)
[15:32:34.435]             base::close(...future.stdout)
[15:32:34.435]         }, add = TRUE)
[15:32:34.435]     }
[15:32:34.435]     ...future.frame <- base::sys.nframe()
[15:32:34.435]     ...future.conditions <- base::list()
[15:32:34.435]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:34.435]     if (FALSE) {
[15:32:34.435]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:34.435]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:34.435]     }
[15:32:34.435]     ...future.result <- base::tryCatch({
[15:32:34.435]         base::withCallingHandlers({
[15:32:34.435]             ...future.value <- base::withVisible(base::local({
[15:32:34.435]                 ...future.makeSendCondition <- base::local({
[15:32:34.435]                   sendCondition <- NULL
[15:32:34.435]                   function(frame = 1L) {
[15:32:34.435]                     if (is.function(sendCondition)) 
[15:32:34.435]                       return(sendCondition)
[15:32:34.435]                     ns <- getNamespace("parallel")
[15:32:34.435]                     if (exists("sendData", mode = "function", 
[15:32:34.435]                       envir = ns)) {
[15:32:34.435]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:34.435]                         envir = ns)
[15:32:34.435]                       envir <- sys.frame(frame)
[15:32:34.435]                       master <- NULL
[15:32:34.435]                       while (!identical(envir, .GlobalEnv) && 
[15:32:34.435]                         !identical(envir, emptyenv())) {
[15:32:34.435]                         if (exists("master", mode = "list", envir = envir, 
[15:32:34.435]                           inherits = FALSE)) {
[15:32:34.435]                           master <- get("master", mode = "list", 
[15:32:34.435]                             envir = envir, inherits = FALSE)
[15:32:34.435]                           if (inherits(master, c("SOCKnode", 
[15:32:34.435]                             "SOCK0node"))) {
[15:32:34.435]                             sendCondition <<- function(cond) {
[15:32:34.435]                               data <- list(type = "VALUE", value = cond, 
[15:32:34.435]                                 success = TRUE)
[15:32:34.435]                               parallel_sendData(master, data)
[15:32:34.435]                             }
[15:32:34.435]                             return(sendCondition)
[15:32:34.435]                           }
[15:32:34.435]                         }
[15:32:34.435]                         frame <- frame + 1L
[15:32:34.435]                         envir <- sys.frame(frame)
[15:32:34.435]                       }
[15:32:34.435]                     }
[15:32:34.435]                     sendCondition <<- function(cond) NULL
[15:32:34.435]                   }
[15:32:34.435]                 })
[15:32:34.435]                 withCallingHandlers({
[15:32:34.435]                   {
[15:32:34.435]                     do.call(function(...) {
[15:32:34.435]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:34.435]                       if (!identical(...future.globals.maxSize.org, 
[15:32:34.435]                         ...future.globals.maxSize)) {
[15:32:34.435]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:34.435]                         on.exit(options(oopts), add = TRUE)
[15:32:34.435]                       }
[15:32:34.435]                       {
[15:32:34.435]                         lapply(seq_along(...future.elements_ii), 
[15:32:34.435]                           FUN = function(jj) {
[15:32:34.435]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:34.435]                             ...future.FUN(...future.X_jj, ...)
[15:32:34.435]                           })
[15:32:34.435]                       }
[15:32:34.435]                     }, args = future.call.arguments)
[15:32:34.435]                   }
[15:32:34.435]                 }, immediateCondition = function(cond) {
[15:32:34.435]                   sendCondition <- ...future.makeSendCondition()
[15:32:34.435]                   sendCondition(cond)
[15:32:34.435]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:34.435]                   {
[15:32:34.435]                     inherits <- base::inherits
[15:32:34.435]                     invokeRestart <- base::invokeRestart
[15:32:34.435]                     is.null <- base::is.null
[15:32:34.435]                     muffled <- FALSE
[15:32:34.435]                     if (inherits(cond, "message")) {
[15:32:34.435]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:34.435]                       if (muffled) 
[15:32:34.435]                         invokeRestart("muffleMessage")
[15:32:34.435]                     }
[15:32:34.435]                     else if (inherits(cond, "warning")) {
[15:32:34.435]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:34.435]                       if (muffled) 
[15:32:34.435]                         invokeRestart("muffleWarning")
[15:32:34.435]                     }
[15:32:34.435]                     else if (inherits(cond, "condition")) {
[15:32:34.435]                       if (!is.null(pattern)) {
[15:32:34.435]                         computeRestarts <- base::computeRestarts
[15:32:34.435]                         grepl <- base::grepl
[15:32:34.435]                         restarts <- computeRestarts(cond)
[15:32:34.435]                         for (restart in restarts) {
[15:32:34.435]                           name <- restart$name
[15:32:34.435]                           if (is.null(name)) 
[15:32:34.435]                             next
[15:32:34.435]                           if (!grepl(pattern, name)) 
[15:32:34.435]                             next
[15:32:34.435]                           invokeRestart(restart)
[15:32:34.435]                           muffled <- TRUE
[15:32:34.435]                           break
[15:32:34.435]                         }
[15:32:34.435]                       }
[15:32:34.435]                     }
[15:32:34.435]                     invisible(muffled)
[15:32:34.435]                   }
[15:32:34.435]                   muffleCondition(cond)
[15:32:34.435]                 })
[15:32:34.435]             }))
[15:32:34.435]             future::FutureResult(value = ...future.value$value, 
[15:32:34.435]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:34.435]                   ...future.rng), globalenv = if (FALSE) 
[15:32:34.435]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:34.435]                     ...future.globalenv.names))
[15:32:34.435]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:34.435]         }, condition = base::local({
[15:32:34.435]             c <- base::c
[15:32:34.435]             inherits <- base::inherits
[15:32:34.435]             invokeRestart <- base::invokeRestart
[15:32:34.435]             length <- base::length
[15:32:34.435]             list <- base::list
[15:32:34.435]             seq.int <- base::seq.int
[15:32:34.435]             signalCondition <- base::signalCondition
[15:32:34.435]             sys.calls <- base::sys.calls
[15:32:34.435]             `[[` <- base::`[[`
[15:32:34.435]             `+` <- base::`+`
[15:32:34.435]             `<<-` <- base::`<<-`
[15:32:34.435]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:34.435]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:34.435]                   3L)]
[15:32:34.435]             }
[15:32:34.435]             function(cond) {
[15:32:34.435]                 is_error <- inherits(cond, "error")
[15:32:34.435]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:34.435]                   NULL)
[15:32:34.435]                 if (is_error) {
[15:32:34.435]                   sessionInformation <- function() {
[15:32:34.435]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:34.435]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:34.435]                       search = base::search(), system = base::Sys.info())
[15:32:34.435]                   }
[15:32:34.435]                   ...future.conditions[[length(...future.conditions) + 
[15:32:34.435]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:34.435]                     cond$call), session = sessionInformation(), 
[15:32:34.435]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:34.435]                   signalCondition(cond)
[15:32:34.435]                 }
[15:32:34.435]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:34.435]                 "immediateCondition"))) {
[15:32:34.435]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:34.435]                   ...future.conditions[[length(...future.conditions) + 
[15:32:34.435]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:34.435]                   if (TRUE && !signal) {
[15:32:34.435]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:34.435]                     {
[15:32:34.435]                       inherits <- base::inherits
[15:32:34.435]                       invokeRestart <- base::invokeRestart
[15:32:34.435]                       is.null <- base::is.null
[15:32:34.435]                       muffled <- FALSE
[15:32:34.435]                       if (inherits(cond, "message")) {
[15:32:34.435]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:34.435]                         if (muffled) 
[15:32:34.435]                           invokeRestart("muffleMessage")
[15:32:34.435]                       }
[15:32:34.435]                       else if (inherits(cond, "warning")) {
[15:32:34.435]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:34.435]                         if (muffled) 
[15:32:34.435]                           invokeRestart("muffleWarning")
[15:32:34.435]                       }
[15:32:34.435]                       else if (inherits(cond, "condition")) {
[15:32:34.435]                         if (!is.null(pattern)) {
[15:32:34.435]                           computeRestarts <- base::computeRestarts
[15:32:34.435]                           grepl <- base::grepl
[15:32:34.435]                           restarts <- computeRestarts(cond)
[15:32:34.435]                           for (restart in restarts) {
[15:32:34.435]                             name <- restart$name
[15:32:34.435]                             if (is.null(name)) 
[15:32:34.435]                               next
[15:32:34.435]                             if (!grepl(pattern, name)) 
[15:32:34.435]                               next
[15:32:34.435]                             invokeRestart(restart)
[15:32:34.435]                             muffled <- TRUE
[15:32:34.435]                             break
[15:32:34.435]                           }
[15:32:34.435]                         }
[15:32:34.435]                       }
[15:32:34.435]                       invisible(muffled)
[15:32:34.435]                     }
[15:32:34.435]                     muffleCondition(cond, pattern = "^muffle")
[15:32:34.435]                   }
[15:32:34.435]                 }
[15:32:34.435]                 else {
[15:32:34.435]                   if (TRUE) {
[15:32:34.435]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:34.435]                     {
[15:32:34.435]                       inherits <- base::inherits
[15:32:34.435]                       invokeRestart <- base::invokeRestart
[15:32:34.435]                       is.null <- base::is.null
[15:32:34.435]                       muffled <- FALSE
[15:32:34.435]                       if (inherits(cond, "message")) {
[15:32:34.435]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:34.435]                         if (muffled) 
[15:32:34.435]                           invokeRestart("muffleMessage")
[15:32:34.435]                       }
[15:32:34.435]                       else if (inherits(cond, "warning")) {
[15:32:34.435]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:34.435]                         if (muffled) 
[15:32:34.435]                           invokeRestart("muffleWarning")
[15:32:34.435]                       }
[15:32:34.435]                       else if (inherits(cond, "condition")) {
[15:32:34.435]                         if (!is.null(pattern)) {
[15:32:34.435]                           computeRestarts <- base::computeRestarts
[15:32:34.435]                           grepl <- base::grepl
[15:32:34.435]                           restarts <- computeRestarts(cond)
[15:32:34.435]                           for (restart in restarts) {
[15:32:34.435]                             name <- restart$name
[15:32:34.435]                             if (is.null(name)) 
[15:32:34.435]                               next
[15:32:34.435]                             if (!grepl(pattern, name)) 
[15:32:34.435]                               next
[15:32:34.435]                             invokeRestart(restart)
[15:32:34.435]                             muffled <- TRUE
[15:32:34.435]                             break
[15:32:34.435]                           }
[15:32:34.435]                         }
[15:32:34.435]                       }
[15:32:34.435]                       invisible(muffled)
[15:32:34.435]                     }
[15:32:34.435]                     muffleCondition(cond, pattern = "^muffle")
[15:32:34.435]                   }
[15:32:34.435]                 }
[15:32:34.435]             }
[15:32:34.435]         }))
[15:32:34.435]     }, error = function(ex) {
[15:32:34.435]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:34.435]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:34.435]                 ...future.rng), started = ...future.startTime, 
[15:32:34.435]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:34.435]             version = "1.8"), class = "FutureResult")
[15:32:34.435]     }, finally = {
[15:32:34.435]         if (!identical(...future.workdir, getwd())) 
[15:32:34.435]             setwd(...future.workdir)
[15:32:34.435]         {
[15:32:34.435]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:34.435]                 ...future.oldOptions$nwarnings <- NULL
[15:32:34.435]             }
[15:32:34.435]             base::options(...future.oldOptions)
[15:32:34.435]             if (.Platform$OS.type == "windows") {
[15:32:34.435]                 old_names <- names(...future.oldEnvVars)
[15:32:34.435]                 envs <- base::Sys.getenv()
[15:32:34.435]                 names <- names(envs)
[15:32:34.435]                 common <- intersect(names, old_names)
[15:32:34.435]                 added <- setdiff(names, old_names)
[15:32:34.435]                 removed <- setdiff(old_names, names)
[15:32:34.435]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:34.435]                   envs[common]]
[15:32:34.435]                 NAMES <- toupper(changed)
[15:32:34.435]                 args <- list()
[15:32:34.435]                 for (kk in seq_along(NAMES)) {
[15:32:34.435]                   name <- changed[[kk]]
[15:32:34.435]                   NAME <- NAMES[[kk]]
[15:32:34.435]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:34.435]                     next
[15:32:34.435]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:34.435]                 }
[15:32:34.435]                 NAMES <- toupper(added)
[15:32:34.435]                 for (kk in seq_along(NAMES)) {
[15:32:34.435]                   name <- added[[kk]]
[15:32:34.435]                   NAME <- NAMES[[kk]]
[15:32:34.435]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:34.435]                     next
[15:32:34.435]                   args[[name]] <- ""
[15:32:34.435]                 }
[15:32:34.435]                 NAMES <- toupper(removed)
[15:32:34.435]                 for (kk in seq_along(NAMES)) {
[15:32:34.435]                   name <- removed[[kk]]
[15:32:34.435]                   NAME <- NAMES[[kk]]
[15:32:34.435]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:34.435]                     next
[15:32:34.435]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:34.435]                 }
[15:32:34.435]                 if (length(args) > 0) 
[15:32:34.435]                   base::do.call(base::Sys.setenv, args = args)
[15:32:34.435]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:34.435]             }
[15:32:34.435]             else {
[15:32:34.435]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:34.435]             }
[15:32:34.435]             {
[15:32:34.435]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:34.435]                   0L) {
[15:32:34.435]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:34.435]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:34.435]                   base::options(opts)
[15:32:34.435]                 }
[15:32:34.435]                 {
[15:32:34.435]                   {
[15:32:34.435]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:34.435]                     NULL
[15:32:34.435]                   }
[15:32:34.435]                   options(future.plan = NULL)
[15:32:34.435]                   if (is.na(NA_character_)) 
[15:32:34.435]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:34.435]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:34.435]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:34.435]                     .init = FALSE)
[15:32:34.435]                 }
[15:32:34.435]             }
[15:32:34.435]         }
[15:32:34.435]     })
[15:32:34.435]     if (TRUE) {
[15:32:34.435]         base::sink(type = "output", split = FALSE)
[15:32:34.435]         if (TRUE) {
[15:32:34.435]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:34.435]         }
[15:32:34.435]         else {
[15:32:34.435]             ...future.result["stdout"] <- base::list(NULL)
[15:32:34.435]         }
[15:32:34.435]         base::close(...future.stdout)
[15:32:34.435]         ...future.stdout <- NULL
[15:32:34.435]     }
[15:32:34.435]     ...future.result$conditions <- ...future.conditions
[15:32:34.435]     ...future.result$finished <- base::Sys.time()
[15:32:34.435]     ...future.result
[15:32:34.435] }
[15:32:34.444] Exporting 5 global objects (848 bytes) to cluster node #1 ...
[15:32:34.444] Exporting '...future.FUN' (848 bytes) to cluster node #1 ...
[15:32:34.445] Exporting '...future.FUN' (848 bytes) to cluster node #1 ... DONE
[15:32:34.445] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:34.446] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:34.447] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ...
[15:32:34.447] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ... DONE
[15:32:34.448] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:34.448] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:34.449] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:34.450] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:34.450] Exporting 5 global objects (848 bytes) to cluster node #1 ... DONE
[15:32:34.451] MultisessionFuture started
[15:32:34.451] - Launch lazy future ... done
[15:32:34.452] run() for 'MultisessionFuture' ... done
[15:32:34.452] Created future:
[15:32:34.474] receiveMessageFromWorker() for ClusterFuture ...
[15:32:34.474] - Validating connection of MultisessionFuture
[15:32:34.474] - received message: FutureResult
[15:32:34.475] - Received FutureResult
[15:32:34.475] - Erased future from FutureRegistry
[15:32:34.475] result() for ClusterFuture ...
[15:32:34.475] - result already collected: FutureResult
[15:32:34.476] result() for ClusterFuture ... done
[15:32:34.476] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:34.452] MultisessionFuture:
[15:32:34.452] Label: 'future_sapply-2'
[15:32:34.452] Expression:
[15:32:34.452] {
[15:32:34.452]     do.call(function(...) {
[15:32:34.452]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:34.452]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:34.452]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:34.452]             on.exit(options(oopts), add = TRUE)
[15:32:34.452]         }
[15:32:34.452]         {
[15:32:34.452]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:34.452]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:34.452]                 ...future.FUN(...future.X_jj, ...)
[15:32:34.452]             })
[15:32:34.452]         }
[15:32:34.452]     }, args = future.call.arguments)
[15:32:34.452] }
[15:32:34.452] Lazy evaluation: FALSE
[15:32:34.452] Asynchronous evaluation: TRUE
[15:32:34.452] Local evaluation: TRUE
[15:32:34.452] Environment: R_GlobalEnv
[15:32:34.452] Capture standard output: TRUE
[15:32:34.452] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:34.452] Globals: 5 objects totaling 0.99 KiB (function '...future.FUN' of 848 bytes, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:34.452] Packages: <none>
[15:32:34.452] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:34.452] Resolved: TRUE
[15:32:34.452] Value: <not collected>
[15:32:34.452] Conditions captured: <none>
[15:32:34.452] Early signaling: FALSE
[15:32:34.452] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:34.452] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:34.477] Chunk #2 of 2 ... DONE
[15:32:34.477] Launching 2 futures (chunks) ... DONE
[15:32:34.477] Resolving 2 futures (chunks) ...
[15:32:34.477] resolve() on list ...
[15:32:34.477]  recursive: 0
[15:32:34.477]  length: 2
[15:32:34.478] 
[15:32:34.478] Future #1
[15:32:34.478] result() for ClusterFuture ...
[15:32:34.478] - result already collected: FutureResult
[15:32:34.478] result() for ClusterFuture ... done
[15:32:34.478] result() for ClusterFuture ...
[15:32:34.479] - result already collected: FutureResult
[15:32:34.479] result() for ClusterFuture ... done
[15:32:34.479] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:34.479] - nx: 2
[15:32:34.479] - relay: TRUE
[15:32:34.479] - stdout: TRUE
[15:32:34.480] - signal: TRUE
[15:32:34.480] - resignal: FALSE
[15:32:34.480] - force: TRUE
[15:32:34.480] - relayed: [n=2] FALSE, FALSE
[15:32:34.480] - queued futures: [n=2] FALSE, FALSE
[15:32:34.480]  - until=1
[15:32:34.481]  - relaying element #1
[15:32:34.481] result() for ClusterFuture ...
[15:32:34.481] - result already collected: FutureResult
[15:32:34.481] result() for ClusterFuture ... done
[15:32:34.481] result() for ClusterFuture ...
[15:32:34.481] - result already collected: FutureResult
[15:32:34.482] result() for ClusterFuture ... done
[15:32:34.482] result() for ClusterFuture ...
[15:32:34.482] - result already collected: FutureResult
[15:32:34.483] result() for ClusterFuture ... done
[15:32:34.483] result() for ClusterFuture ...
[15:32:34.483] - result already collected: FutureResult
[15:32:34.483] result() for ClusterFuture ... done
[15:32:34.483] - relayed: [n=2] TRUE, FALSE
[15:32:34.483] - queued futures: [n=2] TRUE, FALSE
[15:32:34.484] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:34.484]  length: 1 (resolved future 1)
[15:32:34.484] Future #2
[15:32:34.484] result() for ClusterFuture ...
[15:32:34.484] - result already collected: FutureResult
[15:32:34.485] result() for ClusterFuture ... done
[15:32:34.485] result() for ClusterFuture ...
[15:32:34.485] - result already collected: FutureResult
[15:32:34.485] result() for ClusterFuture ... done
[15:32:34.485] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:34.485] - nx: 2
[15:32:34.486] - relay: TRUE
[15:32:34.486] - stdout: TRUE
[15:32:34.486] - signal: TRUE
[15:32:34.486] - resignal: FALSE
[15:32:34.486] - force: TRUE
[15:32:34.486] - relayed: [n=2] TRUE, FALSE
[15:32:34.487] - queued futures: [n=2] TRUE, FALSE
[15:32:34.487]  - until=2
[15:32:34.487]  - relaying element #2
[15:32:34.487] result() for ClusterFuture ...
[15:32:34.487] - result already collected: FutureResult
[15:32:34.487] result() for ClusterFuture ... done
[15:32:34.488] result() for ClusterFuture ...
[15:32:34.488] - result already collected: FutureResult
[15:32:34.488] result() for ClusterFuture ... done
[15:32:34.488] result() for ClusterFuture ...
[15:32:34.488] - result already collected: FutureResult
[15:32:34.488] result() for ClusterFuture ... done
[15:32:34.489] result() for ClusterFuture ...
[15:32:34.489] - result already collected: FutureResult
[15:32:34.489] result() for ClusterFuture ... done
[15:32:34.489] - relayed: [n=2] TRUE, TRUE
[15:32:34.489] - queued futures: [n=2] TRUE, TRUE
[15:32:34.489] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:34.490]  length: 0 (resolved future 2)
[15:32:34.490] Relaying remaining futures
[15:32:34.490] signalConditionsASAP(NULL, pos=0) ...
[15:32:34.490] - nx: 2
[15:32:34.490] - relay: TRUE
[15:32:34.491] - stdout: TRUE
[15:32:34.491] - signal: TRUE
[15:32:34.491] - resignal: FALSE
[15:32:34.491] - force: TRUE
[15:32:34.491] - relayed: [n=2] TRUE, TRUE
[15:32:34.491] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:34.492] - relayed: [n=2] TRUE, TRUE
[15:32:34.492] - queued futures: [n=2] TRUE, TRUE
[15:32:34.492] signalConditionsASAP(NULL, pos=0) ... done
[15:32:34.492] resolve() on list ... DONE
[15:32:34.492] result() for ClusterFuture ...
[15:32:34.492] - result already collected: FutureResult
[15:32:34.493] result() for ClusterFuture ... done
[15:32:34.493] result() for ClusterFuture ...
[15:32:34.493] - result already collected: FutureResult
[15:32:34.493] result() for ClusterFuture ... done
[15:32:34.493] result() for ClusterFuture ...
[15:32:34.493] - result already collected: FutureResult
[15:32:34.494] result() for ClusterFuture ... done
[15:32:34.494] result() for ClusterFuture ...
[15:32:34.494] - result already collected: FutureResult
[15:32:34.494] result() for ClusterFuture ... done
[15:32:34.494]  - Number of value chunks collected: 2
[15:32:34.494] Resolving 2 futures (chunks) ... DONE
[15:32:34.495] Reducing values from 2 chunks ...
[15:32:34.495]  - Number of values collected after concatenation: 6
[15:32:34.495]  - Number of values expected: 6
[15:32:34.495] Reducing values from 2 chunks ... DONE
[15:32:34.495] future_lapply() ... DONE
List of 2
 $ y0: Named int [1:6] 1 2 2 3 3 4
  ..- attr(*, "names")= chr [1:6] "a1" "a2" "b1" "b2" ...
 $ y1: Named int [1:6] 1 2 2 3 3 4
  ..- attr(*, "names")= chr [1:6] "a1" "a2" "b1" "b2" ...
[15:32:34.498] future_lapply() ...
[15:32:34.501] Number of chunks: 2
[15:32:34.501] getGlobalsAndPackagesXApply() ...
[15:32:34.502]  - future.globals: TRUE
[15:32:34.502] getGlobalsAndPackages() ...
[15:32:34.502] Searching for globals...
[15:32:34.504] - globals found: [2] 'FUN', 'UseMethod'
[15:32:34.505] Searching for globals ... DONE
[15:32:34.505] Resolving globals: FALSE
[15:32:34.506] The total size of the 1 globals is 1.22 KiB (1248 bytes)
[15:32:34.507] The total size of the 1 globals exported for future expression ('FUN()') is 1.22 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.22 KiB of class 'function')
[15:32:34.507] - globals: [1] 'FUN'
[15:32:34.508] 
[15:32:34.508] getGlobalsAndPackages() ... DONE
[15:32:34.508]  - globals found/used: [n=1] 'FUN'
[15:32:34.508]  - needed namespaces: [n=0] 
[15:32:34.509] Finding globals ... DONE
[15:32:34.509]  - use_args: TRUE
[15:32:34.509]  - Getting '...' globals ...
[15:32:34.510] resolve() on list ...
[15:32:34.511]  recursive: 0
[15:32:34.511]  length: 1
[15:32:34.511]  elements: '...'
[15:32:34.512]  length: 0 (resolved future 1)
[15:32:34.512] resolve() on list ... DONE
[15:32:34.512]    - '...' content: [n=0] 
[15:32:34.512] List of 1
[15:32:34.512]  $ ...: list()
[15:32:34.512]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:34.512]  - attr(*, "where")=List of 1
[15:32:34.512]   ..$ ...:<environment: 0x00000276e532de28> 
[15:32:34.512]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:34.512]  - attr(*, "resolved")= logi TRUE
[15:32:34.512]  - attr(*, "total_size")= num NA
[15:32:34.518]  - Getting '...' globals ... DONE
[15:32:34.518] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:34.519] List of 2
[15:32:34.519]  $ ...future.FUN:function (x, ...)  
[15:32:34.519]  $ ...          : list()
[15:32:34.519]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:34.519]  - attr(*, "where")=List of 2
[15:32:34.519]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:34.519]   ..$ ...          :<environment: 0x00000276e532de28> 
[15:32:34.519]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:34.519]  - attr(*, "resolved")= logi FALSE
[15:32:34.519]  - attr(*, "total_size")= num 1248
[15:32:34.524] Packages to be attached in all futures: [n=0] 
[15:32:34.525] getGlobalsAndPackagesXApply() ... DONE
[15:32:34.525] Number of futures (= number of chunks): 2
[15:32:34.525] Launching 2 futures (chunks) ...
[15:32:34.526] Chunk #1 of 2 ...
[15:32:34.526]  - Finding globals in 'X' for chunk #1 ...
[15:32:34.526] getGlobalsAndPackages() ...
[15:32:34.527] Searching for globals...
[15:32:34.527] 
[15:32:34.528] Searching for globals ... DONE
[15:32:34.528] - globals: [0] <none>
[15:32:34.528] getGlobalsAndPackages() ... DONE
[15:32:34.529]    + additional globals found: [n=0] 
[15:32:34.529]    + additional namespaces needed: [n=0] 
[15:32:34.529]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:34.530]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:34.530]  - seeds: <none>
[15:32:34.530]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:34.531] getGlobalsAndPackages() ...
[15:32:34.531] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:34.531] Resolving globals: FALSE
[15:32:34.532] Tweak future expression to call with '...' arguments ...
[15:32:34.532] {
[15:32:34.532]     do.call(function(...) {
[15:32:34.532]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:34.532]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:34.532]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:34.532]             on.exit(options(oopts), add = TRUE)
[15:32:34.532]         }
[15:32:34.532]         {
[15:32:34.532]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:34.532]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:34.532]                 ...future.FUN(...future.X_jj, ...)
[15:32:34.532]             })
[15:32:34.532]         }
[15:32:34.532]     }, args = future.call.arguments)
[15:32:34.532] }
[15:32:34.533] Tweak future expression to call with '...' arguments ... DONE
[15:32:34.534] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:34.534] 
[15:32:34.534] getGlobalsAndPackages() ... DONE
[15:32:34.535] run() for 'Future' ...
[15:32:34.535] - state: 'created'
[15:32:34.536] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:34.558] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:34.558] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:34.559]   - Field: 'node'
[15:32:34.559]   - Field: 'label'
[15:32:34.560]   - Field: 'local'
[15:32:34.560]   - Field: 'owner'
[15:32:34.560]   - Field: 'envir'
[15:32:34.561]   - Field: 'workers'
[15:32:34.561]   - Field: 'packages'
[15:32:34.561]   - Field: 'gc'
[15:32:34.562]   - Field: 'conditions'
[15:32:34.567]   - Field: 'persistent'
[15:32:34.568]   - Field: 'expr'
[15:32:34.568]   - Field: 'uuid'
[15:32:34.568]   - Field: 'seed'
[15:32:34.569]   - Field: 'version'
[15:32:34.569]   - Field: 'result'
[15:32:34.570]   - Field: 'asynchronous'
[15:32:34.570]   - Field: 'calls'
[15:32:34.570]   - Field: 'globals'
[15:32:34.571]   - Field: 'stdout'
[15:32:34.571]   - Field: 'earlySignal'
[15:32:34.571]   - Field: 'lazy'
[15:32:34.572]   - Field: 'state'
[15:32:34.572] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:34.573] - Launch lazy future ...
[15:32:34.573] Packages needed by the future expression (n = 0): <none>
[15:32:34.574] Packages needed by future strategies (n = 0): <none>
[15:32:34.575] {
[15:32:34.575]     {
[15:32:34.575]         {
[15:32:34.575]             ...future.startTime <- base::Sys.time()
[15:32:34.575]             {
[15:32:34.575]                 {
[15:32:34.575]                   {
[15:32:34.575]                     {
[15:32:34.575]                       base::local({
[15:32:34.575]                         has_future <- base::requireNamespace("future", 
[15:32:34.575]                           quietly = TRUE)
[15:32:34.575]                         if (has_future) {
[15:32:34.575]                           ns <- base::getNamespace("future")
[15:32:34.575]                           version <- ns[[".package"]][["version"]]
[15:32:34.575]                           if (is.null(version)) 
[15:32:34.575]                             version <- utils::packageVersion("future")
[15:32:34.575]                         }
[15:32:34.575]                         else {
[15:32:34.575]                           version <- NULL
[15:32:34.575]                         }
[15:32:34.575]                         if (!has_future || version < "1.8.0") {
[15:32:34.575]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:34.575]                             "", base::R.version$version.string), 
[15:32:34.575]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:34.575]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:34.575]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:34.575]                               "release", "version")], collapse = " "), 
[15:32:34.575]                             hostname = base::Sys.info()[["nodename"]])
[15:32:34.575]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:34.575]                             info)
[15:32:34.575]                           info <- base::paste(info, collapse = "; ")
[15:32:34.575]                           if (!has_future) {
[15:32:34.575]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:34.575]                               info)
[15:32:34.575]                           }
[15:32:34.575]                           else {
[15:32:34.575]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:34.575]                               info, version)
[15:32:34.575]                           }
[15:32:34.575]                           base::stop(msg)
[15:32:34.575]                         }
[15:32:34.575]                       })
[15:32:34.575]                     }
[15:32:34.575]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:34.575]                     base::options(mc.cores = 1L)
[15:32:34.575]                   }
[15:32:34.575]                   ...future.strategy.old <- future::plan("list")
[15:32:34.575]                   options(future.plan = NULL)
[15:32:34.575]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:34.575]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:34.575]                 }
[15:32:34.575]                 ...future.workdir <- getwd()
[15:32:34.575]             }
[15:32:34.575]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:34.575]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:34.575]         }
[15:32:34.575]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:34.575]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:34.575]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:34.575]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:34.575]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:34.575]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:34.575]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:34.575]             base::names(...future.oldOptions))
[15:32:34.575]     }
[15:32:34.575]     if (FALSE) {
[15:32:34.575]     }
[15:32:34.575]     else {
[15:32:34.575]         if (TRUE) {
[15:32:34.575]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:34.575]                 open = "w")
[15:32:34.575]         }
[15:32:34.575]         else {
[15:32:34.575]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:34.575]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:34.575]         }
[15:32:34.575]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:34.575]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:34.575]             base::sink(type = "output", split = FALSE)
[15:32:34.575]             base::close(...future.stdout)
[15:32:34.575]         }, add = TRUE)
[15:32:34.575]     }
[15:32:34.575]     ...future.frame <- base::sys.nframe()
[15:32:34.575]     ...future.conditions <- base::list()
[15:32:34.575]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:34.575]     if (FALSE) {
[15:32:34.575]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:34.575]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:34.575]     }
[15:32:34.575]     ...future.result <- base::tryCatch({
[15:32:34.575]         base::withCallingHandlers({
[15:32:34.575]             ...future.value <- base::withVisible(base::local({
[15:32:34.575]                 ...future.makeSendCondition <- base::local({
[15:32:34.575]                   sendCondition <- NULL
[15:32:34.575]                   function(frame = 1L) {
[15:32:34.575]                     if (is.function(sendCondition)) 
[15:32:34.575]                       return(sendCondition)
[15:32:34.575]                     ns <- getNamespace("parallel")
[15:32:34.575]                     if (exists("sendData", mode = "function", 
[15:32:34.575]                       envir = ns)) {
[15:32:34.575]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:34.575]                         envir = ns)
[15:32:34.575]                       envir <- sys.frame(frame)
[15:32:34.575]                       master <- NULL
[15:32:34.575]                       while (!identical(envir, .GlobalEnv) && 
[15:32:34.575]                         !identical(envir, emptyenv())) {
[15:32:34.575]                         if (exists("master", mode = "list", envir = envir, 
[15:32:34.575]                           inherits = FALSE)) {
[15:32:34.575]                           master <- get("master", mode = "list", 
[15:32:34.575]                             envir = envir, inherits = FALSE)
[15:32:34.575]                           if (inherits(master, c("SOCKnode", 
[15:32:34.575]                             "SOCK0node"))) {
[15:32:34.575]                             sendCondition <<- function(cond) {
[15:32:34.575]                               data <- list(type = "VALUE", value = cond, 
[15:32:34.575]                                 success = TRUE)
[15:32:34.575]                               parallel_sendData(master, data)
[15:32:34.575]                             }
[15:32:34.575]                             return(sendCondition)
[15:32:34.575]                           }
[15:32:34.575]                         }
[15:32:34.575]                         frame <- frame + 1L
[15:32:34.575]                         envir <- sys.frame(frame)
[15:32:34.575]                       }
[15:32:34.575]                     }
[15:32:34.575]                     sendCondition <<- function(cond) NULL
[15:32:34.575]                   }
[15:32:34.575]                 })
[15:32:34.575]                 withCallingHandlers({
[15:32:34.575]                   {
[15:32:34.575]                     do.call(function(...) {
[15:32:34.575]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:34.575]                       if (!identical(...future.globals.maxSize.org, 
[15:32:34.575]                         ...future.globals.maxSize)) {
[15:32:34.575]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:34.575]                         on.exit(options(oopts), add = TRUE)
[15:32:34.575]                       }
[15:32:34.575]                       {
[15:32:34.575]                         lapply(seq_along(...future.elements_ii), 
[15:32:34.575]                           FUN = function(jj) {
[15:32:34.575]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:34.575]                             ...future.FUN(...future.X_jj, ...)
[15:32:34.575]                           })
[15:32:34.575]                       }
[15:32:34.575]                     }, args = future.call.arguments)
[15:32:34.575]                   }
[15:32:34.575]                 }, immediateCondition = function(cond) {
[15:32:34.575]                   sendCondition <- ...future.makeSendCondition()
[15:32:34.575]                   sendCondition(cond)
[15:32:34.575]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:34.575]                   {
[15:32:34.575]                     inherits <- base::inherits
[15:32:34.575]                     invokeRestart <- base::invokeRestart
[15:32:34.575]                     is.null <- base::is.null
[15:32:34.575]                     muffled <- FALSE
[15:32:34.575]                     if (inherits(cond, "message")) {
[15:32:34.575]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:34.575]                       if (muffled) 
[15:32:34.575]                         invokeRestart("muffleMessage")
[15:32:34.575]                     }
[15:32:34.575]                     else if (inherits(cond, "warning")) {
[15:32:34.575]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:34.575]                       if (muffled) 
[15:32:34.575]                         invokeRestart("muffleWarning")
[15:32:34.575]                     }
[15:32:34.575]                     else if (inherits(cond, "condition")) {
[15:32:34.575]                       if (!is.null(pattern)) {
[15:32:34.575]                         computeRestarts <- base::computeRestarts
[15:32:34.575]                         grepl <- base::grepl
[15:32:34.575]                         restarts <- computeRestarts(cond)
[15:32:34.575]                         for (restart in restarts) {
[15:32:34.575]                           name <- restart$name
[15:32:34.575]                           if (is.null(name)) 
[15:32:34.575]                             next
[15:32:34.575]                           if (!grepl(pattern, name)) 
[15:32:34.575]                             next
[15:32:34.575]                           invokeRestart(restart)
[15:32:34.575]                           muffled <- TRUE
[15:32:34.575]                           break
[15:32:34.575]                         }
[15:32:34.575]                       }
[15:32:34.575]                     }
[15:32:34.575]                     invisible(muffled)
[15:32:34.575]                   }
[15:32:34.575]                   muffleCondition(cond)
[15:32:34.575]                 })
[15:32:34.575]             }))
[15:32:34.575]             future::FutureResult(value = ...future.value$value, 
[15:32:34.575]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:34.575]                   ...future.rng), globalenv = if (FALSE) 
[15:32:34.575]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:34.575]                     ...future.globalenv.names))
[15:32:34.575]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:34.575]         }, condition = base::local({
[15:32:34.575]             c <- base::c
[15:32:34.575]             inherits <- base::inherits
[15:32:34.575]             invokeRestart <- base::invokeRestart
[15:32:34.575]             length <- base::length
[15:32:34.575]             list <- base::list
[15:32:34.575]             seq.int <- base::seq.int
[15:32:34.575]             signalCondition <- base::signalCondition
[15:32:34.575]             sys.calls <- base::sys.calls
[15:32:34.575]             `[[` <- base::`[[`
[15:32:34.575]             `+` <- base::`+`
[15:32:34.575]             `<<-` <- base::`<<-`
[15:32:34.575]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:34.575]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:34.575]                   3L)]
[15:32:34.575]             }
[15:32:34.575]             function(cond) {
[15:32:34.575]                 is_error <- inherits(cond, "error")
[15:32:34.575]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:34.575]                   NULL)
[15:32:34.575]                 if (is_error) {
[15:32:34.575]                   sessionInformation <- function() {
[15:32:34.575]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:34.575]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:34.575]                       search = base::search(), system = base::Sys.info())
[15:32:34.575]                   }
[15:32:34.575]                   ...future.conditions[[length(...future.conditions) + 
[15:32:34.575]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:34.575]                     cond$call), session = sessionInformation(), 
[15:32:34.575]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:34.575]                   signalCondition(cond)
[15:32:34.575]                 }
[15:32:34.575]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:34.575]                 "immediateCondition"))) {
[15:32:34.575]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:34.575]                   ...future.conditions[[length(...future.conditions) + 
[15:32:34.575]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:34.575]                   if (TRUE && !signal) {
[15:32:34.575]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:34.575]                     {
[15:32:34.575]                       inherits <- base::inherits
[15:32:34.575]                       invokeRestart <- base::invokeRestart
[15:32:34.575]                       is.null <- base::is.null
[15:32:34.575]                       muffled <- FALSE
[15:32:34.575]                       if (inherits(cond, "message")) {
[15:32:34.575]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:34.575]                         if (muffled) 
[15:32:34.575]                           invokeRestart("muffleMessage")
[15:32:34.575]                       }
[15:32:34.575]                       else if (inherits(cond, "warning")) {
[15:32:34.575]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:34.575]                         if (muffled) 
[15:32:34.575]                           invokeRestart("muffleWarning")
[15:32:34.575]                       }
[15:32:34.575]                       else if (inherits(cond, "condition")) {
[15:32:34.575]                         if (!is.null(pattern)) {
[15:32:34.575]                           computeRestarts <- base::computeRestarts
[15:32:34.575]                           grepl <- base::grepl
[15:32:34.575]                           restarts <- computeRestarts(cond)
[15:32:34.575]                           for (restart in restarts) {
[15:32:34.575]                             name <- restart$name
[15:32:34.575]                             if (is.null(name)) 
[15:32:34.575]                               next
[15:32:34.575]                             if (!grepl(pattern, name)) 
[15:32:34.575]                               next
[15:32:34.575]                             invokeRestart(restart)
[15:32:34.575]                             muffled <- TRUE
[15:32:34.575]                             break
[15:32:34.575]                           }
[15:32:34.575]                         }
[15:32:34.575]                       }
[15:32:34.575]                       invisible(muffled)
[15:32:34.575]                     }
[15:32:34.575]                     muffleCondition(cond, pattern = "^muffle")
[15:32:34.575]                   }
[15:32:34.575]                 }
[15:32:34.575]                 else {
[15:32:34.575]                   if (TRUE) {
[15:32:34.575]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:34.575]                     {
[15:32:34.575]                       inherits <- base::inherits
[15:32:34.575]                       invokeRestart <- base::invokeRestart
[15:32:34.575]                       is.null <- base::is.null
[15:32:34.575]                       muffled <- FALSE
[15:32:34.575]                       if (inherits(cond, "message")) {
[15:32:34.575]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:34.575]                         if (muffled) 
[15:32:34.575]                           invokeRestart("muffleMessage")
[15:32:34.575]                       }
[15:32:34.575]                       else if (inherits(cond, "warning")) {
[15:32:34.575]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:34.575]                         if (muffled) 
[15:32:34.575]                           invokeRestart("muffleWarning")
[15:32:34.575]                       }
[15:32:34.575]                       else if (inherits(cond, "condition")) {
[15:32:34.575]                         if (!is.null(pattern)) {
[15:32:34.575]                           computeRestarts <- base::computeRestarts
[15:32:34.575]                           grepl <- base::grepl
[15:32:34.575]                           restarts <- computeRestarts(cond)
[15:32:34.575]                           for (restart in restarts) {
[15:32:34.575]                             name <- restart$name
[15:32:34.575]                             if (is.null(name)) 
[15:32:34.575]                               next
[15:32:34.575]                             if (!grepl(pattern, name)) 
[15:32:34.575]                               next
[15:32:34.575]                             invokeRestart(restart)
[15:32:34.575]                             muffled <- TRUE
[15:32:34.575]                             break
[15:32:34.575]                           }
[15:32:34.575]                         }
[15:32:34.575]                       }
[15:32:34.575]                       invisible(muffled)
[15:32:34.575]                     }
[15:32:34.575]                     muffleCondition(cond, pattern = "^muffle")
[15:32:34.575]                   }
[15:32:34.575]                 }
[15:32:34.575]             }
[15:32:34.575]         }))
[15:32:34.575]     }, error = function(ex) {
[15:32:34.575]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:34.575]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:34.575]                 ...future.rng), started = ...future.startTime, 
[15:32:34.575]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:34.575]             version = "1.8"), class = "FutureResult")
[15:32:34.575]     }, finally = {
[15:32:34.575]         if (!identical(...future.workdir, getwd())) 
[15:32:34.575]             setwd(...future.workdir)
[15:32:34.575]         {
[15:32:34.575]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:34.575]                 ...future.oldOptions$nwarnings <- NULL
[15:32:34.575]             }
[15:32:34.575]             base::options(...future.oldOptions)
[15:32:34.575]             if (.Platform$OS.type == "windows") {
[15:32:34.575]                 old_names <- names(...future.oldEnvVars)
[15:32:34.575]                 envs <- base::Sys.getenv()
[15:32:34.575]                 names <- names(envs)
[15:32:34.575]                 common <- intersect(names, old_names)
[15:32:34.575]                 added <- setdiff(names, old_names)
[15:32:34.575]                 removed <- setdiff(old_names, names)
[15:32:34.575]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:34.575]                   envs[common]]
[15:32:34.575]                 NAMES <- toupper(changed)
[15:32:34.575]                 args <- list()
[15:32:34.575]                 for (kk in seq_along(NAMES)) {
[15:32:34.575]                   name <- changed[[kk]]
[15:32:34.575]                   NAME <- NAMES[[kk]]
[15:32:34.575]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:34.575]                     next
[15:32:34.575]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:34.575]                 }
[15:32:34.575]                 NAMES <- toupper(added)
[15:32:34.575]                 for (kk in seq_along(NAMES)) {
[15:32:34.575]                   name <- added[[kk]]
[15:32:34.575]                   NAME <- NAMES[[kk]]
[15:32:34.575]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:34.575]                     next
[15:32:34.575]                   args[[name]] <- ""
[15:32:34.575]                 }
[15:32:34.575]                 NAMES <- toupper(removed)
[15:32:34.575]                 for (kk in seq_along(NAMES)) {
[15:32:34.575]                   name <- removed[[kk]]
[15:32:34.575]                   NAME <- NAMES[[kk]]
[15:32:34.575]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:34.575]                     next
[15:32:34.575]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:34.575]                 }
[15:32:34.575]                 if (length(args) > 0) 
[15:32:34.575]                   base::do.call(base::Sys.setenv, args = args)
[15:32:34.575]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:34.575]             }
[15:32:34.575]             else {
[15:32:34.575]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:34.575]             }
[15:32:34.575]             {
[15:32:34.575]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:34.575]                   0L) {
[15:32:34.575]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:34.575]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:34.575]                   base::options(opts)
[15:32:34.575]                 }
[15:32:34.575]                 {
[15:32:34.575]                   {
[15:32:34.575]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:34.575]                     NULL
[15:32:34.575]                   }
[15:32:34.575]                   options(future.plan = NULL)
[15:32:34.575]                   if (is.na(NA_character_)) 
[15:32:34.575]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:34.575]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:34.575]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:34.575]                     .init = FALSE)
[15:32:34.575]                 }
[15:32:34.575]             }
[15:32:34.575]         }
[15:32:34.575]     })
[15:32:34.575]     if (TRUE) {
[15:32:34.575]         base::sink(type = "output", split = FALSE)
[15:32:34.575]         if (TRUE) {
[15:32:34.575]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:34.575]         }
[15:32:34.575]         else {
[15:32:34.575]             ...future.result["stdout"] <- base::list(NULL)
[15:32:34.575]         }
[15:32:34.575]         base::close(...future.stdout)
[15:32:34.575]         ...future.stdout <- NULL
[15:32:34.575]     }
[15:32:34.575]     ...future.result$conditions <- ...future.conditions
[15:32:34.575]     ...future.result$finished <- base::Sys.time()
[15:32:34.575]     ...future.result
[15:32:34.575] }
[15:32:34.586] Exporting 5 global objects (1.22 KiB) to cluster node #1 ...
[15:32:34.587] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ...
[15:32:34.588] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ... DONE
[15:32:34.588] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:34.589] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:34.589] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ...
[15:32:34.590] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ... DONE
[15:32:34.590] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:34.591] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:34.591] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:34.592] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:34.592] Exporting 5 global objects (1.22 KiB) to cluster node #1 ... DONE
[15:32:34.593] MultisessionFuture started
[15:32:34.594] - Launch lazy future ... done
[15:32:34.594] run() for 'MultisessionFuture' ... done
[15:32:34.595] Created future:
[15:32:34.626] receiveMessageFromWorker() for ClusterFuture ...
[15:32:34.627] - Validating connection of MultisessionFuture
[15:32:34.627] - received message: FutureResult
[15:32:34.628] - Received FutureResult
[15:32:34.628] - Erased future from FutureRegistry
[15:32:34.628] result() for ClusterFuture ...
[15:32:34.629] - result already collected: FutureResult
[15:32:34.629] result() for ClusterFuture ... done
[15:32:34.629] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:34.595] MultisessionFuture:
[15:32:34.595] Label: 'future_sapply-1'
[15:32:34.595] Expression:
[15:32:34.595] {
[15:32:34.595]     do.call(function(...) {
[15:32:34.595]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:34.595]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:34.595]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:34.595]             on.exit(options(oopts), add = TRUE)
[15:32:34.595]         }
[15:32:34.595]         {
[15:32:34.595]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:34.595]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:34.595]                 ...future.FUN(...future.X_jj, ...)
[15:32:34.595]             })
[15:32:34.595]         }
[15:32:34.595]     }, args = future.call.arguments)
[15:32:34.595] }
[15:32:34.595] Lazy evaluation: FALSE
[15:32:34.595] Asynchronous evaluation: TRUE
[15:32:34.595] Local evaluation: TRUE
[15:32:34.595] Environment: R_GlobalEnv
[15:32:34.595] Capture standard output: TRUE
[15:32:34.595] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:34.595] Globals: 5 objects totaling 1.38 KiB (function '...future.FUN' of 1.22 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:34.595] Packages: <none>
[15:32:34.595] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:34.595] Resolved: TRUE
[15:32:34.595] Value: <not collected>
[15:32:34.595] Conditions captured: <none>
[15:32:34.595] Early signaling: FALSE
[15:32:34.595] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:34.595] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:34.630] Chunk #1 of 2 ... DONE
[15:32:34.630] Chunk #2 of 2 ...
[15:32:34.630]  - Finding globals in 'X' for chunk #2 ...
[15:32:34.631] getGlobalsAndPackages() ...
[15:32:34.631] Searching for globals...
[15:32:34.631] 
[15:32:34.632] Searching for globals ... DONE
[15:32:34.632] - globals: [0] <none>
[15:32:34.632] getGlobalsAndPackages() ... DONE
[15:32:34.632]    + additional globals found: [n=0] 
[15:32:34.633]    + additional namespaces needed: [n=0] 
[15:32:34.633]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:34.633]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:34.633]  - seeds: <none>
[15:32:34.634]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:34.634] getGlobalsAndPackages() ...
[15:32:34.634] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:34.634] Resolving globals: FALSE
[15:32:34.635] Tweak future expression to call with '...' arguments ...
[15:32:34.635] {
[15:32:34.635]     do.call(function(...) {
[15:32:34.635]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:34.635]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:34.635]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:34.635]             on.exit(options(oopts), add = TRUE)
[15:32:34.635]         }
[15:32:34.635]         {
[15:32:34.635]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:34.635]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:34.635]                 ...future.FUN(...future.X_jj, ...)
[15:32:34.635]             })
[15:32:34.635]         }
[15:32:34.635]     }, args = future.call.arguments)
[15:32:34.635] }
[15:32:34.636] Tweak future expression to call with '...' arguments ... DONE
[15:32:34.637] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:34.637] 
[15:32:34.637] getGlobalsAndPackages() ... DONE
[15:32:34.638] run() for 'Future' ...
[15:32:34.638] - state: 'created'
[15:32:34.639] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:34.656] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:34.657] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:34.657]   - Field: 'node'
[15:32:34.657]   - Field: 'label'
[15:32:34.658]   - Field: 'local'
[15:32:34.658]   - Field: 'owner'
[15:32:34.658]   - Field: 'envir'
[15:32:34.659]   - Field: 'workers'
[15:32:34.659]   - Field: 'packages'
[15:32:34.659]   - Field: 'gc'
[15:32:34.659]   - Field: 'conditions'
[15:32:34.660]   - Field: 'persistent'
[15:32:34.660]   - Field: 'expr'
[15:32:34.660]   - Field: 'uuid'
[15:32:34.660]   - Field: 'seed'
[15:32:34.660]   - Field: 'version'
[15:32:34.660]   - Field: 'result'
[15:32:34.661]   - Field: 'asynchronous'
[15:32:34.661]   - Field: 'calls'
[15:32:34.661]   - Field: 'globals'
[15:32:34.661]   - Field: 'stdout'
[15:32:34.661]   - Field: 'earlySignal'
[15:32:34.661]   - Field: 'lazy'
[15:32:34.662]   - Field: 'state'
[15:32:34.662] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:34.662] - Launch lazy future ...
[15:32:34.663] Packages needed by the future expression (n = 0): <none>
[15:32:34.663] Packages needed by future strategies (n = 0): <none>
[15:32:34.663] {
[15:32:34.663]     {
[15:32:34.663]         {
[15:32:34.663]             ...future.startTime <- base::Sys.time()
[15:32:34.663]             {
[15:32:34.663]                 {
[15:32:34.663]                   {
[15:32:34.663]                     {
[15:32:34.663]                       base::local({
[15:32:34.663]                         has_future <- base::requireNamespace("future", 
[15:32:34.663]                           quietly = TRUE)
[15:32:34.663]                         if (has_future) {
[15:32:34.663]                           ns <- base::getNamespace("future")
[15:32:34.663]                           version <- ns[[".package"]][["version"]]
[15:32:34.663]                           if (is.null(version)) 
[15:32:34.663]                             version <- utils::packageVersion("future")
[15:32:34.663]                         }
[15:32:34.663]                         else {
[15:32:34.663]                           version <- NULL
[15:32:34.663]                         }
[15:32:34.663]                         if (!has_future || version < "1.8.0") {
[15:32:34.663]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:34.663]                             "", base::R.version$version.string), 
[15:32:34.663]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:34.663]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:34.663]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:34.663]                               "release", "version")], collapse = " "), 
[15:32:34.663]                             hostname = base::Sys.info()[["nodename"]])
[15:32:34.663]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:34.663]                             info)
[15:32:34.663]                           info <- base::paste(info, collapse = "; ")
[15:32:34.663]                           if (!has_future) {
[15:32:34.663]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:34.663]                               info)
[15:32:34.663]                           }
[15:32:34.663]                           else {
[15:32:34.663]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:34.663]                               info, version)
[15:32:34.663]                           }
[15:32:34.663]                           base::stop(msg)
[15:32:34.663]                         }
[15:32:34.663]                       })
[15:32:34.663]                     }
[15:32:34.663]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:34.663]                     base::options(mc.cores = 1L)
[15:32:34.663]                   }
[15:32:34.663]                   ...future.strategy.old <- future::plan("list")
[15:32:34.663]                   options(future.plan = NULL)
[15:32:34.663]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:34.663]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:34.663]                 }
[15:32:34.663]                 ...future.workdir <- getwd()
[15:32:34.663]             }
[15:32:34.663]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:34.663]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:34.663]         }
[15:32:34.663]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:34.663]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:34.663]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:34.663]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:34.663]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:34.663]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:34.663]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:34.663]             base::names(...future.oldOptions))
[15:32:34.663]     }
[15:32:34.663]     if (FALSE) {
[15:32:34.663]     }
[15:32:34.663]     else {
[15:32:34.663]         if (TRUE) {
[15:32:34.663]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:34.663]                 open = "w")
[15:32:34.663]         }
[15:32:34.663]         else {
[15:32:34.663]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:34.663]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:34.663]         }
[15:32:34.663]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:34.663]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:34.663]             base::sink(type = "output", split = FALSE)
[15:32:34.663]             base::close(...future.stdout)
[15:32:34.663]         }, add = TRUE)
[15:32:34.663]     }
[15:32:34.663]     ...future.frame <- base::sys.nframe()
[15:32:34.663]     ...future.conditions <- base::list()
[15:32:34.663]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:34.663]     if (FALSE) {
[15:32:34.663]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:34.663]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:34.663]     }
[15:32:34.663]     ...future.result <- base::tryCatch({
[15:32:34.663]         base::withCallingHandlers({
[15:32:34.663]             ...future.value <- base::withVisible(base::local({
[15:32:34.663]                 ...future.makeSendCondition <- base::local({
[15:32:34.663]                   sendCondition <- NULL
[15:32:34.663]                   function(frame = 1L) {
[15:32:34.663]                     if (is.function(sendCondition)) 
[15:32:34.663]                       return(sendCondition)
[15:32:34.663]                     ns <- getNamespace("parallel")
[15:32:34.663]                     if (exists("sendData", mode = "function", 
[15:32:34.663]                       envir = ns)) {
[15:32:34.663]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:34.663]                         envir = ns)
[15:32:34.663]                       envir <- sys.frame(frame)
[15:32:34.663]                       master <- NULL
[15:32:34.663]                       while (!identical(envir, .GlobalEnv) && 
[15:32:34.663]                         !identical(envir, emptyenv())) {
[15:32:34.663]                         if (exists("master", mode = "list", envir = envir, 
[15:32:34.663]                           inherits = FALSE)) {
[15:32:34.663]                           master <- get("master", mode = "list", 
[15:32:34.663]                             envir = envir, inherits = FALSE)
[15:32:34.663]                           if (inherits(master, c("SOCKnode", 
[15:32:34.663]                             "SOCK0node"))) {
[15:32:34.663]                             sendCondition <<- function(cond) {
[15:32:34.663]                               data <- list(type = "VALUE", value = cond, 
[15:32:34.663]                                 success = TRUE)
[15:32:34.663]                               parallel_sendData(master, data)
[15:32:34.663]                             }
[15:32:34.663]                             return(sendCondition)
[15:32:34.663]                           }
[15:32:34.663]                         }
[15:32:34.663]                         frame <- frame + 1L
[15:32:34.663]                         envir <- sys.frame(frame)
[15:32:34.663]                       }
[15:32:34.663]                     }
[15:32:34.663]                     sendCondition <<- function(cond) NULL
[15:32:34.663]                   }
[15:32:34.663]                 })
[15:32:34.663]                 withCallingHandlers({
[15:32:34.663]                   {
[15:32:34.663]                     do.call(function(...) {
[15:32:34.663]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:34.663]                       if (!identical(...future.globals.maxSize.org, 
[15:32:34.663]                         ...future.globals.maxSize)) {
[15:32:34.663]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:34.663]                         on.exit(options(oopts), add = TRUE)
[15:32:34.663]                       }
[15:32:34.663]                       {
[15:32:34.663]                         lapply(seq_along(...future.elements_ii), 
[15:32:34.663]                           FUN = function(jj) {
[15:32:34.663]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:34.663]                             ...future.FUN(...future.X_jj, ...)
[15:32:34.663]                           })
[15:32:34.663]                       }
[15:32:34.663]                     }, args = future.call.arguments)
[15:32:34.663]                   }
[15:32:34.663]                 }, immediateCondition = function(cond) {
[15:32:34.663]                   sendCondition <- ...future.makeSendCondition()
[15:32:34.663]                   sendCondition(cond)
[15:32:34.663]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:34.663]                   {
[15:32:34.663]                     inherits <- base::inherits
[15:32:34.663]                     invokeRestart <- base::invokeRestart
[15:32:34.663]                     is.null <- base::is.null
[15:32:34.663]                     muffled <- FALSE
[15:32:34.663]                     if (inherits(cond, "message")) {
[15:32:34.663]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:34.663]                       if (muffled) 
[15:32:34.663]                         invokeRestart("muffleMessage")
[15:32:34.663]                     }
[15:32:34.663]                     else if (inherits(cond, "warning")) {
[15:32:34.663]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:34.663]                       if (muffled) 
[15:32:34.663]                         invokeRestart("muffleWarning")
[15:32:34.663]                     }
[15:32:34.663]                     else if (inherits(cond, "condition")) {
[15:32:34.663]                       if (!is.null(pattern)) {
[15:32:34.663]                         computeRestarts <- base::computeRestarts
[15:32:34.663]                         grepl <- base::grepl
[15:32:34.663]                         restarts <- computeRestarts(cond)
[15:32:34.663]                         for (restart in restarts) {
[15:32:34.663]                           name <- restart$name
[15:32:34.663]                           if (is.null(name)) 
[15:32:34.663]                             next
[15:32:34.663]                           if (!grepl(pattern, name)) 
[15:32:34.663]                             next
[15:32:34.663]                           invokeRestart(restart)
[15:32:34.663]                           muffled <- TRUE
[15:32:34.663]                           break
[15:32:34.663]                         }
[15:32:34.663]                       }
[15:32:34.663]                     }
[15:32:34.663]                     invisible(muffled)
[15:32:34.663]                   }
[15:32:34.663]                   muffleCondition(cond)
[15:32:34.663]                 })
[15:32:34.663]             }))
[15:32:34.663]             future::FutureResult(value = ...future.value$value, 
[15:32:34.663]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:34.663]                   ...future.rng), globalenv = if (FALSE) 
[15:32:34.663]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:34.663]                     ...future.globalenv.names))
[15:32:34.663]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:34.663]         }, condition = base::local({
[15:32:34.663]             c <- base::c
[15:32:34.663]             inherits <- base::inherits
[15:32:34.663]             invokeRestart <- base::invokeRestart
[15:32:34.663]             length <- base::length
[15:32:34.663]             list <- base::list
[15:32:34.663]             seq.int <- base::seq.int
[15:32:34.663]             signalCondition <- base::signalCondition
[15:32:34.663]             sys.calls <- base::sys.calls
[15:32:34.663]             `[[` <- base::`[[`
[15:32:34.663]             `+` <- base::`+`
[15:32:34.663]             `<<-` <- base::`<<-`
[15:32:34.663]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:34.663]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:34.663]                   3L)]
[15:32:34.663]             }
[15:32:34.663]             function(cond) {
[15:32:34.663]                 is_error <- inherits(cond, "error")
[15:32:34.663]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:34.663]                   NULL)
[15:32:34.663]                 if (is_error) {
[15:32:34.663]                   sessionInformation <- function() {
[15:32:34.663]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:34.663]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:34.663]                       search = base::search(), system = base::Sys.info())
[15:32:34.663]                   }
[15:32:34.663]                   ...future.conditions[[length(...future.conditions) + 
[15:32:34.663]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:34.663]                     cond$call), session = sessionInformation(), 
[15:32:34.663]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:34.663]                   signalCondition(cond)
[15:32:34.663]                 }
[15:32:34.663]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:34.663]                 "immediateCondition"))) {
[15:32:34.663]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:34.663]                   ...future.conditions[[length(...future.conditions) + 
[15:32:34.663]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:34.663]                   if (TRUE && !signal) {
[15:32:34.663]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:34.663]                     {
[15:32:34.663]                       inherits <- base::inherits
[15:32:34.663]                       invokeRestart <- base::invokeRestart
[15:32:34.663]                       is.null <- base::is.null
[15:32:34.663]                       muffled <- FALSE
[15:32:34.663]                       if (inherits(cond, "message")) {
[15:32:34.663]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:34.663]                         if (muffled) 
[15:32:34.663]                           invokeRestart("muffleMessage")
[15:32:34.663]                       }
[15:32:34.663]                       else if (inherits(cond, "warning")) {
[15:32:34.663]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:34.663]                         if (muffled) 
[15:32:34.663]                           invokeRestart("muffleWarning")
[15:32:34.663]                       }
[15:32:34.663]                       else if (inherits(cond, "condition")) {
[15:32:34.663]                         if (!is.null(pattern)) {
[15:32:34.663]                           computeRestarts <- base::computeRestarts
[15:32:34.663]                           grepl <- base::grepl
[15:32:34.663]                           restarts <- computeRestarts(cond)
[15:32:34.663]                           for (restart in restarts) {
[15:32:34.663]                             name <- restart$name
[15:32:34.663]                             if (is.null(name)) 
[15:32:34.663]                               next
[15:32:34.663]                             if (!grepl(pattern, name)) 
[15:32:34.663]                               next
[15:32:34.663]                             invokeRestart(restart)
[15:32:34.663]                             muffled <- TRUE
[15:32:34.663]                             break
[15:32:34.663]                           }
[15:32:34.663]                         }
[15:32:34.663]                       }
[15:32:34.663]                       invisible(muffled)
[15:32:34.663]                     }
[15:32:34.663]                     muffleCondition(cond, pattern = "^muffle")
[15:32:34.663]                   }
[15:32:34.663]                 }
[15:32:34.663]                 else {
[15:32:34.663]                   if (TRUE) {
[15:32:34.663]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:34.663]                     {
[15:32:34.663]                       inherits <- base::inherits
[15:32:34.663]                       invokeRestart <- base::invokeRestart
[15:32:34.663]                       is.null <- base::is.null
[15:32:34.663]                       muffled <- FALSE
[15:32:34.663]                       if (inherits(cond, "message")) {
[15:32:34.663]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:34.663]                         if (muffled) 
[15:32:34.663]                           invokeRestart("muffleMessage")
[15:32:34.663]                       }
[15:32:34.663]                       else if (inherits(cond, "warning")) {
[15:32:34.663]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:34.663]                         if (muffled) 
[15:32:34.663]                           invokeRestart("muffleWarning")
[15:32:34.663]                       }
[15:32:34.663]                       else if (inherits(cond, "condition")) {
[15:32:34.663]                         if (!is.null(pattern)) {
[15:32:34.663]                           computeRestarts <- base::computeRestarts
[15:32:34.663]                           grepl <- base::grepl
[15:32:34.663]                           restarts <- computeRestarts(cond)
[15:32:34.663]                           for (restart in restarts) {
[15:32:34.663]                             name <- restart$name
[15:32:34.663]                             if (is.null(name)) 
[15:32:34.663]                               next
[15:32:34.663]                             if (!grepl(pattern, name)) 
[15:32:34.663]                               next
[15:32:34.663]                             invokeRestart(restart)
[15:32:34.663]                             muffled <- TRUE
[15:32:34.663]                             break
[15:32:34.663]                           }
[15:32:34.663]                         }
[15:32:34.663]                       }
[15:32:34.663]                       invisible(muffled)
[15:32:34.663]                     }
[15:32:34.663]                     muffleCondition(cond, pattern = "^muffle")
[15:32:34.663]                   }
[15:32:34.663]                 }
[15:32:34.663]             }
[15:32:34.663]         }))
[15:32:34.663]     }, error = function(ex) {
[15:32:34.663]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:34.663]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:34.663]                 ...future.rng), started = ...future.startTime, 
[15:32:34.663]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:34.663]             version = "1.8"), class = "FutureResult")
[15:32:34.663]     }, finally = {
[15:32:34.663]         if (!identical(...future.workdir, getwd())) 
[15:32:34.663]             setwd(...future.workdir)
[15:32:34.663]         {
[15:32:34.663]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:34.663]                 ...future.oldOptions$nwarnings <- NULL
[15:32:34.663]             }
[15:32:34.663]             base::options(...future.oldOptions)
[15:32:34.663]             if (.Platform$OS.type == "windows") {
[15:32:34.663]                 old_names <- names(...future.oldEnvVars)
[15:32:34.663]                 envs <- base::Sys.getenv()
[15:32:34.663]                 names <- names(envs)
[15:32:34.663]                 common <- intersect(names, old_names)
[15:32:34.663]                 added <- setdiff(names, old_names)
[15:32:34.663]                 removed <- setdiff(old_names, names)
[15:32:34.663]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:34.663]                   envs[common]]
[15:32:34.663]                 NAMES <- toupper(changed)
[15:32:34.663]                 args <- list()
[15:32:34.663]                 for (kk in seq_along(NAMES)) {
[15:32:34.663]                   name <- changed[[kk]]
[15:32:34.663]                   NAME <- NAMES[[kk]]
[15:32:34.663]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:34.663]                     next
[15:32:34.663]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:34.663]                 }
[15:32:34.663]                 NAMES <- toupper(added)
[15:32:34.663]                 for (kk in seq_along(NAMES)) {
[15:32:34.663]                   name <- added[[kk]]
[15:32:34.663]                   NAME <- NAMES[[kk]]
[15:32:34.663]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:34.663]                     next
[15:32:34.663]                   args[[name]] <- ""
[15:32:34.663]                 }
[15:32:34.663]                 NAMES <- toupper(removed)
[15:32:34.663]                 for (kk in seq_along(NAMES)) {
[15:32:34.663]                   name <- removed[[kk]]
[15:32:34.663]                   NAME <- NAMES[[kk]]
[15:32:34.663]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:34.663]                     next
[15:32:34.663]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:34.663]                 }
[15:32:34.663]                 if (length(args) > 0) 
[15:32:34.663]                   base::do.call(base::Sys.setenv, args = args)
[15:32:34.663]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:34.663]             }
[15:32:34.663]             else {
[15:32:34.663]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:34.663]             }
[15:32:34.663]             {
[15:32:34.663]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:34.663]                   0L) {
[15:32:34.663]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:34.663]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:34.663]                   base::options(opts)
[15:32:34.663]                 }
[15:32:34.663]                 {
[15:32:34.663]                   {
[15:32:34.663]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:34.663]                     NULL
[15:32:34.663]                   }
[15:32:34.663]                   options(future.plan = NULL)
[15:32:34.663]                   if (is.na(NA_character_)) 
[15:32:34.663]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:34.663]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:34.663]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:34.663]                     .init = FALSE)
[15:32:34.663]                 }
[15:32:34.663]             }
[15:32:34.663]         }
[15:32:34.663]     })
[15:32:34.663]     if (TRUE) {
[15:32:34.663]         base::sink(type = "output", split = FALSE)
[15:32:34.663]         if (TRUE) {
[15:32:34.663]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:34.663]         }
[15:32:34.663]         else {
[15:32:34.663]             ...future.result["stdout"] <- base::list(NULL)
[15:32:34.663]         }
[15:32:34.663]         base::close(...future.stdout)
[15:32:34.663]         ...future.stdout <- NULL
[15:32:34.663]     }
[15:32:34.663]     ...future.result$conditions <- ...future.conditions
[15:32:34.663]     ...future.result$finished <- base::Sys.time()
[15:32:34.663]     ...future.result
[15:32:34.663] }
[15:32:34.670] Exporting 5 global objects (1.22 KiB) to cluster node #1 ...
[15:32:34.670] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ...
[15:32:34.671] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ... DONE
[15:32:34.672] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:34.673] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:34.673] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ...
[15:32:34.674] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ... DONE
[15:32:34.675] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:34.675] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:34.676] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:34.676] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:34.677] Exporting 5 global objects (1.22 KiB) to cluster node #1 ... DONE
[15:32:34.678] MultisessionFuture started
[15:32:34.679] - Launch lazy future ... done
[15:32:34.679] run() for 'MultisessionFuture' ... done
[15:32:34.680] Created future:
[15:32:34.709] receiveMessageFromWorker() for ClusterFuture ...
[15:32:34.710] - Validating connection of MultisessionFuture
[15:32:34.711] - received message: FutureResult
[15:32:34.711] - Received FutureResult
[15:32:34.712] - Erased future from FutureRegistry
[15:32:34.712] result() for ClusterFuture ...
[15:32:34.712] - result already collected: FutureResult
[15:32:34.713] result() for ClusterFuture ... done
[15:32:34.713] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:34.680] MultisessionFuture:
[15:32:34.680] Label: 'future_sapply-2'
[15:32:34.680] Expression:
[15:32:34.680] {
[15:32:34.680]     do.call(function(...) {
[15:32:34.680]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:34.680]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:34.680]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:34.680]             on.exit(options(oopts), add = TRUE)
[15:32:34.680]         }
[15:32:34.680]         {
[15:32:34.680]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:34.680]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:34.680]                 ...future.FUN(...future.X_jj, ...)
[15:32:34.680]             })
[15:32:34.680]         }
[15:32:34.680]     }, args = future.call.arguments)
[15:32:34.680] }
[15:32:34.680] Lazy evaluation: FALSE
[15:32:34.680] Asynchronous evaluation: TRUE
[15:32:34.680] Local evaluation: TRUE
[15:32:34.680] Environment: R_GlobalEnv
[15:32:34.680] Capture standard output: TRUE
[15:32:34.680] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:34.680] Globals: 5 objects totaling 1.38 KiB (function '...future.FUN' of 1.22 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:34.680] Packages: <none>
[15:32:34.680] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:34.680] Resolved: TRUE
[15:32:34.680] Value: <not collected>
[15:32:34.680] Conditions captured: <none>
[15:32:34.680] Early signaling: FALSE
[15:32:34.680] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:34.680] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:34.714] Chunk #2 of 2 ... DONE
[15:32:34.714] Launching 2 futures (chunks) ... DONE
[15:32:34.715] Resolving 2 futures (chunks) ...
[15:32:34.715] resolve() on list ...
[15:32:34.715]  recursive: 0
[15:32:34.716]  length: 2
[15:32:34.716] 
[15:32:34.716] Future #1
[15:32:34.717] result() for ClusterFuture ...
[15:32:34.717] - result already collected: FutureResult
[15:32:34.717] result() for ClusterFuture ... done
[15:32:34.718] result() for ClusterFuture ...
[15:32:34.718] - result already collected: FutureResult
[15:32:34.718] result() for ClusterFuture ... done
[15:32:34.719] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:34.719] - nx: 2
[15:32:34.720] - relay: TRUE
[15:32:34.720] - stdout: TRUE
[15:32:34.720] - signal: TRUE
[15:32:34.721] - resignal: FALSE
[15:32:34.721] - force: TRUE
[15:32:34.721] - relayed: [n=2] FALSE, FALSE
[15:32:34.721] - queued futures: [n=2] FALSE, FALSE
[15:32:34.722]  - until=1
[15:32:34.722]  - relaying element #1
[15:32:34.723] result() for ClusterFuture ...
[15:32:34.723] - result already collected: FutureResult
[15:32:34.723] result() for ClusterFuture ... done
[15:32:34.724] result() for ClusterFuture ...
[15:32:34.724] - result already collected: FutureResult
[15:32:34.724] result() for ClusterFuture ... done
[15:32:34.725] result() for ClusterFuture ...
[15:32:34.725] - result already collected: FutureResult
[15:32:34.725] result() for ClusterFuture ... done
[15:32:34.726] result() for ClusterFuture ...
[15:32:34.726] - result already collected: FutureResult
[15:32:34.726] result() for ClusterFuture ... done
[15:32:34.727] - relayed: [n=2] TRUE, FALSE
[15:32:34.727] - queued futures: [n=2] TRUE, FALSE
[15:32:34.727] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:34.728]  length: 1 (resolved future 1)
[15:32:34.728] Future #2
[15:32:34.728] result() for ClusterFuture ...
[15:32:34.729] - result already collected: FutureResult
[15:32:34.729] result() for ClusterFuture ... done
[15:32:34.729] result() for ClusterFuture ...
[15:32:34.730] - result already collected: FutureResult
[15:32:34.730] result() for ClusterFuture ... done
[15:32:34.730] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:34.731] - nx: 2
[15:32:34.731] - relay: TRUE
[15:32:34.731] - stdout: TRUE
[15:32:34.732] - signal: TRUE
[15:32:34.732] - resignal: FALSE
[15:32:34.732] - force: TRUE
[15:32:34.733] - relayed: [n=2] TRUE, FALSE
[15:32:34.733] - queued futures: [n=2] TRUE, FALSE
[15:32:34.733]  - until=2
[15:32:34.734]  - relaying element #2
[15:32:34.734] result() for ClusterFuture ...
[15:32:34.734] - result already collected: FutureResult
[15:32:34.735] result() for ClusterFuture ... done
[15:32:34.735] result() for ClusterFuture ...
[15:32:34.735] - result already collected: FutureResult
[15:32:34.736] result() for ClusterFuture ... done
[15:32:34.736] result() for ClusterFuture ...
[15:32:34.736] - result already collected: FutureResult
[15:32:34.737] result() for ClusterFuture ... done
[15:32:34.737] result() for ClusterFuture ...
[15:32:34.737] - result already collected: FutureResult
[15:32:34.738] result() for ClusterFuture ... done
[15:32:34.738] - relayed: [n=2] TRUE, TRUE
[15:32:34.738] - queued futures: [n=2] TRUE, TRUE
[15:32:34.739] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:34.739]  length: 0 (resolved future 2)
[15:32:34.740] Relaying remaining futures
[15:32:34.740] signalConditionsASAP(NULL, pos=0) ...
[15:32:34.740] - nx: 2
[15:32:34.741] - relay: TRUE
[15:32:34.741] - stdout: TRUE
[15:32:34.741] - signal: TRUE
[15:32:34.742] - resignal: FALSE
[15:32:34.742] - force: TRUE
[15:32:34.742] - relayed: [n=2] TRUE, TRUE
[15:32:34.743] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:34.743] - relayed: [n=2] TRUE, TRUE
[15:32:34.744] - queued futures: [n=2] TRUE, TRUE
[15:32:34.744] signalConditionsASAP(NULL, pos=0) ... done
[15:32:34.744] resolve() on list ... DONE
[15:32:34.745] result() for ClusterFuture ...
[15:32:34.745] - result already collected: FutureResult
[15:32:34.745] result() for ClusterFuture ... done
[15:32:34.746] result() for ClusterFuture ...
[15:32:34.746] - result already collected: FutureResult
[15:32:34.746] result() for ClusterFuture ... done
[15:32:34.747] result() for ClusterFuture ...
[15:32:34.747] - result already collected: FutureResult
[15:32:34.747] result() for ClusterFuture ... done
[15:32:34.748] result() for ClusterFuture ...
[15:32:34.748] - result already collected: FutureResult
[15:32:34.748] result() for ClusterFuture ... done
[15:32:34.749]  - Number of value chunks collected: 2
[15:32:34.749] Resolving 2 futures (chunks) ... DONE
[15:32:34.750] Reducing values from 2 chunks ...
[15:32:34.750]  - Number of values collected after concatenation: 6
[15:32:34.750]  - Number of values expected: 6
[15:32:34.751] Reducing values from 2 chunks ... DONE
[15:32:34.751] future_lapply() ... DONE
List of 2
 $ y0: Named int [1:6] 1 2 2 3 3 4
  ..- attr(*, "names")= chr [1:6] "a1" "a2" "b1" "b2" ...
 $ y1: Named int [1:6] 1 2 2 3 3 4
  ..- attr(*, "names")= chr [1:6] "a1" "a2" "b1" "b2" ...
[15:32:34.755] future_lapply() ...
[15:32:34.761] Number of chunks: 2
[15:32:34.761] getGlobalsAndPackagesXApply() ...
[15:32:34.761]  - future.globals: TRUE
[15:32:34.762] getGlobalsAndPackages() ...
[15:32:34.762] Searching for globals...
[15:32:34.765] - globals found: [5] 'FUN', '*', ':', 'outer', 'rep'
[15:32:34.765] Searching for globals ... DONE
[15:32:34.766] Resolving globals: FALSE
[15:32:34.767] The total size of the 1 globals is 4.62 KiB (4728 bytes)
[15:32:34.767] The total size of the 1 globals exported for future expression ('FUN()') is 4.62 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.62 KiB of class 'function')
[15:32:34.768] - globals: [1] 'FUN'
[15:32:34.768] 
[15:32:34.768] getGlobalsAndPackages() ... DONE
[15:32:34.769]  - globals found/used: [n=1] 'FUN'
[15:32:34.769]  - needed namespaces: [n=0] 
[15:32:34.769] Finding globals ... DONE
[15:32:34.770]  - use_args: TRUE
[15:32:34.770]  - Getting '...' globals ...
[15:32:34.771] resolve() on list ...
[15:32:34.771]  recursive: 0
[15:32:34.771]  length: 1
[15:32:34.771]  elements: '...'
[15:32:34.772]  length: 0 (resolved future 1)
[15:32:34.772] resolve() on list ... DONE
[15:32:34.772]    - '...' content: [n=0] 
[15:32:34.773] List of 1
[15:32:34.773]  $ ...: list()
[15:32:34.773]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:34.773]  - attr(*, "where")=List of 1
[15:32:34.773]   ..$ ...:<environment: 0x00000276e5a4e9c8> 
[15:32:34.773]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:34.773]  - attr(*, "resolved")= logi TRUE
[15:32:34.773]  - attr(*, "total_size")= num NA
[15:32:34.778]  - Getting '...' globals ... DONE
[15:32:34.779] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:34.779] List of 2
[15:32:34.779]  $ ...future.FUN:function (x, y = 2 * 1:5)  
[15:32:34.779]  $ ...          : list()
[15:32:34.779]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:34.779]  - attr(*, "where")=List of 2
[15:32:34.779]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:34.779]   ..$ ...          :<environment: 0x00000276e5a4e9c8> 
[15:32:34.779]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:34.779]  - attr(*, "resolved")= logi FALSE
[15:32:34.779]  - attr(*, "total_size")= num 4728
[15:32:34.785] Packages to be attached in all futures: [n=0] 
[15:32:34.785] getGlobalsAndPackagesXApply() ... DONE
[15:32:34.785] Number of futures (= number of chunks): 2
[15:32:34.786] Launching 2 futures (chunks) ...
[15:32:34.786] Chunk #1 of 2 ...
[15:32:34.786]  - Finding globals in 'X' for chunk #1 ...
[15:32:34.787] getGlobalsAndPackages() ...
[15:32:34.787] Searching for globals...
[15:32:34.788] 
[15:32:34.788] Searching for globals ... DONE
[15:32:34.788] - globals: [0] <none>
[15:32:34.789] getGlobalsAndPackages() ... DONE
[15:32:34.789]    + additional globals found: [n=0] 
[15:32:34.789]    + additional namespaces needed: [n=0] 
[15:32:34.790]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:34.790]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:34.790]  - seeds: <none>
[15:32:34.790]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:34.791] getGlobalsAndPackages() ...
[15:32:34.791] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:34.791] Resolving globals: FALSE
[15:32:34.792] Tweak future expression to call with '...' arguments ...
[15:32:34.792] {
[15:32:34.792]     do.call(function(...) {
[15:32:34.792]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:34.792]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:34.792]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:34.792]             on.exit(options(oopts), add = TRUE)
[15:32:34.792]         }
[15:32:34.792]         {
[15:32:34.792]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:34.792]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:34.792]                 ...future.FUN(...future.X_jj, ...)
[15:32:34.792]             })
[15:32:34.792]         }
[15:32:34.792]     }, args = future.call.arguments)
[15:32:34.792] }
[15:32:34.793] Tweak future expression to call with '...' arguments ... DONE
[15:32:34.794] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:34.794] 
[15:32:34.794] getGlobalsAndPackages() ... DONE
[15:32:34.795] run() for 'Future' ...
[15:32:34.795] - state: 'created'
[15:32:34.796] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:34.815] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:34.816] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:34.816]   - Field: 'node'
[15:32:34.817]   - Field: 'label'
[15:32:34.817]   - Field: 'local'
[15:32:34.817]   - Field: 'owner'
[15:32:34.818]   - Field: 'envir'
[15:32:34.818]   - Field: 'workers'
[15:32:34.818]   - Field: 'packages'
[15:32:34.818]   - Field: 'gc'
[15:32:34.819]   - Field: 'conditions'
[15:32:34.819]   - Field: 'persistent'
[15:32:34.819]   - Field: 'expr'
[15:32:34.820]   - Field: 'uuid'
[15:32:34.820]   - Field: 'seed'
[15:32:34.820]   - Field: 'version'
[15:32:34.821]   - Field: 'result'
[15:32:34.821]   - Field: 'asynchronous'
[15:32:34.821]   - Field: 'calls'
[15:32:34.822]   - Field: 'globals'
[15:32:34.822]   - Field: 'stdout'
[15:32:34.822]   - Field: 'earlySignal'
[15:32:34.823]   - Field: 'lazy'
[15:32:34.823]   - Field: 'state'
[15:32:34.823] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:34.824] - Launch lazy future ...
[15:32:34.824] Packages needed by the future expression (n = 0): <none>
[15:32:34.825] Packages needed by future strategies (n = 0): <none>
[15:32:34.826] {
[15:32:34.826]     {
[15:32:34.826]         {
[15:32:34.826]             ...future.startTime <- base::Sys.time()
[15:32:34.826]             {
[15:32:34.826]                 {
[15:32:34.826]                   {
[15:32:34.826]                     {
[15:32:34.826]                       base::local({
[15:32:34.826]                         has_future <- base::requireNamespace("future", 
[15:32:34.826]                           quietly = TRUE)
[15:32:34.826]                         if (has_future) {
[15:32:34.826]                           ns <- base::getNamespace("future")
[15:32:34.826]                           version <- ns[[".package"]][["version"]]
[15:32:34.826]                           if (is.null(version)) 
[15:32:34.826]                             version <- utils::packageVersion("future")
[15:32:34.826]                         }
[15:32:34.826]                         else {
[15:32:34.826]                           version <- NULL
[15:32:34.826]                         }
[15:32:34.826]                         if (!has_future || version < "1.8.0") {
[15:32:34.826]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:34.826]                             "", base::R.version$version.string), 
[15:32:34.826]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:34.826]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:34.826]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:34.826]                               "release", "version")], collapse = " "), 
[15:32:34.826]                             hostname = base::Sys.info()[["nodename"]])
[15:32:34.826]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:34.826]                             info)
[15:32:34.826]                           info <- base::paste(info, collapse = "; ")
[15:32:34.826]                           if (!has_future) {
[15:32:34.826]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:34.826]                               info)
[15:32:34.826]                           }
[15:32:34.826]                           else {
[15:32:34.826]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:34.826]                               info, version)
[15:32:34.826]                           }
[15:32:34.826]                           base::stop(msg)
[15:32:34.826]                         }
[15:32:34.826]                       })
[15:32:34.826]                     }
[15:32:34.826]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:34.826]                     base::options(mc.cores = 1L)
[15:32:34.826]                   }
[15:32:34.826]                   ...future.strategy.old <- future::plan("list")
[15:32:34.826]                   options(future.plan = NULL)
[15:32:34.826]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:34.826]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:34.826]                 }
[15:32:34.826]                 ...future.workdir <- getwd()
[15:32:34.826]             }
[15:32:34.826]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:34.826]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:34.826]         }
[15:32:34.826]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:34.826]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:34.826]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:34.826]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:34.826]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:34.826]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:34.826]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:34.826]             base::names(...future.oldOptions))
[15:32:34.826]     }
[15:32:34.826]     if (FALSE) {
[15:32:34.826]     }
[15:32:34.826]     else {
[15:32:34.826]         if (TRUE) {
[15:32:34.826]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:34.826]                 open = "w")
[15:32:34.826]         }
[15:32:34.826]         else {
[15:32:34.826]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:34.826]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:34.826]         }
[15:32:34.826]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:34.826]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:34.826]             base::sink(type = "output", split = FALSE)
[15:32:34.826]             base::close(...future.stdout)
[15:32:34.826]         }, add = TRUE)
[15:32:34.826]     }
[15:32:34.826]     ...future.frame <- base::sys.nframe()
[15:32:34.826]     ...future.conditions <- base::list()
[15:32:34.826]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:34.826]     if (FALSE) {
[15:32:34.826]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:34.826]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:34.826]     }
[15:32:34.826]     ...future.result <- base::tryCatch({
[15:32:34.826]         base::withCallingHandlers({
[15:32:34.826]             ...future.value <- base::withVisible(base::local({
[15:32:34.826]                 ...future.makeSendCondition <- base::local({
[15:32:34.826]                   sendCondition <- NULL
[15:32:34.826]                   function(frame = 1L) {
[15:32:34.826]                     if (is.function(sendCondition)) 
[15:32:34.826]                       return(sendCondition)
[15:32:34.826]                     ns <- getNamespace("parallel")
[15:32:34.826]                     if (exists("sendData", mode = "function", 
[15:32:34.826]                       envir = ns)) {
[15:32:34.826]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:34.826]                         envir = ns)
[15:32:34.826]                       envir <- sys.frame(frame)
[15:32:34.826]                       master <- NULL
[15:32:34.826]                       while (!identical(envir, .GlobalEnv) && 
[15:32:34.826]                         !identical(envir, emptyenv())) {
[15:32:34.826]                         if (exists("master", mode = "list", envir = envir, 
[15:32:34.826]                           inherits = FALSE)) {
[15:32:34.826]                           master <- get("master", mode = "list", 
[15:32:34.826]                             envir = envir, inherits = FALSE)
[15:32:34.826]                           if (inherits(master, c("SOCKnode", 
[15:32:34.826]                             "SOCK0node"))) {
[15:32:34.826]                             sendCondition <<- function(cond) {
[15:32:34.826]                               data <- list(type = "VALUE", value = cond, 
[15:32:34.826]                                 success = TRUE)
[15:32:34.826]                               parallel_sendData(master, data)
[15:32:34.826]                             }
[15:32:34.826]                             return(sendCondition)
[15:32:34.826]                           }
[15:32:34.826]                         }
[15:32:34.826]                         frame <- frame + 1L
[15:32:34.826]                         envir <- sys.frame(frame)
[15:32:34.826]                       }
[15:32:34.826]                     }
[15:32:34.826]                     sendCondition <<- function(cond) NULL
[15:32:34.826]                   }
[15:32:34.826]                 })
[15:32:34.826]                 withCallingHandlers({
[15:32:34.826]                   {
[15:32:34.826]                     do.call(function(...) {
[15:32:34.826]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:34.826]                       if (!identical(...future.globals.maxSize.org, 
[15:32:34.826]                         ...future.globals.maxSize)) {
[15:32:34.826]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:34.826]                         on.exit(options(oopts), add = TRUE)
[15:32:34.826]                       }
[15:32:34.826]                       {
[15:32:34.826]                         lapply(seq_along(...future.elements_ii), 
[15:32:34.826]                           FUN = function(jj) {
[15:32:34.826]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:34.826]                             ...future.FUN(...future.X_jj, ...)
[15:32:34.826]                           })
[15:32:34.826]                       }
[15:32:34.826]                     }, args = future.call.arguments)
[15:32:34.826]                   }
[15:32:34.826]                 }, immediateCondition = function(cond) {
[15:32:34.826]                   sendCondition <- ...future.makeSendCondition()
[15:32:34.826]                   sendCondition(cond)
[15:32:34.826]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:34.826]                   {
[15:32:34.826]                     inherits <- base::inherits
[15:32:34.826]                     invokeRestart <- base::invokeRestart
[15:32:34.826]                     is.null <- base::is.null
[15:32:34.826]                     muffled <- FALSE
[15:32:34.826]                     if (inherits(cond, "message")) {
[15:32:34.826]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:34.826]                       if (muffled) 
[15:32:34.826]                         invokeRestart("muffleMessage")
[15:32:34.826]                     }
[15:32:34.826]                     else if (inherits(cond, "warning")) {
[15:32:34.826]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:34.826]                       if (muffled) 
[15:32:34.826]                         invokeRestart("muffleWarning")
[15:32:34.826]                     }
[15:32:34.826]                     else if (inherits(cond, "condition")) {
[15:32:34.826]                       if (!is.null(pattern)) {
[15:32:34.826]                         computeRestarts <- base::computeRestarts
[15:32:34.826]                         grepl <- base::grepl
[15:32:34.826]                         restarts <- computeRestarts(cond)
[15:32:34.826]                         for (restart in restarts) {
[15:32:34.826]                           name <- restart$name
[15:32:34.826]                           if (is.null(name)) 
[15:32:34.826]                             next
[15:32:34.826]                           if (!grepl(pattern, name)) 
[15:32:34.826]                             next
[15:32:34.826]                           invokeRestart(restart)
[15:32:34.826]                           muffled <- TRUE
[15:32:34.826]                           break
[15:32:34.826]                         }
[15:32:34.826]                       }
[15:32:34.826]                     }
[15:32:34.826]                     invisible(muffled)
[15:32:34.826]                   }
[15:32:34.826]                   muffleCondition(cond)
[15:32:34.826]                 })
[15:32:34.826]             }))
[15:32:34.826]             future::FutureResult(value = ...future.value$value, 
[15:32:34.826]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:34.826]                   ...future.rng), globalenv = if (FALSE) 
[15:32:34.826]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:34.826]                     ...future.globalenv.names))
[15:32:34.826]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:34.826]         }, condition = base::local({
[15:32:34.826]             c <- base::c
[15:32:34.826]             inherits <- base::inherits
[15:32:34.826]             invokeRestart <- base::invokeRestart
[15:32:34.826]             length <- base::length
[15:32:34.826]             list <- base::list
[15:32:34.826]             seq.int <- base::seq.int
[15:32:34.826]             signalCondition <- base::signalCondition
[15:32:34.826]             sys.calls <- base::sys.calls
[15:32:34.826]             `[[` <- base::`[[`
[15:32:34.826]             `+` <- base::`+`
[15:32:34.826]             `<<-` <- base::`<<-`
[15:32:34.826]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:34.826]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:34.826]                   3L)]
[15:32:34.826]             }
[15:32:34.826]             function(cond) {
[15:32:34.826]                 is_error <- inherits(cond, "error")
[15:32:34.826]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:34.826]                   NULL)
[15:32:34.826]                 if (is_error) {
[15:32:34.826]                   sessionInformation <- function() {
[15:32:34.826]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:34.826]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:34.826]                       search = base::search(), system = base::Sys.info())
[15:32:34.826]                   }
[15:32:34.826]                   ...future.conditions[[length(...future.conditions) + 
[15:32:34.826]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:34.826]                     cond$call), session = sessionInformation(), 
[15:32:34.826]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:34.826]                   signalCondition(cond)
[15:32:34.826]                 }
[15:32:34.826]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:34.826]                 "immediateCondition"))) {
[15:32:34.826]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:34.826]                   ...future.conditions[[length(...future.conditions) + 
[15:32:34.826]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:34.826]                   if (TRUE && !signal) {
[15:32:34.826]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:34.826]                     {
[15:32:34.826]                       inherits <- base::inherits
[15:32:34.826]                       invokeRestart <- base::invokeRestart
[15:32:34.826]                       is.null <- base::is.null
[15:32:34.826]                       muffled <- FALSE
[15:32:34.826]                       if (inherits(cond, "message")) {
[15:32:34.826]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:34.826]                         if (muffled) 
[15:32:34.826]                           invokeRestart("muffleMessage")
[15:32:34.826]                       }
[15:32:34.826]                       else if (inherits(cond, "warning")) {
[15:32:34.826]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:34.826]                         if (muffled) 
[15:32:34.826]                           invokeRestart("muffleWarning")
[15:32:34.826]                       }
[15:32:34.826]                       else if (inherits(cond, "condition")) {
[15:32:34.826]                         if (!is.null(pattern)) {
[15:32:34.826]                           computeRestarts <- base::computeRestarts
[15:32:34.826]                           grepl <- base::grepl
[15:32:34.826]                           restarts <- computeRestarts(cond)
[15:32:34.826]                           for (restart in restarts) {
[15:32:34.826]                             name <- restart$name
[15:32:34.826]                             if (is.null(name)) 
[15:32:34.826]                               next
[15:32:34.826]                             if (!grepl(pattern, name)) 
[15:32:34.826]                               next
[15:32:34.826]                             invokeRestart(restart)
[15:32:34.826]                             muffled <- TRUE
[15:32:34.826]                             break
[15:32:34.826]                           }
[15:32:34.826]                         }
[15:32:34.826]                       }
[15:32:34.826]                       invisible(muffled)
[15:32:34.826]                     }
[15:32:34.826]                     muffleCondition(cond, pattern = "^muffle")
[15:32:34.826]                   }
[15:32:34.826]                 }
[15:32:34.826]                 else {
[15:32:34.826]                   if (TRUE) {
[15:32:34.826]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:34.826]                     {
[15:32:34.826]                       inherits <- base::inherits
[15:32:34.826]                       invokeRestart <- base::invokeRestart
[15:32:34.826]                       is.null <- base::is.null
[15:32:34.826]                       muffled <- FALSE
[15:32:34.826]                       if (inherits(cond, "message")) {
[15:32:34.826]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:34.826]                         if (muffled) 
[15:32:34.826]                           invokeRestart("muffleMessage")
[15:32:34.826]                       }
[15:32:34.826]                       else if (inherits(cond, "warning")) {
[15:32:34.826]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:34.826]                         if (muffled) 
[15:32:34.826]                           invokeRestart("muffleWarning")
[15:32:34.826]                       }
[15:32:34.826]                       else if (inherits(cond, "condition")) {
[15:32:34.826]                         if (!is.null(pattern)) {
[15:32:34.826]                           computeRestarts <- base::computeRestarts
[15:32:34.826]                           grepl <- base::grepl
[15:32:34.826]                           restarts <- computeRestarts(cond)
[15:32:34.826]                           for (restart in restarts) {
[15:32:34.826]                             name <- restart$name
[15:32:34.826]                             if (is.null(name)) 
[15:32:34.826]                               next
[15:32:34.826]                             if (!grepl(pattern, name)) 
[15:32:34.826]                               next
[15:32:34.826]                             invokeRestart(restart)
[15:32:34.826]                             muffled <- TRUE
[15:32:34.826]                             break
[15:32:34.826]                           }
[15:32:34.826]                         }
[15:32:34.826]                       }
[15:32:34.826]                       invisible(muffled)
[15:32:34.826]                     }
[15:32:34.826]                     muffleCondition(cond, pattern = "^muffle")
[15:32:34.826]                   }
[15:32:34.826]                 }
[15:32:34.826]             }
[15:32:34.826]         }))
[15:32:34.826]     }, error = function(ex) {
[15:32:34.826]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:34.826]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:34.826]                 ...future.rng), started = ...future.startTime, 
[15:32:34.826]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:34.826]             version = "1.8"), class = "FutureResult")
[15:32:34.826]     }, finally = {
[15:32:34.826]         if (!identical(...future.workdir, getwd())) 
[15:32:34.826]             setwd(...future.workdir)
[15:32:34.826]         {
[15:32:34.826]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:34.826]                 ...future.oldOptions$nwarnings <- NULL
[15:32:34.826]             }
[15:32:34.826]             base::options(...future.oldOptions)
[15:32:34.826]             if (.Platform$OS.type == "windows") {
[15:32:34.826]                 old_names <- names(...future.oldEnvVars)
[15:32:34.826]                 envs <- base::Sys.getenv()
[15:32:34.826]                 names <- names(envs)
[15:32:34.826]                 common <- intersect(names, old_names)
[15:32:34.826]                 added <- setdiff(names, old_names)
[15:32:34.826]                 removed <- setdiff(old_names, names)
[15:32:34.826]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:34.826]                   envs[common]]
[15:32:34.826]                 NAMES <- toupper(changed)
[15:32:34.826]                 args <- list()
[15:32:34.826]                 for (kk in seq_along(NAMES)) {
[15:32:34.826]                   name <- changed[[kk]]
[15:32:34.826]                   NAME <- NAMES[[kk]]
[15:32:34.826]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:34.826]                     next
[15:32:34.826]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:34.826]                 }
[15:32:34.826]                 NAMES <- toupper(added)
[15:32:34.826]                 for (kk in seq_along(NAMES)) {
[15:32:34.826]                   name <- added[[kk]]
[15:32:34.826]                   NAME <- NAMES[[kk]]
[15:32:34.826]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:34.826]                     next
[15:32:34.826]                   args[[name]] <- ""
[15:32:34.826]                 }
[15:32:34.826]                 NAMES <- toupper(removed)
[15:32:34.826]                 for (kk in seq_along(NAMES)) {
[15:32:34.826]                   name <- removed[[kk]]
[15:32:34.826]                   NAME <- NAMES[[kk]]
[15:32:34.826]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:34.826]                     next
[15:32:34.826]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:34.826]                 }
[15:32:34.826]                 if (length(args) > 0) 
[15:32:34.826]                   base::do.call(base::Sys.setenv, args = args)
[15:32:34.826]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:34.826]             }
[15:32:34.826]             else {
[15:32:34.826]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:34.826]             }
[15:32:34.826]             {
[15:32:34.826]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:34.826]                   0L) {
[15:32:34.826]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:34.826]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:34.826]                   base::options(opts)
[15:32:34.826]                 }
[15:32:34.826]                 {
[15:32:34.826]                   {
[15:32:34.826]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:34.826]                     NULL
[15:32:34.826]                   }
[15:32:34.826]                   options(future.plan = NULL)
[15:32:34.826]                   if (is.na(NA_character_)) 
[15:32:34.826]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:34.826]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:34.826]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:34.826]                     .init = FALSE)
[15:32:34.826]                 }
[15:32:34.826]             }
[15:32:34.826]         }
[15:32:34.826]     })
[15:32:34.826]     if (TRUE) {
[15:32:34.826]         base::sink(type = "output", split = FALSE)
[15:32:34.826]         if (TRUE) {
[15:32:34.826]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:34.826]         }
[15:32:34.826]         else {
[15:32:34.826]             ...future.result["stdout"] <- base::list(NULL)
[15:32:34.826]         }
[15:32:34.826]         base::close(...future.stdout)
[15:32:34.826]         ...future.stdout <- NULL
[15:32:34.826]     }
[15:32:34.826]     ...future.result$conditions <- ...future.conditions
[15:32:34.826]     ...future.result$finished <- base::Sys.time()
[15:32:34.826]     ...future.result
[15:32:34.826] }
[15:32:34.836] Exporting 5 global objects (4.62 KiB) to cluster node #1 ...
[15:32:34.836] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ...
[15:32:34.837] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ... DONE
[15:32:34.838] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:34.839] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:34.839] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ...
[15:32:34.840] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ... DONE
[15:32:34.840] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:34.841] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:34.841] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:34.842] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:34.842] Exporting 5 global objects (4.62 KiB) to cluster node #1 ... DONE
[15:32:34.843] MultisessionFuture started
[15:32:34.843] - Launch lazy future ... done
[15:32:34.844] run() for 'MultisessionFuture' ... done
[15:32:34.844] Created future:
[15:32:34.868] receiveMessageFromWorker() for ClusterFuture ...
[15:32:34.869] - Validating connection of MultisessionFuture
[15:32:34.869] - received message: FutureResult
[15:32:34.870] - Received FutureResult
[15:32:34.870] - Erased future from FutureRegistry
[15:32:34.870] result() for ClusterFuture ...
[15:32:34.870] - result already collected: FutureResult
[15:32:34.871] result() for ClusterFuture ... done
[15:32:34.871] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:34.844] MultisessionFuture:
[15:32:34.844] Label: 'future_sapply-1'
[15:32:34.844] Expression:
[15:32:34.844] {
[15:32:34.844]     do.call(function(...) {
[15:32:34.844]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:34.844]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:34.844]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:34.844]             on.exit(options(oopts), add = TRUE)
[15:32:34.844]         }
[15:32:34.844]         {
[15:32:34.844]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:34.844]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:34.844]                 ...future.FUN(...future.X_jj, ...)
[15:32:34.844]             })
[15:32:34.844]         }
[15:32:34.844]     }, args = future.call.arguments)
[15:32:34.844] }
[15:32:34.844] Lazy evaluation: FALSE
[15:32:34.844] Asynchronous evaluation: TRUE
[15:32:34.844] Local evaluation: TRUE
[15:32:34.844] Environment: R_GlobalEnv
[15:32:34.844] Capture standard output: TRUE
[15:32:34.844] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:34.844] Globals: 5 objects totaling 4.78 KiB (function '...future.FUN' of 4.62 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:34.844] Packages: <none>
[15:32:34.844] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:34.844] Resolved: TRUE
[15:32:34.844] Value: <not collected>
[15:32:34.844] Conditions captured: <none>
[15:32:34.844] Early signaling: FALSE
[15:32:34.844] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:34.844] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:34.872] Chunk #1 of 2 ... DONE
[15:32:34.872] Chunk #2 of 2 ...
[15:32:34.872]  - Finding globals in 'X' for chunk #2 ...
[15:32:34.873] getGlobalsAndPackages() ...
[15:32:34.873] Searching for globals...
[15:32:34.874] 
[15:32:34.874] Searching for globals ... DONE
[15:32:34.874] - globals: [0] <none>
[15:32:34.874] getGlobalsAndPackages() ... DONE
[15:32:34.880]    + additional globals found: [n=0] 
[15:32:34.881]    + additional namespaces needed: [n=0] 
[15:32:34.881]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:34.881]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:34.882]  - seeds: <none>
[15:32:34.882]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:34.882] getGlobalsAndPackages() ...
[15:32:34.883] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:34.883] Resolving globals: FALSE
[15:32:34.883] Tweak future expression to call with '...' arguments ...
[15:32:34.884] {
[15:32:34.884]     do.call(function(...) {
[15:32:34.884]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:34.884]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:34.884]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:34.884]             on.exit(options(oopts), add = TRUE)
[15:32:34.884]         }
[15:32:34.884]         {
[15:32:34.884]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:34.884]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:34.884]                 ...future.FUN(...future.X_jj, ...)
[15:32:34.884]             })
[15:32:34.884]         }
[15:32:34.884]     }, args = future.call.arguments)
[15:32:34.884] }
[15:32:34.885] Tweak future expression to call with '...' arguments ... DONE
[15:32:34.886] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:34.886] 
[15:32:34.886] getGlobalsAndPackages() ... DONE
[15:32:34.887] run() for 'Future' ...
[15:32:34.887] - state: 'created'
[15:32:34.888] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:34.907] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:34.907] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:34.908]   - Field: 'node'
[15:32:34.908]   - Field: 'label'
[15:32:34.908]   - Field: 'local'
[15:32:34.909]   - Field: 'owner'
[15:32:34.909]   - Field: 'envir'
[15:32:34.909]   - Field: 'workers'
[15:32:34.910]   - Field: 'packages'
[15:32:34.910]   - Field: 'gc'
[15:32:34.910]   - Field: 'conditions'
[15:32:34.911]   - Field: 'persistent'
[15:32:34.911]   - Field: 'expr'
[15:32:34.911]   - Field: 'uuid'
[15:32:34.911]   - Field: 'seed'
[15:32:34.912]   - Field: 'version'
[15:32:34.912]   - Field: 'result'
[15:32:34.912]   - Field: 'asynchronous'
[15:32:34.913]   - Field: 'calls'
[15:32:34.913]   - Field: 'globals'
[15:32:34.913]   - Field: 'stdout'
[15:32:34.914]   - Field: 'earlySignal'
[15:32:34.914]   - Field: 'lazy'
[15:32:34.914]   - Field: 'state'
[15:32:34.914] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:34.915] - Launch lazy future ...
[15:32:34.915] Packages needed by the future expression (n = 0): <none>
[15:32:34.916] Packages needed by future strategies (n = 0): <none>
[15:32:34.917] {
[15:32:34.917]     {
[15:32:34.917]         {
[15:32:34.917]             ...future.startTime <- base::Sys.time()
[15:32:34.917]             {
[15:32:34.917]                 {
[15:32:34.917]                   {
[15:32:34.917]                     {
[15:32:34.917]                       base::local({
[15:32:34.917]                         has_future <- base::requireNamespace("future", 
[15:32:34.917]                           quietly = TRUE)
[15:32:34.917]                         if (has_future) {
[15:32:34.917]                           ns <- base::getNamespace("future")
[15:32:34.917]                           version <- ns[[".package"]][["version"]]
[15:32:34.917]                           if (is.null(version)) 
[15:32:34.917]                             version <- utils::packageVersion("future")
[15:32:34.917]                         }
[15:32:34.917]                         else {
[15:32:34.917]                           version <- NULL
[15:32:34.917]                         }
[15:32:34.917]                         if (!has_future || version < "1.8.0") {
[15:32:34.917]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:34.917]                             "", base::R.version$version.string), 
[15:32:34.917]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:34.917]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:34.917]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:34.917]                               "release", "version")], collapse = " "), 
[15:32:34.917]                             hostname = base::Sys.info()[["nodename"]])
[15:32:34.917]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:34.917]                             info)
[15:32:34.917]                           info <- base::paste(info, collapse = "; ")
[15:32:34.917]                           if (!has_future) {
[15:32:34.917]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:34.917]                               info)
[15:32:34.917]                           }
[15:32:34.917]                           else {
[15:32:34.917]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:34.917]                               info, version)
[15:32:34.917]                           }
[15:32:34.917]                           base::stop(msg)
[15:32:34.917]                         }
[15:32:34.917]                       })
[15:32:34.917]                     }
[15:32:34.917]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:34.917]                     base::options(mc.cores = 1L)
[15:32:34.917]                   }
[15:32:34.917]                   ...future.strategy.old <- future::plan("list")
[15:32:34.917]                   options(future.plan = NULL)
[15:32:34.917]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:34.917]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:34.917]                 }
[15:32:34.917]                 ...future.workdir <- getwd()
[15:32:34.917]             }
[15:32:34.917]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:34.917]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:34.917]         }
[15:32:34.917]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:34.917]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:34.917]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:34.917]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:34.917]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:34.917]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:34.917]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:34.917]             base::names(...future.oldOptions))
[15:32:34.917]     }
[15:32:34.917]     if (FALSE) {
[15:32:34.917]     }
[15:32:34.917]     else {
[15:32:34.917]         if (TRUE) {
[15:32:34.917]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:34.917]                 open = "w")
[15:32:34.917]         }
[15:32:34.917]         else {
[15:32:34.917]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:34.917]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:34.917]         }
[15:32:34.917]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:34.917]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:34.917]             base::sink(type = "output", split = FALSE)
[15:32:34.917]             base::close(...future.stdout)
[15:32:34.917]         }, add = TRUE)
[15:32:34.917]     }
[15:32:34.917]     ...future.frame <- base::sys.nframe()
[15:32:34.917]     ...future.conditions <- base::list()
[15:32:34.917]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:34.917]     if (FALSE) {
[15:32:34.917]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:34.917]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:34.917]     }
[15:32:34.917]     ...future.result <- base::tryCatch({
[15:32:34.917]         base::withCallingHandlers({
[15:32:34.917]             ...future.value <- base::withVisible(base::local({
[15:32:34.917]                 ...future.makeSendCondition <- base::local({
[15:32:34.917]                   sendCondition <- NULL
[15:32:34.917]                   function(frame = 1L) {
[15:32:34.917]                     if (is.function(sendCondition)) 
[15:32:34.917]                       return(sendCondition)
[15:32:34.917]                     ns <- getNamespace("parallel")
[15:32:34.917]                     if (exists("sendData", mode = "function", 
[15:32:34.917]                       envir = ns)) {
[15:32:34.917]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:34.917]                         envir = ns)
[15:32:34.917]                       envir <- sys.frame(frame)
[15:32:34.917]                       master <- NULL
[15:32:34.917]                       while (!identical(envir, .GlobalEnv) && 
[15:32:34.917]                         !identical(envir, emptyenv())) {
[15:32:34.917]                         if (exists("master", mode = "list", envir = envir, 
[15:32:34.917]                           inherits = FALSE)) {
[15:32:34.917]                           master <- get("master", mode = "list", 
[15:32:34.917]                             envir = envir, inherits = FALSE)
[15:32:34.917]                           if (inherits(master, c("SOCKnode", 
[15:32:34.917]                             "SOCK0node"))) {
[15:32:34.917]                             sendCondition <<- function(cond) {
[15:32:34.917]                               data <- list(type = "VALUE", value = cond, 
[15:32:34.917]                                 success = TRUE)
[15:32:34.917]                               parallel_sendData(master, data)
[15:32:34.917]                             }
[15:32:34.917]                             return(sendCondition)
[15:32:34.917]                           }
[15:32:34.917]                         }
[15:32:34.917]                         frame <- frame + 1L
[15:32:34.917]                         envir <- sys.frame(frame)
[15:32:34.917]                       }
[15:32:34.917]                     }
[15:32:34.917]                     sendCondition <<- function(cond) NULL
[15:32:34.917]                   }
[15:32:34.917]                 })
[15:32:34.917]                 withCallingHandlers({
[15:32:34.917]                   {
[15:32:34.917]                     do.call(function(...) {
[15:32:34.917]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:34.917]                       if (!identical(...future.globals.maxSize.org, 
[15:32:34.917]                         ...future.globals.maxSize)) {
[15:32:34.917]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:34.917]                         on.exit(options(oopts), add = TRUE)
[15:32:34.917]                       }
[15:32:34.917]                       {
[15:32:34.917]                         lapply(seq_along(...future.elements_ii), 
[15:32:34.917]                           FUN = function(jj) {
[15:32:34.917]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:34.917]                             ...future.FUN(...future.X_jj, ...)
[15:32:34.917]                           })
[15:32:34.917]                       }
[15:32:34.917]                     }, args = future.call.arguments)
[15:32:34.917]                   }
[15:32:34.917]                 }, immediateCondition = function(cond) {
[15:32:34.917]                   sendCondition <- ...future.makeSendCondition()
[15:32:34.917]                   sendCondition(cond)
[15:32:34.917]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:34.917]                   {
[15:32:34.917]                     inherits <- base::inherits
[15:32:34.917]                     invokeRestart <- base::invokeRestart
[15:32:34.917]                     is.null <- base::is.null
[15:32:34.917]                     muffled <- FALSE
[15:32:34.917]                     if (inherits(cond, "message")) {
[15:32:34.917]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:34.917]                       if (muffled) 
[15:32:34.917]                         invokeRestart("muffleMessage")
[15:32:34.917]                     }
[15:32:34.917]                     else if (inherits(cond, "warning")) {
[15:32:34.917]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:34.917]                       if (muffled) 
[15:32:34.917]                         invokeRestart("muffleWarning")
[15:32:34.917]                     }
[15:32:34.917]                     else if (inherits(cond, "condition")) {
[15:32:34.917]                       if (!is.null(pattern)) {
[15:32:34.917]                         computeRestarts <- base::computeRestarts
[15:32:34.917]                         grepl <- base::grepl
[15:32:34.917]                         restarts <- computeRestarts(cond)
[15:32:34.917]                         for (restart in restarts) {
[15:32:34.917]                           name <- restart$name
[15:32:34.917]                           if (is.null(name)) 
[15:32:34.917]                             next
[15:32:34.917]                           if (!grepl(pattern, name)) 
[15:32:34.917]                             next
[15:32:34.917]                           invokeRestart(restart)
[15:32:34.917]                           muffled <- TRUE
[15:32:34.917]                           break
[15:32:34.917]                         }
[15:32:34.917]                       }
[15:32:34.917]                     }
[15:32:34.917]                     invisible(muffled)
[15:32:34.917]                   }
[15:32:34.917]                   muffleCondition(cond)
[15:32:34.917]                 })
[15:32:34.917]             }))
[15:32:34.917]             future::FutureResult(value = ...future.value$value, 
[15:32:34.917]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:34.917]                   ...future.rng), globalenv = if (FALSE) 
[15:32:34.917]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:34.917]                     ...future.globalenv.names))
[15:32:34.917]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:34.917]         }, condition = base::local({
[15:32:34.917]             c <- base::c
[15:32:34.917]             inherits <- base::inherits
[15:32:34.917]             invokeRestart <- base::invokeRestart
[15:32:34.917]             length <- base::length
[15:32:34.917]             list <- base::list
[15:32:34.917]             seq.int <- base::seq.int
[15:32:34.917]             signalCondition <- base::signalCondition
[15:32:34.917]             sys.calls <- base::sys.calls
[15:32:34.917]             `[[` <- base::`[[`
[15:32:34.917]             `+` <- base::`+`
[15:32:34.917]             `<<-` <- base::`<<-`
[15:32:34.917]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:34.917]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:34.917]                   3L)]
[15:32:34.917]             }
[15:32:34.917]             function(cond) {
[15:32:34.917]                 is_error <- inherits(cond, "error")
[15:32:34.917]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:34.917]                   NULL)
[15:32:34.917]                 if (is_error) {
[15:32:34.917]                   sessionInformation <- function() {
[15:32:34.917]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:34.917]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:34.917]                       search = base::search(), system = base::Sys.info())
[15:32:34.917]                   }
[15:32:34.917]                   ...future.conditions[[length(...future.conditions) + 
[15:32:34.917]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:34.917]                     cond$call), session = sessionInformation(), 
[15:32:34.917]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:34.917]                   signalCondition(cond)
[15:32:34.917]                 }
[15:32:34.917]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:34.917]                 "immediateCondition"))) {
[15:32:34.917]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:34.917]                   ...future.conditions[[length(...future.conditions) + 
[15:32:34.917]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:34.917]                   if (TRUE && !signal) {
[15:32:34.917]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:34.917]                     {
[15:32:34.917]                       inherits <- base::inherits
[15:32:34.917]                       invokeRestart <- base::invokeRestart
[15:32:34.917]                       is.null <- base::is.null
[15:32:34.917]                       muffled <- FALSE
[15:32:34.917]                       if (inherits(cond, "message")) {
[15:32:34.917]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:34.917]                         if (muffled) 
[15:32:34.917]                           invokeRestart("muffleMessage")
[15:32:34.917]                       }
[15:32:34.917]                       else if (inherits(cond, "warning")) {
[15:32:34.917]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:34.917]                         if (muffled) 
[15:32:34.917]                           invokeRestart("muffleWarning")
[15:32:34.917]                       }
[15:32:34.917]                       else if (inherits(cond, "condition")) {
[15:32:34.917]                         if (!is.null(pattern)) {
[15:32:34.917]                           computeRestarts <- base::computeRestarts
[15:32:34.917]                           grepl <- base::grepl
[15:32:34.917]                           restarts <- computeRestarts(cond)
[15:32:34.917]                           for (restart in restarts) {
[15:32:34.917]                             name <- restart$name
[15:32:34.917]                             if (is.null(name)) 
[15:32:34.917]                               next
[15:32:34.917]                             if (!grepl(pattern, name)) 
[15:32:34.917]                               next
[15:32:34.917]                             invokeRestart(restart)
[15:32:34.917]                             muffled <- TRUE
[15:32:34.917]                             break
[15:32:34.917]                           }
[15:32:34.917]                         }
[15:32:34.917]                       }
[15:32:34.917]                       invisible(muffled)
[15:32:34.917]                     }
[15:32:34.917]                     muffleCondition(cond, pattern = "^muffle")
[15:32:34.917]                   }
[15:32:34.917]                 }
[15:32:34.917]                 else {
[15:32:34.917]                   if (TRUE) {
[15:32:34.917]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:34.917]                     {
[15:32:34.917]                       inherits <- base::inherits
[15:32:34.917]                       invokeRestart <- base::invokeRestart
[15:32:34.917]                       is.null <- base::is.null
[15:32:34.917]                       muffled <- FALSE
[15:32:34.917]                       if (inherits(cond, "message")) {
[15:32:34.917]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:34.917]                         if (muffled) 
[15:32:34.917]                           invokeRestart("muffleMessage")
[15:32:34.917]                       }
[15:32:34.917]                       else if (inherits(cond, "warning")) {
[15:32:34.917]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:34.917]                         if (muffled) 
[15:32:34.917]                           invokeRestart("muffleWarning")
[15:32:34.917]                       }
[15:32:34.917]                       else if (inherits(cond, "condition")) {
[15:32:34.917]                         if (!is.null(pattern)) {
[15:32:34.917]                           computeRestarts <- base::computeRestarts
[15:32:34.917]                           grepl <- base::grepl
[15:32:34.917]                           restarts <- computeRestarts(cond)
[15:32:34.917]                           for (restart in restarts) {
[15:32:34.917]                             name <- restart$name
[15:32:34.917]                             if (is.null(name)) 
[15:32:34.917]                               next
[15:32:34.917]                             if (!grepl(pattern, name)) 
[15:32:34.917]                               next
[15:32:34.917]                             invokeRestart(restart)
[15:32:34.917]                             muffled <- TRUE
[15:32:34.917]                             break
[15:32:34.917]                           }
[15:32:34.917]                         }
[15:32:34.917]                       }
[15:32:34.917]                       invisible(muffled)
[15:32:34.917]                     }
[15:32:34.917]                     muffleCondition(cond, pattern = "^muffle")
[15:32:34.917]                   }
[15:32:34.917]                 }
[15:32:34.917]             }
[15:32:34.917]         }))
[15:32:34.917]     }, error = function(ex) {
[15:32:34.917]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:34.917]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:34.917]                 ...future.rng), started = ...future.startTime, 
[15:32:34.917]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:34.917]             version = "1.8"), class = "FutureResult")
[15:32:34.917]     }, finally = {
[15:32:34.917]         if (!identical(...future.workdir, getwd())) 
[15:32:34.917]             setwd(...future.workdir)
[15:32:34.917]         {
[15:32:34.917]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:34.917]                 ...future.oldOptions$nwarnings <- NULL
[15:32:34.917]             }
[15:32:34.917]             base::options(...future.oldOptions)
[15:32:34.917]             if (.Platform$OS.type == "windows") {
[15:32:34.917]                 old_names <- names(...future.oldEnvVars)
[15:32:34.917]                 envs <- base::Sys.getenv()
[15:32:34.917]                 names <- names(envs)
[15:32:34.917]                 common <- intersect(names, old_names)
[15:32:34.917]                 added <- setdiff(names, old_names)
[15:32:34.917]                 removed <- setdiff(old_names, names)
[15:32:34.917]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:34.917]                   envs[common]]
[15:32:34.917]                 NAMES <- toupper(changed)
[15:32:34.917]                 args <- list()
[15:32:34.917]                 for (kk in seq_along(NAMES)) {
[15:32:34.917]                   name <- changed[[kk]]
[15:32:34.917]                   NAME <- NAMES[[kk]]
[15:32:34.917]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:34.917]                     next
[15:32:34.917]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:34.917]                 }
[15:32:34.917]                 NAMES <- toupper(added)
[15:32:34.917]                 for (kk in seq_along(NAMES)) {
[15:32:34.917]                   name <- added[[kk]]
[15:32:34.917]                   NAME <- NAMES[[kk]]
[15:32:34.917]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:34.917]                     next
[15:32:34.917]                   args[[name]] <- ""
[15:32:34.917]                 }
[15:32:34.917]                 NAMES <- toupper(removed)
[15:32:34.917]                 for (kk in seq_along(NAMES)) {
[15:32:34.917]                   name <- removed[[kk]]
[15:32:34.917]                   NAME <- NAMES[[kk]]
[15:32:34.917]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:34.917]                     next
[15:32:34.917]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:34.917]                 }
[15:32:34.917]                 if (length(args) > 0) 
[15:32:34.917]                   base::do.call(base::Sys.setenv, args = args)
[15:32:34.917]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:34.917]             }
[15:32:34.917]             else {
[15:32:34.917]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:34.917]             }
[15:32:34.917]             {
[15:32:34.917]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:34.917]                   0L) {
[15:32:34.917]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:34.917]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:34.917]                   base::options(opts)
[15:32:34.917]                 }
[15:32:34.917]                 {
[15:32:34.917]                   {
[15:32:34.917]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:34.917]                     NULL
[15:32:34.917]                   }
[15:32:34.917]                   options(future.plan = NULL)
[15:32:34.917]                   if (is.na(NA_character_)) 
[15:32:34.917]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:34.917]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:34.917]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:34.917]                     .init = FALSE)
[15:32:34.917]                 }
[15:32:34.917]             }
[15:32:34.917]         }
[15:32:34.917]     })
[15:32:34.917]     if (TRUE) {
[15:32:34.917]         base::sink(type = "output", split = FALSE)
[15:32:34.917]         if (TRUE) {
[15:32:34.917]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:34.917]         }
[15:32:34.917]         else {
[15:32:34.917]             ...future.result["stdout"] <- base::list(NULL)
[15:32:34.917]         }
[15:32:34.917]         base::close(...future.stdout)
[15:32:34.917]         ...future.stdout <- NULL
[15:32:34.917]     }
[15:32:34.917]     ...future.result$conditions <- ...future.conditions
[15:32:34.917]     ...future.result$finished <- base::Sys.time()
[15:32:34.917]     ...future.result
[15:32:34.917] }
[15:32:34.926] Exporting 5 global objects (4.62 KiB) to cluster node #1 ...
[15:32:34.926] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ...
[15:32:34.927] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ... DONE
[15:32:34.928] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:34.928] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:34.929] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ...
[15:32:34.929] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ... DONE
[15:32:34.930] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:34.930] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:34.931] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:34.931] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:34.931] Exporting 5 global objects (4.62 KiB) to cluster node #1 ... DONE
[15:32:34.932] MultisessionFuture started
[15:32:34.933] - Launch lazy future ... done
[15:32:34.933] run() for 'MultisessionFuture' ... done
[15:32:34.933] Created future:
[15:32:34.962] receiveMessageFromWorker() for ClusterFuture ...
[15:32:34.963] - Validating connection of MultisessionFuture
[15:32:34.963] - received message: FutureResult
[15:32:34.964] - Received FutureResult
[15:32:34.964] - Erased future from FutureRegistry
[15:32:34.964] result() for ClusterFuture ...
[15:32:34.964] - result already collected: FutureResult
[15:32:34.965] result() for ClusterFuture ... done
[15:32:34.965] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:34.934] MultisessionFuture:
[15:32:34.934] Label: 'future_sapply-2'
[15:32:34.934] Expression:
[15:32:34.934] {
[15:32:34.934]     do.call(function(...) {
[15:32:34.934]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:34.934]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:34.934]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:34.934]             on.exit(options(oopts), add = TRUE)
[15:32:34.934]         }
[15:32:34.934]         {
[15:32:34.934]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:34.934]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:34.934]                 ...future.FUN(...future.X_jj, ...)
[15:32:34.934]             })
[15:32:34.934]         }
[15:32:34.934]     }, args = future.call.arguments)
[15:32:34.934] }
[15:32:34.934] Lazy evaluation: FALSE
[15:32:34.934] Asynchronous evaluation: TRUE
[15:32:34.934] Local evaluation: TRUE
[15:32:34.934] Environment: R_GlobalEnv
[15:32:34.934] Capture standard output: TRUE
[15:32:34.934] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:34.934] Globals: 5 objects totaling 4.78 KiB (function '...future.FUN' of 4.62 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:34.934] Packages: <none>
[15:32:34.934] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:34.934] Resolved: TRUE
[15:32:34.934] Value: <not collected>
[15:32:34.934] Conditions captured: <none>
[15:32:34.934] Early signaling: FALSE
[15:32:34.934] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:34.934] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:34.966] Chunk #2 of 2 ... DONE
[15:32:34.966] Launching 2 futures (chunks) ... DONE
[15:32:34.966] Resolving 2 futures (chunks) ...
[15:32:34.967] resolve() on list ...
[15:32:34.967]  recursive: 0
[15:32:34.967]  length: 2
[15:32:34.967] 
[15:32:34.968] Future #1
[15:32:34.968] result() for ClusterFuture ...
[15:32:34.968] - result already collected: FutureResult
[15:32:34.969] result() for ClusterFuture ... done
[15:32:34.969] result() for ClusterFuture ...
[15:32:34.969] - result already collected: FutureResult
[15:32:34.969] result() for ClusterFuture ... done
[15:32:34.970] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:34.970] - nx: 2
[15:32:34.970] - relay: TRUE
[15:32:34.971] - stdout: TRUE
[15:32:34.971] - signal: TRUE
[15:32:34.971] - resignal: FALSE
[15:32:34.971] - force: TRUE
[15:32:34.972] - relayed: [n=2] FALSE, FALSE
[15:32:34.972] - queued futures: [n=2] FALSE, FALSE
[15:32:34.972]  - until=1
[15:32:34.972]  - relaying element #1
[15:32:34.973] result() for ClusterFuture ...
[15:32:34.973] - result already collected: FutureResult
[15:32:34.973] result() for ClusterFuture ... done
[15:32:34.973] result() for ClusterFuture ...
[15:32:34.974] - result already collected: FutureResult
[15:32:34.974] result() for ClusterFuture ... done
[15:32:34.974] result() for ClusterFuture ...
[15:32:34.975] - result already collected: FutureResult
[15:32:34.975] result() for ClusterFuture ... done
[15:32:34.975] result() for ClusterFuture ...
[15:32:34.975] - result already collected: FutureResult
[15:32:34.976] result() for ClusterFuture ... done
[15:32:34.976] - relayed: [n=2] TRUE, FALSE
[15:32:34.976] - queued futures: [n=2] TRUE, FALSE
[15:32:34.976] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:34.977]  length: 1 (resolved future 1)
[15:32:34.977] Future #2
[15:32:34.977] result() for ClusterFuture ...
[15:32:34.978] - result already collected: FutureResult
[15:32:34.978] result() for ClusterFuture ... done
[15:32:34.978] result() for ClusterFuture ...
[15:32:34.978] - result already collected: FutureResult
[15:32:34.979] result() for ClusterFuture ... done
[15:32:34.979] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:34.979] - nx: 2
[15:32:34.979] - relay: TRUE
[15:32:34.980] - stdout: TRUE
[15:32:34.980] - signal: TRUE
[15:32:34.980] - resignal: FALSE
[15:32:34.980] - force: TRUE
[15:32:34.981] - relayed: [n=2] TRUE, FALSE
[15:32:34.981] - queued futures: [n=2] TRUE, FALSE
[15:32:34.981]  - until=2
[15:32:34.982]  - relaying element #2
[15:32:34.982] result() for ClusterFuture ...
[15:32:34.982] - result already collected: FutureResult
[15:32:34.982] result() for ClusterFuture ... done
[15:32:34.983] result() for ClusterFuture ...
[15:32:34.983] - result already collected: FutureResult
[15:32:34.983] result() for ClusterFuture ... done
[15:32:34.983] result() for ClusterFuture ...
[15:32:34.984] - result already collected: FutureResult
[15:32:34.984] result() for ClusterFuture ... done
[15:32:34.984] result() for ClusterFuture ...
[15:32:34.985] - result already collected: FutureResult
[15:32:34.985] result() for ClusterFuture ... done
[15:32:34.985] - relayed: [n=2] TRUE, TRUE
[15:32:34.985] - queued futures: [n=2] TRUE, TRUE
[15:32:34.986] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:34.986]  length: 0 (resolved future 2)
[15:32:34.986] Relaying remaining futures
[15:32:34.986] signalConditionsASAP(NULL, pos=0) ...
[15:32:34.987] - nx: 2
[15:32:34.987] - relay: TRUE
[15:32:34.987] - stdout: TRUE
[15:32:34.987] - signal: TRUE
[15:32:34.988] - resignal: FALSE
[15:32:34.988] - force: TRUE
[15:32:34.988] - relayed: [n=2] TRUE, TRUE
[15:32:34.988] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:34.989] - relayed: [n=2] TRUE, TRUE
[15:32:34.989] - queued futures: [n=2] TRUE, TRUE
[15:32:34.989] signalConditionsASAP(NULL, pos=0) ... done
[15:32:34.990] resolve() on list ... DONE
[15:32:34.990] result() for ClusterFuture ...
[15:32:34.990] - result already collected: FutureResult
[15:32:34.990] result() for ClusterFuture ... done
[15:32:34.991] result() for ClusterFuture ...
[15:32:34.991] - result already collected: FutureResult
[15:32:34.991] result() for ClusterFuture ... done
[15:32:34.992] result() for ClusterFuture ...
[15:32:34.992] - result already collected: FutureResult
[15:32:34.992] result() for ClusterFuture ... done
[15:32:34.992] result() for ClusterFuture ...
[15:32:34.993] - result already collected: FutureResult
[15:32:34.993] result() for ClusterFuture ... done
[15:32:34.993]  - Number of value chunks collected: 2
[15:32:34.993] Resolving 2 futures (chunks) ... DONE
[15:32:34.994] Reducing values from 2 chunks ...
[15:32:34.994]  - Number of values collected after concatenation: 6
[15:32:34.994]  - Number of values expected: 6
[15:32:34.995] Reducing values from 2 chunks ... DONE
[15:32:34.995] future_lapply() ... DONE
List of 2
 $ y0: num [1:3, 1:5, 1:6] 2 2 2 4 4 4 6 6 6 8 ...
  ..- attr(*, "dimnames")=List of 3
  .. ..$ : NULL
  .. ..$ : NULL
  .. ..$ : chr [1:6] "a1" "a2" "b1" "b2" ...
 $ y1: num [1:3, 1:5, 1:6] 2 2 2 4 4 4 6 6 6 8 ...
  ..- attr(*, "dimnames")=List of 3
  .. ..$ : NULL
  .. ..$ : NULL
  .. ..$ : chr [1:6] "a1" "a2" "b1" "b2" ...
[15:32:35.001] future_lapply() ...
[15:32:35.007] Number of chunks: 2
[15:32:35.007] getGlobalsAndPackagesXApply() ...
[15:32:35.007]  - future.globals: TRUE
[15:32:35.007] getGlobalsAndPackages() ...
[15:32:35.008] Searching for globals...
[15:32:35.010] - globals found: [1] 'FUN'
[15:32:35.010] Searching for globals ... DONE
[15:32:35.010] Resolving globals: FALSE
[15:32:35.011] The total size of the 1 globals is 848 bytes (848 bytes)
[15:32:35.012] The total size of the 1 globals exported for future expression ('FUN()') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:32:35.012] - globals: [1] 'FUN'
[15:32:35.012] 
[15:32:35.013] getGlobalsAndPackages() ... DONE
[15:32:35.013]  - globals found/used: [n=1] 'FUN'
[15:32:35.013]  - needed namespaces: [n=0] 
[15:32:35.013] Finding globals ... DONE
[15:32:35.014]  - use_args: TRUE
[15:32:35.014]  - Getting '...' globals ...
[15:32:35.015] resolve() on list ...
[15:32:35.015]  recursive: 0
[15:32:35.015]  length: 1
[15:32:35.016]  elements: '...'
[15:32:35.016]  length: 0 (resolved future 1)
[15:32:35.016] resolve() on list ... DONE
[15:32:35.016]    - '...' content: [n=0] 
[15:32:35.017] List of 1
[15:32:35.017]  $ ...: list()
[15:32:35.017]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:35.017]  - attr(*, "where")=List of 1
[15:32:35.017]   ..$ ...:<environment: 0x00000276de923098> 
[15:32:35.017]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:35.017]  - attr(*, "resolved")= logi TRUE
[15:32:35.017]  - attr(*, "total_size")= num NA
[15:32:35.022]  - Getting '...' globals ... DONE
[15:32:35.022] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:35.022] List of 2
[15:32:35.022]  $ ...future.FUN:function (x)  
[15:32:35.022]  $ ...          : list()
[15:32:35.022]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:35.022]  - attr(*, "where")=List of 2
[15:32:35.022]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:35.022]   ..$ ...          :<environment: 0x00000276de923098> 
[15:32:35.022]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:35.022]  - attr(*, "resolved")= logi FALSE
[15:32:35.022]  - attr(*, "total_size")= num 848
[15:32:35.028] Packages to be attached in all futures: [n=0] 
[15:32:35.028] getGlobalsAndPackagesXApply() ... DONE
[15:32:35.028] Number of futures (= number of chunks): 2
[15:32:35.029] Launching 2 futures (chunks) ...
[15:32:35.029] Chunk #1 of 2 ...
[15:32:35.029]  - Finding globals in 'X' for chunk #1 ...
[15:32:35.030] getGlobalsAndPackages() ...
[15:32:35.030] Searching for globals...
[15:32:35.030] 
[15:32:35.031] Searching for globals ... DONE
[15:32:35.031] - globals: [0] <none>
[15:32:35.031] getGlobalsAndPackages() ... DONE
[15:32:35.031]    + additional globals found: [n=0] 
[15:32:35.032]    + additional namespaces needed: [n=0] 
[15:32:35.032]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:35.032]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:35.033]  - seeds: <none>
[15:32:35.033]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:35.033] getGlobalsAndPackages() ...
[15:32:35.033] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:35.034] Resolving globals: FALSE
[15:32:35.034] Tweak future expression to call with '...' arguments ...
[15:32:35.034] {
[15:32:35.034]     do.call(function(...) {
[15:32:35.034]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:35.034]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:35.034]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:35.034]             on.exit(options(oopts), add = TRUE)
[15:32:35.034]         }
[15:32:35.034]         {
[15:32:35.034]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:35.034]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:35.034]                 ...future.FUN(...future.X_jj, ...)
[15:32:35.034]             })
[15:32:35.034]         }
[15:32:35.034]     }, args = future.call.arguments)
[15:32:35.034] }
[15:32:35.035] Tweak future expression to call with '...' arguments ... DONE
[15:32:35.036] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:35.036] 
[15:32:35.037] getGlobalsAndPackages() ... DONE
[15:32:35.037] run() for 'Future' ...
[15:32:35.038] - state: 'created'
[15:32:35.038] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:35.057] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:35.058] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:35.058]   - Field: 'node'
[15:32:35.058]   - Field: 'label'
[15:32:35.059]   - Field: 'local'
[15:32:35.059]   - Field: 'owner'
[15:32:35.059]   - Field: 'envir'
[15:32:35.060]   - Field: 'workers'
[15:32:35.060]   - Field: 'packages'
[15:32:35.060]   - Field: 'gc'
[15:32:35.060]   - Field: 'conditions'
[15:32:35.061]   - Field: 'persistent'
[15:32:35.061]   - Field: 'expr'
[15:32:35.061]   - Field: 'uuid'
[15:32:35.062]   - Field: 'seed'
[15:32:35.062]   - Field: 'version'
[15:32:35.062]   - Field: 'result'
[15:32:35.062]   - Field: 'asynchronous'
[15:32:35.063]   - Field: 'calls'
[15:32:35.063]   - Field: 'globals'
[15:32:35.063]   - Field: 'stdout'
[15:32:35.063]   - Field: 'earlySignal'
[15:32:35.063]   - Field: 'lazy'
[15:32:35.064]   - Field: 'state'
[15:32:35.064] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:35.064] - Launch lazy future ...
[15:32:35.064] Packages needed by the future expression (n = 0): <none>
[15:32:35.065] Packages needed by future strategies (n = 0): <none>
[15:32:35.065] {
[15:32:35.065]     {
[15:32:35.065]         {
[15:32:35.065]             ...future.startTime <- base::Sys.time()
[15:32:35.065]             {
[15:32:35.065]                 {
[15:32:35.065]                   {
[15:32:35.065]                     {
[15:32:35.065]                       base::local({
[15:32:35.065]                         has_future <- base::requireNamespace("future", 
[15:32:35.065]                           quietly = TRUE)
[15:32:35.065]                         if (has_future) {
[15:32:35.065]                           ns <- base::getNamespace("future")
[15:32:35.065]                           version <- ns[[".package"]][["version"]]
[15:32:35.065]                           if (is.null(version)) 
[15:32:35.065]                             version <- utils::packageVersion("future")
[15:32:35.065]                         }
[15:32:35.065]                         else {
[15:32:35.065]                           version <- NULL
[15:32:35.065]                         }
[15:32:35.065]                         if (!has_future || version < "1.8.0") {
[15:32:35.065]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:35.065]                             "", base::R.version$version.string), 
[15:32:35.065]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:35.065]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:35.065]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:35.065]                               "release", "version")], collapse = " "), 
[15:32:35.065]                             hostname = base::Sys.info()[["nodename"]])
[15:32:35.065]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:35.065]                             info)
[15:32:35.065]                           info <- base::paste(info, collapse = "; ")
[15:32:35.065]                           if (!has_future) {
[15:32:35.065]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:35.065]                               info)
[15:32:35.065]                           }
[15:32:35.065]                           else {
[15:32:35.065]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:35.065]                               info, version)
[15:32:35.065]                           }
[15:32:35.065]                           base::stop(msg)
[15:32:35.065]                         }
[15:32:35.065]                       })
[15:32:35.065]                     }
[15:32:35.065]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:35.065]                     base::options(mc.cores = 1L)
[15:32:35.065]                   }
[15:32:35.065]                   ...future.strategy.old <- future::plan("list")
[15:32:35.065]                   options(future.plan = NULL)
[15:32:35.065]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:35.065]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:35.065]                 }
[15:32:35.065]                 ...future.workdir <- getwd()
[15:32:35.065]             }
[15:32:35.065]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:35.065]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:35.065]         }
[15:32:35.065]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:35.065]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:35.065]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:35.065]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:35.065]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:35.065]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:35.065]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:35.065]             base::names(...future.oldOptions))
[15:32:35.065]     }
[15:32:35.065]     if (FALSE) {
[15:32:35.065]     }
[15:32:35.065]     else {
[15:32:35.065]         if (TRUE) {
[15:32:35.065]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:35.065]                 open = "w")
[15:32:35.065]         }
[15:32:35.065]         else {
[15:32:35.065]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:35.065]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:35.065]         }
[15:32:35.065]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:35.065]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:35.065]             base::sink(type = "output", split = FALSE)
[15:32:35.065]             base::close(...future.stdout)
[15:32:35.065]         }, add = TRUE)
[15:32:35.065]     }
[15:32:35.065]     ...future.frame <- base::sys.nframe()
[15:32:35.065]     ...future.conditions <- base::list()
[15:32:35.065]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:35.065]     if (FALSE) {
[15:32:35.065]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:35.065]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:35.065]     }
[15:32:35.065]     ...future.result <- base::tryCatch({
[15:32:35.065]         base::withCallingHandlers({
[15:32:35.065]             ...future.value <- base::withVisible(base::local({
[15:32:35.065]                 ...future.makeSendCondition <- base::local({
[15:32:35.065]                   sendCondition <- NULL
[15:32:35.065]                   function(frame = 1L) {
[15:32:35.065]                     if (is.function(sendCondition)) 
[15:32:35.065]                       return(sendCondition)
[15:32:35.065]                     ns <- getNamespace("parallel")
[15:32:35.065]                     if (exists("sendData", mode = "function", 
[15:32:35.065]                       envir = ns)) {
[15:32:35.065]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:35.065]                         envir = ns)
[15:32:35.065]                       envir <- sys.frame(frame)
[15:32:35.065]                       master <- NULL
[15:32:35.065]                       while (!identical(envir, .GlobalEnv) && 
[15:32:35.065]                         !identical(envir, emptyenv())) {
[15:32:35.065]                         if (exists("master", mode = "list", envir = envir, 
[15:32:35.065]                           inherits = FALSE)) {
[15:32:35.065]                           master <- get("master", mode = "list", 
[15:32:35.065]                             envir = envir, inherits = FALSE)
[15:32:35.065]                           if (inherits(master, c("SOCKnode", 
[15:32:35.065]                             "SOCK0node"))) {
[15:32:35.065]                             sendCondition <<- function(cond) {
[15:32:35.065]                               data <- list(type = "VALUE", value = cond, 
[15:32:35.065]                                 success = TRUE)
[15:32:35.065]                               parallel_sendData(master, data)
[15:32:35.065]                             }
[15:32:35.065]                             return(sendCondition)
[15:32:35.065]                           }
[15:32:35.065]                         }
[15:32:35.065]                         frame <- frame + 1L
[15:32:35.065]                         envir <- sys.frame(frame)
[15:32:35.065]                       }
[15:32:35.065]                     }
[15:32:35.065]                     sendCondition <<- function(cond) NULL
[15:32:35.065]                   }
[15:32:35.065]                 })
[15:32:35.065]                 withCallingHandlers({
[15:32:35.065]                   {
[15:32:35.065]                     do.call(function(...) {
[15:32:35.065]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:35.065]                       if (!identical(...future.globals.maxSize.org, 
[15:32:35.065]                         ...future.globals.maxSize)) {
[15:32:35.065]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:35.065]                         on.exit(options(oopts), add = TRUE)
[15:32:35.065]                       }
[15:32:35.065]                       {
[15:32:35.065]                         lapply(seq_along(...future.elements_ii), 
[15:32:35.065]                           FUN = function(jj) {
[15:32:35.065]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:35.065]                             ...future.FUN(...future.X_jj, ...)
[15:32:35.065]                           })
[15:32:35.065]                       }
[15:32:35.065]                     }, args = future.call.arguments)
[15:32:35.065]                   }
[15:32:35.065]                 }, immediateCondition = function(cond) {
[15:32:35.065]                   sendCondition <- ...future.makeSendCondition()
[15:32:35.065]                   sendCondition(cond)
[15:32:35.065]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:35.065]                   {
[15:32:35.065]                     inherits <- base::inherits
[15:32:35.065]                     invokeRestart <- base::invokeRestart
[15:32:35.065]                     is.null <- base::is.null
[15:32:35.065]                     muffled <- FALSE
[15:32:35.065]                     if (inherits(cond, "message")) {
[15:32:35.065]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:35.065]                       if (muffled) 
[15:32:35.065]                         invokeRestart("muffleMessage")
[15:32:35.065]                     }
[15:32:35.065]                     else if (inherits(cond, "warning")) {
[15:32:35.065]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:35.065]                       if (muffled) 
[15:32:35.065]                         invokeRestart("muffleWarning")
[15:32:35.065]                     }
[15:32:35.065]                     else if (inherits(cond, "condition")) {
[15:32:35.065]                       if (!is.null(pattern)) {
[15:32:35.065]                         computeRestarts <- base::computeRestarts
[15:32:35.065]                         grepl <- base::grepl
[15:32:35.065]                         restarts <- computeRestarts(cond)
[15:32:35.065]                         for (restart in restarts) {
[15:32:35.065]                           name <- restart$name
[15:32:35.065]                           if (is.null(name)) 
[15:32:35.065]                             next
[15:32:35.065]                           if (!grepl(pattern, name)) 
[15:32:35.065]                             next
[15:32:35.065]                           invokeRestart(restart)
[15:32:35.065]                           muffled <- TRUE
[15:32:35.065]                           break
[15:32:35.065]                         }
[15:32:35.065]                       }
[15:32:35.065]                     }
[15:32:35.065]                     invisible(muffled)
[15:32:35.065]                   }
[15:32:35.065]                   muffleCondition(cond)
[15:32:35.065]                 })
[15:32:35.065]             }))
[15:32:35.065]             future::FutureResult(value = ...future.value$value, 
[15:32:35.065]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:35.065]                   ...future.rng), globalenv = if (FALSE) 
[15:32:35.065]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:35.065]                     ...future.globalenv.names))
[15:32:35.065]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:35.065]         }, condition = base::local({
[15:32:35.065]             c <- base::c
[15:32:35.065]             inherits <- base::inherits
[15:32:35.065]             invokeRestart <- base::invokeRestart
[15:32:35.065]             length <- base::length
[15:32:35.065]             list <- base::list
[15:32:35.065]             seq.int <- base::seq.int
[15:32:35.065]             signalCondition <- base::signalCondition
[15:32:35.065]             sys.calls <- base::sys.calls
[15:32:35.065]             `[[` <- base::`[[`
[15:32:35.065]             `+` <- base::`+`
[15:32:35.065]             `<<-` <- base::`<<-`
[15:32:35.065]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:35.065]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:35.065]                   3L)]
[15:32:35.065]             }
[15:32:35.065]             function(cond) {
[15:32:35.065]                 is_error <- inherits(cond, "error")
[15:32:35.065]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:35.065]                   NULL)
[15:32:35.065]                 if (is_error) {
[15:32:35.065]                   sessionInformation <- function() {
[15:32:35.065]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:35.065]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:35.065]                       search = base::search(), system = base::Sys.info())
[15:32:35.065]                   }
[15:32:35.065]                   ...future.conditions[[length(...future.conditions) + 
[15:32:35.065]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:35.065]                     cond$call), session = sessionInformation(), 
[15:32:35.065]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:35.065]                   signalCondition(cond)
[15:32:35.065]                 }
[15:32:35.065]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:35.065]                 "immediateCondition"))) {
[15:32:35.065]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:35.065]                   ...future.conditions[[length(...future.conditions) + 
[15:32:35.065]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:35.065]                   if (TRUE && !signal) {
[15:32:35.065]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:35.065]                     {
[15:32:35.065]                       inherits <- base::inherits
[15:32:35.065]                       invokeRestart <- base::invokeRestart
[15:32:35.065]                       is.null <- base::is.null
[15:32:35.065]                       muffled <- FALSE
[15:32:35.065]                       if (inherits(cond, "message")) {
[15:32:35.065]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:35.065]                         if (muffled) 
[15:32:35.065]                           invokeRestart("muffleMessage")
[15:32:35.065]                       }
[15:32:35.065]                       else if (inherits(cond, "warning")) {
[15:32:35.065]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:35.065]                         if (muffled) 
[15:32:35.065]                           invokeRestart("muffleWarning")
[15:32:35.065]                       }
[15:32:35.065]                       else if (inherits(cond, "condition")) {
[15:32:35.065]                         if (!is.null(pattern)) {
[15:32:35.065]                           computeRestarts <- base::computeRestarts
[15:32:35.065]                           grepl <- base::grepl
[15:32:35.065]                           restarts <- computeRestarts(cond)
[15:32:35.065]                           for (restart in restarts) {
[15:32:35.065]                             name <- restart$name
[15:32:35.065]                             if (is.null(name)) 
[15:32:35.065]                               next
[15:32:35.065]                             if (!grepl(pattern, name)) 
[15:32:35.065]                               next
[15:32:35.065]                             invokeRestart(restart)
[15:32:35.065]                             muffled <- TRUE
[15:32:35.065]                             break
[15:32:35.065]                           }
[15:32:35.065]                         }
[15:32:35.065]                       }
[15:32:35.065]                       invisible(muffled)
[15:32:35.065]                     }
[15:32:35.065]                     muffleCondition(cond, pattern = "^muffle")
[15:32:35.065]                   }
[15:32:35.065]                 }
[15:32:35.065]                 else {
[15:32:35.065]                   if (TRUE) {
[15:32:35.065]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:35.065]                     {
[15:32:35.065]                       inherits <- base::inherits
[15:32:35.065]                       invokeRestart <- base::invokeRestart
[15:32:35.065]                       is.null <- base::is.null
[15:32:35.065]                       muffled <- FALSE
[15:32:35.065]                       if (inherits(cond, "message")) {
[15:32:35.065]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:35.065]                         if (muffled) 
[15:32:35.065]                           invokeRestart("muffleMessage")
[15:32:35.065]                       }
[15:32:35.065]                       else if (inherits(cond, "warning")) {
[15:32:35.065]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:35.065]                         if (muffled) 
[15:32:35.065]                           invokeRestart("muffleWarning")
[15:32:35.065]                       }
[15:32:35.065]                       else if (inherits(cond, "condition")) {
[15:32:35.065]                         if (!is.null(pattern)) {
[15:32:35.065]                           computeRestarts <- base::computeRestarts
[15:32:35.065]                           grepl <- base::grepl
[15:32:35.065]                           restarts <- computeRestarts(cond)
[15:32:35.065]                           for (restart in restarts) {
[15:32:35.065]                             name <- restart$name
[15:32:35.065]                             if (is.null(name)) 
[15:32:35.065]                               next
[15:32:35.065]                             if (!grepl(pattern, name)) 
[15:32:35.065]                               next
[15:32:35.065]                             invokeRestart(restart)
[15:32:35.065]                             muffled <- TRUE
[15:32:35.065]                             break
[15:32:35.065]                           }
[15:32:35.065]                         }
[15:32:35.065]                       }
[15:32:35.065]                       invisible(muffled)
[15:32:35.065]                     }
[15:32:35.065]                     muffleCondition(cond, pattern = "^muffle")
[15:32:35.065]                   }
[15:32:35.065]                 }
[15:32:35.065]             }
[15:32:35.065]         }))
[15:32:35.065]     }, error = function(ex) {
[15:32:35.065]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:35.065]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:35.065]                 ...future.rng), started = ...future.startTime, 
[15:32:35.065]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:35.065]             version = "1.8"), class = "FutureResult")
[15:32:35.065]     }, finally = {
[15:32:35.065]         if (!identical(...future.workdir, getwd())) 
[15:32:35.065]             setwd(...future.workdir)
[15:32:35.065]         {
[15:32:35.065]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:35.065]                 ...future.oldOptions$nwarnings <- NULL
[15:32:35.065]             }
[15:32:35.065]             base::options(...future.oldOptions)
[15:32:35.065]             if (.Platform$OS.type == "windows") {
[15:32:35.065]                 old_names <- names(...future.oldEnvVars)
[15:32:35.065]                 envs <- base::Sys.getenv()
[15:32:35.065]                 names <- names(envs)
[15:32:35.065]                 common <- intersect(names, old_names)
[15:32:35.065]                 added <- setdiff(names, old_names)
[15:32:35.065]                 removed <- setdiff(old_names, names)
[15:32:35.065]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:35.065]                   envs[common]]
[15:32:35.065]                 NAMES <- toupper(changed)
[15:32:35.065]                 args <- list()
[15:32:35.065]                 for (kk in seq_along(NAMES)) {
[15:32:35.065]                   name <- changed[[kk]]
[15:32:35.065]                   NAME <- NAMES[[kk]]
[15:32:35.065]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:35.065]                     next
[15:32:35.065]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:35.065]                 }
[15:32:35.065]                 NAMES <- toupper(added)
[15:32:35.065]                 for (kk in seq_along(NAMES)) {
[15:32:35.065]                   name <- added[[kk]]
[15:32:35.065]                   NAME <- NAMES[[kk]]
[15:32:35.065]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:35.065]                     next
[15:32:35.065]                   args[[name]] <- ""
[15:32:35.065]                 }
[15:32:35.065]                 NAMES <- toupper(removed)
[15:32:35.065]                 for (kk in seq_along(NAMES)) {
[15:32:35.065]                   name <- removed[[kk]]
[15:32:35.065]                   NAME <- NAMES[[kk]]
[15:32:35.065]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:35.065]                     next
[15:32:35.065]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:35.065]                 }
[15:32:35.065]                 if (length(args) > 0) 
[15:32:35.065]                   base::do.call(base::Sys.setenv, args = args)
[15:32:35.065]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:35.065]             }
[15:32:35.065]             else {
[15:32:35.065]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:35.065]             }
[15:32:35.065]             {
[15:32:35.065]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:35.065]                   0L) {
[15:32:35.065]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:35.065]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:35.065]                   base::options(opts)
[15:32:35.065]                 }
[15:32:35.065]                 {
[15:32:35.065]                   {
[15:32:35.065]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:35.065]                     NULL
[15:32:35.065]                   }
[15:32:35.065]                   options(future.plan = NULL)
[15:32:35.065]                   if (is.na(NA_character_)) 
[15:32:35.065]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:35.065]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:35.065]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:35.065]                     .init = FALSE)
[15:32:35.065]                 }
[15:32:35.065]             }
[15:32:35.065]         }
[15:32:35.065]     })
[15:32:35.065]     if (TRUE) {
[15:32:35.065]         base::sink(type = "output", split = FALSE)
[15:32:35.065]         if (TRUE) {
[15:32:35.065]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:35.065]         }
[15:32:35.065]         else {
[15:32:35.065]             ...future.result["stdout"] <- base::list(NULL)
[15:32:35.065]         }
[15:32:35.065]         base::close(...future.stdout)
[15:32:35.065]         ...future.stdout <- NULL
[15:32:35.065]     }
[15:32:35.065]     ...future.result$conditions <- ...future.conditions
[15:32:35.065]     ...future.result$finished <- base::Sys.time()
[15:32:35.065]     ...future.result
[15:32:35.065] }
[15:32:35.072] Exporting 5 global objects (848 bytes) to cluster node #1 ...
[15:32:35.073] Exporting '...future.FUN' (848 bytes) to cluster node #1 ...
[15:32:35.073] Exporting '...future.FUN' (848 bytes) to cluster node #1 ... DONE
[15:32:35.074] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:35.075] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:35.075] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:35.076] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:35.077] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:35.078] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:35.078] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:35.079] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:35.079] Exporting 5 global objects (848 bytes) to cluster node #1 ... DONE
[15:32:35.080] MultisessionFuture started
[15:32:35.081] - Launch lazy future ... done
[15:32:35.081] run() for 'MultisessionFuture' ... done
[15:32:35.081] Created future:
[15:32:35.114] receiveMessageFromWorker() for ClusterFuture ...
[15:32:35.115] - Validating connection of MultisessionFuture
[15:32:35.115] - received message: FutureResult
[15:32:35.116] - Received FutureResult
[15:32:35.116] - Erased future from FutureRegistry
[15:32:35.116] result() for ClusterFuture ...
[15:32:35.116] - result already collected: FutureResult
[15:32:35.117] result() for ClusterFuture ... done
[15:32:35.117] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:35.082] MultisessionFuture:
[15:32:35.082] Label: 'future_sapply-1'
[15:32:35.082] Expression:
[15:32:35.082] {
[15:32:35.082]     do.call(function(...) {
[15:32:35.082]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:35.082]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:35.082]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:35.082]             on.exit(options(oopts), add = TRUE)
[15:32:35.082]         }
[15:32:35.082]         {
[15:32:35.082]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:35.082]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:35.082]                 ...future.FUN(...future.X_jj, ...)
[15:32:35.082]             })
[15:32:35.082]         }
[15:32:35.082]     }, args = future.call.arguments)
[15:32:35.082] }
[15:32:35.082] Lazy evaluation: FALSE
[15:32:35.082] Asynchronous evaluation: TRUE
[15:32:35.082] Local evaluation: TRUE
[15:32:35.082] Environment: R_GlobalEnv
[15:32:35.082] Capture standard output: TRUE
[15:32:35.082] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:35.082] Globals: 5 objects totaling 960 bytes (function '...future.FUN' of 848 bytes, 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)
[15:32:35.082] Packages: <none>
[15:32:35.082] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:35.082] Resolved: TRUE
[15:32:35.082] Value: <not collected>
[15:32:35.082] Conditions captured: <none>
[15:32:35.082] Early signaling: FALSE
[15:32:35.082] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:35.082] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:35.118] Chunk #1 of 2 ... DONE
[15:32:35.118] Chunk #2 of 2 ...
[15:32:35.118]  - Finding globals in 'X' for chunk #2 ...
[15:32:35.119] getGlobalsAndPackages() ...
[15:32:35.119] Searching for globals...
[15:32:35.119] 
[15:32:35.120] Searching for globals ... DONE
[15:32:35.120] - globals: [0] <none>
[15:32:35.120] getGlobalsAndPackages() ... DONE
[15:32:35.120]    + additional globals found: [n=0] 
[15:32:35.121]    + additional namespaces needed: [n=0] 
[15:32:35.121]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:35.121]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:35.121]  - seeds: <none>
[15:32:35.122]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:35.122] getGlobalsAndPackages() ...
[15:32:35.122] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:35.122] Resolving globals: FALSE
[15:32:35.123] Tweak future expression to call with '...' arguments ...
[15:32:35.123] {
[15:32:35.123]     do.call(function(...) {
[15:32:35.123]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:35.123]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:35.123]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:35.123]             on.exit(options(oopts), add = TRUE)
[15:32:35.123]         }
[15:32:35.123]         {
[15:32:35.123]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:35.123]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:35.123]                 ...future.FUN(...future.X_jj, ...)
[15:32:35.123]             })
[15:32:35.123]         }
[15:32:35.123]     }, args = future.call.arguments)
[15:32:35.123] }
[15:32:35.124] Tweak future expression to call with '...' arguments ... DONE
[15:32:35.125] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:35.125] 
[15:32:35.125] getGlobalsAndPackages() ... DONE
[15:32:35.126] run() for 'Future' ...
[15:32:35.126] - state: 'created'
[15:32:35.126] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:35.144] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:35.145] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:35.145]   - Field: 'node'
[15:32:35.145]   - Field: 'label'
[15:32:35.146]   - Field: 'local'
[15:32:35.146]   - Field: 'owner'
[15:32:35.146]   - Field: 'envir'
[15:32:35.146]   - Field: 'workers'
[15:32:35.147]   - Field: 'packages'
[15:32:35.147]   - Field: 'gc'
[15:32:35.147]   - Field: 'conditions'
[15:32:35.147]   - Field: 'persistent'
[15:32:35.148]   - Field: 'expr'
[15:32:35.148]   - Field: 'uuid'
[15:32:35.148]   - Field: 'seed'
[15:32:35.148]   - Field: 'version'
[15:32:35.149]   - Field: 'result'
[15:32:35.149]   - Field: 'asynchronous'
[15:32:35.149]   - Field: 'calls'
[15:32:35.149]   - Field: 'globals'
[15:32:35.150]   - Field: 'stdout'
[15:32:35.150]   - Field: 'earlySignal'
[15:32:35.150]   - Field: 'lazy'
[15:32:35.150]   - Field: 'state'
[15:32:35.151] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:35.151] - Launch lazy future ...
[15:32:35.158] Packages needed by the future expression (n = 0): <none>
[15:32:35.158] Packages needed by future strategies (n = 0): <none>
[15:32:35.159] {
[15:32:35.159]     {
[15:32:35.159]         {
[15:32:35.159]             ...future.startTime <- base::Sys.time()
[15:32:35.159]             {
[15:32:35.159]                 {
[15:32:35.159]                   {
[15:32:35.159]                     {
[15:32:35.159]                       base::local({
[15:32:35.159]                         has_future <- base::requireNamespace("future", 
[15:32:35.159]                           quietly = TRUE)
[15:32:35.159]                         if (has_future) {
[15:32:35.159]                           ns <- base::getNamespace("future")
[15:32:35.159]                           version <- ns[[".package"]][["version"]]
[15:32:35.159]                           if (is.null(version)) 
[15:32:35.159]                             version <- utils::packageVersion("future")
[15:32:35.159]                         }
[15:32:35.159]                         else {
[15:32:35.159]                           version <- NULL
[15:32:35.159]                         }
[15:32:35.159]                         if (!has_future || version < "1.8.0") {
[15:32:35.159]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:35.159]                             "", base::R.version$version.string), 
[15:32:35.159]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:35.159]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:35.159]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:35.159]                               "release", "version")], collapse = " "), 
[15:32:35.159]                             hostname = base::Sys.info()[["nodename"]])
[15:32:35.159]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:35.159]                             info)
[15:32:35.159]                           info <- base::paste(info, collapse = "; ")
[15:32:35.159]                           if (!has_future) {
[15:32:35.159]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:35.159]                               info)
[15:32:35.159]                           }
[15:32:35.159]                           else {
[15:32:35.159]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:35.159]                               info, version)
[15:32:35.159]                           }
[15:32:35.159]                           base::stop(msg)
[15:32:35.159]                         }
[15:32:35.159]                       })
[15:32:35.159]                     }
[15:32:35.159]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:35.159]                     base::options(mc.cores = 1L)
[15:32:35.159]                   }
[15:32:35.159]                   ...future.strategy.old <- future::plan("list")
[15:32:35.159]                   options(future.plan = NULL)
[15:32:35.159]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:35.159]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:35.159]                 }
[15:32:35.159]                 ...future.workdir <- getwd()
[15:32:35.159]             }
[15:32:35.159]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:35.159]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:35.159]         }
[15:32:35.159]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:35.159]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:35.159]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:35.159]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:35.159]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:35.159]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:35.159]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:35.159]             base::names(...future.oldOptions))
[15:32:35.159]     }
[15:32:35.159]     if (FALSE) {
[15:32:35.159]     }
[15:32:35.159]     else {
[15:32:35.159]         if (TRUE) {
[15:32:35.159]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:35.159]                 open = "w")
[15:32:35.159]         }
[15:32:35.159]         else {
[15:32:35.159]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:35.159]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:35.159]         }
[15:32:35.159]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:35.159]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:35.159]             base::sink(type = "output", split = FALSE)
[15:32:35.159]             base::close(...future.stdout)
[15:32:35.159]         }, add = TRUE)
[15:32:35.159]     }
[15:32:35.159]     ...future.frame <- base::sys.nframe()
[15:32:35.159]     ...future.conditions <- base::list()
[15:32:35.159]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:35.159]     if (FALSE) {
[15:32:35.159]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:35.159]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:35.159]     }
[15:32:35.159]     ...future.result <- base::tryCatch({
[15:32:35.159]         base::withCallingHandlers({
[15:32:35.159]             ...future.value <- base::withVisible(base::local({
[15:32:35.159]                 ...future.makeSendCondition <- base::local({
[15:32:35.159]                   sendCondition <- NULL
[15:32:35.159]                   function(frame = 1L) {
[15:32:35.159]                     if (is.function(sendCondition)) 
[15:32:35.159]                       return(sendCondition)
[15:32:35.159]                     ns <- getNamespace("parallel")
[15:32:35.159]                     if (exists("sendData", mode = "function", 
[15:32:35.159]                       envir = ns)) {
[15:32:35.159]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:35.159]                         envir = ns)
[15:32:35.159]                       envir <- sys.frame(frame)
[15:32:35.159]                       master <- NULL
[15:32:35.159]                       while (!identical(envir, .GlobalEnv) && 
[15:32:35.159]                         !identical(envir, emptyenv())) {
[15:32:35.159]                         if (exists("master", mode = "list", envir = envir, 
[15:32:35.159]                           inherits = FALSE)) {
[15:32:35.159]                           master <- get("master", mode = "list", 
[15:32:35.159]                             envir = envir, inherits = FALSE)
[15:32:35.159]                           if (inherits(master, c("SOCKnode", 
[15:32:35.159]                             "SOCK0node"))) {
[15:32:35.159]                             sendCondition <<- function(cond) {
[15:32:35.159]                               data <- list(type = "VALUE", value = cond, 
[15:32:35.159]                                 success = TRUE)
[15:32:35.159]                               parallel_sendData(master, data)
[15:32:35.159]                             }
[15:32:35.159]                             return(sendCondition)
[15:32:35.159]                           }
[15:32:35.159]                         }
[15:32:35.159]                         frame <- frame + 1L
[15:32:35.159]                         envir <- sys.frame(frame)
[15:32:35.159]                       }
[15:32:35.159]                     }
[15:32:35.159]                     sendCondition <<- function(cond) NULL
[15:32:35.159]                   }
[15:32:35.159]                 })
[15:32:35.159]                 withCallingHandlers({
[15:32:35.159]                   {
[15:32:35.159]                     do.call(function(...) {
[15:32:35.159]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:35.159]                       if (!identical(...future.globals.maxSize.org, 
[15:32:35.159]                         ...future.globals.maxSize)) {
[15:32:35.159]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:35.159]                         on.exit(options(oopts), add = TRUE)
[15:32:35.159]                       }
[15:32:35.159]                       {
[15:32:35.159]                         lapply(seq_along(...future.elements_ii), 
[15:32:35.159]                           FUN = function(jj) {
[15:32:35.159]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:35.159]                             ...future.FUN(...future.X_jj, ...)
[15:32:35.159]                           })
[15:32:35.159]                       }
[15:32:35.159]                     }, args = future.call.arguments)
[15:32:35.159]                   }
[15:32:35.159]                 }, immediateCondition = function(cond) {
[15:32:35.159]                   sendCondition <- ...future.makeSendCondition()
[15:32:35.159]                   sendCondition(cond)
[15:32:35.159]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:35.159]                   {
[15:32:35.159]                     inherits <- base::inherits
[15:32:35.159]                     invokeRestart <- base::invokeRestart
[15:32:35.159]                     is.null <- base::is.null
[15:32:35.159]                     muffled <- FALSE
[15:32:35.159]                     if (inherits(cond, "message")) {
[15:32:35.159]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:35.159]                       if (muffled) 
[15:32:35.159]                         invokeRestart("muffleMessage")
[15:32:35.159]                     }
[15:32:35.159]                     else if (inherits(cond, "warning")) {
[15:32:35.159]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:35.159]                       if (muffled) 
[15:32:35.159]                         invokeRestart("muffleWarning")
[15:32:35.159]                     }
[15:32:35.159]                     else if (inherits(cond, "condition")) {
[15:32:35.159]                       if (!is.null(pattern)) {
[15:32:35.159]                         computeRestarts <- base::computeRestarts
[15:32:35.159]                         grepl <- base::grepl
[15:32:35.159]                         restarts <- computeRestarts(cond)
[15:32:35.159]                         for (restart in restarts) {
[15:32:35.159]                           name <- restart$name
[15:32:35.159]                           if (is.null(name)) 
[15:32:35.159]                             next
[15:32:35.159]                           if (!grepl(pattern, name)) 
[15:32:35.159]                             next
[15:32:35.159]                           invokeRestart(restart)
[15:32:35.159]                           muffled <- TRUE
[15:32:35.159]                           break
[15:32:35.159]                         }
[15:32:35.159]                       }
[15:32:35.159]                     }
[15:32:35.159]                     invisible(muffled)
[15:32:35.159]                   }
[15:32:35.159]                   muffleCondition(cond)
[15:32:35.159]                 })
[15:32:35.159]             }))
[15:32:35.159]             future::FutureResult(value = ...future.value$value, 
[15:32:35.159]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:35.159]                   ...future.rng), globalenv = if (FALSE) 
[15:32:35.159]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:35.159]                     ...future.globalenv.names))
[15:32:35.159]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:35.159]         }, condition = base::local({
[15:32:35.159]             c <- base::c
[15:32:35.159]             inherits <- base::inherits
[15:32:35.159]             invokeRestart <- base::invokeRestart
[15:32:35.159]             length <- base::length
[15:32:35.159]             list <- base::list
[15:32:35.159]             seq.int <- base::seq.int
[15:32:35.159]             signalCondition <- base::signalCondition
[15:32:35.159]             sys.calls <- base::sys.calls
[15:32:35.159]             `[[` <- base::`[[`
[15:32:35.159]             `+` <- base::`+`
[15:32:35.159]             `<<-` <- base::`<<-`
[15:32:35.159]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:35.159]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:35.159]                   3L)]
[15:32:35.159]             }
[15:32:35.159]             function(cond) {
[15:32:35.159]                 is_error <- inherits(cond, "error")
[15:32:35.159]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:35.159]                   NULL)
[15:32:35.159]                 if (is_error) {
[15:32:35.159]                   sessionInformation <- function() {
[15:32:35.159]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:35.159]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:35.159]                       search = base::search(), system = base::Sys.info())
[15:32:35.159]                   }
[15:32:35.159]                   ...future.conditions[[length(...future.conditions) + 
[15:32:35.159]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:35.159]                     cond$call), session = sessionInformation(), 
[15:32:35.159]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:35.159]                   signalCondition(cond)
[15:32:35.159]                 }
[15:32:35.159]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:35.159]                 "immediateCondition"))) {
[15:32:35.159]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:35.159]                   ...future.conditions[[length(...future.conditions) + 
[15:32:35.159]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:35.159]                   if (TRUE && !signal) {
[15:32:35.159]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:35.159]                     {
[15:32:35.159]                       inherits <- base::inherits
[15:32:35.159]                       invokeRestart <- base::invokeRestart
[15:32:35.159]                       is.null <- base::is.null
[15:32:35.159]                       muffled <- FALSE
[15:32:35.159]                       if (inherits(cond, "message")) {
[15:32:35.159]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:35.159]                         if (muffled) 
[15:32:35.159]                           invokeRestart("muffleMessage")
[15:32:35.159]                       }
[15:32:35.159]                       else if (inherits(cond, "warning")) {
[15:32:35.159]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:35.159]                         if (muffled) 
[15:32:35.159]                           invokeRestart("muffleWarning")
[15:32:35.159]                       }
[15:32:35.159]                       else if (inherits(cond, "condition")) {
[15:32:35.159]                         if (!is.null(pattern)) {
[15:32:35.159]                           computeRestarts <- base::computeRestarts
[15:32:35.159]                           grepl <- base::grepl
[15:32:35.159]                           restarts <- computeRestarts(cond)
[15:32:35.159]                           for (restart in restarts) {
[15:32:35.159]                             name <- restart$name
[15:32:35.159]                             if (is.null(name)) 
[15:32:35.159]                               next
[15:32:35.159]                             if (!grepl(pattern, name)) 
[15:32:35.159]                               next
[15:32:35.159]                             invokeRestart(restart)
[15:32:35.159]                             muffled <- TRUE
[15:32:35.159]                             break
[15:32:35.159]                           }
[15:32:35.159]                         }
[15:32:35.159]                       }
[15:32:35.159]                       invisible(muffled)
[15:32:35.159]                     }
[15:32:35.159]                     muffleCondition(cond, pattern = "^muffle")
[15:32:35.159]                   }
[15:32:35.159]                 }
[15:32:35.159]                 else {
[15:32:35.159]                   if (TRUE) {
[15:32:35.159]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:35.159]                     {
[15:32:35.159]                       inherits <- base::inherits
[15:32:35.159]                       invokeRestart <- base::invokeRestart
[15:32:35.159]                       is.null <- base::is.null
[15:32:35.159]                       muffled <- FALSE
[15:32:35.159]                       if (inherits(cond, "message")) {
[15:32:35.159]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:35.159]                         if (muffled) 
[15:32:35.159]                           invokeRestart("muffleMessage")
[15:32:35.159]                       }
[15:32:35.159]                       else if (inherits(cond, "warning")) {
[15:32:35.159]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:35.159]                         if (muffled) 
[15:32:35.159]                           invokeRestart("muffleWarning")
[15:32:35.159]                       }
[15:32:35.159]                       else if (inherits(cond, "condition")) {
[15:32:35.159]                         if (!is.null(pattern)) {
[15:32:35.159]                           computeRestarts <- base::computeRestarts
[15:32:35.159]                           grepl <- base::grepl
[15:32:35.159]                           restarts <- computeRestarts(cond)
[15:32:35.159]                           for (restart in restarts) {
[15:32:35.159]                             name <- restart$name
[15:32:35.159]                             if (is.null(name)) 
[15:32:35.159]                               next
[15:32:35.159]                             if (!grepl(pattern, name)) 
[15:32:35.159]                               next
[15:32:35.159]                             invokeRestart(restart)
[15:32:35.159]                             muffled <- TRUE
[15:32:35.159]                             break
[15:32:35.159]                           }
[15:32:35.159]                         }
[15:32:35.159]                       }
[15:32:35.159]                       invisible(muffled)
[15:32:35.159]                     }
[15:32:35.159]                     muffleCondition(cond, pattern = "^muffle")
[15:32:35.159]                   }
[15:32:35.159]                 }
[15:32:35.159]             }
[15:32:35.159]         }))
[15:32:35.159]     }, error = function(ex) {
[15:32:35.159]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:35.159]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:35.159]                 ...future.rng), started = ...future.startTime, 
[15:32:35.159]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:35.159]             version = "1.8"), class = "FutureResult")
[15:32:35.159]     }, finally = {
[15:32:35.159]         if (!identical(...future.workdir, getwd())) 
[15:32:35.159]             setwd(...future.workdir)
[15:32:35.159]         {
[15:32:35.159]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:35.159]                 ...future.oldOptions$nwarnings <- NULL
[15:32:35.159]             }
[15:32:35.159]             base::options(...future.oldOptions)
[15:32:35.159]             if (.Platform$OS.type == "windows") {
[15:32:35.159]                 old_names <- names(...future.oldEnvVars)
[15:32:35.159]                 envs <- base::Sys.getenv()
[15:32:35.159]                 names <- names(envs)
[15:32:35.159]                 common <- intersect(names, old_names)
[15:32:35.159]                 added <- setdiff(names, old_names)
[15:32:35.159]                 removed <- setdiff(old_names, names)
[15:32:35.159]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:35.159]                   envs[common]]
[15:32:35.159]                 NAMES <- toupper(changed)
[15:32:35.159]                 args <- list()
[15:32:35.159]                 for (kk in seq_along(NAMES)) {
[15:32:35.159]                   name <- changed[[kk]]
[15:32:35.159]                   NAME <- NAMES[[kk]]
[15:32:35.159]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:35.159]                     next
[15:32:35.159]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:35.159]                 }
[15:32:35.159]                 NAMES <- toupper(added)
[15:32:35.159]                 for (kk in seq_along(NAMES)) {
[15:32:35.159]                   name <- added[[kk]]
[15:32:35.159]                   NAME <- NAMES[[kk]]
[15:32:35.159]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:35.159]                     next
[15:32:35.159]                   args[[name]] <- ""
[15:32:35.159]                 }
[15:32:35.159]                 NAMES <- toupper(removed)
[15:32:35.159]                 for (kk in seq_along(NAMES)) {
[15:32:35.159]                   name <- removed[[kk]]
[15:32:35.159]                   NAME <- NAMES[[kk]]
[15:32:35.159]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:35.159]                     next
[15:32:35.159]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:35.159]                 }
[15:32:35.159]                 if (length(args) > 0) 
[15:32:35.159]                   base::do.call(base::Sys.setenv, args = args)
[15:32:35.159]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:35.159]             }
[15:32:35.159]             else {
[15:32:35.159]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:35.159]             }
[15:32:35.159]             {
[15:32:35.159]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:35.159]                   0L) {
[15:32:35.159]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:35.159]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:35.159]                   base::options(opts)
[15:32:35.159]                 }
[15:32:35.159]                 {
[15:32:35.159]                   {
[15:32:35.159]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:35.159]                     NULL
[15:32:35.159]                   }
[15:32:35.159]                   options(future.plan = NULL)
[15:32:35.159]                   if (is.na(NA_character_)) 
[15:32:35.159]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:35.159]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:35.159]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:35.159]                     .init = FALSE)
[15:32:35.159]                 }
[15:32:35.159]             }
[15:32:35.159]         }
[15:32:35.159]     })
[15:32:35.159]     if (TRUE) {
[15:32:35.159]         base::sink(type = "output", split = FALSE)
[15:32:35.159]         if (TRUE) {
[15:32:35.159]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:35.159]         }
[15:32:35.159]         else {
[15:32:35.159]             ...future.result["stdout"] <- base::list(NULL)
[15:32:35.159]         }
[15:32:35.159]         base::close(...future.stdout)
[15:32:35.159]         ...future.stdout <- NULL
[15:32:35.159]     }
[15:32:35.159]     ...future.result$conditions <- ...future.conditions
[15:32:35.159]     ...future.result$finished <- base::Sys.time()
[15:32:35.159]     ...future.result
[15:32:35.159] }
[15:32:35.168] Exporting 5 global objects (848 bytes) to cluster node #1 ...
[15:32:35.168] Exporting '...future.FUN' (848 bytes) to cluster node #1 ...
[15:32:35.169] Exporting '...future.FUN' (848 bytes) to cluster node #1 ... DONE
[15:32:35.170] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:35.170] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:35.171] Exporting '...future.elements_ii' (224 bytes) to cluster node #1 ...
[15:32:35.171] Exporting '...future.elements_ii' (224 bytes) to cluster node #1 ... DONE
[15:32:35.172] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:35.172] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:35.173] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:35.173] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:35.173] Exporting 5 global objects (848 bytes) to cluster node #1 ... DONE
[15:32:35.174] MultisessionFuture started
[15:32:35.175] - Launch lazy future ... done
[15:32:35.175] run() for 'MultisessionFuture' ... done
[15:32:35.175] Created future:
[15:32:35.192] receiveMessageFromWorker() for ClusterFuture ...
[15:32:35.193] - Validating connection of MultisessionFuture
[15:32:35.193] - received message: FutureResult
[15:32:35.193] - Received FutureResult
[15:32:35.193] - Erased future from FutureRegistry
[15:32:35.194] result() for ClusterFuture ...
[15:32:35.194] - result already collected: FutureResult
[15:32:35.194] result() for ClusterFuture ... done
[15:32:35.194] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:35.175] MultisessionFuture:
[15:32:35.175] Label: 'future_sapply-2'
[15:32:35.175] Expression:
[15:32:35.175] {
[15:32:35.175]     do.call(function(...) {
[15:32:35.175]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:35.175]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:35.175]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:35.175]             on.exit(options(oopts), add = TRUE)
[15:32:35.175]         }
[15:32:35.175]         {
[15:32:35.175]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:35.175]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:35.175]                 ...future.FUN(...future.X_jj, ...)
[15:32:35.175]             })
[15:32:35.175]         }
[15:32:35.175]     }, args = future.call.arguments)
[15:32:35.175] }
[15:32:35.175] Lazy evaluation: FALSE
[15:32:35.175] Asynchronous evaluation: TRUE
[15:32:35.175] Local evaluation: TRUE
[15:32:35.175] Environment: R_GlobalEnv
[15:32:35.175] Capture standard output: TRUE
[15:32:35.175] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:35.175] Globals: 5 objects totaling 1.05 KiB (function '...future.FUN' of 848 bytes, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 224 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:35.175] Packages: <none>
[15:32:35.175] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:35.175] Resolved: TRUE
[15:32:35.175] Value: <not collected>
[15:32:35.175] Conditions captured: <none>
[15:32:35.175] Early signaling: FALSE
[15:32:35.175] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:35.175] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:35.195] Chunk #2 of 2 ... DONE
[15:32:35.195] Launching 2 futures (chunks) ... DONE
[15:32:35.195] Resolving 2 futures (chunks) ...
[15:32:35.195] resolve() on list ...
[15:32:35.195]  recursive: 0
[15:32:35.196]  length: 2
[15:32:35.196] 
[15:32:35.196] Future #1
[15:32:35.196] result() for ClusterFuture ...
[15:32:35.196] - result already collected: FutureResult
[15:32:35.196] result() for ClusterFuture ... done
[15:32:35.197] result() for ClusterFuture ...
[15:32:35.197] - result already collected: FutureResult
[15:32:35.197] result() for ClusterFuture ... done
[15:32:35.197] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:35.197] - nx: 2
[15:32:35.197] - relay: TRUE
[15:32:35.198] - stdout: TRUE
[15:32:35.198] - signal: TRUE
[15:32:35.198] - resignal: FALSE
[15:32:35.198] - force: TRUE
[15:32:35.198] - relayed: [n=2] FALSE, FALSE
[15:32:35.198] - queued futures: [n=2] FALSE, FALSE
[15:32:35.199]  - until=1
[15:32:35.199]  - relaying element #1
[15:32:35.199] result() for ClusterFuture ...
[15:32:35.199] - result already collected: FutureResult
[15:32:35.199] result() for ClusterFuture ... done
[15:32:35.199] result() for ClusterFuture ...
[15:32:35.200] - result already collected: FutureResult
[15:32:35.200] result() for ClusterFuture ... done
[15:32:35.200] result() for ClusterFuture ...
[15:32:35.200] - result already collected: FutureResult
[15:32:35.200] result() for ClusterFuture ... done
[15:32:35.201] result() for ClusterFuture ...
[15:32:35.201] - result already collected: FutureResult
[15:32:35.201] result() for ClusterFuture ... done
[15:32:35.201] - relayed: [n=2] TRUE, FALSE
[15:32:35.201] - queued futures: [n=2] TRUE, FALSE
[15:32:35.201] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:35.202]  length: 1 (resolved future 1)
[15:32:35.202] Future #2
[15:32:35.202] result() for ClusterFuture ...
[15:32:35.202] - result already collected: FutureResult
[15:32:35.202] result() for ClusterFuture ... done
[15:32:35.203] result() for ClusterFuture ...
[15:32:35.203] - result already collected: FutureResult
[15:32:35.203] result() for ClusterFuture ... done
[15:32:35.203] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:35.203] - nx: 2
[15:32:35.203] - relay: TRUE
[15:32:35.203] - stdout: TRUE
[15:32:35.204] - signal: TRUE
[15:32:35.204] - resignal: FALSE
[15:32:35.204] - force: TRUE
[15:32:35.204] - relayed: [n=2] TRUE, FALSE
[15:32:35.204] - queued futures: [n=2] TRUE, FALSE
[15:32:35.204]  - until=2
[15:32:35.205]  - relaying element #2
[15:32:35.205] result() for ClusterFuture ...
[15:32:35.205] - result already collected: FutureResult
[15:32:35.205] result() for ClusterFuture ... done
[15:32:35.205] result() for ClusterFuture ...
[15:32:35.205] - result already collected: FutureResult
[15:32:35.206] result() for ClusterFuture ... done
[15:32:35.206] result() for ClusterFuture ...
[15:32:35.206] - result already collected: FutureResult
[15:32:35.206] result() for ClusterFuture ... done
[15:32:35.206] result() for ClusterFuture ...
[15:32:35.206] - result already collected: FutureResult
[15:32:35.207] result() for ClusterFuture ... done
[15:32:35.207] - relayed: [n=2] TRUE, TRUE
[15:32:35.207] - queued futures: [n=2] TRUE, TRUE
[15:32:35.207] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:35.207]  length: 0 (resolved future 2)
[15:32:35.207] Relaying remaining futures
[15:32:35.208] signalConditionsASAP(NULL, pos=0) ...
[15:32:35.208] - nx: 2
[15:32:35.208] - relay: TRUE
[15:32:35.208] - stdout: TRUE
[15:32:35.208] - signal: TRUE
[15:32:35.208] - resignal: FALSE
[15:32:35.209] - force: TRUE
[15:32:35.209] - relayed: [n=2] TRUE, TRUE
[15:32:35.209] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:35.209] - relayed: [n=2] TRUE, TRUE
[15:32:35.209] - queued futures: [n=2] TRUE, TRUE
[15:32:35.209] signalConditionsASAP(NULL, pos=0) ... done
[15:32:35.210] resolve() on list ... DONE
[15:32:35.210] result() for ClusterFuture ...
[15:32:35.210] - result already collected: FutureResult
[15:32:35.210] result() for ClusterFuture ... done
[15:32:35.210] result() for ClusterFuture ...
[15:32:35.210] - result already collected: FutureResult
[15:32:35.211] result() for ClusterFuture ... done
[15:32:35.211] result() for ClusterFuture ...
[15:32:35.211] - result already collected: FutureResult
[15:32:35.211] result() for ClusterFuture ... done
[15:32:35.211] result() for ClusterFuture ...
[15:32:35.211] - result already collected: FutureResult
[15:32:35.212] result() for ClusterFuture ... done
[15:32:35.212]  - Number of value chunks collected: 2
[15:32:35.212] Resolving 2 futures (chunks) ... DONE
[15:32:35.212] Reducing values from 2 chunks ...
[15:32:35.212]  - Number of values collected after concatenation: 3
[15:32:35.212]  - Number of values expected: 3
[15:32:35.213] Reducing values from 2 chunks ... DONE
[15:32:35.213] future_lapply() ... DONE
List of 2
 $ y0:List of 3
  ..$ : chr "a"
  ..$ : chr "b"
  ..$ : chr "c"
 $ y1:List of 3
  ..$ : chr "a"
  ..$ : chr "b"
  ..$ : chr "c"
List of 2
 $ y0:List of 3
  ..$ : chr "a"
  ..$ : chr "b"
  ..$ : chr "c"
 $ y2:List of 3
  ..$ : chr "a"
  ..$ : chr "b"
  ..$ : chr "c"
[15:32:35.219] future_lapply() ...
[15:32:35.224] Number of chunks: 2
[15:32:35.224] getGlobalsAndPackagesXApply() ...
[15:32:35.224]  - future.globals: TRUE
[15:32:35.224] getGlobalsAndPackages() ...
[15:32:35.225] Searching for globals...
[15:32:35.227] - globals found: [2] 'FUN', 'UseMethod'
[15:32:35.227] Searching for globals ... DONE
[15:32:35.227] Resolving globals: FALSE
[15:32:35.228] The total size of the 1 globals is 1.22 KiB (1248 bytes)
[15:32:35.229] The total size of the 1 globals exported for future expression ('FUN()') is 1.22 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.22 KiB of class 'function')
[15:32:35.229] - globals: [1] 'FUN'
[15:32:35.229] 
[15:32:35.230] getGlobalsAndPackages() ... DONE
[15:32:35.230]  - globals found/used: [n=1] 'FUN'
[15:32:35.230]  - needed namespaces: [n=0] 
[15:32:35.230] Finding globals ... DONE
[15:32:35.231]  - use_args: TRUE
[15:32:35.231]  - Getting '...' globals ...
[15:32:35.231] resolve() on list ...
[15:32:35.232]  recursive: 0
[15:32:35.232]  length: 1
[15:32:35.232]  elements: '...'
[15:32:35.233]  length: 0 (resolved future 1)
[15:32:35.233] resolve() on list ... DONE
[15:32:35.233]    - '...' content: [n=0] 
[15:32:35.233] List of 1
[15:32:35.233]  $ ...: list()
[15:32:35.233]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:35.233]  - attr(*, "where")=List of 1
[15:32:35.233]   ..$ ...:<environment: 0x00000276e074bfb8> 
[15:32:35.233]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:35.233]  - attr(*, "resolved")= logi TRUE
[15:32:35.233]  - attr(*, "total_size")= num NA
[15:32:35.238]  - Getting '...' globals ... DONE
[15:32:35.238] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:35.238] List of 2
[15:32:35.238]  $ ...future.FUN:function (x, ...)  
[15:32:35.238]  $ ...          : list()
[15:32:35.238]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:35.238]  - attr(*, "where")=List of 2
[15:32:35.238]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:35.238]   ..$ ...          :<environment: 0x00000276e074bfb8> 
[15:32:35.238]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:35.238]  - attr(*, "resolved")= logi FALSE
[15:32:35.238]  - attr(*, "total_size")= num 1248
[15:32:35.243] Packages to be attached in all futures: [n=0] 
[15:32:35.244] getGlobalsAndPackagesXApply() ... DONE
[15:32:35.244] Number of futures (= number of chunks): 2
[15:32:35.244] Launching 2 futures (chunks) ...
[15:32:35.245] Chunk #1 of 2 ...
[15:32:35.245]  - Finding globals in 'X' for chunk #1 ...
[15:32:35.245] getGlobalsAndPackages() ...
[15:32:35.246] Searching for globals...
[15:32:35.246] 
[15:32:35.246] Searching for globals ... DONE
[15:32:35.247] - globals: [0] <none>
[15:32:35.247] getGlobalsAndPackages() ... DONE
[15:32:35.247]    + additional globals found: [n=0] 
[15:32:35.248]    + additional namespaces needed: [n=0] 
[15:32:35.248]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:35.248]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:35.248]  - seeds: <none>
[15:32:35.248]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:35.249] getGlobalsAndPackages() ...
[15:32:35.249] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:35.249] Resolving globals: FALSE
[15:32:35.249] Tweak future expression to call with '...' arguments ...
[15:32:35.250] {
[15:32:35.250]     do.call(function(...) {
[15:32:35.250]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:35.250]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:35.250]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:35.250]             on.exit(options(oopts), add = TRUE)
[15:32:35.250]         }
[15:32:35.250]         {
[15:32:35.250]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:35.250]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:35.250]                 ...future.FUN(...future.X_jj, ...)
[15:32:35.250]             })
[15:32:35.250]         }
[15:32:35.250]     }, args = future.call.arguments)
[15:32:35.250] }
[15:32:35.250] Tweak future expression to call with '...' arguments ... DONE
[15:32:35.250] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:35.251] 
[15:32:35.251] getGlobalsAndPackages() ... DONE
[15:32:35.251] run() for 'Future' ...
[15:32:35.251] - state: 'created'
[15:32:35.252] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:35.267] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:35.267] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:35.267]   - Field: 'node'
[15:32:35.267]   - Field: 'label'
[15:32:35.268]   - Field: 'local'
[15:32:35.268]   - Field: 'owner'
[15:32:35.268]   - Field: 'envir'
[15:32:35.268]   - Field: 'workers'
[15:32:35.268]   - Field: 'packages'
[15:32:35.269]   - Field: 'gc'
[15:32:35.269]   - Field: 'conditions'
[15:32:35.269]   - Field: 'persistent'
[15:32:35.269]   - Field: 'expr'
[15:32:35.269]   - Field: 'uuid'
[15:32:35.270]   - Field: 'seed'
[15:32:35.270]   - Field: 'version'
[15:32:35.270]   - Field: 'result'
[15:32:35.270]   - Field: 'asynchronous'
[15:32:35.270]   - Field: 'calls'
[15:32:35.270]   - Field: 'globals'
[15:32:35.271]   - Field: 'stdout'
[15:32:35.271]   - Field: 'earlySignal'
[15:32:35.271]   - Field: 'lazy'
[15:32:35.272]   - Field: 'state'
[15:32:35.272] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:35.272] - Launch lazy future ...
[15:32:35.273] Packages needed by the future expression (n = 0): <none>
[15:32:35.273] Packages needed by future strategies (n = 0): <none>
[15:32:35.274] {
[15:32:35.274]     {
[15:32:35.274]         {
[15:32:35.274]             ...future.startTime <- base::Sys.time()
[15:32:35.274]             {
[15:32:35.274]                 {
[15:32:35.274]                   {
[15:32:35.274]                     {
[15:32:35.274]                       base::local({
[15:32:35.274]                         has_future <- base::requireNamespace("future", 
[15:32:35.274]                           quietly = TRUE)
[15:32:35.274]                         if (has_future) {
[15:32:35.274]                           ns <- base::getNamespace("future")
[15:32:35.274]                           version <- ns[[".package"]][["version"]]
[15:32:35.274]                           if (is.null(version)) 
[15:32:35.274]                             version <- utils::packageVersion("future")
[15:32:35.274]                         }
[15:32:35.274]                         else {
[15:32:35.274]                           version <- NULL
[15:32:35.274]                         }
[15:32:35.274]                         if (!has_future || version < "1.8.0") {
[15:32:35.274]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:35.274]                             "", base::R.version$version.string), 
[15:32:35.274]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:35.274]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:35.274]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:35.274]                               "release", "version")], collapse = " "), 
[15:32:35.274]                             hostname = base::Sys.info()[["nodename"]])
[15:32:35.274]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:35.274]                             info)
[15:32:35.274]                           info <- base::paste(info, collapse = "; ")
[15:32:35.274]                           if (!has_future) {
[15:32:35.274]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:35.274]                               info)
[15:32:35.274]                           }
[15:32:35.274]                           else {
[15:32:35.274]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:35.274]                               info, version)
[15:32:35.274]                           }
[15:32:35.274]                           base::stop(msg)
[15:32:35.274]                         }
[15:32:35.274]                       })
[15:32:35.274]                     }
[15:32:35.274]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:35.274]                     base::options(mc.cores = 1L)
[15:32:35.274]                   }
[15:32:35.274]                   ...future.strategy.old <- future::plan("list")
[15:32:35.274]                   options(future.plan = NULL)
[15:32:35.274]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:35.274]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:35.274]                 }
[15:32:35.274]                 ...future.workdir <- getwd()
[15:32:35.274]             }
[15:32:35.274]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:35.274]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:35.274]         }
[15:32:35.274]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:35.274]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:35.274]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:35.274]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:35.274]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:35.274]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:35.274]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:35.274]             base::names(...future.oldOptions))
[15:32:35.274]     }
[15:32:35.274]     if (FALSE) {
[15:32:35.274]     }
[15:32:35.274]     else {
[15:32:35.274]         if (TRUE) {
[15:32:35.274]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:35.274]                 open = "w")
[15:32:35.274]         }
[15:32:35.274]         else {
[15:32:35.274]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:35.274]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:35.274]         }
[15:32:35.274]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:35.274]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:35.274]             base::sink(type = "output", split = FALSE)
[15:32:35.274]             base::close(...future.stdout)
[15:32:35.274]         }, add = TRUE)
[15:32:35.274]     }
[15:32:35.274]     ...future.frame <- base::sys.nframe()
[15:32:35.274]     ...future.conditions <- base::list()
[15:32:35.274]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:35.274]     if (FALSE) {
[15:32:35.274]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:35.274]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:35.274]     }
[15:32:35.274]     ...future.result <- base::tryCatch({
[15:32:35.274]         base::withCallingHandlers({
[15:32:35.274]             ...future.value <- base::withVisible(base::local({
[15:32:35.274]                 ...future.makeSendCondition <- base::local({
[15:32:35.274]                   sendCondition <- NULL
[15:32:35.274]                   function(frame = 1L) {
[15:32:35.274]                     if (is.function(sendCondition)) 
[15:32:35.274]                       return(sendCondition)
[15:32:35.274]                     ns <- getNamespace("parallel")
[15:32:35.274]                     if (exists("sendData", mode = "function", 
[15:32:35.274]                       envir = ns)) {
[15:32:35.274]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:35.274]                         envir = ns)
[15:32:35.274]                       envir <- sys.frame(frame)
[15:32:35.274]                       master <- NULL
[15:32:35.274]                       while (!identical(envir, .GlobalEnv) && 
[15:32:35.274]                         !identical(envir, emptyenv())) {
[15:32:35.274]                         if (exists("master", mode = "list", envir = envir, 
[15:32:35.274]                           inherits = FALSE)) {
[15:32:35.274]                           master <- get("master", mode = "list", 
[15:32:35.274]                             envir = envir, inherits = FALSE)
[15:32:35.274]                           if (inherits(master, c("SOCKnode", 
[15:32:35.274]                             "SOCK0node"))) {
[15:32:35.274]                             sendCondition <<- function(cond) {
[15:32:35.274]                               data <- list(type = "VALUE", value = cond, 
[15:32:35.274]                                 success = TRUE)
[15:32:35.274]                               parallel_sendData(master, data)
[15:32:35.274]                             }
[15:32:35.274]                             return(sendCondition)
[15:32:35.274]                           }
[15:32:35.274]                         }
[15:32:35.274]                         frame <- frame + 1L
[15:32:35.274]                         envir <- sys.frame(frame)
[15:32:35.274]                       }
[15:32:35.274]                     }
[15:32:35.274]                     sendCondition <<- function(cond) NULL
[15:32:35.274]                   }
[15:32:35.274]                 })
[15:32:35.274]                 withCallingHandlers({
[15:32:35.274]                   {
[15:32:35.274]                     do.call(function(...) {
[15:32:35.274]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:35.274]                       if (!identical(...future.globals.maxSize.org, 
[15:32:35.274]                         ...future.globals.maxSize)) {
[15:32:35.274]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:35.274]                         on.exit(options(oopts), add = TRUE)
[15:32:35.274]                       }
[15:32:35.274]                       {
[15:32:35.274]                         lapply(seq_along(...future.elements_ii), 
[15:32:35.274]                           FUN = function(jj) {
[15:32:35.274]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:35.274]                             ...future.FUN(...future.X_jj, ...)
[15:32:35.274]                           })
[15:32:35.274]                       }
[15:32:35.274]                     }, args = future.call.arguments)
[15:32:35.274]                   }
[15:32:35.274]                 }, immediateCondition = function(cond) {
[15:32:35.274]                   sendCondition <- ...future.makeSendCondition()
[15:32:35.274]                   sendCondition(cond)
[15:32:35.274]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:35.274]                   {
[15:32:35.274]                     inherits <- base::inherits
[15:32:35.274]                     invokeRestart <- base::invokeRestart
[15:32:35.274]                     is.null <- base::is.null
[15:32:35.274]                     muffled <- FALSE
[15:32:35.274]                     if (inherits(cond, "message")) {
[15:32:35.274]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:35.274]                       if (muffled) 
[15:32:35.274]                         invokeRestart("muffleMessage")
[15:32:35.274]                     }
[15:32:35.274]                     else if (inherits(cond, "warning")) {
[15:32:35.274]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:35.274]                       if (muffled) 
[15:32:35.274]                         invokeRestart("muffleWarning")
[15:32:35.274]                     }
[15:32:35.274]                     else if (inherits(cond, "condition")) {
[15:32:35.274]                       if (!is.null(pattern)) {
[15:32:35.274]                         computeRestarts <- base::computeRestarts
[15:32:35.274]                         grepl <- base::grepl
[15:32:35.274]                         restarts <- computeRestarts(cond)
[15:32:35.274]                         for (restart in restarts) {
[15:32:35.274]                           name <- restart$name
[15:32:35.274]                           if (is.null(name)) 
[15:32:35.274]                             next
[15:32:35.274]                           if (!grepl(pattern, name)) 
[15:32:35.274]                             next
[15:32:35.274]                           invokeRestart(restart)
[15:32:35.274]                           muffled <- TRUE
[15:32:35.274]                           break
[15:32:35.274]                         }
[15:32:35.274]                       }
[15:32:35.274]                     }
[15:32:35.274]                     invisible(muffled)
[15:32:35.274]                   }
[15:32:35.274]                   muffleCondition(cond)
[15:32:35.274]                 })
[15:32:35.274]             }))
[15:32:35.274]             future::FutureResult(value = ...future.value$value, 
[15:32:35.274]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:35.274]                   ...future.rng), globalenv = if (FALSE) 
[15:32:35.274]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:35.274]                     ...future.globalenv.names))
[15:32:35.274]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:35.274]         }, condition = base::local({
[15:32:35.274]             c <- base::c
[15:32:35.274]             inherits <- base::inherits
[15:32:35.274]             invokeRestart <- base::invokeRestart
[15:32:35.274]             length <- base::length
[15:32:35.274]             list <- base::list
[15:32:35.274]             seq.int <- base::seq.int
[15:32:35.274]             signalCondition <- base::signalCondition
[15:32:35.274]             sys.calls <- base::sys.calls
[15:32:35.274]             `[[` <- base::`[[`
[15:32:35.274]             `+` <- base::`+`
[15:32:35.274]             `<<-` <- base::`<<-`
[15:32:35.274]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:35.274]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:35.274]                   3L)]
[15:32:35.274]             }
[15:32:35.274]             function(cond) {
[15:32:35.274]                 is_error <- inherits(cond, "error")
[15:32:35.274]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:35.274]                   NULL)
[15:32:35.274]                 if (is_error) {
[15:32:35.274]                   sessionInformation <- function() {
[15:32:35.274]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:35.274]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:35.274]                       search = base::search(), system = base::Sys.info())
[15:32:35.274]                   }
[15:32:35.274]                   ...future.conditions[[length(...future.conditions) + 
[15:32:35.274]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:35.274]                     cond$call), session = sessionInformation(), 
[15:32:35.274]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:35.274]                   signalCondition(cond)
[15:32:35.274]                 }
[15:32:35.274]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:35.274]                 "immediateCondition"))) {
[15:32:35.274]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:35.274]                   ...future.conditions[[length(...future.conditions) + 
[15:32:35.274]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:35.274]                   if (TRUE && !signal) {
[15:32:35.274]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:35.274]                     {
[15:32:35.274]                       inherits <- base::inherits
[15:32:35.274]                       invokeRestart <- base::invokeRestart
[15:32:35.274]                       is.null <- base::is.null
[15:32:35.274]                       muffled <- FALSE
[15:32:35.274]                       if (inherits(cond, "message")) {
[15:32:35.274]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:35.274]                         if (muffled) 
[15:32:35.274]                           invokeRestart("muffleMessage")
[15:32:35.274]                       }
[15:32:35.274]                       else if (inherits(cond, "warning")) {
[15:32:35.274]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:35.274]                         if (muffled) 
[15:32:35.274]                           invokeRestart("muffleWarning")
[15:32:35.274]                       }
[15:32:35.274]                       else if (inherits(cond, "condition")) {
[15:32:35.274]                         if (!is.null(pattern)) {
[15:32:35.274]                           computeRestarts <- base::computeRestarts
[15:32:35.274]                           grepl <- base::grepl
[15:32:35.274]                           restarts <- computeRestarts(cond)
[15:32:35.274]                           for (restart in restarts) {
[15:32:35.274]                             name <- restart$name
[15:32:35.274]                             if (is.null(name)) 
[15:32:35.274]                               next
[15:32:35.274]                             if (!grepl(pattern, name)) 
[15:32:35.274]                               next
[15:32:35.274]                             invokeRestart(restart)
[15:32:35.274]                             muffled <- TRUE
[15:32:35.274]                             break
[15:32:35.274]                           }
[15:32:35.274]                         }
[15:32:35.274]                       }
[15:32:35.274]                       invisible(muffled)
[15:32:35.274]                     }
[15:32:35.274]                     muffleCondition(cond, pattern = "^muffle")
[15:32:35.274]                   }
[15:32:35.274]                 }
[15:32:35.274]                 else {
[15:32:35.274]                   if (TRUE) {
[15:32:35.274]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:35.274]                     {
[15:32:35.274]                       inherits <- base::inherits
[15:32:35.274]                       invokeRestart <- base::invokeRestart
[15:32:35.274]                       is.null <- base::is.null
[15:32:35.274]                       muffled <- FALSE
[15:32:35.274]                       if (inherits(cond, "message")) {
[15:32:35.274]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:35.274]                         if (muffled) 
[15:32:35.274]                           invokeRestart("muffleMessage")
[15:32:35.274]                       }
[15:32:35.274]                       else if (inherits(cond, "warning")) {
[15:32:35.274]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:35.274]                         if (muffled) 
[15:32:35.274]                           invokeRestart("muffleWarning")
[15:32:35.274]                       }
[15:32:35.274]                       else if (inherits(cond, "condition")) {
[15:32:35.274]                         if (!is.null(pattern)) {
[15:32:35.274]                           computeRestarts <- base::computeRestarts
[15:32:35.274]                           grepl <- base::grepl
[15:32:35.274]                           restarts <- computeRestarts(cond)
[15:32:35.274]                           for (restart in restarts) {
[15:32:35.274]                             name <- restart$name
[15:32:35.274]                             if (is.null(name)) 
[15:32:35.274]                               next
[15:32:35.274]                             if (!grepl(pattern, name)) 
[15:32:35.274]                               next
[15:32:35.274]                             invokeRestart(restart)
[15:32:35.274]                             muffled <- TRUE
[15:32:35.274]                             break
[15:32:35.274]                           }
[15:32:35.274]                         }
[15:32:35.274]                       }
[15:32:35.274]                       invisible(muffled)
[15:32:35.274]                     }
[15:32:35.274]                     muffleCondition(cond, pattern = "^muffle")
[15:32:35.274]                   }
[15:32:35.274]                 }
[15:32:35.274]             }
[15:32:35.274]         }))
[15:32:35.274]     }, error = function(ex) {
[15:32:35.274]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:35.274]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:35.274]                 ...future.rng), started = ...future.startTime, 
[15:32:35.274]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:35.274]             version = "1.8"), class = "FutureResult")
[15:32:35.274]     }, finally = {
[15:32:35.274]         if (!identical(...future.workdir, getwd())) 
[15:32:35.274]             setwd(...future.workdir)
[15:32:35.274]         {
[15:32:35.274]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:35.274]                 ...future.oldOptions$nwarnings <- NULL
[15:32:35.274]             }
[15:32:35.274]             base::options(...future.oldOptions)
[15:32:35.274]             if (.Platform$OS.type == "windows") {
[15:32:35.274]                 old_names <- names(...future.oldEnvVars)
[15:32:35.274]                 envs <- base::Sys.getenv()
[15:32:35.274]                 names <- names(envs)
[15:32:35.274]                 common <- intersect(names, old_names)
[15:32:35.274]                 added <- setdiff(names, old_names)
[15:32:35.274]                 removed <- setdiff(old_names, names)
[15:32:35.274]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:35.274]                   envs[common]]
[15:32:35.274]                 NAMES <- toupper(changed)
[15:32:35.274]                 args <- list()
[15:32:35.274]                 for (kk in seq_along(NAMES)) {
[15:32:35.274]                   name <- changed[[kk]]
[15:32:35.274]                   NAME <- NAMES[[kk]]
[15:32:35.274]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:35.274]                     next
[15:32:35.274]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:35.274]                 }
[15:32:35.274]                 NAMES <- toupper(added)
[15:32:35.274]                 for (kk in seq_along(NAMES)) {
[15:32:35.274]                   name <- added[[kk]]
[15:32:35.274]                   NAME <- NAMES[[kk]]
[15:32:35.274]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:35.274]                     next
[15:32:35.274]                   args[[name]] <- ""
[15:32:35.274]                 }
[15:32:35.274]                 NAMES <- toupper(removed)
[15:32:35.274]                 for (kk in seq_along(NAMES)) {
[15:32:35.274]                   name <- removed[[kk]]
[15:32:35.274]                   NAME <- NAMES[[kk]]
[15:32:35.274]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:35.274]                     next
[15:32:35.274]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:35.274]                 }
[15:32:35.274]                 if (length(args) > 0) 
[15:32:35.274]                   base::do.call(base::Sys.setenv, args = args)
[15:32:35.274]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:35.274]             }
[15:32:35.274]             else {
[15:32:35.274]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:35.274]             }
[15:32:35.274]             {
[15:32:35.274]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:35.274]                   0L) {
[15:32:35.274]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:35.274]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:35.274]                   base::options(opts)
[15:32:35.274]                 }
[15:32:35.274]                 {
[15:32:35.274]                   {
[15:32:35.274]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:35.274]                     NULL
[15:32:35.274]                   }
[15:32:35.274]                   options(future.plan = NULL)
[15:32:35.274]                   if (is.na(NA_character_)) 
[15:32:35.274]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:35.274]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:35.274]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:35.274]                     .init = FALSE)
[15:32:35.274]                 }
[15:32:35.274]             }
[15:32:35.274]         }
[15:32:35.274]     })
[15:32:35.274]     if (TRUE) {
[15:32:35.274]         base::sink(type = "output", split = FALSE)
[15:32:35.274]         if (TRUE) {
[15:32:35.274]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:35.274]         }
[15:32:35.274]         else {
[15:32:35.274]             ...future.result["stdout"] <- base::list(NULL)
[15:32:35.274]         }
[15:32:35.274]         base::close(...future.stdout)
[15:32:35.274]         ...future.stdout <- NULL
[15:32:35.274]     }
[15:32:35.274]     ...future.result$conditions <- ...future.conditions
[15:32:35.274]     ...future.result$finished <- base::Sys.time()
[15:32:35.274]     ...future.result
[15:32:35.274] }
[15:32:35.280] Exporting 5 global objects (1.22 KiB) to cluster node #1 ...
[15:32:35.280] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ...
[15:32:35.280] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ... DONE
[15:32:35.281] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:35.281] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:35.281] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:35.282] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:35.282] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:35.283] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:35.283] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:35.283] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:35.284] Exporting 5 global objects (1.22 KiB) to cluster node #1 ... DONE
[15:32:35.284] MultisessionFuture started
[15:32:35.284] - Launch lazy future ... done
[15:32:35.284] run() for 'MultisessionFuture' ... done
[15:32:35.285] Created future:
[15:32:35.303] receiveMessageFromWorker() for ClusterFuture ...
[15:32:35.304] - Validating connection of MultisessionFuture
[15:32:35.304] - received message: FutureResult
[15:32:35.304] - Received FutureResult
[15:32:35.304] - Erased future from FutureRegistry
[15:32:35.305] result() for ClusterFuture ...
[15:32:35.305] - result already collected: FutureResult
[15:32:35.305] result() for ClusterFuture ... done
[15:32:35.305] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:35.285] MultisessionFuture:
[15:32:35.285] Label: 'future_sapply-1'
[15:32:35.285] Expression:
[15:32:35.285] {
[15:32:35.285]     do.call(function(...) {
[15:32:35.285]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:35.285]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:35.285]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:35.285]             on.exit(options(oopts), add = TRUE)
[15:32:35.285]         }
[15:32:35.285]         {
[15:32:35.285]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:35.285]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:35.285]                 ...future.FUN(...future.X_jj, ...)
[15:32:35.285]             })
[15:32:35.285]         }
[15:32:35.285]     }, args = future.call.arguments)
[15:32:35.285] }
[15:32:35.285] Lazy evaluation: FALSE
[15:32:35.285] Asynchronous evaluation: TRUE
[15:32:35.285] Local evaluation: TRUE
[15:32:35.285] Environment: R_GlobalEnv
[15:32:35.285] Capture standard output: TRUE
[15:32:35.285] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:35.285] Globals: 5 objects totaling 1.33 KiB (function '...future.FUN' of 1.22 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)
[15:32:35.285] Packages: <none>
[15:32:35.285] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:35.285] Resolved: TRUE
[15:32:35.285] Value: <not collected>
[15:32:35.285] Conditions captured: <none>
[15:32:35.285] Early signaling: FALSE
[15:32:35.285] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:35.285] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:35.306] Chunk #1 of 2 ... DONE
[15:32:35.306] Chunk #2 of 2 ...
[15:32:35.306]  - Finding globals in 'X' for chunk #2 ...
[15:32:35.306] getGlobalsAndPackages() ...
[15:32:35.306] Searching for globals...
[15:32:35.307] 
[15:32:35.307] Searching for globals ... DONE
[15:32:35.307] - globals: [0] <none>
[15:32:35.307] getGlobalsAndPackages() ... DONE
[15:32:35.308]    + additional globals found: [n=0] 
[15:32:35.308]    + additional namespaces needed: [n=0] 
[15:32:35.308]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:35.308]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:35.308]  - seeds: <none>
[15:32:35.308]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:35.309] getGlobalsAndPackages() ...
[15:32:35.309] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:35.309] Resolving globals: FALSE
[15:32:35.309] Tweak future expression to call with '...' arguments ...
[15:32:35.309] {
[15:32:35.309]     do.call(function(...) {
[15:32:35.309]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:35.309]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:35.309]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:35.309]             on.exit(options(oopts), add = TRUE)
[15:32:35.309]         }
[15:32:35.309]         {
[15:32:35.309]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:35.309]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:35.309]                 ...future.FUN(...future.X_jj, ...)
[15:32:35.309]             })
[15:32:35.309]         }
[15:32:35.309]     }, args = future.call.arguments)
[15:32:35.309] }
[15:32:35.310] Tweak future expression to call with '...' arguments ... DONE
[15:32:35.310] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:35.311] 
[15:32:35.311] getGlobalsAndPackages() ... DONE
[15:32:35.311] run() for 'Future' ...
[15:32:35.311] - state: 'created'
[15:32:35.312] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:35.331] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:35.332] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:35.332]   - Field: 'node'
[15:32:35.332]   - Field: 'label'
[15:32:35.333]   - Field: 'local'
[15:32:35.333]   - Field: 'owner'
[15:32:35.333]   - Field: 'envir'
[15:32:35.334]   - Field: 'workers'
[15:32:35.334]   - Field: 'packages'
[15:32:35.334]   - Field: 'gc'
[15:32:35.335]   - Field: 'conditions'
[15:32:35.335]   - Field: 'persistent'
[15:32:35.335]   - Field: 'expr'
[15:32:35.336]   - Field: 'uuid'
[15:32:35.336]   - Field: 'seed'
[15:32:35.336]   - Field: 'version'
[15:32:35.337]   - Field: 'result'
[15:32:35.337]   - Field: 'asynchronous'
[15:32:35.337]   - Field: 'calls'
[15:32:35.338]   - Field: 'globals'
[15:32:35.338]   - Field: 'stdout'
[15:32:35.338]   - Field: 'earlySignal'
[15:32:35.339]   - Field: 'lazy'
[15:32:35.339]   - Field: 'state'
[15:32:35.339] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:35.340] - Launch lazy future ...
[15:32:35.341] Packages needed by the future expression (n = 0): <none>
[15:32:35.341] Packages needed by future strategies (n = 0): <none>
[15:32:35.342] {
[15:32:35.342]     {
[15:32:35.342]         {
[15:32:35.342]             ...future.startTime <- base::Sys.time()
[15:32:35.342]             {
[15:32:35.342]                 {
[15:32:35.342]                   {
[15:32:35.342]                     {
[15:32:35.342]                       base::local({
[15:32:35.342]                         has_future <- base::requireNamespace("future", 
[15:32:35.342]                           quietly = TRUE)
[15:32:35.342]                         if (has_future) {
[15:32:35.342]                           ns <- base::getNamespace("future")
[15:32:35.342]                           version <- ns[[".package"]][["version"]]
[15:32:35.342]                           if (is.null(version)) 
[15:32:35.342]                             version <- utils::packageVersion("future")
[15:32:35.342]                         }
[15:32:35.342]                         else {
[15:32:35.342]                           version <- NULL
[15:32:35.342]                         }
[15:32:35.342]                         if (!has_future || version < "1.8.0") {
[15:32:35.342]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:35.342]                             "", base::R.version$version.string), 
[15:32:35.342]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:35.342]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:35.342]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:35.342]                               "release", "version")], collapse = " "), 
[15:32:35.342]                             hostname = base::Sys.info()[["nodename"]])
[15:32:35.342]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:35.342]                             info)
[15:32:35.342]                           info <- base::paste(info, collapse = "; ")
[15:32:35.342]                           if (!has_future) {
[15:32:35.342]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:35.342]                               info)
[15:32:35.342]                           }
[15:32:35.342]                           else {
[15:32:35.342]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:35.342]                               info, version)
[15:32:35.342]                           }
[15:32:35.342]                           base::stop(msg)
[15:32:35.342]                         }
[15:32:35.342]                       })
[15:32:35.342]                     }
[15:32:35.342]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:35.342]                     base::options(mc.cores = 1L)
[15:32:35.342]                   }
[15:32:35.342]                   ...future.strategy.old <- future::plan("list")
[15:32:35.342]                   options(future.plan = NULL)
[15:32:35.342]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:35.342]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:35.342]                 }
[15:32:35.342]                 ...future.workdir <- getwd()
[15:32:35.342]             }
[15:32:35.342]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:35.342]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:35.342]         }
[15:32:35.342]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:35.342]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:35.342]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:35.342]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:35.342]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:35.342]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:35.342]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:35.342]             base::names(...future.oldOptions))
[15:32:35.342]     }
[15:32:35.342]     if (FALSE) {
[15:32:35.342]     }
[15:32:35.342]     else {
[15:32:35.342]         if (TRUE) {
[15:32:35.342]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:35.342]                 open = "w")
[15:32:35.342]         }
[15:32:35.342]         else {
[15:32:35.342]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:35.342]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:35.342]         }
[15:32:35.342]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:35.342]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:35.342]             base::sink(type = "output", split = FALSE)
[15:32:35.342]             base::close(...future.stdout)
[15:32:35.342]         }, add = TRUE)
[15:32:35.342]     }
[15:32:35.342]     ...future.frame <- base::sys.nframe()
[15:32:35.342]     ...future.conditions <- base::list()
[15:32:35.342]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:35.342]     if (FALSE) {
[15:32:35.342]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:35.342]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:35.342]     }
[15:32:35.342]     ...future.result <- base::tryCatch({
[15:32:35.342]         base::withCallingHandlers({
[15:32:35.342]             ...future.value <- base::withVisible(base::local({
[15:32:35.342]                 ...future.makeSendCondition <- base::local({
[15:32:35.342]                   sendCondition <- NULL
[15:32:35.342]                   function(frame = 1L) {
[15:32:35.342]                     if (is.function(sendCondition)) 
[15:32:35.342]                       return(sendCondition)
[15:32:35.342]                     ns <- getNamespace("parallel")
[15:32:35.342]                     if (exists("sendData", mode = "function", 
[15:32:35.342]                       envir = ns)) {
[15:32:35.342]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:35.342]                         envir = ns)
[15:32:35.342]                       envir <- sys.frame(frame)
[15:32:35.342]                       master <- NULL
[15:32:35.342]                       while (!identical(envir, .GlobalEnv) && 
[15:32:35.342]                         !identical(envir, emptyenv())) {
[15:32:35.342]                         if (exists("master", mode = "list", envir = envir, 
[15:32:35.342]                           inherits = FALSE)) {
[15:32:35.342]                           master <- get("master", mode = "list", 
[15:32:35.342]                             envir = envir, inherits = FALSE)
[15:32:35.342]                           if (inherits(master, c("SOCKnode", 
[15:32:35.342]                             "SOCK0node"))) {
[15:32:35.342]                             sendCondition <<- function(cond) {
[15:32:35.342]                               data <- list(type = "VALUE", value = cond, 
[15:32:35.342]                                 success = TRUE)
[15:32:35.342]                               parallel_sendData(master, data)
[15:32:35.342]                             }
[15:32:35.342]                             return(sendCondition)
[15:32:35.342]                           }
[15:32:35.342]                         }
[15:32:35.342]                         frame <- frame + 1L
[15:32:35.342]                         envir <- sys.frame(frame)
[15:32:35.342]                       }
[15:32:35.342]                     }
[15:32:35.342]                     sendCondition <<- function(cond) NULL
[15:32:35.342]                   }
[15:32:35.342]                 })
[15:32:35.342]                 withCallingHandlers({
[15:32:35.342]                   {
[15:32:35.342]                     do.call(function(...) {
[15:32:35.342]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:35.342]                       if (!identical(...future.globals.maxSize.org, 
[15:32:35.342]                         ...future.globals.maxSize)) {
[15:32:35.342]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:35.342]                         on.exit(options(oopts), add = TRUE)
[15:32:35.342]                       }
[15:32:35.342]                       {
[15:32:35.342]                         lapply(seq_along(...future.elements_ii), 
[15:32:35.342]                           FUN = function(jj) {
[15:32:35.342]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:35.342]                             ...future.FUN(...future.X_jj, ...)
[15:32:35.342]                           })
[15:32:35.342]                       }
[15:32:35.342]                     }, args = future.call.arguments)
[15:32:35.342]                   }
[15:32:35.342]                 }, immediateCondition = function(cond) {
[15:32:35.342]                   sendCondition <- ...future.makeSendCondition()
[15:32:35.342]                   sendCondition(cond)
[15:32:35.342]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:35.342]                   {
[15:32:35.342]                     inherits <- base::inherits
[15:32:35.342]                     invokeRestart <- base::invokeRestart
[15:32:35.342]                     is.null <- base::is.null
[15:32:35.342]                     muffled <- FALSE
[15:32:35.342]                     if (inherits(cond, "message")) {
[15:32:35.342]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:35.342]                       if (muffled) 
[15:32:35.342]                         invokeRestart("muffleMessage")
[15:32:35.342]                     }
[15:32:35.342]                     else if (inherits(cond, "warning")) {
[15:32:35.342]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:35.342]                       if (muffled) 
[15:32:35.342]                         invokeRestart("muffleWarning")
[15:32:35.342]                     }
[15:32:35.342]                     else if (inherits(cond, "condition")) {
[15:32:35.342]                       if (!is.null(pattern)) {
[15:32:35.342]                         computeRestarts <- base::computeRestarts
[15:32:35.342]                         grepl <- base::grepl
[15:32:35.342]                         restarts <- computeRestarts(cond)
[15:32:35.342]                         for (restart in restarts) {
[15:32:35.342]                           name <- restart$name
[15:32:35.342]                           if (is.null(name)) 
[15:32:35.342]                             next
[15:32:35.342]                           if (!grepl(pattern, name)) 
[15:32:35.342]                             next
[15:32:35.342]                           invokeRestart(restart)
[15:32:35.342]                           muffled <- TRUE
[15:32:35.342]                           break
[15:32:35.342]                         }
[15:32:35.342]                       }
[15:32:35.342]                     }
[15:32:35.342]                     invisible(muffled)
[15:32:35.342]                   }
[15:32:35.342]                   muffleCondition(cond)
[15:32:35.342]                 })
[15:32:35.342]             }))
[15:32:35.342]             future::FutureResult(value = ...future.value$value, 
[15:32:35.342]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:35.342]                   ...future.rng), globalenv = if (FALSE) 
[15:32:35.342]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:35.342]                     ...future.globalenv.names))
[15:32:35.342]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:35.342]         }, condition = base::local({
[15:32:35.342]             c <- base::c
[15:32:35.342]             inherits <- base::inherits
[15:32:35.342]             invokeRestart <- base::invokeRestart
[15:32:35.342]             length <- base::length
[15:32:35.342]             list <- base::list
[15:32:35.342]             seq.int <- base::seq.int
[15:32:35.342]             signalCondition <- base::signalCondition
[15:32:35.342]             sys.calls <- base::sys.calls
[15:32:35.342]             `[[` <- base::`[[`
[15:32:35.342]             `+` <- base::`+`
[15:32:35.342]             `<<-` <- base::`<<-`
[15:32:35.342]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:35.342]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:35.342]                   3L)]
[15:32:35.342]             }
[15:32:35.342]             function(cond) {
[15:32:35.342]                 is_error <- inherits(cond, "error")
[15:32:35.342]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:35.342]                   NULL)
[15:32:35.342]                 if (is_error) {
[15:32:35.342]                   sessionInformation <- function() {
[15:32:35.342]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:35.342]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:35.342]                       search = base::search(), system = base::Sys.info())
[15:32:35.342]                   }
[15:32:35.342]                   ...future.conditions[[length(...future.conditions) + 
[15:32:35.342]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:35.342]                     cond$call), session = sessionInformation(), 
[15:32:35.342]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:35.342]                   signalCondition(cond)
[15:32:35.342]                 }
[15:32:35.342]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:35.342]                 "immediateCondition"))) {
[15:32:35.342]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:35.342]                   ...future.conditions[[length(...future.conditions) + 
[15:32:35.342]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:35.342]                   if (TRUE && !signal) {
[15:32:35.342]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:35.342]                     {
[15:32:35.342]                       inherits <- base::inherits
[15:32:35.342]                       invokeRestart <- base::invokeRestart
[15:32:35.342]                       is.null <- base::is.null
[15:32:35.342]                       muffled <- FALSE
[15:32:35.342]                       if (inherits(cond, "message")) {
[15:32:35.342]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:35.342]                         if (muffled) 
[15:32:35.342]                           invokeRestart("muffleMessage")
[15:32:35.342]                       }
[15:32:35.342]                       else if (inherits(cond, "warning")) {
[15:32:35.342]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:35.342]                         if (muffled) 
[15:32:35.342]                           invokeRestart("muffleWarning")
[15:32:35.342]                       }
[15:32:35.342]                       else if (inherits(cond, "condition")) {
[15:32:35.342]                         if (!is.null(pattern)) {
[15:32:35.342]                           computeRestarts <- base::computeRestarts
[15:32:35.342]                           grepl <- base::grepl
[15:32:35.342]                           restarts <- computeRestarts(cond)
[15:32:35.342]                           for (restart in restarts) {
[15:32:35.342]                             name <- restart$name
[15:32:35.342]                             if (is.null(name)) 
[15:32:35.342]                               next
[15:32:35.342]                             if (!grepl(pattern, name)) 
[15:32:35.342]                               next
[15:32:35.342]                             invokeRestart(restart)
[15:32:35.342]                             muffled <- TRUE
[15:32:35.342]                             break
[15:32:35.342]                           }
[15:32:35.342]                         }
[15:32:35.342]                       }
[15:32:35.342]                       invisible(muffled)
[15:32:35.342]                     }
[15:32:35.342]                     muffleCondition(cond, pattern = "^muffle")
[15:32:35.342]                   }
[15:32:35.342]                 }
[15:32:35.342]                 else {
[15:32:35.342]                   if (TRUE) {
[15:32:35.342]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:35.342]                     {
[15:32:35.342]                       inherits <- base::inherits
[15:32:35.342]                       invokeRestart <- base::invokeRestart
[15:32:35.342]                       is.null <- base::is.null
[15:32:35.342]                       muffled <- FALSE
[15:32:35.342]                       if (inherits(cond, "message")) {
[15:32:35.342]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:35.342]                         if (muffled) 
[15:32:35.342]                           invokeRestart("muffleMessage")
[15:32:35.342]                       }
[15:32:35.342]                       else if (inherits(cond, "warning")) {
[15:32:35.342]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:35.342]                         if (muffled) 
[15:32:35.342]                           invokeRestart("muffleWarning")
[15:32:35.342]                       }
[15:32:35.342]                       else if (inherits(cond, "condition")) {
[15:32:35.342]                         if (!is.null(pattern)) {
[15:32:35.342]                           computeRestarts <- base::computeRestarts
[15:32:35.342]                           grepl <- base::grepl
[15:32:35.342]                           restarts <- computeRestarts(cond)
[15:32:35.342]                           for (restart in restarts) {
[15:32:35.342]                             name <- restart$name
[15:32:35.342]                             if (is.null(name)) 
[15:32:35.342]                               next
[15:32:35.342]                             if (!grepl(pattern, name)) 
[15:32:35.342]                               next
[15:32:35.342]                             invokeRestart(restart)
[15:32:35.342]                             muffled <- TRUE
[15:32:35.342]                             break
[15:32:35.342]                           }
[15:32:35.342]                         }
[15:32:35.342]                       }
[15:32:35.342]                       invisible(muffled)
[15:32:35.342]                     }
[15:32:35.342]                     muffleCondition(cond, pattern = "^muffle")
[15:32:35.342]                   }
[15:32:35.342]                 }
[15:32:35.342]             }
[15:32:35.342]         }))
[15:32:35.342]     }, error = function(ex) {
[15:32:35.342]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:35.342]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:35.342]                 ...future.rng), started = ...future.startTime, 
[15:32:35.342]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:35.342]             version = "1.8"), class = "FutureResult")
[15:32:35.342]     }, finally = {
[15:32:35.342]         if (!identical(...future.workdir, getwd())) 
[15:32:35.342]             setwd(...future.workdir)
[15:32:35.342]         {
[15:32:35.342]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:35.342]                 ...future.oldOptions$nwarnings <- NULL
[15:32:35.342]             }
[15:32:35.342]             base::options(...future.oldOptions)
[15:32:35.342]             if (.Platform$OS.type == "windows") {
[15:32:35.342]                 old_names <- names(...future.oldEnvVars)
[15:32:35.342]                 envs <- base::Sys.getenv()
[15:32:35.342]                 names <- names(envs)
[15:32:35.342]                 common <- intersect(names, old_names)
[15:32:35.342]                 added <- setdiff(names, old_names)
[15:32:35.342]                 removed <- setdiff(old_names, names)
[15:32:35.342]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:35.342]                   envs[common]]
[15:32:35.342]                 NAMES <- toupper(changed)
[15:32:35.342]                 args <- list()
[15:32:35.342]                 for (kk in seq_along(NAMES)) {
[15:32:35.342]                   name <- changed[[kk]]
[15:32:35.342]                   NAME <- NAMES[[kk]]
[15:32:35.342]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:35.342]                     next
[15:32:35.342]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:35.342]                 }
[15:32:35.342]                 NAMES <- toupper(added)
[15:32:35.342]                 for (kk in seq_along(NAMES)) {
[15:32:35.342]                   name <- added[[kk]]
[15:32:35.342]                   NAME <- NAMES[[kk]]
[15:32:35.342]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:35.342]                     next
[15:32:35.342]                   args[[name]] <- ""
[15:32:35.342]                 }
[15:32:35.342]                 NAMES <- toupper(removed)
[15:32:35.342]                 for (kk in seq_along(NAMES)) {
[15:32:35.342]                   name <- removed[[kk]]
[15:32:35.342]                   NAME <- NAMES[[kk]]
[15:32:35.342]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:35.342]                     next
[15:32:35.342]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:35.342]                 }
[15:32:35.342]                 if (length(args) > 0) 
[15:32:35.342]                   base::do.call(base::Sys.setenv, args = args)
[15:32:35.342]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:35.342]             }
[15:32:35.342]             else {
[15:32:35.342]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:35.342]             }
[15:32:35.342]             {
[15:32:35.342]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:35.342]                   0L) {
[15:32:35.342]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:35.342]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:35.342]                   base::options(opts)
[15:32:35.342]                 }
[15:32:35.342]                 {
[15:32:35.342]                   {
[15:32:35.342]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:35.342]                     NULL
[15:32:35.342]                   }
[15:32:35.342]                   options(future.plan = NULL)
[15:32:35.342]                   if (is.na(NA_character_)) 
[15:32:35.342]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:35.342]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:35.342]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:35.342]                     .init = FALSE)
[15:32:35.342]                 }
[15:32:35.342]             }
[15:32:35.342]         }
[15:32:35.342]     })
[15:32:35.342]     if (TRUE) {
[15:32:35.342]         base::sink(type = "output", split = FALSE)
[15:32:35.342]         if (TRUE) {
[15:32:35.342]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:35.342]         }
[15:32:35.342]         else {
[15:32:35.342]             ...future.result["stdout"] <- base::list(NULL)
[15:32:35.342]         }
[15:32:35.342]         base::close(...future.stdout)
[15:32:35.342]         ...future.stdout <- NULL
[15:32:35.342]     }
[15:32:35.342]     ...future.result$conditions <- ...future.conditions
[15:32:35.342]     ...future.result$finished <- base::Sys.time()
[15:32:35.342]     ...future.result
[15:32:35.342] }
[15:32:35.354] Exporting 5 global objects (1.22 KiB) to cluster node #1 ...
[15:32:35.354] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ...
[15:32:35.355] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ... DONE
[15:32:35.355] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:35.356] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:35.357] Exporting '...future.elements_ii' (224 bytes) to cluster node #1 ...
[15:32:35.357] Exporting '...future.elements_ii' (224 bytes) to cluster node #1 ... DONE
[15:32:35.358] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:35.358] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:35.359] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:35.359] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:35.360] Exporting 5 global objects (1.22 KiB) to cluster node #1 ... DONE
[15:32:35.361] MultisessionFuture started
[15:32:35.361] - Launch lazy future ... done
[15:32:35.362] run() for 'MultisessionFuture' ... done
[15:32:35.362] Created future:
[15:32:35.378] receiveMessageFromWorker() for ClusterFuture ...
[15:32:35.379] - Validating connection of MultisessionFuture
[15:32:35.379] - received message: FutureResult
[15:32:35.379] - Received FutureResult
[15:32:35.379] - Erased future from FutureRegistry
[15:32:35.380] result() for ClusterFuture ...
[15:32:35.380] - result already collected: FutureResult
[15:32:35.380] result() for ClusterFuture ... done
[15:32:35.380] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:35.362] MultisessionFuture:
[15:32:35.362] Label: 'future_sapply-2'
[15:32:35.362] Expression:
[15:32:35.362] {
[15:32:35.362]     do.call(function(...) {
[15:32:35.362]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:35.362]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:35.362]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:35.362]             on.exit(options(oopts), add = TRUE)
[15:32:35.362]         }
[15:32:35.362]         {
[15:32:35.362]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:35.362]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:35.362]                 ...future.FUN(...future.X_jj, ...)
[15:32:35.362]             })
[15:32:35.362]         }
[15:32:35.362]     }, args = future.call.arguments)
[15:32:35.362] }
[15:32:35.362] Lazy evaluation: FALSE
[15:32:35.362] Asynchronous evaluation: TRUE
[15:32:35.362] Local evaluation: TRUE
[15:32:35.362] Environment: R_GlobalEnv
[15:32:35.362] Capture standard output: TRUE
[15:32:35.362] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:35.362] Globals: 5 objects totaling 1.44 KiB (function '...future.FUN' of 1.22 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 224 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:35.362] Packages: <none>
[15:32:35.362] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:35.362] Resolved: TRUE
[15:32:35.362] Value: <not collected>
[15:32:35.362] Conditions captured: <none>
[15:32:35.362] Early signaling: FALSE
[15:32:35.362] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:35.362] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:35.385] Chunk #2 of 2 ... DONE
[15:32:35.385] Launching 2 futures (chunks) ... DONE
[15:32:35.386] Resolving 2 futures (chunks) ...
[15:32:35.386] resolve() on list ...
[15:32:35.386]  recursive: 0
[15:32:35.387]  length: 2
[15:32:35.387] 
[15:32:35.387] Future #1
[15:32:35.387] result() for ClusterFuture ...
[15:32:35.388] - result already collected: FutureResult
[15:32:35.388] result() for ClusterFuture ... done
[15:32:35.388] result() for ClusterFuture ...
[15:32:35.389] - result already collected: FutureResult
[15:32:35.389] result() for ClusterFuture ... done
[15:32:35.389] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:35.390] - nx: 2
[15:32:35.390] - relay: TRUE
[15:32:35.390] - stdout: TRUE
[15:32:35.391] - signal: TRUE
[15:32:35.391] - resignal: FALSE
[15:32:35.391] - force: TRUE
[15:32:35.391] - relayed: [n=2] FALSE, FALSE
[15:32:35.392] - queued futures: [n=2] FALSE, FALSE
[15:32:35.392]  - until=1
[15:32:35.392]  - relaying element #1
[15:32:35.393] result() for ClusterFuture ...
[15:32:35.393] - result already collected: FutureResult
[15:32:35.393] result() for ClusterFuture ... done
[15:32:35.393] result() for ClusterFuture ...
[15:32:35.394] - result already collected: FutureResult
[15:32:35.394] result() for ClusterFuture ... done
[15:32:35.394] result() for ClusterFuture ...
[15:32:35.395] - result already collected: FutureResult
[15:32:35.395] result() for ClusterFuture ... done
[15:32:35.395] result() for ClusterFuture ...
[15:32:35.396] - result already collected: FutureResult
[15:32:35.396] result() for ClusterFuture ... done
[15:32:35.396] - relayed: [n=2] TRUE, FALSE
[15:32:35.396] - queued futures: [n=2] TRUE, FALSE
[15:32:35.397] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:35.397]  length: 1 (resolved future 1)
[15:32:35.397] Future #2
[15:32:35.398] result() for ClusterFuture ...
[15:32:35.398] - result already collected: FutureResult
[15:32:35.398] result() for ClusterFuture ... done
[15:32:35.398] result() for ClusterFuture ...
[15:32:35.399] - result already collected: FutureResult
[15:32:35.399] result() for ClusterFuture ... done
[15:32:35.399] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:35.400] - nx: 2
[15:32:35.400] - relay: TRUE
[15:32:35.400] - stdout: TRUE
[15:32:35.400] - signal: TRUE
[15:32:35.401] - resignal: FALSE
[15:32:35.401] - force: TRUE
[15:32:35.401] - relayed: [n=2] TRUE, FALSE
[15:32:35.402] - queued futures: [n=2] TRUE, FALSE
[15:32:35.402]  - until=2
[15:32:35.402]  - relaying element #2
[15:32:35.403] result() for ClusterFuture ...
[15:32:35.403] - result already collected: FutureResult
[15:32:35.403] result() for ClusterFuture ... done
[15:32:35.403] result() for ClusterFuture ...
[15:32:35.404] - result already collected: FutureResult
[15:32:35.404] result() for ClusterFuture ... done
[15:32:35.404] result() for ClusterFuture ...
[15:32:35.405] - result already collected: FutureResult
[15:32:35.405] result() for ClusterFuture ... done
[15:32:35.405] result() for ClusterFuture ...
[15:32:35.406] - result already collected: FutureResult
[15:32:35.406] result() for ClusterFuture ... done
[15:32:35.406] - relayed: [n=2] TRUE, TRUE
[15:32:35.407] - queued futures: [n=2] TRUE, TRUE
[15:32:35.407] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:35.407]  length: 0 (resolved future 2)
[15:32:35.408] Relaying remaining futures
[15:32:35.408] signalConditionsASAP(NULL, pos=0) ...
[15:32:35.408] - nx: 2
[15:32:35.408] - relay: TRUE
[15:32:35.409] - stdout: TRUE
[15:32:35.409] - signal: TRUE
[15:32:35.409] - resignal: FALSE
[15:32:35.409] - force: TRUE
[15:32:35.410] - relayed: [n=2] TRUE, TRUE
[15:32:35.410] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:35.410] - relayed: [n=2] TRUE, TRUE
[15:32:35.411] - queued futures: [n=2] TRUE, TRUE
[15:32:35.411] signalConditionsASAP(NULL, pos=0) ... done
[15:32:35.411] resolve() on list ... DONE
[15:32:35.412] result() for ClusterFuture ...
[15:32:35.412] - result already collected: FutureResult
[15:32:35.412] result() for ClusterFuture ... done
[15:32:35.412] result() for ClusterFuture ...
[15:32:35.413] - result already collected: FutureResult
[15:32:35.413] result() for ClusterFuture ... done
[15:32:35.413] result() for ClusterFuture ...
[15:32:35.413] - result already collected: FutureResult
[15:32:35.414] result() for ClusterFuture ... done
[15:32:35.414] result() for ClusterFuture ...
[15:32:35.414] - result already collected: FutureResult
[15:32:35.415] result() for ClusterFuture ... done
[15:32:35.415]  - Number of value chunks collected: 2
[15:32:35.415] Resolving 2 futures (chunks) ... DONE
[15:32:35.415] Reducing values from 2 chunks ...
[15:32:35.416]  - Number of values collected after concatenation: 3
[15:32:35.416]  - Number of values expected: 3
[15:32:35.416] Reducing values from 2 chunks ... DONE
[15:32:35.417] future_lapply() ... DONE
List of 2
 $ y0:List of 3
  ..$ : chr [1, 1] "a"
  ..$ : chr [1, 1] "b"
  ..$ : chr [1, 1] "c"
 $ y1:List of 3
  ..$ : chr [1, 1] "a"
  ..$ : chr [1, 1] "b"
  ..$ : chr [1, 1] "c"
List of 2
 $ y0:List of 3
  ..$ : chr [1, 1] "a"
  ..$ : chr [1, 1] "b"
  ..$ : chr [1, 1] "c"
 $ y2:List of 3
  ..$ : chr [1, 1] "a"
  ..$ : chr [1, 1] "b"
  ..$ : chr [1, 1] "c"
[15:32:35.427] future_lapply() ...
[15:32:35.431] Number of chunks: 2
[15:32:35.432] getGlobalsAndPackagesXApply() ...
[15:32:35.432]  - future.globals: TRUE
[15:32:35.432] getGlobalsAndPackages() ...
[15:32:35.433] Searching for globals...
[15:32:35.434] - globals found: [1] 'FUN'
[15:32:35.435] Searching for globals ... DONE
[15:32:35.435] Resolving globals: FALSE
[15:32:35.436] The total size of the 1 globals is 848 bytes (848 bytes)
[15:32:35.436] The total size of the 1 globals exported for future expression ('FUN()') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:32:35.437] - globals: [1] 'FUN'
[15:32:35.437] 
[15:32:35.437] getGlobalsAndPackages() ... DONE
[15:32:35.437]  - globals found/used: [n=1] 'FUN'
[15:32:35.438]  - needed namespaces: [n=0] 
[15:32:35.438] Finding globals ... DONE
[15:32:35.438]  - use_args: TRUE
[15:32:35.438]  - Getting '...' globals ...
[15:32:35.439] resolve() on list ...
[15:32:35.439]  recursive: 0
[15:32:35.440]  length: 1
[15:32:35.440]  elements: '...'
[15:32:35.440]  length: 0 (resolved future 1)
[15:32:35.441] resolve() on list ... DONE
[15:32:35.441]    - '...' content: [n=0] 
[15:32:35.441] List of 1
[15:32:35.441]  $ ...: list()
[15:32:35.441]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:35.441]  - attr(*, "where")=List of 1
[15:32:35.441]   ..$ ...:<environment: 0x00000276e1d30768> 
[15:32:35.441]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:35.441]  - attr(*, "resolved")= logi TRUE
[15:32:35.441]  - attr(*, "total_size")= num NA
[15:32:35.446]  - Getting '...' globals ... DONE
[15:32:35.446] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:35.447] List of 2
[15:32:35.447]  $ ...future.FUN:function (x)  
[15:32:35.447]  $ ...          : list()
[15:32:35.447]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:35.447]  - attr(*, "where")=List of 2
[15:32:35.447]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:35.447]   ..$ ...          :<environment: 0x00000276e1d30768> 
[15:32:35.447]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:35.447]  - attr(*, "resolved")= logi FALSE
[15:32:35.447]  - attr(*, "total_size")= num 848
[15:32:35.452] Packages to be attached in all futures: [n=0] 
[15:32:35.453] getGlobalsAndPackagesXApply() ... DONE
[15:32:35.453] Number of futures (= number of chunks): 2
[15:32:35.454] Launching 2 futures (chunks) ...
[15:32:35.454] Chunk #1 of 2 ...
[15:32:35.454]  - Finding globals in 'X' for chunk #1 ...
[15:32:35.454] getGlobalsAndPackages() ...
[15:32:35.454] Searching for globals...
[15:32:35.455] 
[15:32:35.455] Searching for globals ... DONE
[15:32:35.455] - globals: [0] <none>
[15:32:35.456] getGlobalsAndPackages() ... DONE
[15:32:35.456]    + additional globals found: [n=0] 
[15:32:35.456]    + additional namespaces needed: [n=0] 
[15:32:35.457]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:35.457]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:35.457]  - seeds: <none>
[15:32:35.458]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:35.458] getGlobalsAndPackages() ...
[15:32:35.458] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:35.459] Resolving globals: FALSE
[15:32:35.459] Tweak future expression to call with '...' arguments ...
[15:32:35.459] {
[15:32:35.459]     do.call(function(...) {
[15:32:35.459]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:35.459]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:35.459]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:35.459]             on.exit(options(oopts), add = TRUE)
[15:32:35.459]         }
[15:32:35.459]         {
[15:32:35.459]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:35.459]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:35.459]                 ...future.FUN(...future.X_jj, ...)
[15:32:35.459]             })
[15:32:35.459]         }
[15:32:35.459]     }, args = future.call.arguments)
[15:32:35.459] }
[15:32:35.460] Tweak future expression to call with '...' arguments ... DONE
[15:32:35.461] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:35.461] 
[15:32:35.461] getGlobalsAndPackages() ... DONE
[15:32:35.462] run() for 'Future' ...
[15:32:35.463] - state: 'created'
[15:32:35.463] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:35.481] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:35.481] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:35.482]   - Field: 'node'
[15:32:35.482]   - Field: 'label'
[15:32:35.482]   - Field: 'local'
[15:32:35.482]   - Field: 'owner'
[15:32:35.482]   - Field: 'envir'
[15:32:35.483]   - Field: 'workers'
[15:32:35.483]   - Field: 'packages'
[15:32:35.483]   - Field: 'gc'
[15:32:35.483]   - Field: 'conditions'
[15:32:35.484]   - Field: 'persistent'
[15:32:35.484]   - Field: 'expr'
[15:32:35.484]   - Field: 'uuid'
[15:32:35.484]   - Field: 'seed'
[15:32:35.485]   - Field: 'version'
[15:32:35.485]   - Field: 'result'
[15:32:35.486]   - Field: 'asynchronous'
[15:32:35.486]   - Field: 'calls'
[15:32:35.486]   - Field: 'globals'
[15:32:35.487]   - Field: 'stdout'
[15:32:35.487]   - Field: 'earlySignal'
[15:32:35.487]   - Field: 'lazy'
[15:32:35.487]   - Field: 'state'
[15:32:35.488] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:35.488] - Launch lazy future ...
[15:32:35.488] Packages needed by the future expression (n = 0): <none>
[15:32:35.489] Packages needed by future strategies (n = 0): <none>
[15:32:35.490] {
[15:32:35.490]     {
[15:32:35.490]         {
[15:32:35.490]             ...future.startTime <- base::Sys.time()
[15:32:35.490]             {
[15:32:35.490]                 {
[15:32:35.490]                   {
[15:32:35.490]                     {
[15:32:35.490]                       base::local({
[15:32:35.490]                         has_future <- base::requireNamespace("future", 
[15:32:35.490]                           quietly = TRUE)
[15:32:35.490]                         if (has_future) {
[15:32:35.490]                           ns <- base::getNamespace("future")
[15:32:35.490]                           version <- ns[[".package"]][["version"]]
[15:32:35.490]                           if (is.null(version)) 
[15:32:35.490]                             version <- utils::packageVersion("future")
[15:32:35.490]                         }
[15:32:35.490]                         else {
[15:32:35.490]                           version <- NULL
[15:32:35.490]                         }
[15:32:35.490]                         if (!has_future || version < "1.8.0") {
[15:32:35.490]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:35.490]                             "", base::R.version$version.string), 
[15:32:35.490]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:35.490]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:35.490]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:35.490]                               "release", "version")], collapse = " "), 
[15:32:35.490]                             hostname = base::Sys.info()[["nodename"]])
[15:32:35.490]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:35.490]                             info)
[15:32:35.490]                           info <- base::paste(info, collapse = "; ")
[15:32:35.490]                           if (!has_future) {
[15:32:35.490]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:35.490]                               info)
[15:32:35.490]                           }
[15:32:35.490]                           else {
[15:32:35.490]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:35.490]                               info, version)
[15:32:35.490]                           }
[15:32:35.490]                           base::stop(msg)
[15:32:35.490]                         }
[15:32:35.490]                       })
[15:32:35.490]                     }
[15:32:35.490]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:35.490]                     base::options(mc.cores = 1L)
[15:32:35.490]                   }
[15:32:35.490]                   ...future.strategy.old <- future::plan("list")
[15:32:35.490]                   options(future.plan = NULL)
[15:32:35.490]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:35.490]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:35.490]                 }
[15:32:35.490]                 ...future.workdir <- getwd()
[15:32:35.490]             }
[15:32:35.490]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:35.490]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:35.490]         }
[15:32:35.490]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:35.490]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:35.490]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:35.490]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:35.490]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:35.490]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:35.490]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:35.490]             base::names(...future.oldOptions))
[15:32:35.490]     }
[15:32:35.490]     if (FALSE) {
[15:32:35.490]     }
[15:32:35.490]     else {
[15:32:35.490]         if (TRUE) {
[15:32:35.490]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:35.490]                 open = "w")
[15:32:35.490]         }
[15:32:35.490]         else {
[15:32:35.490]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:35.490]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:35.490]         }
[15:32:35.490]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:35.490]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:35.490]             base::sink(type = "output", split = FALSE)
[15:32:35.490]             base::close(...future.stdout)
[15:32:35.490]         }, add = TRUE)
[15:32:35.490]     }
[15:32:35.490]     ...future.frame <- base::sys.nframe()
[15:32:35.490]     ...future.conditions <- base::list()
[15:32:35.490]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:35.490]     if (FALSE) {
[15:32:35.490]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:35.490]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:35.490]     }
[15:32:35.490]     ...future.result <- base::tryCatch({
[15:32:35.490]         base::withCallingHandlers({
[15:32:35.490]             ...future.value <- base::withVisible(base::local({
[15:32:35.490]                 ...future.makeSendCondition <- base::local({
[15:32:35.490]                   sendCondition <- NULL
[15:32:35.490]                   function(frame = 1L) {
[15:32:35.490]                     if (is.function(sendCondition)) 
[15:32:35.490]                       return(sendCondition)
[15:32:35.490]                     ns <- getNamespace("parallel")
[15:32:35.490]                     if (exists("sendData", mode = "function", 
[15:32:35.490]                       envir = ns)) {
[15:32:35.490]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:35.490]                         envir = ns)
[15:32:35.490]                       envir <- sys.frame(frame)
[15:32:35.490]                       master <- NULL
[15:32:35.490]                       while (!identical(envir, .GlobalEnv) && 
[15:32:35.490]                         !identical(envir, emptyenv())) {
[15:32:35.490]                         if (exists("master", mode = "list", envir = envir, 
[15:32:35.490]                           inherits = FALSE)) {
[15:32:35.490]                           master <- get("master", mode = "list", 
[15:32:35.490]                             envir = envir, inherits = FALSE)
[15:32:35.490]                           if (inherits(master, c("SOCKnode", 
[15:32:35.490]                             "SOCK0node"))) {
[15:32:35.490]                             sendCondition <<- function(cond) {
[15:32:35.490]                               data <- list(type = "VALUE", value = cond, 
[15:32:35.490]                                 success = TRUE)
[15:32:35.490]                               parallel_sendData(master, data)
[15:32:35.490]                             }
[15:32:35.490]                             return(sendCondition)
[15:32:35.490]                           }
[15:32:35.490]                         }
[15:32:35.490]                         frame <- frame + 1L
[15:32:35.490]                         envir <- sys.frame(frame)
[15:32:35.490]                       }
[15:32:35.490]                     }
[15:32:35.490]                     sendCondition <<- function(cond) NULL
[15:32:35.490]                   }
[15:32:35.490]                 })
[15:32:35.490]                 withCallingHandlers({
[15:32:35.490]                   {
[15:32:35.490]                     do.call(function(...) {
[15:32:35.490]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:35.490]                       if (!identical(...future.globals.maxSize.org, 
[15:32:35.490]                         ...future.globals.maxSize)) {
[15:32:35.490]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:35.490]                         on.exit(options(oopts), add = TRUE)
[15:32:35.490]                       }
[15:32:35.490]                       {
[15:32:35.490]                         lapply(seq_along(...future.elements_ii), 
[15:32:35.490]                           FUN = function(jj) {
[15:32:35.490]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:35.490]                             ...future.FUN(...future.X_jj, ...)
[15:32:35.490]                           })
[15:32:35.490]                       }
[15:32:35.490]                     }, args = future.call.arguments)
[15:32:35.490]                   }
[15:32:35.490]                 }, immediateCondition = function(cond) {
[15:32:35.490]                   sendCondition <- ...future.makeSendCondition()
[15:32:35.490]                   sendCondition(cond)
[15:32:35.490]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:35.490]                   {
[15:32:35.490]                     inherits <- base::inherits
[15:32:35.490]                     invokeRestart <- base::invokeRestart
[15:32:35.490]                     is.null <- base::is.null
[15:32:35.490]                     muffled <- FALSE
[15:32:35.490]                     if (inherits(cond, "message")) {
[15:32:35.490]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:35.490]                       if (muffled) 
[15:32:35.490]                         invokeRestart("muffleMessage")
[15:32:35.490]                     }
[15:32:35.490]                     else if (inherits(cond, "warning")) {
[15:32:35.490]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:35.490]                       if (muffled) 
[15:32:35.490]                         invokeRestart("muffleWarning")
[15:32:35.490]                     }
[15:32:35.490]                     else if (inherits(cond, "condition")) {
[15:32:35.490]                       if (!is.null(pattern)) {
[15:32:35.490]                         computeRestarts <- base::computeRestarts
[15:32:35.490]                         grepl <- base::grepl
[15:32:35.490]                         restarts <- computeRestarts(cond)
[15:32:35.490]                         for (restart in restarts) {
[15:32:35.490]                           name <- restart$name
[15:32:35.490]                           if (is.null(name)) 
[15:32:35.490]                             next
[15:32:35.490]                           if (!grepl(pattern, name)) 
[15:32:35.490]                             next
[15:32:35.490]                           invokeRestart(restart)
[15:32:35.490]                           muffled <- TRUE
[15:32:35.490]                           break
[15:32:35.490]                         }
[15:32:35.490]                       }
[15:32:35.490]                     }
[15:32:35.490]                     invisible(muffled)
[15:32:35.490]                   }
[15:32:35.490]                   muffleCondition(cond)
[15:32:35.490]                 })
[15:32:35.490]             }))
[15:32:35.490]             future::FutureResult(value = ...future.value$value, 
[15:32:35.490]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:35.490]                   ...future.rng), globalenv = if (FALSE) 
[15:32:35.490]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:35.490]                     ...future.globalenv.names))
[15:32:35.490]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:35.490]         }, condition = base::local({
[15:32:35.490]             c <- base::c
[15:32:35.490]             inherits <- base::inherits
[15:32:35.490]             invokeRestart <- base::invokeRestart
[15:32:35.490]             length <- base::length
[15:32:35.490]             list <- base::list
[15:32:35.490]             seq.int <- base::seq.int
[15:32:35.490]             signalCondition <- base::signalCondition
[15:32:35.490]             sys.calls <- base::sys.calls
[15:32:35.490]             `[[` <- base::`[[`
[15:32:35.490]             `+` <- base::`+`
[15:32:35.490]             `<<-` <- base::`<<-`
[15:32:35.490]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:35.490]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:35.490]                   3L)]
[15:32:35.490]             }
[15:32:35.490]             function(cond) {
[15:32:35.490]                 is_error <- inherits(cond, "error")
[15:32:35.490]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:35.490]                   NULL)
[15:32:35.490]                 if (is_error) {
[15:32:35.490]                   sessionInformation <- function() {
[15:32:35.490]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:35.490]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:35.490]                       search = base::search(), system = base::Sys.info())
[15:32:35.490]                   }
[15:32:35.490]                   ...future.conditions[[length(...future.conditions) + 
[15:32:35.490]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:35.490]                     cond$call), session = sessionInformation(), 
[15:32:35.490]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:35.490]                   signalCondition(cond)
[15:32:35.490]                 }
[15:32:35.490]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:35.490]                 "immediateCondition"))) {
[15:32:35.490]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:35.490]                   ...future.conditions[[length(...future.conditions) + 
[15:32:35.490]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:35.490]                   if (TRUE && !signal) {
[15:32:35.490]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:35.490]                     {
[15:32:35.490]                       inherits <- base::inherits
[15:32:35.490]                       invokeRestart <- base::invokeRestart
[15:32:35.490]                       is.null <- base::is.null
[15:32:35.490]                       muffled <- FALSE
[15:32:35.490]                       if (inherits(cond, "message")) {
[15:32:35.490]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:35.490]                         if (muffled) 
[15:32:35.490]                           invokeRestart("muffleMessage")
[15:32:35.490]                       }
[15:32:35.490]                       else if (inherits(cond, "warning")) {
[15:32:35.490]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:35.490]                         if (muffled) 
[15:32:35.490]                           invokeRestart("muffleWarning")
[15:32:35.490]                       }
[15:32:35.490]                       else if (inherits(cond, "condition")) {
[15:32:35.490]                         if (!is.null(pattern)) {
[15:32:35.490]                           computeRestarts <- base::computeRestarts
[15:32:35.490]                           grepl <- base::grepl
[15:32:35.490]                           restarts <- computeRestarts(cond)
[15:32:35.490]                           for (restart in restarts) {
[15:32:35.490]                             name <- restart$name
[15:32:35.490]                             if (is.null(name)) 
[15:32:35.490]                               next
[15:32:35.490]                             if (!grepl(pattern, name)) 
[15:32:35.490]                               next
[15:32:35.490]                             invokeRestart(restart)
[15:32:35.490]                             muffled <- TRUE
[15:32:35.490]                             break
[15:32:35.490]                           }
[15:32:35.490]                         }
[15:32:35.490]                       }
[15:32:35.490]                       invisible(muffled)
[15:32:35.490]                     }
[15:32:35.490]                     muffleCondition(cond, pattern = "^muffle")
[15:32:35.490]                   }
[15:32:35.490]                 }
[15:32:35.490]                 else {
[15:32:35.490]                   if (TRUE) {
[15:32:35.490]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:35.490]                     {
[15:32:35.490]                       inherits <- base::inherits
[15:32:35.490]                       invokeRestart <- base::invokeRestart
[15:32:35.490]                       is.null <- base::is.null
[15:32:35.490]                       muffled <- FALSE
[15:32:35.490]                       if (inherits(cond, "message")) {
[15:32:35.490]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:35.490]                         if (muffled) 
[15:32:35.490]                           invokeRestart("muffleMessage")
[15:32:35.490]                       }
[15:32:35.490]                       else if (inherits(cond, "warning")) {
[15:32:35.490]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:35.490]                         if (muffled) 
[15:32:35.490]                           invokeRestart("muffleWarning")
[15:32:35.490]                       }
[15:32:35.490]                       else if (inherits(cond, "condition")) {
[15:32:35.490]                         if (!is.null(pattern)) {
[15:32:35.490]                           computeRestarts <- base::computeRestarts
[15:32:35.490]                           grepl <- base::grepl
[15:32:35.490]                           restarts <- computeRestarts(cond)
[15:32:35.490]                           for (restart in restarts) {
[15:32:35.490]                             name <- restart$name
[15:32:35.490]                             if (is.null(name)) 
[15:32:35.490]                               next
[15:32:35.490]                             if (!grepl(pattern, name)) 
[15:32:35.490]                               next
[15:32:35.490]                             invokeRestart(restart)
[15:32:35.490]                             muffled <- TRUE
[15:32:35.490]                             break
[15:32:35.490]                           }
[15:32:35.490]                         }
[15:32:35.490]                       }
[15:32:35.490]                       invisible(muffled)
[15:32:35.490]                     }
[15:32:35.490]                     muffleCondition(cond, pattern = "^muffle")
[15:32:35.490]                   }
[15:32:35.490]                 }
[15:32:35.490]             }
[15:32:35.490]         }))
[15:32:35.490]     }, error = function(ex) {
[15:32:35.490]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:35.490]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:35.490]                 ...future.rng), started = ...future.startTime, 
[15:32:35.490]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:35.490]             version = "1.8"), class = "FutureResult")
[15:32:35.490]     }, finally = {
[15:32:35.490]         if (!identical(...future.workdir, getwd())) 
[15:32:35.490]             setwd(...future.workdir)
[15:32:35.490]         {
[15:32:35.490]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:35.490]                 ...future.oldOptions$nwarnings <- NULL
[15:32:35.490]             }
[15:32:35.490]             base::options(...future.oldOptions)
[15:32:35.490]             if (.Platform$OS.type == "windows") {
[15:32:35.490]                 old_names <- names(...future.oldEnvVars)
[15:32:35.490]                 envs <- base::Sys.getenv()
[15:32:35.490]                 names <- names(envs)
[15:32:35.490]                 common <- intersect(names, old_names)
[15:32:35.490]                 added <- setdiff(names, old_names)
[15:32:35.490]                 removed <- setdiff(old_names, names)
[15:32:35.490]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:35.490]                   envs[common]]
[15:32:35.490]                 NAMES <- toupper(changed)
[15:32:35.490]                 args <- list()
[15:32:35.490]                 for (kk in seq_along(NAMES)) {
[15:32:35.490]                   name <- changed[[kk]]
[15:32:35.490]                   NAME <- NAMES[[kk]]
[15:32:35.490]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:35.490]                     next
[15:32:35.490]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:35.490]                 }
[15:32:35.490]                 NAMES <- toupper(added)
[15:32:35.490]                 for (kk in seq_along(NAMES)) {
[15:32:35.490]                   name <- added[[kk]]
[15:32:35.490]                   NAME <- NAMES[[kk]]
[15:32:35.490]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:35.490]                     next
[15:32:35.490]                   args[[name]] <- ""
[15:32:35.490]                 }
[15:32:35.490]                 NAMES <- toupper(removed)
[15:32:35.490]                 for (kk in seq_along(NAMES)) {
[15:32:35.490]                   name <- removed[[kk]]
[15:32:35.490]                   NAME <- NAMES[[kk]]
[15:32:35.490]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:35.490]                     next
[15:32:35.490]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:35.490]                 }
[15:32:35.490]                 if (length(args) > 0) 
[15:32:35.490]                   base::do.call(base::Sys.setenv, args = args)
[15:32:35.490]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:35.490]             }
[15:32:35.490]             else {
[15:32:35.490]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:35.490]             }
[15:32:35.490]             {
[15:32:35.490]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:35.490]                   0L) {
[15:32:35.490]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:35.490]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:35.490]                   base::options(opts)
[15:32:35.490]                 }
[15:32:35.490]                 {
[15:32:35.490]                   {
[15:32:35.490]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:35.490]                     NULL
[15:32:35.490]                   }
[15:32:35.490]                   options(future.plan = NULL)
[15:32:35.490]                   if (is.na(NA_character_)) 
[15:32:35.490]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:35.490]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:35.490]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:35.490]                     .init = FALSE)
[15:32:35.490]                 }
[15:32:35.490]             }
[15:32:35.490]         }
[15:32:35.490]     })
[15:32:35.490]     if (TRUE) {
[15:32:35.490]         base::sink(type = "output", split = FALSE)
[15:32:35.490]         if (TRUE) {
[15:32:35.490]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:35.490]         }
[15:32:35.490]         else {
[15:32:35.490]             ...future.result["stdout"] <- base::list(NULL)
[15:32:35.490]         }
[15:32:35.490]         base::close(...future.stdout)
[15:32:35.490]         ...future.stdout <- NULL
[15:32:35.490]     }
[15:32:35.490]     ...future.result$conditions <- ...future.conditions
[15:32:35.490]     ...future.result$finished <- base::Sys.time()
[15:32:35.490]     ...future.result
[15:32:35.490] }
[15:32:35.496] Exporting 5 global objects (848 bytes) to cluster node #1 ...
[15:32:35.497] Exporting '...future.FUN' (848 bytes) to cluster node #1 ...
[15:32:35.497] Exporting '...future.FUN' (848 bytes) to cluster node #1 ... DONE
[15:32:35.498] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:35.498] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:35.499] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:35.499] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:35.499] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:35.500] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:35.501] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:35.501] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:35.502] Exporting 5 global objects (848 bytes) to cluster node #1 ... DONE
[15:32:35.503] MultisessionFuture started
[15:32:35.503] - Launch lazy future ... done
[15:32:35.504] run() for 'MultisessionFuture' ... done
[15:32:35.504] Created future:
[15:32:35.527] receiveMessageFromWorker() for ClusterFuture ...
[15:32:35.528] - Validating connection of MultisessionFuture
[15:32:35.528] - received message: FutureResult
[15:32:35.529] - Received FutureResult
[15:32:35.529] - Erased future from FutureRegistry
[15:32:35.529] result() for ClusterFuture ...
[15:32:35.529] - result already collected: FutureResult
[15:32:35.530] result() for ClusterFuture ... done
[15:32:35.530] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:35.504] MultisessionFuture:
[15:32:35.504] Label: 'future_sapply-1'
[15:32:35.504] Expression:
[15:32:35.504] {
[15:32:35.504]     do.call(function(...) {
[15:32:35.504]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:35.504]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:35.504]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:35.504]             on.exit(options(oopts), add = TRUE)
[15:32:35.504]         }
[15:32:35.504]         {
[15:32:35.504]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:35.504]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:35.504]                 ...future.FUN(...future.X_jj, ...)
[15:32:35.504]             })
[15:32:35.504]         }
[15:32:35.504]     }, args = future.call.arguments)
[15:32:35.504] }
[15:32:35.504] Lazy evaluation: FALSE
[15:32:35.504] Asynchronous evaluation: TRUE
[15:32:35.504] Local evaluation: TRUE
[15:32:35.504] Environment: R_GlobalEnv
[15:32:35.504] Capture standard output: TRUE
[15:32:35.504] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:35.504] Globals: 5 objects totaling 960 bytes (function '...future.FUN' of 848 bytes, 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)
[15:32:35.504] Packages: <none>
[15:32:35.504] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:35.504] Resolved: TRUE
[15:32:35.504] Value: <not collected>
[15:32:35.504] Conditions captured: <none>
[15:32:35.504] Early signaling: FALSE
[15:32:35.504] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:35.504] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:35.530] Chunk #1 of 2 ... DONE
[15:32:35.531] Chunk #2 of 2 ...
[15:32:35.531]  - Finding globals in 'X' for chunk #2 ...
[15:32:35.532] getGlobalsAndPackages() ...
[15:32:35.532] Searching for globals...
[15:32:35.533] 
[15:32:35.533] Searching for globals ... DONE
[15:32:35.533] - globals: [0] <none>
[15:32:35.534] getGlobalsAndPackages() ... DONE
[15:32:35.534]    + additional globals found: [n=0] 
[15:32:35.535]    + additional namespaces needed: [n=0] 
[15:32:35.535]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:35.535]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:35.536]  - seeds: <none>
[15:32:35.536]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:35.536] getGlobalsAndPackages() ...
[15:32:35.537] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:35.537] Resolving globals: FALSE
[15:32:35.538] Tweak future expression to call with '...' arguments ...
[15:32:35.538] {
[15:32:35.538]     do.call(function(...) {
[15:32:35.538]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:35.538]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:35.538]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:35.538]             on.exit(options(oopts), add = TRUE)
[15:32:35.538]         }
[15:32:35.538]         {
[15:32:35.538]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:35.538]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:35.538]                 ...future.FUN(...future.X_jj, ...)
[15:32:35.538]             })
[15:32:35.538]         }
[15:32:35.538]     }, args = future.call.arguments)
[15:32:35.538] }
[15:32:35.539] Tweak future expression to call with '...' arguments ... DONE
[15:32:35.540] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:35.540] 
[15:32:35.541] getGlobalsAndPackages() ... DONE
[15:32:35.541] run() for 'Future' ...
[15:32:35.542] - state: 'created'
[15:32:35.542] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:35.564] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:35.564] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:35.564]   - Field: 'node'
[15:32:35.565]   - Field: 'label'
[15:32:35.565]   - Field: 'local'
[15:32:35.565]   - Field: 'owner'
[15:32:35.565]   - Field: 'envir'
[15:32:35.565]   - Field: 'workers'
[15:32:35.566]   - Field: 'packages'
[15:32:35.566]   - Field: 'gc'
[15:32:35.566]   - Field: 'conditions'
[15:32:35.566]   - Field: 'persistent'
[15:32:35.566]   - Field: 'expr'
[15:32:35.567]   - Field: 'uuid'
[15:32:35.567]   - Field: 'seed'
[15:32:35.567]   - Field: 'version'
[15:32:35.567]   - Field: 'result'
[15:32:35.567]   - Field: 'asynchronous'
[15:32:35.567]   - Field: 'calls'
[15:32:35.568]   - Field: 'globals'
[15:32:35.568]   - Field: 'stdout'
[15:32:35.568]   - Field: 'earlySignal'
[15:32:35.568]   - Field: 'lazy'
[15:32:35.568]   - Field: 'state'
[15:32:35.569] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:35.569] - Launch lazy future ...
[15:32:35.569] Packages needed by the future expression (n = 0): <none>
[15:32:35.569] Packages needed by future strategies (n = 0): <none>
[15:32:35.570] {
[15:32:35.570]     {
[15:32:35.570]         {
[15:32:35.570]             ...future.startTime <- base::Sys.time()
[15:32:35.570]             {
[15:32:35.570]                 {
[15:32:35.570]                   {
[15:32:35.570]                     {
[15:32:35.570]                       base::local({
[15:32:35.570]                         has_future <- base::requireNamespace("future", 
[15:32:35.570]                           quietly = TRUE)
[15:32:35.570]                         if (has_future) {
[15:32:35.570]                           ns <- base::getNamespace("future")
[15:32:35.570]                           version <- ns[[".package"]][["version"]]
[15:32:35.570]                           if (is.null(version)) 
[15:32:35.570]                             version <- utils::packageVersion("future")
[15:32:35.570]                         }
[15:32:35.570]                         else {
[15:32:35.570]                           version <- NULL
[15:32:35.570]                         }
[15:32:35.570]                         if (!has_future || version < "1.8.0") {
[15:32:35.570]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:35.570]                             "", base::R.version$version.string), 
[15:32:35.570]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:35.570]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:35.570]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:35.570]                               "release", "version")], collapse = " "), 
[15:32:35.570]                             hostname = base::Sys.info()[["nodename"]])
[15:32:35.570]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:35.570]                             info)
[15:32:35.570]                           info <- base::paste(info, collapse = "; ")
[15:32:35.570]                           if (!has_future) {
[15:32:35.570]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:35.570]                               info)
[15:32:35.570]                           }
[15:32:35.570]                           else {
[15:32:35.570]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:35.570]                               info, version)
[15:32:35.570]                           }
[15:32:35.570]                           base::stop(msg)
[15:32:35.570]                         }
[15:32:35.570]                       })
[15:32:35.570]                     }
[15:32:35.570]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:35.570]                     base::options(mc.cores = 1L)
[15:32:35.570]                   }
[15:32:35.570]                   ...future.strategy.old <- future::plan("list")
[15:32:35.570]                   options(future.plan = NULL)
[15:32:35.570]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:35.570]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:35.570]                 }
[15:32:35.570]                 ...future.workdir <- getwd()
[15:32:35.570]             }
[15:32:35.570]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:35.570]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:35.570]         }
[15:32:35.570]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:35.570]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:35.570]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:35.570]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:35.570]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:35.570]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:35.570]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:35.570]             base::names(...future.oldOptions))
[15:32:35.570]     }
[15:32:35.570]     if (FALSE) {
[15:32:35.570]     }
[15:32:35.570]     else {
[15:32:35.570]         if (TRUE) {
[15:32:35.570]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:35.570]                 open = "w")
[15:32:35.570]         }
[15:32:35.570]         else {
[15:32:35.570]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:35.570]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:35.570]         }
[15:32:35.570]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:35.570]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:35.570]             base::sink(type = "output", split = FALSE)
[15:32:35.570]             base::close(...future.stdout)
[15:32:35.570]         }, add = TRUE)
[15:32:35.570]     }
[15:32:35.570]     ...future.frame <- base::sys.nframe()
[15:32:35.570]     ...future.conditions <- base::list()
[15:32:35.570]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:35.570]     if (FALSE) {
[15:32:35.570]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:35.570]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:35.570]     }
[15:32:35.570]     ...future.result <- base::tryCatch({
[15:32:35.570]         base::withCallingHandlers({
[15:32:35.570]             ...future.value <- base::withVisible(base::local({
[15:32:35.570]                 ...future.makeSendCondition <- base::local({
[15:32:35.570]                   sendCondition <- NULL
[15:32:35.570]                   function(frame = 1L) {
[15:32:35.570]                     if (is.function(sendCondition)) 
[15:32:35.570]                       return(sendCondition)
[15:32:35.570]                     ns <- getNamespace("parallel")
[15:32:35.570]                     if (exists("sendData", mode = "function", 
[15:32:35.570]                       envir = ns)) {
[15:32:35.570]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:35.570]                         envir = ns)
[15:32:35.570]                       envir <- sys.frame(frame)
[15:32:35.570]                       master <- NULL
[15:32:35.570]                       while (!identical(envir, .GlobalEnv) && 
[15:32:35.570]                         !identical(envir, emptyenv())) {
[15:32:35.570]                         if (exists("master", mode = "list", envir = envir, 
[15:32:35.570]                           inherits = FALSE)) {
[15:32:35.570]                           master <- get("master", mode = "list", 
[15:32:35.570]                             envir = envir, inherits = FALSE)
[15:32:35.570]                           if (inherits(master, c("SOCKnode", 
[15:32:35.570]                             "SOCK0node"))) {
[15:32:35.570]                             sendCondition <<- function(cond) {
[15:32:35.570]                               data <- list(type = "VALUE", value = cond, 
[15:32:35.570]                                 success = TRUE)
[15:32:35.570]                               parallel_sendData(master, data)
[15:32:35.570]                             }
[15:32:35.570]                             return(sendCondition)
[15:32:35.570]                           }
[15:32:35.570]                         }
[15:32:35.570]                         frame <- frame + 1L
[15:32:35.570]                         envir <- sys.frame(frame)
[15:32:35.570]                       }
[15:32:35.570]                     }
[15:32:35.570]                     sendCondition <<- function(cond) NULL
[15:32:35.570]                   }
[15:32:35.570]                 })
[15:32:35.570]                 withCallingHandlers({
[15:32:35.570]                   {
[15:32:35.570]                     do.call(function(...) {
[15:32:35.570]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:35.570]                       if (!identical(...future.globals.maxSize.org, 
[15:32:35.570]                         ...future.globals.maxSize)) {
[15:32:35.570]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:35.570]                         on.exit(options(oopts), add = TRUE)
[15:32:35.570]                       }
[15:32:35.570]                       {
[15:32:35.570]                         lapply(seq_along(...future.elements_ii), 
[15:32:35.570]                           FUN = function(jj) {
[15:32:35.570]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:35.570]                             ...future.FUN(...future.X_jj, ...)
[15:32:35.570]                           })
[15:32:35.570]                       }
[15:32:35.570]                     }, args = future.call.arguments)
[15:32:35.570]                   }
[15:32:35.570]                 }, immediateCondition = function(cond) {
[15:32:35.570]                   sendCondition <- ...future.makeSendCondition()
[15:32:35.570]                   sendCondition(cond)
[15:32:35.570]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:35.570]                   {
[15:32:35.570]                     inherits <- base::inherits
[15:32:35.570]                     invokeRestart <- base::invokeRestart
[15:32:35.570]                     is.null <- base::is.null
[15:32:35.570]                     muffled <- FALSE
[15:32:35.570]                     if (inherits(cond, "message")) {
[15:32:35.570]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:35.570]                       if (muffled) 
[15:32:35.570]                         invokeRestart("muffleMessage")
[15:32:35.570]                     }
[15:32:35.570]                     else if (inherits(cond, "warning")) {
[15:32:35.570]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:35.570]                       if (muffled) 
[15:32:35.570]                         invokeRestart("muffleWarning")
[15:32:35.570]                     }
[15:32:35.570]                     else if (inherits(cond, "condition")) {
[15:32:35.570]                       if (!is.null(pattern)) {
[15:32:35.570]                         computeRestarts <- base::computeRestarts
[15:32:35.570]                         grepl <- base::grepl
[15:32:35.570]                         restarts <- computeRestarts(cond)
[15:32:35.570]                         for (restart in restarts) {
[15:32:35.570]                           name <- restart$name
[15:32:35.570]                           if (is.null(name)) 
[15:32:35.570]                             next
[15:32:35.570]                           if (!grepl(pattern, name)) 
[15:32:35.570]                             next
[15:32:35.570]                           invokeRestart(restart)
[15:32:35.570]                           muffled <- TRUE
[15:32:35.570]                           break
[15:32:35.570]                         }
[15:32:35.570]                       }
[15:32:35.570]                     }
[15:32:35.570]                     invisible(muffled)
[15:32:35.570]                   }
[15:32:35.570]                   muffleCondition(cond)
[15:32:35.570]                 })
[15:32:35.570]             }))
[15:32:35.570]             future::FutureResult(value = ...future.value$value, 
[15:32:35.570]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:35.570]                   ...future.rng), globalenv = if (FALSE) 
[15:32:35.570]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:35.570]                     ...future.globalenv.names))
[15:32:35.570]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:35.570]         }, condition = base::local({
[15:32:35.570]             c <- base::c
[15:32:35.570]             inherits <- base::inherits
[15:32:35.570]             invokeRestart <- base::invokeRestart
[15:32:35.570]             length <- base::length
[15:32:35.570]             list <- base::list
[15:32:35.570]             seq.int <- base::seq.int
[15:32:35.570]             signalCondition <- base::signalCondition
[15:32:35.570]             sys.calls <- base::sys.calls
[15:32:35.570]             `[[` <- base::`[[`
[15:32:35.570]             `+` <- base::`+`
[15:32:35.570]             `<<-` <- base::`<<-`
[15:32:35.570]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:35.570]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:35.570]                   3L)]
[15:32:35.570]             }
[15:32:35.570]             function(cond) {
[15:32:35.570]                 is_error <- inherits(cond, "error")
[15:32:35.570]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:35.570]                   NULL)
[15:32:35.570]                 if (is_error) {
[15:32:35.570]                   sessionInformation <- function() {
[15:32:35.570]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:35.570]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:35.570]                       search = base::search(), system = base::Sys.info())
[15:32:35.570]                   }
[15:32:35.570]                   ...future.conditions[[length(...future.conditions) + 
[15:32:35.570]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:35.570]                     cond$call), session = sessionInformation(), 
[15:32:35.570]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:35.570]                   signalCondition(cond)
[15:32:35.570]                 }
[15:32:35.570]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:35.570]                 "immediateCondition"))) {
[15:32:35.570]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:35.570]                   ...future.conditions[[length(...future.conditions) + 
[15:32:35.570]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:35.570]                   if (TRUE && !signal) {
[15:32:35.570]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:35.570]                     {
[15:32:35.570]                       inherits <- base::inherits
[15:32:35.570]                       invokeRestart <- base::invokeRestart
[15:32:35.570]                       is.null <- base::is.null
[15:32:35.570]                       muffled <- FALSE
[15:32:35.570]                       if (inherits(cond, "message")) {
[15:32:35.570]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:35.570]                         if (muffled) 
[15:32:35.570]                           invokeRestart("muffleMessage")
[15:32:35.570]                       }
[15:32:35.570]                       else if (inherits(cond, "warning")) {
[15:32:35.570]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:35.570]                         if (muffled) 
[15:32:35.570]                           invokeRestart("muffleWarning")
[15:32:35.570]                       }
[15:32:35.570]                       else if (inherits(cond, "condition")) {
[15:32:35.570]                         if (!is.null(pattern)) {
[15:32:35.570]                           computeRestarts <- base::computeRestarts
[15:32:35.570]                           grepl <- base::grepl
[15:32:35.570]                           restarts <- computeRestarts(cond)
[15:32:35.570]                           for (restart in restarts) {
[15:32:35.570]                             name <- restart$name
[15:32:35.570]                             if (is.null(name)) 
[15:32:35.570]                               next
[15:32:35.570]                             if (!grepl(pattern, name)) 
[15:32:35.570]                               next
[15:32:35.570]                             invokeRestart(restart)
[15:32:35.570]                             muffled <- TRUE
[15:32:35.570]                             break
[15:32:35.570]                           }
[15:32:35.570]                         }
[15:32:35.570]                       }
[15:32:35.570]                       invisible(muffled)
[15:32:35.570]                     }
[15:32:35.570]                     muffleCondition(cond, pattern = "^muffle")
[15:32:35.570]                   }
[15:32:35.570]                 }
[15:32:35.570]                 else {
[15:32:35.570]                   if (TRUE) {
[15:32:35.570]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:35.570]                     {
[15:32:35.570]                       inherits <- base::inherits
[15:32:35.570]                       invokeRestart <- base::invokeRestart
[15:32:35.570]                       is.null <- base::is.null
[15:32:35.570]                       muffled <- FALSE
[15:32:35.570]                       if (inherits(cond, "message")) {
[15:32:35.570]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:35.570]                         if (muffled) 
[15:32:35.570]                           invokeRestart("muffleMessage")
[15:32:35.570]                       }
[15:32:35.570]                       else if (inherits(cond, "warning")) {
[15:32:35.570]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:35.570]                         if (muffled) 
[15:32:35.570]                           invokeRestart("muffleWarning")
[15:32:35.570]                       }
[15:32:35.570]                       else if (inherits(cond, "condition")) {
[15:32:35.570]                         if (!is.null(pattern)) {
[15:32:35.570]                           computeRestarts <- base::computeRestarts
[15:32:35.570]                           grepl <- base::grepl
[15:32:35.570]                           restarts <- computeRestarts(cond)
[15:32:35.570]                           for (restart in restarts) {
[15:32:35.570]                             name <- restart$name
[15:32:35.570]                             if (is.null(name)) 
[15:32:35.570]                               next
[15:32:35.570]                             if (!grepl(pattern, name)) 
[15:32:35.570]                               next
[15:32:35.570]                             invokeRestart(restart)
[15:32:35.570]                             muffled <- TRUE
[15:32:35.570]                             break
[15:32:35.570]                           }
[15:32:35.570]                         }
[15:32:35.570]                       }
[15:32:35.570]                       invisible(muffled)
[15:32:35.570]                     }
[15:32:35.570]                     muffleCondition(cond, pattern = "^muffle")
[15:32:35.570]                   }
[15:32:35.570]                 }
[15:32:35.570]             }
[15:32:35.570]         }))
[15:32:35.570]     }, error = function(ex) {
[15:32:35.570]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:35.570]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:35.570]                 ...future.rng), started = ...future.startTime, 
[15:32:35.570]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:35.570]             version = "1.8"), class = "FutureResult")
[15:32:35.570]     }, finally = {
[15:32:35.570]         if (!identical(...future.workdir, getwd())) 
[15:32:35.570]             setwd(...future.workdir)
[15:32:35.570]         {
[15:32:35.570]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:35.570]                 ...future.oldOptions$nwarnings <- NULL
[15:32:35.570]             }
[15:32:35.570]             base::options(...future.oldOptions)
[15:32:35.570]             if (.Platform$OS.type == "windows") {
[15:32:35.570]                 old_names <- names(...future.oldEnvVars)
[15:32:35.570]                 envs <- base::Sys.getenv()
[15:32:35.570]                 names <- names(envs)
[15:32:35.570]                 common <- intersect(names, old_names)
[15:32:35.570]                 added <- setdiff(names, old_names)
[15:32:35.570]                 removed <- setdiff(old_names, names)
[15:32:35.570]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:35.570]                   envs[common]]
[15:32:35.570]                 NAMES <- toupper(changed)
[15:32:35.570]                 args <- list()
[15:32:35.570]                 for (kk in seq_along(NAMES)) {
[15:32:35.570]                   name <- changed[[kk]]
[15:32:35.570]                   NAME <- NAMES[[kk]]
[15:32:35.570]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:35.570]                     next
[15:32:35.570]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:35.570]                 }
[15:32:35.570]                 NAMES <- toupper(added)
[15:32:35.570]                 for (kk in seq_along(NAMES)) {
[15:32:35.570]                   name <- added[[kk]]
[15:32:35.570]                   NAME <- NAMES[[kk]]
[15:32:35.570]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:35.570]                     next
[15:32:35.570]                   args[[name]] <- ""
[15:32:35.570]                 }
[15:32:35.570]                 NAMES <- toupper(removed)
[15:32:35.570]                 for (kk in seq_along(NAMES)) {
[15:32:35.570]                   name <- removed[[kk]]
[15:32:35.570]                   NAME <- NAMES[[kk]]
[15:32:35.570]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:35.570]                     next
[15:32:35.570]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:35.570]                 }
[15:32:35.570]                 if (length(args) > 0) 
[15:32:35.570]                   base::do.call(base::Sys.setenv, args = args)
[15:32:35.570]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:35.570]             }
[15:32:35.570]             else {
[15:32:35.570]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:35.570]             }
[15:32:35.570]             {
[15:32:35.570]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:35.570]                   0L) {
[15:32:35.570]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:35.570]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:35.570]                   base::options(opts)
[15:32:35.570]                 }
[15:32:35.570]                 {
[15:32:35.570]                   {
[15:32:35.570]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:35.570]                     NULL
[15:32:35.570]                   }
[15:32:35.570]                   options(future.plan = NULL)
[15:32:35.570]                   if (is.na(NA_character_)) 
[15:32:35.570]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:35.570]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:35.570]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:35.570]                     .init = FALSE)
[15:32:35.570]                 }
[15:32:35.570]             }
[15:32:35.570]         }
[15:32:35.570]     })
[15:32:35.570]     if (TRUE) {
[15:32:35.570]         base::sink(type = "output", split = FALSE)
[15:32:35.570]         if (TRUE) {
[15:32:35.570]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:35.570]         }
[15:32:35.570]         else {
[15:32:35.570]             ...future.result["stdout"] <- base::list(NULL)
[15:32:35.570]         }
[15:32:35.570]         base::close(...future.stdout)
[15:32:35.570]         ...future.stdout <- NULL
[15:32:35.570]     }
[15:32:35.570]     ...future.result$conditions <- ...future.conditions
[15:32:35.570]     ...future.result$finished <- base::Sys.time()
[15:32:35.570]     ...future.result
[15:32:35.570] }
[15:32:35.577] Exporting 5 global objects (848 bytes) to cluster node #1 ...
[15:32:35.577] Exporting '...future.FUN' (848 bytes) to cluster node #1 ...
[15:32:35.578] Exporting '...future.FUN' (848 bytes) to cluster node #1 ... DONE
[15:32:35.579] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:35.580] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:35.580] Exporting '...future.elements_ii' (224 bytes) to cluster node #1 ...
[15:32:35.581] Exporting '...future.elements_ii' (224 bytes) to cluster node #1 ... DONE
[15:32:35.581] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:35.582] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:35.582] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:35.583] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:35.583] Exporting 5 global objects (848 bytes) to cluster node #1 ... DONE
[15:32:35.584] MultisessionFuture started
[15:32:35.584] - Launch lazy future ... done
[15:32:35.585] run() for 'MultisessionFuture' ... done
[15:32:35.585] Created future:
[15:32:35.606] receiveMessageFromWorker() for ClusterFuture ...
[15:32:35.606] - Validating connection of MultisessionFuture
[15:32:35.607] - received message: FutureResult
[15:32:35.607] - Received FutureResult
[15:32:35.607] - Erased future from FutureRegistry
[15:32:35.607] result() for ClusterFuture ...
[15:32:35.608] - result already collected: FutureResult
[15:32:35.608] result() for ClusterFuture ... done
[15:32:35.608] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:35.585] MultisessionFuture:
[15:32:35.585] Label: 'future_sapply-2'
[15:32:35.585] Expression:
[15:32:35.585] {
[15:32:35.585]     do.call(function(...) {
[15:32:35.585]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:35.585]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:35.585]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:35.585]             on.exit(options(oopts), add = TRUE)
[15:32:35.585]         }
[15:32:35.585]         {
[15:32:35.585]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:35.585]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:35.585]                 ...future.FUN(...future.X_jj, ...)
[15:32:35.585]             })
[15:32:35.585]         }
[15:32:35.585]     }, args = future.call.arguments)
[15:32:35.585] }
[15:32:35.585] Lazy evaluation: FALSE
[15:32:35.585] Asynchronous evaluation: TRUE
[15:32:35.585] Local evaluation: TRUE
[15:32:35.585] Environment: R_GlobalEnv
[15:32:35.585] Capture standard output: TRUE
[15:32:35.585] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:35.585] Globals: 5 objects totaling 1.05 KiB (function '...future.FUN' of 848 bytes, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 224 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:35.585] Packages: <none>
[15:32:35.585] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:35.585] Resolved: TRUE
[15:32:35.585] Value: <not collected>
[15:32:35.585] Conditions captured: <none>
[15:32:35.585] Early signaling: FALSE
[15:32:35.585] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:35.585] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:35.609] Chunk #2 of 2 ... DONE
[15:32:35.609] Launching 2 futures (chunks) ... DONE
[15:32:35.609] Resolving 2 futures (chunks) ...
[15:32:35.610] resolve() on list ...
[15:32:35.610]  recursive: 0
[15:32:35.610]  length: 2
[15:32:35.610] 
[15:32:35.611] Future #1
[15:32:35.611] result() for ClusterFuture ...
[15:32:35.611] - result already collected: FutureResult
[15:32:35.611] result() for ClusterFuture ... done
[15:32:35.612] result() for ClusterFuture ...
[15:32:35.612] - result already collected: FutureResult
[15:32:35.612] result() for ClusterFuture ... done
[15:32:35.612] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:35.613] - nx: 2
[15:32:35.613] - relay: TRUE
[15:32:35.613] - stdout: TRUE
[15:32:35.613] - signal: TRUE
[15:32:35.613] - resignal: FALSE
[15:32:35.614] - force: TRUE
[15:32:35.614] - relayed: [n=2] FALSE, FALSE
[15:32:35.614] - queued futures: [n=2] FALSE, FALSE
[15:32:35.614]  - until=1
[15:32:35.615]  - relaying element #1
[15:32:35.615] result() for ClusterFuture ...
[15:32:35.615] - result already collected: FutureResult
[15:32:35.615] result() for ClusterFuture ... done
[15:32:35.616] result() for ClusterFuture ...
[15:32:35.616] - result already collected: FutureResult
[15:32:35.616] result() for ClusterFuture ... done
[15:32:35.616] result() for ClusterFuture ...
[15:32:35.617] - result already collected: FutureResult
[15:32:35.617] result() for ClusterFuture ... done
[15:32:35.617] result() for ClusterFuture ...
[15:32:35.617] - result already collected: FutureResult
[15:32:35.617] result() for ClusterFuture ... done
[15:32:35.618] - relayed: [n=2] TRUE, FALSE
[15:32:35.618] - queued futures: [n=2] TRUE, FALSE
[15:32:35.618] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:35.618]  length: 1 (resolved future 1)
[15:32:35.619] Future #2
[15:32:35.619] result() for ClusterFuture ...
[15:32:35.619] - result already collected: FutureResult
[15:32:35.619] result() for ClusterFuture ... done
[15:32:35.626] result() for ClusterFuture ...
[15:32:35.626] - result already collected: FutureResult
[15:32:35.627] result() for ClusterFuture ... done
[15:32:35.627] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:35.627] - nx: 2
[15:32:35.628] - relay: TRUE
[15:32:35.628] - stdout: TRUE
[15:32:35.628] - signal: TRUE
[15:32:35.628] - resignal: FALSE
[15:32:35.629] - force: TRUE
[15:32:35.629] - relayed: [n=2] TRUE, FALSE
[15:32:35.629] - queued futures: [n=2] TRUE, FALSE
[15:32:35.630]  - until=2
[15:32:35.630]  - relaying element #2
[15:32:35.630] result() for ClusterFuture ...
[15:32:35.631] - result already collected: FutureResult
[15:32:35.631] result() for ClusterFuture ... done
[15:32:35.631] result() for ClusterFuture ...
[15:32:35.631] - result already collected: FutureResult
[15:32:35.632] result() for ClusterFuture ... done
[15:32:35.632] result() for ClusterFuture ...
[15:32:35.632] - result already collected: FutureResult
[15:32:35.633] result() for ClusterFuture ... done
[15:32:35.633] result() for ClusterFuture ...
[15:32:35.633] - result already collected: FutureResult
[15:32:35.633] result() for ClusterFuture ... done
[15:32:35.634] - relayed: [n=2] TRUE, TRUE
[15:32:35.634] - queued futures: [n=2] TRUE, TRUE
[15:32:35.634] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:35.635]  length: 0 (resolved future 2)
[15:32:35.635] Relaying remaining futures
[15:32:35.635] signalConditionsASAP(NULL, pos=0) ...
[15:32:35.635] - nx: 2
[15:32:35.636] - relay: TRUE
[15:32:35.636] - stdout: TRUE
[15:32:35.636] - signal: TRUE
[15:32:35.636] - resignal: FALSE
[15:32:35.637] - force: TRUE
[15:32:35.637] - relayed: [n=2] TRUE, TRUE
[15:32:35.637] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:35.638] - relayed: [n=2] TRUE, TRUE
[15:32:35.638] - queued futures: [n=2] TRUE, TRUE
[15:32:35.638] signalConditionsASAP(NULL, pos=0) ... done
[15:32:35.638] resolve() on list ... DONE
[15:32:35.638] result() for ClusterFuture ...
[15:32:35.638] - result already collected: FutureResult
[15:32:35.639] result() for ClusterFuture ... done
[15:32:35.639] result() for ClusterFuture ...
[15:32:35.639] - result already collected: FutureResult
[15:32:35.639] result() for ClusterFuture ... done
[15:32:35.639] result() for ClusterFuture ...
[15:32:35.640] - result already collected: FutureResult
[15:32:35.640] result() for ClusterFuture ... done
[15:32:35.640] result() for ClusterFuture ...
[15:32:35.640] - result already collected: FutureResult
[15:32:35.640] result() for ClusterFuture ... done
[15:32:35.640]  - Number of value chunks collected: 2
[15:32:35.641] Resolving 2 futures (chunks) ... DONE
[15:32:35.641] Reducing values from 2 chunks ...
[15:32:35.641]  - Number of values collected after concatenation: 3
[15:32:35.641]  - Number of values expected: 3
[15:32:35.641] Reducing values from 2 chunks ... DONE
[15:32:35.641] future_lapply() ... DONE
List of 2
 $ y0: chr [1:3] "a" "b" "c"
 $ y1: chr [1:3] "a" "b" "c"
[15:32:35.643] future_lapply() ...
[15:32:35.646] Number of chunks: 2
[15:32:35.647] getGlobalsAndPackagesXApply() ...
[15:32:35.647]  - future.globals: TRUE
[15:32:35.647] getGlobalsAndPackages() ...
[15:32:35.647] Searching for globals...
[15:32:35.649] - globals found: [2] 'FUN', 'UseMethod'
[15:32:35.649] Searching for globals ... DONE
[15:32:35.649] Resolving globals: FALSE
[15:32:35.650] The total size of the 1 globals is 1.22 KiB (1248 bytes)
[15:32:35.650] The total size of the 1 globals exported for future expression ('FUN()') is 1.22 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.22 KiB of class 'function')
[15:32:35.650] - globals: [1] 'FUN'
[15:32:35.651] 
[15:32:35.651] getGlobalsAndPackages() ... DONE
[15:32:35.651]  - globals found/used: [n=1] 'FUN'
[15:32:35.651]  - needed namespaces: [n=0] 
[15:32:35.651] Finding globals ... DONE
[15:32:35.651]  - use_args: TRUE
[15:32:35.652]  - Getting '...' globals ...
[15:32:35.652] resolve() on list ...
[15:32:35.652]  recursive: 0
[15:32:35.652]  length: 1
[15:32:35.653]  elements: '...'
[15:32:35.653]  length: 0 (resolved future 1)
[15:32:35.653] resolve() on list ... DONE
[15:32:35.653]    - '...' content: [n=0] 
[15:32:35.653] List of 1
[15:32:35.653]  $ ...: list()
[15:32:35.653]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:35.653]  - attr(*, "where")=List of 1
[15:32:35.653]   ..$ ...:<environment: 0x00000276e2a03cd8> 
[15:32:35.653]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:35.653]  - attr(*, "resolved")= logi TRUE
[15:32:35.653]  - attr(*, "total_size")= num NA
[15:32:35.657]  - Getting '...' globals ... DONE
[15:32:35.657] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:35.657] List of 2
[15:32:35.657]  $ ...future.FUN:function (x, ...)  
[15:32:35.657]  $ ...          : list()
[15:32:35.657]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:35.657]  - attr(*, "where")=List of 2
[15:32:35.657]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:35.657]   ..$ ...          :<environment: 0x00000276e2a03cd8> 
[15:32:35.657]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:35.657]  - attr(*, "resolved")= logi FALSE
[15:32:35.657]  - attr(*, "total_size")= num 1248
[15:32:35.662] Packages to be attached in all futures: [n=0] 
[15:32:35.663] getGlobalsAndPackagesXApply() ... DONE
[15:32:35.663] Number of futures (= number of chunks): 2
[15:32:35.663] Launching 2 futures (chunks) ...
[15:32:35.663] Chunk #1 of 2 ...
[15:32:35.664]  - Finding globals in 'X' for chunk #1 ...
[15:32:35.664] getGlobalsAndPackages() ...
[15:32:35.664] Searching for globals...
[15:32:35.665] 
[15:32:35.665] Searching for globals ... DONE
[15:32:35.665] - globals: [0] <none>
[15:32:35.665] getGlobalsAndPackages() ... DONE
[15:32:35.665]    + additional globals found: [n=0] 
[15:32:35.666]    + additional namespaces needed: [n=0] 
[15:32:35.666]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:35.666]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:35.666]  - seeds: <none>
[15:32:35.666]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:35.667] getGlobalsAndPackages() ...
[15:32:35.667] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:35.667] Resolving globals: FALSE
[15:32:35.667] Tweak future expression to call with '...' arguments ...
[15:32:35.668] {
[15:32:35.668]     do.call(function(...) {
[15:32:35.668]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:35.668]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:35.668]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:35.668]             on.exit(options(oopts), add = TRUE)
[15:32:35.668]         }
[15:32:35.668]         {
[15:32:35.668]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:35.668]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:35.668]                 ...future.FUN(...future.X_jj, ...)
[15:32:35.668]             })
[15:32:35.668]         }
[15:32:35.668]     }, args = future.call.arguments)
[15:32:35.668] }
[15:32:35.668] Tweak future expression to call with '...' arguments ... DONE
[15:32:35.669] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:35.669] 
[15:32:35.669] getGlobalsAndPackages() ... DONE
[15:32:35.670] run() for 'Future' ...
[15:32:35.670] - state: 'created'
[15:32:35.670] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:35.690] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:35.690] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:35.691]   - Field: 'node'
[15:32:35.691]   - Field: 'label'
[15:32:35.691]   - Field: 'local'
[15:32:35.691]   - Field: 'owner'
[15:32:35.692]   - Field: 'envir'
[15:32:35.692]   - Field: 'workers'
[15:32:35.692]   - Field: 'packages'
[15:32:35.692]   - Field: 'gc'
[15:32:35.692]   - Field: 'conditions'
[15:32:35.693]   - Field: 'persistent'
[15:32:35.693]   - Field: 'expr'
[15:32:35.693]   - Field: 'uuid'
[15:32:35.693]   - Field: 'seed'
[15:32:35.694]   - Field: 'version'
[15:32:35.694]   - Field: 'result'
[15:32:35.694]   - Field: 'asynchronous'
[15:32:35.694]   - Field: 'calls'
[15:32:35.694]   - Field: 'globals'
[15:32:35.695]   - Field: 'stdout'
[15:32:35.695]   - Field: 'earlySignal'
[15:32:35.695]   - Field: 'lazy'
[15:32:35.695]   - Field: 'state'
[15:32:35.695] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:35.696] - Launch lazy future ...
[15:32:35.696] Packages needed by the future expression (n = 0): <none>
[15:32:35.696] Packages needed by future strategies (n = 0): <none>
[15:32:35.697] {
[15:32:35.697]     {
[15:32:35.697]         {
[15:32:35.697]             ...future.startTime <- base::Sys.time()
[15:32:35.697]             {
[15:32:35.697]                 {
[15:32:35.697]                   {
[15:32:35.697]                     {
[15:32:35.697]                       base::local({
[15:32:35.697]                         has_future <- base::requireNamespace("future", 
[15:32:35.697]                           quietly = TRUE)
[15:32:35.697]                         if (has_future) {
[15:32:35.697]                           ns <- base::getNamespace("future")
[15:32:35.697]                           version <- ns[[".package"]][["version"]]
[15:32:35.697]                           if (is.null(version)) 
[15:32:35.697]                             version <- utils::packageVersion("future")
[15:32:35.697]                         }
[15:32:35.697]                         else {
[15:32:35.697]                           version <- NULL
[15:32:35.697]                         }
[15:32:35.697]                         if (!has_future || version < "1.8.0") {
[15:32:35.697]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:35.697]                             "", base::R.version$version.string), 
[15:32:35.697]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:35.697]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:35.697]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:35.697]                               "release", "version")], collapse = " "), 
[15:32:35.697]                             hostname = base::Sys.info()[["nodename"]])
[15:32:35.697]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:35.697]                             info)
[15:32:35.697]                           info <- base::paste(info, collapse = "; ")
[15:32:35.697]                           if (!has_future) {
[15:32:35.697]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:35.697]                               info)
[15:32:35.697]                           }
[15:32:35.697]                           else {
[15:32:35.697]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:35.697]                               info, version)
[15:32:35.697]                           }
[15:32:35.697]                           base::stop(msg)
[15:32:35.697]                         }
[15:32:35.697]                       })
[15:32:35.697]                     }
[15:32:35.697]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:35.697]                     base::options(mc.cores = 1L)
[15:32:35.697]                   }
[15:32:35.697]                   ...future.strategy.old <- future::plan("list")
[15:32:35.697]                   options(future.plan = NULL)
[15:32:35.697]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:35.697]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:35.697]                 }
[15:32:35.697]                 ...future.workdir <- getwd()
[15:32:35.697]             }
[15:32:35.697]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:35.697]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:35.697]         }
[15:32:35.697]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:35.697]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:35.697]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:35.697]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:35.697]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:35.697]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:35.697]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:35.697]             base::names(...future.oldOptions))
[15:32:35.697]     }
[15:32:35.697]     if (FALSE) {
[15:32:35.697]     }
[15:32:35.697]     else {
[15:32:35.697]         if (TRUE) {
[15:32:35.697]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:35.697]                 open = "w")
[15:32:35.697]         }
[15:32:35.697]         else {
[15:32:35.697]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:35.697]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:35.697]         }
[15:32:35.697]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:35.697]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:35.697]             base::sink(type = "output", split = FALSE)
[15:32:35.697]             base::close(...future.stdout)
[15:32:35.697]         }, add = TRUE)
[15:32:35.697]     }
[15:32:35.697]     ...future.frame <- base::sys.nframe()
[15:32:35.697]     ...future.conditions <- base::list()
[15:32:35.697]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:35.697]     if (FALSE) {
[15:32:35.697]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:35.697]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:35.697]     }
[15:32:35.697]     ...future.result <- base::tryCatch({
[15:32:35.697]         base::withCallingHandlers({
[15:32:35.697]             ...future.value <- base::withVisible(base::local({
[15:32:35.697]                 ...future.makeSendCondition <- base::local({
[15:32:35.697]                   sendCondition <- NULL
[15:32:35.697]                   function(frame = 1L) {
[15:32:35.697]                     if (is.function(sendCondition)) 
[15:32:35.697]                       return(sendCondition)
[15:32:35.697]                     ns <- getNamespace("parallel")
[15:32:35.697]                     if (exists("sendData", mode = "function", 
[15:32:35.697]                       envir = ns)) {
[15:32:35.697]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:35.697]                         envir = ns)
[15:32:35.697]                       envir <- sys.frame(frame)
[15:32:35.697]                       master <- NULL
[15:32:35.697]                       while (!identical(envir, .GlobalEnv) && 
[15:32:35.697]                         !identical(envir, emptyenv())) {
[15:32:35.697]                         if (exists("master", mode = "list", envir = envir, 
[15:32:35.697]                           inherits = FALSE)) {
[15:32:35.697]                           master <- get("master", mode = "list", 
[15:32:35.697]                             envir = envir, inherits = FALSE)
[15:32:35.697]                           if (inherits(master, c("SOCKnode", 
[15:32:35.697]                             "SOCK0node"))) {
[15:32:35.697]                             sendCondition <<- function(cond) {
[15:32:35.697]                               data <- list(type = "VALUE", value = cond, 
[15:32:35.697]                                 success = TRUE)
[15:32:35.697]                               parallel_sendData(master, data)
[15:32:35.697]                             }
[15:32:35.697]                             return(sendCondition)
[15:32:35.697]                           }
[15:32:35.697]                         }
[15:32:35.697]                         frame <- frame + 1L
[15:32:35.697]                         envir <- sys.frame(frame)
[15:32:35.697]                       }
[15:32:35.697]                     }
[15:32:35.697]                     sendCondition <<- function(cond) NULL
[15:32:35.697]                   }
[15:32:35.697]                 })
[15:32:35.697]                 withCallingHandlers({
[15:32:35.697]                   {
[15:32:35.697]                     do.call(function(...) {
[15:32:35.697]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:35.697]                       if (!identical(...future.globals.maxSize.org, 
[15:32:35.697]                         ...future.globals.maxSize)) {
[15:32:35.697]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:35.697]                         on.exit(options(oopts), add = TRUE)
[15:32:35.697]                       }
[15:32:35.697]                       {
[15:32:35.697]                         lapply(seq_along(...future.elements_ii), 
[15:32:35.697]                           FUN = function(jj) {
[15:32:35.697]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:35.697]                             ...future.FUN(...future.X_jj, ...)
[15:32:35.697]                           })
[15:32:35.697]                       }
[15:32:35.697]                     }, args = future.call.arguments)
[15:32:35.697]                   }
[15:32:35.697]                 }, immediateCondition = function(cond) {
[15:32:35.697]                   sendCondition <- ...future.makeSendCondition()
[15:32:35.697]                   sendCondition(cond)
[15:32:35.697]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:35.697]                   {
[15:32:35.697]                     inherits <- base::inherits
[15:32:35.697]                     invokeRestart <- base::invokeRestart
[15:32:35.697]                     is.null <- base::is.null
[15:32:35.697]                     muffled <- FALSE
[15:32:35.697]                     if (inherits(cond, "message")) {
[15:32:35.697]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:35.697]                       if (muffled) 
[15:32:35.697]                         invokeRestart("muffleMessage")
[15:32:35.697]                     }
[15:32:35.697]                     else if (inherits(cond, "warning")) {
[15:32:35.697]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:35.697]                       if (muffled) 
[15:32:35.697]                         invokeRestart("muffleWarning")
[15:32:35.697]                     }
[15:32:35.697]                     else if (inherits(cond, "condition")) {
[15:32:35.697]                       if (!is.null(pattern)) {
[15:32:35.697]                         computeRestarts <- base::computeRestarts
[15:32:35.697]                         grepl <- base::grepl
[15:32:35.697]                         restarts <- computeRestarts(cond)
[15:32:35.697]                         for (restart in restarts) {
[15:32:35.697]                           name <- restart$name
[15:32:35.697]                           if (is.null(name)) 
[15:32:35.697]                             next
[15:32:35.697]                           if (!grepl(pattern, name)) 
[15:32:35.697]                             next
[15:32:35.697]                           invokeRestart(restart)
[15:32:35.697]                           muffled <- TRUE
[15:32:35.697]                           break
[15:32:35.697]                         }
[15:32:35.697]                       }
[15:32:35.697]                     }
[15:32:35.697]                     invisible(muffled)
[15:32:35.697]                   }
[15:32:35.697]                   muffleCondition(cond)
[15:32:35.697]                 })
[15:32:35.697]             }))
[15:32:35.697]             future::FutureResult(value = ...future.value$value, 
[15:32:35.697]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:35.697]                   ...future.rng), globalenv = if (FALSE) 
[15:32:35.697]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:35.697]                     ...future.globalenv.names))
[15:32:35.697]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:35.697]         }, condition = base::local({
[15:32:35.697]             c <- base::c
[15:32:35.697]             inherits <- base::inherits
[15:32:35.697]             invokeRestart <- base::invokeRestart
[15:32:35.697]             length <- base::length
[15:32:35.697]             list <- base::list
[15:32:35.697]             seq.int <- base::seq.int
[15:32:35.697]             signalCondition <- base::signalCondition
[15:32:35.697]             sys.calls <- base::sys.calls
[15:32:35.697]             `[[` <- base::`[[`
[15:32:35.697]             `+` <- base::`+`
[15:32:35.697]             `<<-` <- base::`<<-`
[15:32:35.697]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:35.697]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:35.697]                   3L)]
[15:32:35.697]             }
[15:32:35.697]             function(cond) {
[15:32:35.697]                 is_error <- inherits(cond, "error")
[15:32:35.697]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:35.697]                   NULL)
[15:32:35.697]                 if (is_error) {
[15:32:35.697]                   sessionInformation <- function() {
[15:32:35.697]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:35.697]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:35.697]                       search = base::search(), system = base::Sys.info())
[15:32:35.697]                   }
[15:32:35.697]                   ...future.conditions[[length(...future.conditions) + 
[15:32:35.697]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:35.697]                     cond$call), session = sessionInformation(), 
[15:32:35.697]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:35.697]                   signalCondition(cond)
[15:32:35.697]                 }
[15:32:35.697]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:35.697]                 "immediateCondition"))) {
[15:32:35.697]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:35.697]                   ...future.conditions[[length(...future.conditions) + 
[15:32:35.697]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:35.697]                   if (TRUE && !signal) {
[15:32:35.697]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:35.697]                     {
[15:32:35.697]                       inherits <- base::inherits
[15:32:35.697]                       invokeRestart <- base::invokeRestart
[15:32:35.697]                       is.null <- base::is.null
[15:32:35.697]                       muffled <- FALSE
[15:32:35.697]                       if (inherits(cond, "message")) {
[15:32:35.697]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:35.697]                         if (muffled) 
[15:32:35.697]                           invokeRestart("muffleMessage")
[15:32:35.697]                       }
[15:32:35.697]                       else if (inherits(cond, "warning")) {
[15:32:35.697]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:35.697]                         if (muffled) 
[15:32:35.697]                           invokeRestart("muffleWarning")
[15:32:35.697]                       }
[15:32:35.697]                       else if (inherits(cond, "condition")) {
[15:32:35.697]                         if (!is.null(pattern)) {
[15:32:35.697]                           computeRestarts <- base::computeRestarts
[15:32:35.697]                           grepl <- base::grepl
[15:32:35.697]                           restarts <- computeRestarts(cond)
[15:32:35.697]                           for (restart in restarts) {
[15:32:35.697]                             name <- restart$name
[15:32:35.697]                             if (is.null(name)) 
[15:32:35.697]                               next
[15:32:35.697]                             if (!grepl(pattern, name)) 
[15:32:35.697]                               next
[15:32:35.697]                             invokeRestart(restart)
[15:32:35.697]                             muffled <- TRUE
[15:32:35.697]                             break
[15:32:35.697]                           }
[15:32:35.697]                         }
[15:32:35.697]                       }
[15:32:35.697]                       invisible(muffled)
[15:32:35.697]                     }
[15:32:35.697]                     muffleCondition(cond, pattern = "^muffle")
[15:32:35.697]                   }
[15:32:35.697]                 }
[15:32:35.697]                 else {
[15:32:35.697]                   if (TRUE) {
[15:32:35.697]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:35.697]                     {
[15:32:35.697]                       inherits <- base::inherits
[15:32:35.697]                       invokeRestart <- base::invokeRestart
[15:32:35.697]                       is.null <- base::is.null
[15:32:35.697]                       muffled <- FALSE
[15:32:35.697]                       if (inherits(cond, "message")) {
[15:32:35.697]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:35.697]                         if (muffled) 
[15:32:35.697]                           invokeRestart("muffleMessage")
[15:32:35.697]                       }
[15:32:35.697]                       else if (inherits(cond, "warning")) {
[15:32:35.697]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:35.697]                         if (muffled) 
[15:32:35.697]                           invokeRestart("muffleWarning")
[15:32:35.697]                       }
[15:32:35.697]                       else if (inherits(cond, "condition")) {
[15:32:35.697]                         if (!is.null(pattern)) {
[15:32:35.697]                           computeRestarts <- base::computeRestarts
[15:32:35.697]                           grepl <- base::grepl
[15:32:35.697]                           restarts <- computeRestarts(cond)
[15:32:35.697]                           for (restart in restarts) {
[15:32:35.697]                             name <- restart$name
[15:32:35.697]                             if (is.null(name)) 
[15:32:35.697]                               next
[15:32:35.697]                             if (!grepl(pattern, name)) 
[15:32:35.697]                               next
[15:32:35.697]                             invokeRestart(restart)
[15:32:35.697]                             muffled <- TRUE
[15:32:35.697]                             break
[15:32:35.697]                           }
[15:32:35.697]                         }
[15:32:35.697]                       }
[15:32:35.697]                       invisible(muffled)
[15:32:35.697]                     }
[15:32:35.697]                     muffleCondition(cond, pattern = "^muffle")
[15:32:35.697]                   }
[15:32:35.697]                 }
[15:32:35.697]             }
[15:32:35.697]         }))
[15:32:35.697]     }, error = function(ex) {
[15:32:35.697]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:35.697]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:35.697]                 ...future.rng), started = ...future.startTime, 
[15:32:35.697]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:35.697]             version = "1.8"), class = "FutureResult")
[15:32:35.697]     }, finally = {
[15:32:35.697]         if (!identical(...future.workdir, getwd())) 
[15:32:35.697]             setwd(...future.workdir)
[15:32:35.697]         {
[15:32:35.697]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:35.697]                 ...future.oldOptions$nwarnings <- NULL
[15:32:35.697]             }
[15:32:35.697]             base::options(...future.oldOptions)
[15:32:35.697]             if (.Platform$OS.type == "windows") {
[15:32:35.697]                 old_names <- names(...future.oldEnvVars)
[15:32:35.697]                 envs <- base::Sys.getenv()
[15:32:35.697]                 names <- names(envs)
[15:32:35.697]                 common <- intersect(names, old_names)
[15:32:35.697]                 added <- setdiff(names, old_names)
[15:32:35.697]                 removed <- setdiff(old_names, names)
[15:32:35.697]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:35.697]                   envs[common]]
[15:32:35.697]                 NAMES <- toupper(changed)
[15:32:35.697]                 args <- list()
[15:32:35.697]                 for (kk in seq_along(NAMES)) {
[15:32:35.697]                   name <- changed[[kk]]
[15:32:35.697]                   NAME <- NAMES[[kk]]
[15:32:35.697]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:35.697]                     next
[15:32:35.697]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:35.697]                 }
[15:32:35.697]                 NAMES <- toupper(added)
[15:32:35.697]                 for (kk in seq_along(NAMES)) {
[15:32:35.697]                   name <- added[[kk]]
[15:32:35.697]                   NAME <- NAMES[[kk]]
[15:32:35.697]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:35.697]                     next
[15:32:35.697]                   args[[name]] <- ""
[15:32:35.697]                 }
[15:32:35.697]                 NAMES <- toupper(removed)
[15:32:35.697]                 for (kk in seq_along(NAMES)) {
[15:32:35.697]                   name <- removed[[kk]]
[15:32:35.697]                   NAME <- NAMES[[kk]]
[15:32:35.697]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:35.697]                     next
[15:32:35.697]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:35.697]                 }
[15:32:35.697]                 if (length(args) > 0) 
[15:32:35.697]                   base::do.call(base::Sys.setenv, args = args)
[15:32:35.697]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:35.697]             }
[15:32:35.697]             else {
[15:32:35.697]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:35.697]             }
[15:32:35.697]             {
[15:32:35.697]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:35.697]                   0L) {
[15:32:35.697]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:35.697]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:35.697]                   base::options(opts)
[15:32:35.697]                 }
[15:32:35.697]                 {
[15:32:35.697]                   {
[15:32:35.697]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:35.697]                     NULL
[15:32:35.697]                   }
[15:32:35.697]                   options(future.plan = NULL)
[15:32:35.697]                   if (is.na(NA_character_)) 
[15:32:35.697]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:35.697]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:35.697]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:35.697]                     .init = FALSE)
[15:32:35.697]                 }
[15:32:35.697]             }
[15:32:35.697]         }
[15:32:35.697]     })
[15:32:35.697]     if (TRUE) {
[15:32:35.697]         base::sink(type = "output", split = FALSE)
[15:32:35.697]         if (TRUE) {
[15:32:35.697]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:35.697]         }
[15:32:35.697]         else {
[15:32:35.697]             ...future.result["stdout"] <- base::list(NULL)
[15:32:35.697]         }
[15:32:35.697]         base::close(...future.stdout)
[15:32:35.697]         ...future.stdout <- NULL
[15:32:35.697]     }
[15:32:35.697]     ...future.result$conditions <- ...future.conditions
[15:32:35.697]     ...future.result$finished <- base::Sys.time()
[15:32:35.697]     ...future.result
[15:32:35.697] }
[15:32:35.705] Exporting 5 global objects (1.22 KiB) to cluster node #1 ...
[15:32:35.705] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ...
[15:32:35.706] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ... DONE
[15:32:35.707] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:35.707] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:35.708] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:35.708] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:35.709] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:35.710] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:35.710] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:35.711] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:35.711] Exporting 5 global objects (1.22 KiB) to cluster node #1 ... DONE
[15:32:35.712] MultisessionFuture started
[15:32:35.713] - Launch lazy future ... done
[15:32:35.713] run() for 'MultisessionFuture' ... done
[15:32:35.713] Created future:
[15:32:35.737] receiveMessageFromWorker() for ClusterFuture ...
[15:32:35.738] - Validating connection of MultisessionFuture
[15:32:35.738] - received message: FutureResult
[15:32:35.739] - Received FutureResult
[15:32:35.739] - Erased future from FutureRegistry
[15:32:35.739] result() for ClusterFuture ...
[15:32:35.739] - result already collected: FutureResult
[15:32:35.740] result() for ClusterFuture ... done
[15:32:35.740] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:35.714] MultisessionFuture:
[15:32:35.714] Label: 'future_sapply-1'
[15:32:35.714] Expression:
[15:32:35.714] {
[15:32:35.714]     do.call(function(...) {
[15:32:35.714]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:35.714]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:35.714]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:35.714]             on.exit(options(oopts), add = TRUE)
[15:32:35.714]         }
[15:32:35.714]         {
[15:32:35.714]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:35.714]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:35.714]                 ...future.FUN(...future.X_jj, ...)
[15:32:35.714]             })
[15:32:35.714]         }
[15:32:35.714]     }, args = future.call.arguments)
[15:32:35.714] }
[15:32:35.714] Lazy evaluation: FALSE
[15:32:35.714] Asynchronous evaluation: TRUE
[15:32:35.714] Local evaluation: TRUE
[15:32:35.714] Environment: R_GlobalEnv
[15:32:35.714] Capture standard output: TRUE
[15:32:35.714] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:35.714] Globals: 5 objects totaling 1.33 KiB (function '...future.FUN' of 1.22 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)
[15:32:35.714] Packages: <none>
[15:32:35.714] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:35.714] Resolved: TRUE
[15:32:35.714] Value: <not collected>
[15:32:35.714] Conditions captured: <none>
[15:32:35.714] Early signaling: FALSE
[15:32:35.714] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:35.714] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:35.741] Chunk #1 of 2 ... DONE
[15:32:35.741] Chunk #2 of 2 ...
[15:32:35.742]  - Finding globals in 'X' for chunk #2 ...
[15:32:35.742] getGlobalsAndPackages() ...
[15:32:35.742] Searching for globals...
[15:32:35.743] 
[15:32:35.743] Searching for globals ... DONE
[15:32:35.743] - globals: [0] <none>
[15:32:35.744] getGlobalsAndPackages() ... DONE
[15:32:35.744]    + additional globals found: [n=0] 
[15:32:35.744]    + additional namespaces needed: [n=0] 
[15:32:35.745]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:35.745]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:35.746]  - seeds: <none>
[15:32:35.746]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:35.746] getGlobalsAndPackages() ...
[15:32:35.747] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:35.747] Resolving globals: FALSE
[15:32:35.748] Tweak future expression to call with '...' arguments ...
[15:32:35.748] {
[15:32:35.748]     do.call(function(...) {
[15:32:35.748]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:35.748]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:35.748]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:35.748]             on.exit(options(oopts), add = TRUE)
[15:32:35.748]         }
[15:32:35.748]         {
[15:32:35.748]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:35.748]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:35.748]                 ...future.FUN(...future.X_jj, ...)
[15:32:35.748]             })
[15:32:35.748]         }
[15:32:35.748]     }, args = future.call.arguments)
[15:32:35.748] }
[15:32:35.749] Tweak future expression to call with '...' arguments ... DONE
[15:32:35.750] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:35.750] 
[15:32:35.750] getGlobalsAndPackages() ... DONE
[15:32:35.751] run() for 'Future' ...
[15:32:35.752] - state: 'created'
[15:32:35.752] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:35.772] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:35.772] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:35.773]   - Field: 'node'
[15:32:35.773]   - Field: 'label'
[15:32:35.773]   - Field: 'local'
[15:32:35.774]   - Field: 'owner'
[15:32:35.774]   - Field: 'envir'
[15:32:35.774]   - Field: 'workers'
[15:32:35.775]   - Field: 'packages'
[15:32:35.775]   - Field: 'gc'
[15:32:35.775]   - Field: 'conditions'
[15:32:35.776]   - Field: 'persistent'
[15:32:35.776]   - Field: 'expr'
[15:32:35.776]   - Field: 'uuid'
[15:32:35.777]   - Field: 'seed'
[15:32:35.777]   - Field: 'version'
[15:32:35.777]   - Field: 'result'
[15:32:35.778]   - Field: 'asynchronous'
[15:32:35.778]   - Field: 'calls'
[15:32:35.778]   - Field: 'globals'
[15:32:35.778]   - Field: 'stdout'
[15:32:35.779]   - Field: 'earlySignal'
[15:32:35.779]   - Field: 'lazy'
[15:32:35.779]   - Field: 'state'
[15:32:35.780] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:35.780] - Launch lazy future ...
[15:32:35.781] Packages needed by the future expression (n = 0): <none>
[15:32:35.781] Packages needed by future strategies (n = 0): <none>
[15:32:35.782] {
[15:32:35.782]     {
[15:32:35.782]         {
[15:32:35.782]             ...future.startTime <- base::Sys.time()
[15:32:35.782]             {
[15:32:35.782]                 {
[15:32:35.782]                   {
[15:32:35.782]                     {
[15:32:35.782]                       base::local({
[15:32:35.782]                         has_future <- base::requireNamespace("future", 
[15:32:35.782]                           quietly = TRUE)
[15:32:35.782]                         if (has_future) {
[15:32:35.782]                           ns <- base::getNamespace("future")
[15:32:35.782]                           version <- ns[[".package"]][["version"]]
[15:32:35.782]                           if (is.null(version)) 
[15:32:35.782]                             version <- utils::packageVersion("future")
[15:32:35.782]                         }
[15:32:35.782]                         else {
[15:32:35.782]                           version <- NULL
[15:32:35.782]                         }
[15:32:35.782]                         if (!has_future || version < "1.8.0") {
[15:32:35.782]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:35.782]                             "", base::R.version$version.string), 
[15:32:35.782]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:35.782]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:35.782]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:35.782]                               "release", "version")], collapse = " "), 
[15:32:35.782]                             hostname = base::Sys.info()[["nodename"]])
[15:32:35.782]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:35.782]                             info)
[15:32:35.782]                           info <- base::paste(info, collapse = "; ")
[15:32:35.782]                           if (!has_future) {
[15:32:35.782]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:35.782]                               info)
[15:32:35.782]                           }
[15:32:35.782]                           else {
[15:32:35.782]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:35.782]                               info, version)
[15:32:35.782]                           }
[15:32:35.782]                           base::stop(msg)
[15:32:35.782]                         }
[15:32:35.782]                       })
[15:32:35.782]                     }
[15:32:35.782]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:35.782]                     base::options(mc.cores = 1L)
[15:32:35.782]                   }
[15:32:35.782]                   ...future.strategy.old <- future::plan("list")
[15:32:35.782]                   options(future.plan = NULL)
[15:32:35.782]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:35.782]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:35.782]                 }
[15:32:35.782]                 ...future.workdir <- getwd()
[15:32:35.782]             }
[15:32:35.782]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:35.782]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:35.782]         }
[15:32:35.782]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:35.782]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:35.782]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:35.782]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:35.782]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:35.782]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:35.782]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:35.782]             base::names(...future.oldOptions))
[15:32:35.782]     }
[15:32:35.782]     if (FALSE) {
[15:32:35.782]     }
[15:32:35.782]     else {
[15:32:35.782]         if (TRUE) {
[15:32:35.782]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:35.782]                 open = "w")
[15:32:35.782]         }
[15:32:35.782]         else {
[15:32:35.782]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:35.782]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:35.782]         }
[15:32:35.782]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:35.782]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:35.782]             base::sink(type = "output", split = FALSE)
[15:32:35.782]             base::close(...future.stdout)
[15:32:35.782]         }, add = TRUE)
[15:32:35.782]     }
[15:32:35.782]     ...future.frame <- base::sys.nframe()
[15:32:35.782]     ...future.conditions <- base::list()
[15:32:35.782]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:35.782]     if (FALSE) {
[15:32:35.782]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:35.782]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:35.782]     }
[15:32:35.782]     ...future.result <- base::tryCatch({
[15:32:35.782]         base::withCallingHandlers({
[15:32:35.782]             ...future.value <- base::withVisible(base::local({
[15:32:35.782]                 ...future.makeSendCondition <- base::local({
[15:32:35.782]                   sendCondition <- NULL
[15:32:35.782]                   function(frame = 1L) {
[15:32:35.782]                     if (is.function(sendCondition)) 
[15:32:35.782]                       return(sendCondition)
[15:32:35.782]                     ns <- getNamespace("parallel")
[15:32:35.782]                     if (exists("sendData", mode = "function", 
[15:32:35.782]                       envir = ns)) {
[15:32:35.782]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:35.782]                         envir = ns)
[15:32:35.782]                       envir <- sys.frame(frame)
[15:32:35.782]                       master <- NULL
[15:32:35.782]                       while (!identical(envir, .GlobalEnv) && 
[15:32:35.782]                         !identical(envir, emptyenv())) {
[15:32:35.782]                         if (exists("master", mode = "list", envir = envir, 
[15:32:35.782]                           inherits = FALSE)) {
[15:32:35.782]                           master <- get("master", mode = "list", 
[15:32:35.782]                             envir = envir, inherits = FALSE)
[15:32:35.782]                           if (inherits(master, c("SOCKnode", 
[15:32:35.782]                             "SOCK0node"))) {
[15:32:35.782]                             sendCondition <<- function(cond) {
[15:32:35.782]                               data <- list(type = "VALUE", value = cond, 
[15:32:35.782]                                 success = TRUE)
[15:32:35.782]                               parallel_sendData(master, data)
[15:32:35.782]                             }
[15:32:35.782]                             return(sendCondition)
[15:32:35.782]                           }
[15:32:35.782]                         }
[15:32:35.782]                         frame <- frame + 1L
[15:32:35.782]                         envir <- sys.frame(frame)
[15:32:35.782]                       }
[15:32:35.782]                     }
[15:32:35.782]                     sendCondition <<- function(cond) NULL
[15:32:35.782]                   }
[15:32:35.782]                 })
[15:32:35.782]                 withCallingHandlers({
[15:32:35.782]                   {
[15:32:35.782]                     do.call(function(...) {
[15:32:35.782]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:35.782]                       if (!identical(...future.globals.maxSize.org, 
[15:32:35.782]                         ...future.globals.maxSize)) {
[15:32:35.782]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:35.782]                         on.exit(options(oopts), add = TRUE)
[15:32:35.782]                       }
[15:32:35.782]                       {
[15:32:35.782]                         lapply(seq_along(...future.elements_ii), 
[15:32:35.782]                           FUN = function(jj) {
[15:32:35.782]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:35.782]                             ...future.FUN(...future.X_jj, ...)
[15:32:35.782]                           })
[15:32:35.782]                       }
[15:32:35.782]                     }, args = future.call.arguments)
[15:32:35.782]                   }
[15:32:35.782]                 }, immediateCondition = function(cond) {
[15:32:35.782]                   sendCondition <- ...future.makeSendCondition()
[15:32:35.782]                   sendCondition(cond)
[15:32:35.782]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:35.782]                   {
[15:32:35.782]                     inherits <- base::inherits
[15:32:35.782]                     invokeRestart <- base::invokeRestart
[15:32:35.782]                     is.null <- base::is.null
[15:32:35.782]                     muffled <- FALSE
[15:32:35.782]                     if (inherits(cond, "message")) {
[15:32:35.782]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:35.782]                       if (muffled) 
[15:32:35.782]                         invokeRestart("muffleMessage")
[15:32:35.782]                     }
[15:32:35.782]                     else if (inherits(cond, "warning")) {
[15:32:35.782]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:35.782]                       if (muffled) 
[15:32:35.782]                         invokeRestart("muffleWarning")
[15:32:35.782]                     }
[15:32:35.782]                     else if (inherits(cond, "condition")) {
[15:32:35.782]                       if (!is.null(pattern)) {
[15:32:35.782]                         computeRestarts <- base::computeRestarts
[15:32:35.782]                         grepl <- base::grepl
[15:32:35.782]                         restarts <- computeRestarts(cond)
[15:32:35.782]                         for (restart in restarts) {
[15:32:35.782]                           name <- restart$name
[15:32:35.782]                           if (is.null(name)) 
[15:32:35.782]                             next
[15:32:35.782]                           if (!grepl(pattern, name)) 
[15:32:35.782]                             next
[15:32:35.782]                           invokeRestart(restart)
[15:32:35.782]                           muffled <- TRUE
[15:32:35.782]                           break
[15:32:35.782]                         }
[15:32:35.782]                       }
[15:32:35.782]                     }
[15:32:35.782]                     invisible(muffled)
[15:32:35.782]                   }
[15:32:35.782]                   muffleCondition(cond)
[15:32:35.782]                 })
[15:32:35.782]             }))
[15:32:35.782]             future::FutureResult(value = ...future.value$value, 
[15:32:35.782]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:35.782]                   ...future.rng), globalenv = if (FALSE) 
[15:32:35.782]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:35.782]                     ...future.globalenv.names))
[15:32:35.782]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:35.782]         }, condition = base::local({
[15:32:35.782]             c <- base::c
[15:32:35.782]             inherits <- base::inherits
[15:32:35.782]             invokeRestart <- base::invokeRestart
[15:32:35.782]             length <- base::length
[15:32:35.782]             list <- base::list
[15:32:35.782]             seq.int <- base::seq.int
[15:32:35.782]             signalCondition <- base::signalCondition
[15:32:35.782]             sys.calls <- base::sys.calls
[15:32:35.782]             `[[` <- base::`[[`
[15:32:35.782]             `+` <- base::`+`
[15:32:35.782]             `<<-` <- base::`<<-`
[15:32:35.782]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:35.782]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:35.782]                   3L)]
[15:32:35.782]             }
[15:32:35.782]             function(cond) {
[15:32:35.782]                 is_error <- inherits(cond, "error")
[15:32:35.782]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:35.782]                   NULL)
[15:32:35.782]                 if (is_error) {
[15:32:35.782]                   sessionInformation <- function() {
[15:32:35.782]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:35.782]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:35.782]                       search = base::search(), system = base::Sys.info())
[15:32:35.782]                   }
[15:32:35.782]                   ...future.conditions[[length(...future.conditions) + 
[15:32:35.782]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:35.782]                     cond$call), session = sessionInformation(), 
[15:32:35.782]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:35.782]                   signalCondition(cond)
[15:32:35.782]                 }
[15:32:35.782]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:35.782]                 "immediateCondition"))) {
[15:32:35.782]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:35.782]                   ...future.conditions[[length(...future.conditions) + 
[15:32:35.782]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:35.782]                   if (TRUE && !signal) {
[15:32:35.782]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:35.782]                     {
[15:32:35.782]                       inherits <- base::inherits
[15:32:35.782]                       invokeRestart <- base::invokeRestart
[15:32:35.782]                       is.null <- base::is.null
[15:32:35.782]                       muffled <- FALSE
[15:32:35.782]                       if (inherits(cond, "message")) {
[15:32:35.782]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:35.782]                         if (muffled) 
[15:32:35.782]                           invokeRestart("muffleMessage")
[15:32:35.782]                       }
[15:32:35.782]                       else if (inherits(cond, "warning")) {
[15:32:35.782]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:35.782]                         if (muffled) 
[15:32:35.782]                           invokeRestart("muffleWarning")
[15:32:35.782]                       }
[15:32:35.782]                       else if (inherits(cond, "condition")) {
[15:32:35.782]                         if (!is.null(pattern)) {
[15:32:35.782]                           computeRestarts <- base::computeRestarts
[15:32:35.782]                           grepl <- base::grepl
[15:32:35.782]                           restarts <- computeRestarts(cond)
[15:32:35.782]                           for (restart in restarts) {
[15:32:35.782]                             name <- restart$name
[15:32:35.782]                             if (is.null(name)) 
[15:32:35.782]                               next
[15:32:35.782]                             if (!grepl(pattern, name)) 
[15:32:35.782]                               next
[15:32:35.782]                             invokeRestart(restart)
[15:32:35.782]                             muffled <- TRUE
[15:32:35.782]                             break
[15:32:35.782]                           }
[15:32:35.782]                         }
[15:32:35.782]                       }
[15:32:35.782]                       invisible(muffled)
[15:32:35.782]                     }
[15:32:35.782]                     muffleCondition(cond, pattern = "^muffle")
[15:32:35.782]                   }
[15:32:35.782]                 }
[15:32:35.782]                 else {
[15:32:35.782]                   if (TRUE) {
[15:32:35.782]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:35.782]                     {
[15:32:35.782]                       inherits <- base::inherits
[15:32:35.782]                       invokeRestart <- base::invokeRestart
[15:32:35.782]                       is.null <- base::is.null
[15:32:35.782]                       muffled <- FALSE
[15:32:35.782]                       if (inherits(cond, "message")) {
[15:32:35.782]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:35.782]                         if (muffled) 
[15:32:35.782]                           invokeRestart("muffleMessage")
[15:32:35.782]                       }
[15:32:35.782]                       else if (inherits(cond, "warning")) {
[15:32:35.782]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:35.782]                         if (muffled) 
[15:32:35.782]                           invokeRestart("muffleWarning")
[15:32:35.782]                       }
[15:32:35.782]                       else if (inherits(cond, "condition")) {
[15:32:35.782]                         if (!is.null(pattern)) {
[15:32:35.782]                           computeRestarts <- base::computeRestarts
[15:32:35.782]                           grepl <- base::grepl
[15:32:35.782]                           restarts <- computeRestarts(cond)
[15:32:35.782]                           for (restart in restarts) {
[15:32:35.782]                             name <- restart$name
[15:32:35.782]                             if (is.null(name)) 
[15:32:35.782]                               next
[15:32:35.782]                             if (!grepl(pattern, name)) 
[15:32:35.782]                               next
[15:32:35.782]                             invokeRestart(restart)
[15:32:35.782]                             muffled <- TRUE
[15:32:35.782]                             break
[15:32:35.782]                           }
[15:32:35.782]                         }
[15:32:35.782]                       }
[15:32:35.782]                       invisible(muffled)
[15:32:35.782]                     }
[15:32:35.782]                     muffleCondition(cond, pattern = "^muffle")
[15:32:35.782]                   }
[15:32:35.782]                 }
[15:32:35.782]             }
[15:32:35.782]         }))
[15:32:35.782]     }, error = function(ex) {
[15:32:35.782]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:35.782]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:35.782]                 ...future.rng), started = ...future.startTime, 
[15:32:35.782]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:35.782]             version = "1.8"), class = "FutureResult")
[15:32:35.782]     }, finally = {
[15:32:35.782]         if (!identical(...future.workdir, getwd())) 
[15:32:35.782]             setwd(...future.workdir)
[15:32:35.782]         {
[15:32:35.782]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:35.782]                 ...future.oldOptions$nwarnings <- NULL
[15:32:35.782]             }
[15:32:35.782]             base::options(...future.oldOptions)
[15:32:35.782]             if (.Platform$OS.type == "windows") {
[15:32:35.782]                 old_names <- names(...future.oldEnvVars)
[15:32:35.782]                 envs <- base::Sys.getenv()
[15:32:35.782]                 names <- names(envs)
[15:32:35.782]                 common <- intersect(names, old_names)
[15:32:35.782]                 added <- setdiff(names, old_names)
[15:32:35.782]                 removed <- setdiff(old_names, names)
[15:32:35.782]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:35.782]                   envs[common]]
[15:32:35.782]                 NAMES <- toupper(changed)
[15:32:35.782]                 args <- list()
[15:32:35.782]                 for (kk in seq_along(NAMES)) {
[15:32:35.782]                   name <- changed[[kk]]
[15:32:35.782]                   NAME <- NAMES[[kk]]
[15:32:35.782]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:35.782]                     next
[15:32:35.782]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:35.782]                 }
[15:32:35.782]                 NAMES <- toupper(added)
[15:32:35.782]                 for (kk in seq_along(NAMES)) {
[15:32:35.782]                   name <- added[[kk]]
[15:32:35.782]                   NAME <- NAMES[[kk]]
[15:32:35.782]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:35.782]                     next
[15:32:35.782]                   args[[name]] <- ""
[15:32:35.782]                 }
[15:32:35.782]                 NAMES <- toupper(removed)
[15:32:35.782]                 for (kk in seq_along(NAMES)) {
[15:32:35.782]                   name <- removed[[kk]]
[15:32:35.782]                   NAME <- NAMES[[kk]]
[15:32:35.782]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:35.782]                     next
[15:32:35.782]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:35.782]                 }
[15:32:35.782]                 if (length(args) > 0) 
[15:32:35.782]                   base::do.call(base::Sys.setenv, args = args)
[15:32:35.782]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:35.782]             }
[15:32:35.782]             else {
[15:32:35.782]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:35.782]             }
[15:32:35.782]             {
[15:32:35.782]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:35.782]                   0L) {
[15:32:35.782]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:35.782]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:35.782]                   base::options(opts)
[15:32:35.782]                 }
[15:32:35.782]                 {
[15:32:35.782]                   {
[15:32:35.782]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:35.782]                     NULL
[15:32:35.782]                   }
[15:32:35.782]                   options(future.plan = NULL)
[15:32:35.782]                   if (is.na(NA_character_)) 
[15:32:35.782]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:35.782]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:35.782]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:35.782]                     .init = FALSE)
[15:32:35.782]                 }
[15:32:35.782]             }
[15:32:35.782]         }
[15:32:35.782]     })
[15:32:35.782]     if (TRUE) {
[15:32:35.782]         base::sink(type = "output", split = FALSE)
[15:32:35.782]         if (TRUE) {
[15:32:35.782]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:35.782]         }
[15:32:35.782]         else {
[15:32:35.782]             ...future.result["stdout"] <- base::list(NULL)
[15:32:35.782]         }
[15:32:35.782]         base::close(...future.stdout)
[15:32:35.782]         ...future.stdout <- NULL
[15:32:35.782]     }
[15:32:35.782]     ...future.result$conditions <- ...future.conditions
[15:32:35.782]     ...future.result$finished <- base::Sys.time()
[15:32:35.782]     ...future.result
[15:32:35.782] }
[15:32:35.793] Exporting 5 global objects (1.22 KiB) to cluster node #1 ...
[15:32:35.793] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ...
[15:32:35.794] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ... DONE
[15:32:35.795] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:35.798] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:35.798] Exporting '...future.elements_ii' (224 bytes) to cluster node #1 ...
[15:32:35.799] Exporting '...future.elements_ii' (224 bytes) to cluster node #1 ... DONE
[15:32:35.799] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:35.800] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:35.801] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:35.801] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:35.801] Exporting 5 global objects (1.22 KiB) to cluster node #1 ... DONE
[15:32:35.803] MultisessionFuture started
[15:32:35.803] - Launch lazy future ... done
[15:32:35.803] run() for 'MultisessionFuture' ... done
[15:32:35.804] Created future:
[15:32:35.820] receiveMessageFromWorker() for ClusterFuture ...
[15:32:35.821] - Validating connection of MultisessionFuture
[15:32:35.821] - received message: FutureResult
[15:32:35.821] - Received FutureResult
[15:32:35.822] - Erased future from FutureRegistry
[15:32:35.822] result() for ClusterFuture ...
[15:32:35.822] - result already collected: FutureResult
[15:32:35.822] result() for ClusterFuture ... done
[15:32:35.822] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:35.804] MultisessionFuture:
[15:32:35.804] Label: 'future_sapply-2'
[15:32:35.804] Expression:
[15:32:35.804] {
[15:32:35.804]     do.call(function(...) {
[15:32:35.804]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:35.804]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:35.804]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:35.804]             on.exit(options(oopts), add = TRUE)
[15:32:35.804]         }
[15:32:35.804]         {
[15:32:35.804]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:35.804]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:35.804]                 ...future.FUN(...future.X_jj, ...)
[15:32:35.804]             })
[15:32:35.804]         }
[15:32:35.804]     }, args = future.call.arguments)
[15:32:35.804] }
[15:32:35.804] Lazy evaluation: FALSE
[15:32:35.804] Asynchronous evaluation: TRUE
[15:32:35.804] Local evaluation: TRUE
[15:32:35.804] Environment: R_GlobalEnv
[15:32:35.804] Capture standard output: TRUE
[15:32:35.804] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:35.804] Globals: 5 objects totaling 1.44 KiB (function '...future.FUN' of 1.22 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 224 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:35.804] Packages: <none>
[15:32:35.804] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:35.804] Resolved: TRUE
[15:32:35.804] Value: <not collected>
[15:32:35.804] Conditions captured: <none>
[15:32:35.804] Early signaling: FALSE
[15:32:35.804] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:35.804] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:35.823] Chunk #2 of 2 ... DONE
[15:32:35.823] Launching 2 futures (chunks) ... DONE
[15:32:35.823] Resolving 2 futures (chunks) ...
[15:32:35.823] resolve() on list ...
[15:32:35.824]  recursive: 0
[15:32:35.824]  length: 2
[15:32:35.824] 
[15:32:35.824] Future #1
[15:32:35.824] result() for ClusterFuture ...
[15:32:35.825] - result already collected: FutureResult
[15:32:35.825] result() for ClusterFuture ... done
[15:32:35.825] result() for ClusterFuture ...
[15:32:35.825] - result already collected: FutureResult
[15:32:35.825] result() for ClusterFuture ... done
[15:32:35.825] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:35.826] - nx: 2
[15:32:35.826] - relay: TRUE
[15:32:35.826] - stdout: TRUE
[15:32:35.826] - signal: TRUE
[15:32:35.826] - resignal: FALSE
[15:32:35.826] - force: TRUE
[15:32:35.827] - relayed: [n=2] FALSE, FALSE
[15:32:35.827] - queued futures: [n=2] FALSE, FALSE
[15:32:35.827]  - until=1
[15:32:35.827]  - relaying element #1
[15:32:35.827] result() for ClusterFuture ...
[15:32:35.828] - result already collected: FutureResult
[15:32:35.828] result() for ClusterFuture ... done
[15:32:35.828] result() for ClusterFuture ...
[15:32:35.828] - result already collected: FutureResult
[15:32:35.828] result() for ClusterFuture ... done
[15:32:35.828] result() for ClusterFuture ...
[15:32:35.829] - result already collected: FutureResult
[15:32:35.829] result() for ClusterFuture ... done
[15:32:35.829] result() for ClusterFuture ...
[15:32:35.829] - result already collected: FutureResult
[15:32:35.829] result() for ClusterFuture ... done
[15:32:35.829] - relayed: [n=2] TRUE, FALSE
[15:32:35.830] - queued futures: [n=2] TRUE, FALSE
[15:32:35.830] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:35.830]  length: 1 (resolved future 1)
[15:32:35.830] Future #2
[15:32:35.830] result() for ClusterFuture ...
[15:32:35.831] - result already collected: FutureResult
[15:32:35.831] result() for ClusterFuture ... done
[15:32:35.831] result() for ClusterFuture ...
[15:32:35.831] - result already collected: FutureResult
[15:32:35.831] result() for ClusterFuture ... done
[15:32:35.831] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:35.832] - nx: 2
[15:32:35.832] - relay: TRUE
[15:32:35.832] - stdout: TRUE
[15:32:35.832] - signal: TRUE
[15:32:35.832] - resignal: FALSE
[15:32:35.832] - force: TRUE
[15:32:35.833] - relayed: [n=2] TRUE, FALSE
[15:32:35.833] - queued futures: [n=2] TRUE, FALSE
[15:32:35.833]  - until=2
[15:32:35.833]  - relaying element #2
[15:32:35.833] result() for ClusterFuture ...
[15:32:35.833] - result already collected: FutureResult
[15:32:35.834] result() for ClusterFuture ... done
[15:32:35.834] result() for ClusterFuture ...
[15:32:35.834] - result already collected: FutureResult
[15:32:35.834] result() for ClusterFuture ... done
[15:32:35.834] result() for ClusterFuture ...
[15:32:35.835] - result already collected: FutureResult
[15:32:35.835] result() for ClusterFuture ... done
[15:32:35.835] result() for ClusterFuture ...
[15:32:35.835] - result already collected: FutureResult
[15:32:35.835] result() for ClusterFuture ... done
[15:32:35.835] - relayed: [n=2] TRUE, TRUE
[15:32:35.836] - queued futures: [n=2] TRUE, TRUE
[15:32:35.836] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:35.836]  length: 0 (resolved future 2)
[15:32:35.836] Relaying remaining futures
[15:32:35.836] signalConditionsASAP(NULL, pos=0) ...
[15:32:35.836] - nx: 2
[15:32:35.837] - relay: TRUE
[15:32:35.837] - stdout: TRUE
[15:32:35.837] - signal: TRUE
[15:32:35.837] - resignal: FALSE
[15:32:35.837] - force: TRUE
[15:32:35.837] - relayed: [n=2] TRUE, TRUE
[15:32:35.838] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:35.838] - relayed: [n=2] TRUE, TRUE
[15:32:35.838] - queued futures: [n=2] TRUE, TRUE
[15:32:35.838] signalConditionsASAP(NULL, pos=0) ... done
[15:32:35.838] resolve() on list ... DONE
[15:32:35.839] result() for ClusterFuture ...
[15:32:35.839] - result already collected: FutureResult
[15:32:35.839] result() for ClusterFuture ... done
[15:32:35.839] result() for ClusterFuture ...
[15:32:35.839] - result already collected: FutureResult
[15:32:35.839] result() for ClusterFuture ... done
[15:32:35.840] result() for ClusterFuture ...
[15:32:35.840] - result already collected: FutureResult
[15:32:35.840] result() for ClusterFuture ... done
[15:32:35.840] result() for ClusterFuture ...
[15:32:35.840] - result already collected: FutureResult
[15:32:35.840] result() for ClusterFuture ... done
[15:32:35.841]  - Number of value chunks collected: 2
[15:32:35.841] Resolving 2 futures (chunks) ... DONE
[15:32:35.841] Reducing values from 2 chunks ...
[15:32:35.841]  - Number of values collected after concatenation: 3
[15:32:35.841]  - Number of values expected: 3
[15:32:35.841] Reducing values from 2 chunks ... DONE
[15:32:35.842] future_lapply() ... DONE
List of 2
 $ y0: chr [1:3] "a" "b" "c"
 $ y1: chr [1:3] "a" "b" "c"
[15:32:35.843] future_lapply() ...
[15:32:35.847] Number of chunks: 2
[15:32:35.851] getGlobalsAndPackagesXApply() ...
[15:32:35.851]  - future.globals: TRUE
[15:32:35.851] getGlobalsAndPackages() ...
[15:32:35.851] Searching for globals...
[15:32:35.853] - globals found: [1] 'FUN'
[15:32:35.853] Searching for globals ... DONE
[15:32:35.854] Resolving globals: FALSE
[15:32:35.854] The total size of the 1 globals is 848 bytes (848 bytes)
[15:32:35.855] The total size of the 1 globals exported for future expression ('FUN()') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:32:35.855] - globals: [1] 'FUN'
[15:32:35.855] 
[15:32:35.855] getGlobalsAndPackages() ... DONE
[15:32:35.856]  - globals found/used: [n=1] 'FUN'
[15:32:35.856]  - needed namespaces: [n=0] 
[15:32:35.856] Finding globals ... DONE
[15:32:35.856]  - use_args: TRUE
[15:32:35.856]  - Getting '...' globals ...
[15:32:35.857] resolve() on list ...
[15:32:35.857]  recursive: 0
[15:32:35.857]  length: 1
[15:32:35.857]  elements: '...'
[15:32:35.858]  length: 0 (resolved future 1)
[15:32:35.858] resolve() on list ... DONE
[15:32:35.858]    - '...' content: [n=0] 
[15:32:35.858] List of 1
[15:32:35.858]  $ ...: list()
[15:32:35.858]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:35.858]  - attr(*, "where")=List of 1
[15:32:35.858]   ..$ ...:<environment: 0x00000276e4609108> 
[15:32:35.858]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:35.858]  - attr(*, "resolved")= logi TRUE
[15:32:35.858]  - attr(*, "total_size")= num NA
[15:32:35.863]  - Getting '...' globals ... DONE
[15:32:35.863] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:35.864] List of 2
[15:32:35.864]  $ ...future.FUN:function (x)  
[15:32:35.864]  $ ...          : list()
[15:32:35.864]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:35.864]  - attr(*, "where")=List of 2
[15:32:35.864]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:35.864]   ..$ ...          :<environment: 0x00000276e4609108> 
[15:32:35.864]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:35.864]  - attr(*, "resolved")= logi FALSE
[15:32:35.864]  - attr(*, "total_size")= num 848
[15:32:35.869] Packages to be attached in all futures: [n=0] 
[15:32:35.869] getGlobalsAndPackagesXApply() ... DONE
[15:32:35.870] Number of futures (= number of chunks): 2
[15:32:35.870] Launching 2 futures (chunks) ...
[15:32:35.870] Chunk #1 of 2 ...
[15:32:35.871]  - Finding globals in 'X' for chunk #1 ...
[15:32:35.871] getGlobalsAndPackages() ...
[15:32:35.871] Searching for globals...
[15:32:35.872] 
[15:32:35.872] Searching for globals ... DONE
[15:32:35.872] - globals: [0] <none>
[15:32:35.872] getGlobalsAndPackages() ... DONE
[15:32:35.873]    + additional globals found: [n=0] 
[15:32:35.873]    + additional namespaces needed: [n=0] 
[15:32:35.873]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:35.874]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:35.874]  - seeds: <none>
[15:32:35.874]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:35.874] getGlobalsAndPackages() ...
[15:32:35.875] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:35.875] Resolving globals: FALSE
[15:32:35.875] Tweak future expression to call with '...' arguments ...
[15:32:35.876] {
[15:32:35.876]     do.call(function(...) {
[15:32:35.876]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:35.876]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:35.876]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:35.876]             on.exit(options(oopts), add = TRUE)
[15:32:35.876]         }
[15:32:35.876]         {
[15:32:35.876]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:35.876]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:35.876]                 ...future.FUN(...future.X_jj, ...)
[15:32:35.876]             })
[15:32:35.876]         }
[15:32:35.876]     }, args = future.call.arguments)
[15:32:35.876] }
[15:32:35.876] Tweak future expression to call with '...' arguments ... DONE
[15:32:35.877] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:35.878] 
[15:32:35.878] getGlobalsAndPackages() ... DONE
[15:32:35.879] run() for 'Future' ...
[15:32:35.879] - state: 'created'
[15:32:35.879] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:35.898] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:35.898] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:35.899]   - Field: 'node'
[15:32:35.899]   - Field: 'label'
[15:32:35.899]   - Field: 'local'
[15:32:35.900]   - Field: 'owner'
[15:32:35.900]   - Field: 'envir'
[15:32:35.900]   - Field: 'workers'
[15:32:35.900]   - Field: 'packages'
[15:32:35.901]   - Field: 'gc'
[15:32:35.901]   - Field: 'conditions'
[15:32:35.901]   - Field: 'persistent'
[15:32:35.902]   - Field: 'expr'
[15:32:35.902]   - Field: 'uuid'
[15:32:35.902]   - Field: 'seed'
[15:32:35.902]   - Field: 'version'
[15:32:35.903]   - Field: 'result'
[15:32:35.903]   - Field: 'asynchronous'
[15:32:35.903]   - Field: 'calls'
[15:32:35.904]   - Field: 'globals'
[15:32:35.904]   - Field: 'stdout'
[15:32:35.904]   - Field: 'earlySignal'
[15:32:35.904]   - Field: 'lazy'
[15:32:35.905]   - Field: 'state'
[15:32:35.905] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:35.905] - Launch lazy future ...
[15:32:35.906] Packages needed by the future expression (n = 0): <none>
[15:32:35.906] Packages needed by future strategies (n = 0): <none>
[15:32:35.907] {
[15:32:35.907]     {
[15:32:35.907]         {
[15:32:35.907]             ...future.startTime <- base::Sys.time()
[15:32:35.907]             {
[15:32:35.907]                 {
[15:32:35.907]                   {
[15:32:35.907]                     {
[15:32:35.907]                       base::local({
[15:32:35.907]                         has_future <- base::requireNamespace("future", 
[15:32:35.907]                           quietly = TRUE)
[15:32:35.907]                         if (has_future) {
[15:32:35.907]                           ns <- base::getNamespace("future")
[15:32:35.907]                           version <- ns[[".package"]][["version"]]
[15:32:35.907]                           if (is.null(version)) 
[15:32:35.907]                             version <- utils::packageVersion("future")
[15:32:35.907]                         }
[15:32:35.907]                         else {
[15:32:35.907]                           version <- NULL
[15:32:35.907]                         }
[15:32:35.907]                         if (!has_future || version < "1.8.0") {
[15:32:35.907]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:35.907]                             "", base::R.version$version.string), 
[15:32:35.907]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:35.907]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:35.907]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:35.907]                               "release", "version")], collapse = " "), 
[15:32:35.907]                             hostname = base::Sys.info()[["nodename"]])
[15:32:35.907]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:35.907]                             info)
[15:32:35.907]                           info <- base::paste(info, collapse = "; ")
[15:32:35.907]                           if (!has_future) {
[15:32:35.907]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:35.907]                               info)
[15:32:35.907]                           }
[15:32:35.907]                           else {
[15:32:35.907]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:35.907]                               info, version)
[15:32:35.907]                           }
[15:32:35.907]                           base::stop(msg)
[15:32:35.907]                         }
[15:32:35.907]                       })
[15:32:35.907]                     }
[15:32:35.907]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:35.907]                     base::options(mc.cores = 1L)
[15:32:35.907]                   }
[15:32:35.907]                   ...future.strategy.old <- future::plan("list")
[15:32:35.907]                   options(future.plan = NULL)
[15:32:35.907]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:35.907]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:35.907]                 }
[15:32:35.907]                 ...future.workdir <- getwd()
[15:32:35.907]             }
[15:32:35.907]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:35.907]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:35.907]         }
[15:32:35.907]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:35.907]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:35.907]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:35.907]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:35.907]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:35.907]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:35.907]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:35.907]             base::names(...future.oldOptions))
[15:32:35.907]     }
[15:32:35.907]     if (FALSE) {
[15:32:35.907]     }
[15:32:35.907]     else {
[15:32:35.907]         if (TRUE) {
[15:32:35.907]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:35.907]                 open = "w")
[15:32:35.907]         }
[15:32:35.907]         else {
[15:32:35.907]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:35.907]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:35.907]         }
[15:32:35.907]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:35.907]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:35.907]             base::sink(type = "output", split = FALSE)
[15:32:35.907]             base::close(...future.stdout)
[15:32:35.907]         }, add = TRUE)
[15:32:35.907]     }
[15:32:35.907]     ...future.frame <- base::sys.nframe()
[15:32:35.907]     ...future.conditions <- base::list()
[15:32:35.907]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:35.907]     if (FALSE) {
[15:32:35.907]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:35.907]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:35.907]     }
[15:32:35.907]     ...future.result <- base::tryCatch({
[15:32:35.907]         base::withCallingHandlers({
[15:32:35.907]             ...future.value <- base::withVisible(base::local({
[15:32:35.907]                 ...future.makeSendCondition <- base::local({
[15:32:35.907]                   sendCondition <- NULL
[15:32:35.907]                   function(frame = 1L) {
[15:32:35.907]                     if (is.function(sendCondition)) 
[15:32:35.907]                       return(sendCondition)
[15:32:35.907]                     ns <- getNamespace("parallel")
[15:32:35.907]                     if (exists("sendData", mode = "function", 
[15:32:35.907]                       envir = ns)) {
[15:32:35.907]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:35.907]                         envir = ns)
[15:32:35.907]                       envir <- sys.frame(frame)
[15:32:35.907]                       master <- NULL
[15:32:35.907]                       while (!identical(envir, .GlobalEnv) && 
[15:32:35.907]                         !identical(envir, emptyenv())) {
[15:32:35.907]                         if (exists("master", mode = "list", envir = envir, 
[15:32:35.907]                           inherits = FALSE)) {
[15:32:35.907]                           master <- get("master", mode = "list", 
[15:32:35.907]                             envir = envir, inherits = FALSE)
[15:32:35.907]                           if (inherits(master, c("SOCKnode", 
[15:32:35.907]                             "SOCK0node"))) {
[15:32:35.907]                             sendCondition <<- function(cond) {
[15:32:35.907]                               data <- list(type = "VALUE", value = cond, 
[15:32:35.907]                                 success = TRUE)
[15:32:35.907]                               parallel_sendData(master, data)
[15:32:35.907]                             }
[15:32:35.907]                             return(sendCondition)
[15:32:35.907]                           }
[15:32:35.907]                         }
[15:32:35.907]                         frame <- frame + 1L
[15:32:35.907]                         envir <- sys.frame(frame)
[15:32:35.907]                       }
[15:32:35.907]                     }
[15:32:35.907]                     sendCondition <<- function(cond) NULL
[15:32:35.907]                   }
[15:32:35.907]                 })
[15:32:35.907]                 withCallingHandlers({
[15:32:35.907]                   {
[15:32:35.907]                     do.call(function(...) {
[15:32:35.907]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:35.907]                       if (!identical(...future.globals.maxSize.org, 
[15:32:35.907]                         ...future.globals.maxSize)) {
[15:32:35.907]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:35.907]                         on.exit(options(oopts), add = TRUE)
[15:32:35.907]                       }
[15:32:35.907]                       {
[15:32:35.907]                         lapply(seq_along(...future.elements_ii), 
[15:32:35.907]                           FUN = function(jj) {
[15:32:35.907]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:35.907]                             ...future.FUN(...future.X_jj, ...)
[15:32:35.907]                           })
[15:32:35.907]                       }
[15:32:35.907]                     }, args = future.call.arguments)
[15:32:35.907]                   }
[15:32:35.907]                 }, immediateCondition = function(cond) {
[15:32:35.907]                   sendCondition <- ...future.makeSendCondition()
[15:32:35.907]                   sendCondition(cond)
[15:32:35.907]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:35.907]                   {
[15:32:35.907]                     inherits <- base::inherits
[15:32:35.907]                     invokeRestart <- base::invokeRestart
[15:32:35.907]                     is.null <- base::is.null
[15:32:35.907]                     muffled <- FALSE
[15:32:35.907]                     if (inherits(cond, "message")) {
[15:32:35.907]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:35.907]                       if (muffled) 
[15:32:35.907]                         invokeRestart("muffleMessage")
[15:32:35.907]                     }
[15:32:35.907]                     else if (inherits(cond, "warning")) {
[15:32:35.907]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:35.907]                       if (muffled) 
[15:32:35.907]                         invokeRestart("muffleWarning")
[15:32:35.907]                     }
[15:32:35.907]                     else if (inherits(cond, "condition")) {
[15:32:35.907]                       if (!is.null(pattern)) {
[15:32:35.907]                         computeRestarts <- base::computeRestarts
[15:32:35.907]                         grepl <- base::grepl
[15:32:35.907]                         restarts <- computeRestarts(cond)
[15:32:35.907]                         for (restart in restarts) {
[15:32:35.907]                           name <- restart$name
[15:32:35.907]                           if (is.null(name)) 
[15:32:35.907]                             next
[15:32:35.907]                           if (!grepl(pattern, name)) 
[15:32:35.907]                             next
[15:32:35.907]                           invokeRestart(restart)
[15:32:35.907]                           muffled <- TRUE
[15:32:35.907]                           break
[15:32:35.907]                         }
[15:32:35.907]                       }
[15:32:35.907]                     }
[15:32:35.907]                     invisible(muffled)
[15:32:35.907]                   }
[15:32:35.907]                   muffleCondition(cond)
[15:32:35.907]                 })
[15:32:35.907]             }))
[15:32:35.907]             future::FutureResult(value = ...future.value$value, 
[15:32:35.907]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:35.907]                   ...future.rng), globalenv = if (FALSE) 
[15:32:35.907]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:35.907]                     ...future.globalenv.names))
[15:32:35.907]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:35.907]         }, condition = base::local({
[15:32:35.907]             c <- base::c
[15:32:35.907]             inherits <- base::inherits
[15:32:35.907]             invokeRestart <- base::invokeRestart
[15:32:35.907]             length <- base::length
[15:32:35.907]             list <- base::list
[15:32:35.907]             seq.int <- base::seq.int
[15:32:35.907]             signalCondition <- base::signalCondition
[15:32:35.907]             sys.calls <- base::sys.calls
[15:32:35.907]             `[[` <- base::`[[`
[15:32:35.907]             `+` <- base::`+`
[15:32:35.907]             `<<-` <- base::`<<-`
[15:32:35.907]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:35.907]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:35.907]                   3L)]
[15:32:35.907]             }
[15:32:35.907]             function(cond) {
[15:32:35.907]                 is_error <- inherits(cond, "error")
[15:32:35.907]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:35.907]                   NULL)
[15:32:35.907]                 if (is_error) {
[15:32:35.907]                   sessionInformation <- function() {
[15:32:35.907]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:35.907]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:35.907]                       search = base::search(), system = base::Sys.info())
[15:32:35.907]                   }
[15:32:35.907]                   ...future.conditions[[length(...future.conditions) + 
[15:32:35.907]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:35.907]                     cond$call), session = sessionInformation(), 
[15:32:35.907]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:35.907]                   signalCondition(cond)
[15:32:35.907]                 }
[15:32:35.907]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:35.907]                 "immediateCondition"))) {
[15:32:35.907]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:35.907]                   ...future.conditions[[length(...future.conditions) + 
[15:32:35.907]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:35.907]                   if (TRUE && !signal) {
[15:32:35.907]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:35.907]                     {
[15:32:35.907]                       inherits <- base::inherits
[15:32:35.907]                       invokeRestart <- base::invokeRestart
[15:32:35.907]                       is.null <- base::is.null
[15:32:35.907]                       muffled <- FALSE
[15:32:35.907]                       if (inherits(cond, "message")) {
[15:32:35.907]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:35.907]                         if (muffled) 
[15:32:35.907]                           invokeRestart("muffleMessage")
[15:32:35.907]                       }
[15:32:35.907]                       else if (inherits(cond, "warning")) {
[15:32:35.907]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:35.907]                         if (muffled) 
[15:32:35.907]                           invokeRestart("muffleWarning")
[15:32:35.907]                       }
[15:32:35.907]                       else if (inherits(cond, "condition")) {
[15:32:35.907]                         if (!is.null(pattern)) {
[15:32:35.907]                           computeRestarts <- base::computeRestarts
[15:32:35.907]                           grepl <- base::grepl
[15:32:35.907]                           restarts <- computeRestarts(cond)
[15:32:35.907]                           for (restart in restarts) {
[15:32:35.907]                             name <- restart$name
[15:32:35.907]                             if (is.null(name)) 
[15:32:35.907]                               next
[15:32:35.907]                             if (!grepl(pattern, name)) 
[15:32:35.907]                               next
[15:32:35.907]                             invokeRestart(restart)
[15:32:35.907]                             muffled <- TRUE
[15:32:35.907]                             break
[15:32:35.907]                           }
[15:32:35.907]                         }
[15:32:35.907]                       }
[15:32:35.907]                       invisible(muffled)
[15:32:35.907]                     }
[15:32:35.907]                     muffleCondition(cond, pattern = "^muffle")
[15:32:35.907]                   }
[15:32:35.907]                 }
[15:32:35.907]                 else {
[15:32:35.907]                   if (TRUE) {
[15:32:35.907]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:35.907]                     {
[15:32:35.907]                       inherits <- base::inherits
[15:32:35.907]                       invokeRestart <- base::invokeRestart
[15:32:35.907]                       is.null <- base::is.null
[15:32:35.907]                       muffled <- FALSE
[15:32:35.907]                       if (inherits(cond, "message")) {
[15:32:35.907]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:35.907]                         if (muffled) 
[15:32:35.907]                           invokeRestart("muffleMessage")
[15:32:35.907]                       }
[15:32:35.907]                       else if (inherits(cond, "warning")) {
[15:32:35.907]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:35.907]                         if (muffled) 
[15:32:35.907]                           invokeRestart("muffleWarning")
[15:32:35.907]                       }
[15:32:35.907]                       else if (inherits(cond, "condition")) {
[15:32:35.907]                         if (!is.null(pattern)) {
[15:32:35.907]                           computeRestarts <- base::computeRestarts
[15:32:35.907]                           grepl <- base::grepl
[15:32:35.907]                           restarts <- computeRestarts(cond)
[15:32:35.907]                           for (restart in restarts) {
[15:32:35.907]                             name <- restart$name
[15:32:35.907]                             if (is.null(name)) 
[15:32:35.907]                               next
[15:32:35.907]                             if (!grepl(pattern, name)) 
[15:32:35.907]                               next
[15:32:35.907]                             invokeRestart(restart)
[15:32:35.907]                             muffled <- TRUE
[15:32:35.907]                             break
[15:32:35.907]                           }
[15:32:35.907]                         }
[15:32:35.907]                       }
[15:32:35.907]                       invisible(muffled)
[15:32:35.907]                     }
[15:32:35.907]                     muffleCondition(cond, pattern = "^muffle")
[15:32:35.907]                   }
[15:32:35.907]                 }
[15:32:35.907]             }
[15:32:35.907]         }))
[15:32:35.907]     }, error = function(ex) {
[15:32:35.907]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:35.907]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:35.907]                 ...future.rng), started = ...future.startTime, 
[15:32:35.907]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:35.907]             version = "1.8"), class = "FutureResult")
[15:32:35.907]     }, finally = {
[15:32:35.907]         if (!identical(...future.workdir, getwd())) 
[15:32:35.907]             setwd(...future.workdir)
[15:32:35.907]         {
[15:32:35.907]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:35.907]                 ...future.oldOptions$nwarnings <- NULL
[15:32:35.907]             }
[15:32:35.907]             base::options(...future.oldOptions)
[15:32:35.907]             if (.Platform$OS.type == "windows") {
[15:32:35.907]                 old_names <- names(...future.oldEnvVars)
[15:32:35.907]                 envs <- base::Sys.getenv()
[15:32:35.907]                 names <- names(envs)
[15:32:35.907]                 common <- intersect(names, old_names)
[15:32:35.907]                 added <- setdiff(names, old_names)
[15:32:35.907]                 removed <- setdiff(old_names, names)
[15:32:35.907]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:35.907]                   envs[common]]
[15:32:35.907]                 NAMES <- toupper(changed)
[15:32:35.907]                 args <- list()
[15:32:35.907]                 for (kk in seq_along(NAMES)) {
[15:32:35.907]                   name <- changed[[kk]]
[15:32:35.907]                   NAME <- NAMES[[kk]]
[15:32:35.907]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:35.907]                     next
[15:32:35.907]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:35.907]                 }
[15:32:35.907]                 NAMES <- toupper(added)
[15:32:35.907]                 for (kk in seq_along(NAMES)) {
[15:32:35.907]                   name <- added[[kk]]
[15:32:35.907]                   NAME <- NAMES[[kk]]
[15:32:35.907]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:35.907]                     next
[15:32:35.907]                   args[[name]] <- ""
[15:32:35.907]                 }
[15:32:35.907]                 NAMES <- toupper(removed)
[15:32:35.907]                 for (kk in seq_along(NAMES)) {
[15:32:35.907]                   name <- removed[[kk]]
[15:32:35.907]                   NAME <- NAMES[[kk]]
[15:32:35.907]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:35.907]                     next
[15:32:35.907]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:35.907]                 }
[15:32:35.907]                 if (length(args) > 0) 
[15:32:35.907]                   base::do.call(base::Sys.setenv, args = args)
[15:32:35.907]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:35.907]             }
[15:32:35.907]             else {
[15:32:35.907]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:35.907]             }
[15:32:35.907]             {
[15:32:35.907]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:35.907]                   0L) {
[15:32:35.907]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:35.907]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:35.907]                   base::options(opts)
[15:32:35.907]                 }
[15:32:35.907]                 {
[15:32:35.907]                   {
[15:32:35.907]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:35.907]                     NULL
[15:32:35.907]                   }
[15:32:35.907]                   options(future.plan = NULL)
[15:32:35.907]                   if (is.na(NA_character_)) 
[15:32:35.907]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:35.907]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:35.907]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:35.907]                     .init = FALSE)
[15:32:35.907]                 }
[15:32:35.907]             }
[15:32:35.907]         }
[15:32:35.907]     })
[15:32:35.907]     if (TRUE) {
[15:32:35.907]         base::sink(type = "output", split = FALSE)
[15:32:35.907]         if (TRUE) {
[15:32:35.907]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:35.907]         }
[15:32:35.907]         else {
[15:32:35.907]             ...future.result["stdout"] <- base::list(NULL)
[15:32:35.907]         }
[15:32:35.907]         base::close(...future.stdout)
[15:32:35.907]         ...future.stdout <- NULL
[15:32:35.907]     }
[15:32:35.907]     ...future.result$conditions <- ...future.conditions
[15:32:35.907]     ...future.result$finished <- base::Sys.time()
[15:32:35.907]     ...future.result
[15:32:35.907] }
[15:32:35.917] Exporting 5 global objects (848 bytes) to cluster node #1 ...
[15:32:35.917] Exporting '...future.FUN' (848 bytes) to cluster node #1 ...
[15:32:35.918] Exporting '...future.FUN' (848 bytes) to cluster node #1 ... DONE
[15:32:35.918] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:35.919] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:35.919] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:35.920] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:35.920] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:35.921] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:35.921] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:35.922] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:35.922] Exporting 5 global objects (848 bytes) to cluster node #1 ... DONE
[15:32:35.923] MultisessionFuture started
[15:32:35.923] - Launch lazy future ... done
[15:32:35.924] run() for 'MultisessionFuture' ... done
[15:32:35.924] Created future:
[15:32:35.946] receiveMessageFromWorker() for ClusterFuture ...
[15:32:35.947] - Validating connection of MultisessionFuture
[15:32:35.947] - received message: FutureResult
[15:32:35.947] - Received FutureResult
[15:32:35.948] - Erased future from FutureRegistry
[15:32:35.948] result() for ClusterFuture ...
[15:32:35.948] - result already collected: FutureResult
[15:32:35.948] result() for ClusterFuture ... done
[15:32:35.948] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:35.924] MultisessionFuture:
[15:32:35.924] Label: 'future_sapply-1'
[15:32:35.924] Expression:
[15:32:35.924] {
[15:32:35.924]     do.call(function(...) {
[15:32:35.924]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:35.924]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:35.924]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:35.924]             on.exit(options(oopts), add = TRUE)
[15:32:35.924]         }
[15:32:35.924]         {
[15:32:35.924]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:35.924]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:35.924]                 ...future.FUN(...future.X_jj, ...)
[15:32:35.924]             })
[15:32:35.924]         }
[15:32:35.924]     }, args = future.call.arguments)
[15:32:35.924] }
[15:32:35.924] Lazy evaluation: FALSE
[15:32:35.924] Asynchronous evaluation: TRUE
[15:32:35.924] Local evaluation: TRUE
[15:32:35.924] Environment: R_GlobalEnv
[15:32:35.924] Capture standard output: TRUE
[15:32:35.924] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:35.924] Globals: 5 objects totaling 960 bytes (function '...future.FUN' of 848 bytes, 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)
[15:32:35.924] Packages: <none>
[15:32:35.924] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:35.924] Resolved: TRUE
[15:32:35.924] Value: <not collected>
[15:32:35.924] Conditions captured: <none>
[15:32:35.924] Early signaling: FALSE
[15:32:35.924] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:35.924] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:35.949] Chunk #1 of 2 ... DONE
[15:32:35.949] Chunk #2 of 2 ...
[15:32:35.949]  - Finding globals in 'X' for chunk #2 ...
[15:32:35.949] getGlobalsAndPackages() ...
[15:32:35.950] Searching for globals...
[15:32:35.950] 
[15:32:35.950] Searching for globals ... DONE
[15:32:35.950] - globals: [0] <none>
[15:32:35.951] getGlobalsAndPackages() ... DONE
[15:32:35.951]    + additional globals found: [n=0] 
[15:32:35.951]    + additional namespaces needed: [n=0] 
[15:32:35.951]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:35.951]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:35.951]  - seeds: <none>
[15:32:35.952]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:35.952] getGlobalsAndPackages() ...
[15:32:35.952] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:35.953] Resolving globals: FALSE
[15:32:35.953] Tweak future expression to call with '...' arguments ...
[15:32:35.953] {
[15:32:35.953]     do.call(function(...) {
[15:32:35.953]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:35.953]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:35.953]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:35.953]             on.exit(options(oopts), add = TRUE)
[15:32:35.953]         }
[15:32:35.953]         {
[15:32:35.953]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:35.953]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:35.953]                 ...future.FUN(...future.X_jj, ...)
[15:32:35.953]             })
[15:32:35.953]         }
[15:32:35.953]     }, args = future.call.arguments)
[15:32:35.953] }
[15:32:35.954] Tweak future expression to call with '...' arguments ... DONE
[15:32:35.954] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:35.955] 
[15:32:35.955] getGlobalsAndPackages() ... DONE
[15:32:35.955] run() for 'Future' ...
[15:32:35.955] - state: 'created'
[15:32:35.956] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:35.972] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:35.972] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:35.973]   - Field: 'node'
[15:32:35.973]   - Field: 'label'
[15:32:35.973]   - Field: 'local'
[15:32:35.973]   - Field: 'owner'
[15:32:35.974]   - Field: 'envir'
[15:32:35.974]   - Field: 'workers'
[15:32:35.974]   - Field: 'packages'
[15:32:35.975]   - Field: 'gc'
[15:32:35.975]   - Field: 'conditions'
[15:32:35.975]   - Field: 'persistent'
[15:32:35.975]   - Field: 'expr'
[15:32:35.976]   - Field: 'uuid'
[15:32:35.976]   - Field: 'seed'
[15:32:35.976]   - Field: 'version'
[15:32:35.976]   - Field: 'result'
[15:32:35.977]   - Field: 'asynchronous'
[15:32:35.977]   - Field: 'calls'
[15:32:35.978]   - Field: 'globals'
[15:32:35.978]   - Field: 'stdout'
[15:32:35.978]   - Field: 'earlySignal'
[15:32:35.979]   - Field: 'lazy'
[15:32:35.979]   - Field: 'state'
[15:32:35.979] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:35.980] - Launch lazy future ...
[15:32:35.980] Packages needed by the future expression (n = 0): <none>
[15:32:35.980] Packages needed by future strategies (n = 0): <none>
[15:32:35.981] {
[15:32:35.981]     {
[15:32:35.981]         {
[15:32:35.981]             ...future.startTime <- base::Sys.time()
[15:32:35.981]             {
[15:32:35.981]                 {
[15:32:35.981]                   {
[15:32:35.981]                     {
[15:32:35.981]                       base::local({
[15:32:35.981]                         has_future <- base::requireNamespace("future", 
[15:32:35.981]                           quietly = TRUE)
[15:32:35.981]                         if (has_future) {
[15:32:35.981]                           ns <- base::getNamespace("future")
[15:32:35.981]                           version <- ns[[".package"]][["version"]]
[15:32:35.981]                           if (is.null(version)) 
[15:32:35.981]                             version <- utils::packageVersion("future")
[15:32:35.981]                         }
[15:32:35.981]                         else {
[15:32:35.981]                           version <- NULL
[15:32:35.981]                         }
[15:32:35.981]                         if (!has_future || version < "1.8.0") {
[15:32:35.981]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:35.981]                             "", base::R.version$version.string), 
[15:32:35.981]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:35.981]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:35.981]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:35.981]                               "release", "version")], collapse = " "), 
[15:32:35.981]                             hostname = base::Sys.info()[["nodename"]])
[15:32:35.981]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:35.981]                             info)
[15:32:35.981]                           info <- base::paste(info, collapse = "; ")
[15:32:35.981]                           if (!has_future) {
[15:32:35.981]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:35.981]                               info)
[15:32:35.981]                           }
[15:32:35.981]                           else {
[15:32:35.981]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:35.981]                               info, version)
[15:32:35.981]                           }
[15:32:35.981]                           base::stop(msg)
[15:32:35.981]                         }
[15:32:35.981]                       })
[15:32:35.981]                     }
[15:32:35.981]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:35.981]                     base::options(mc.cores = 1L)
[15:32:35.981]                   }
[15:32:35.981]                   ...future.strategy.old <- future::plan("list")
[15:32:35.981]                   options(future.plan = NULL)
[15:32:35.981]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:35.981]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:35.981]                 }
[15:32:35.981]                 ...future.workdir <- getwd()
[15:32:35.981]             }
[15:32:35.981]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:35.981]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:35.981]         }
[15:32:35.981]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:35.981]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:35.981]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:35.981]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:35.981]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:35.981]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:35.981]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:35.981]             base::names(...future.oldOptions))
[15:32:35.981]     }
[15:32:35.981]     if (FALSE) {
[15:32:35.981]     }
[15:32:35.981]     else {
[15:32:35.981]         if (TRUE) {
[15:32:35.981]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:35.981]                 open = "w")
[15:32:35.981]         }
[15:32:35.981]         else {
[15:32:35.981]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:35.981]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:35.981]         }
[15:32:35.981]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:35.981]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:35.981]             base::sink(type = "output", split = FALSE)
[15:32:35.981]             base::close(...future.stdout)
[15:32:35.981]         }, add = TRUE)
[15:32:35.981]     }
[15:32:35.981]     ...future.frame <- base::sys.nframe()
[15:32:35.981]     ...future.conditions <- base::list()
[15:32:35.981]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:35.981]     if (FALSE) {
[15:32:35.981]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:35.981]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:35.981]     }
[15:32:35.981]     ...future.result <- base::tryCatch({
[15:32:35.981]         base::withCallingHandlers({
[15:32:35.981]             ...future.value <- base::withVisible(base::local({
[15:32:35.981]                 ...future.makeSendCondition <- base::local({
[15:32:35.981]                   sendCondition <- NULL
[15:32:35.981]                   function(frame = 1L) {
[15:32:35.981]                     if (is.function(sendCondition)) 
[15:32:35.981]                       return(sendCondition)
[15:32:35.981]                     ns <- getNamespace("parallel")
[15:32:35.981]                     if (exists("sendData", mode = "function", 
[15:32:35.981]                       envir = ns)) {
[15:32:35.981]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:35.981]                         envir = ns)
[15:32:35.981]                       envir <- sys.frame(frame)
[15:32:35.981]                       master <- NULL
[15:32:35.981]                       while (!identical(envir, .GlobalEnv) && 
[15:32:35.981]                         !identical(envir, emptyenv())) {
[15:32:35.981]                         if (exists("master", mode = "list", envir = envir, 
[15:32:35.981]                           inherits = FALSE)) {
[15:32:35.981]                           master <- get("master", mode = "list", 
[15:32:35.981]                             envir = envir, inherits = FALSE)
[15:32:35.981]                           if (inherits(master, c("SOCKnode", 
[15:32:35.981]                             "SOCK0node"))) {
[15:32:35.981]                             sendCondition <<- function(cond) {
[15:32:35.981]                               data <- list(type = "VALUE", value = cond, 
[15:32:35.981]                                 success = TRUE)
[15:32:35.981]                               parallel_sendData(master, data)
[15:32:35.981]                             }
[15:32:35.981]                             return(sendCondition)
[15:32:35.981]                           }
[15:32:35.981]                         }
[15:32:35.981]                         frame <- frame + 1L
[15:32:35.981]                         envir <- sys.frame(frame)
[15:32:35.981]                       }
[15:32:35.981]                     }
[15:32:35.981]                     sendCondition <<- function(cond) NULL
[15:32:35.981]                   }
[15:32:35.981]                 })
[15:32:35.981]                 withCallingHandlers({
[15:32:35.981]                   {
[15:32:35.981]                     do.call(function(...) {
[15:32:35.981]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:35.981]                       if (!identical(...future.globals.maxSize.org, 
[15:32:35.981]                         ...future.globals.maxSize)) {
[15:32:35.981]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:35.981]                         on.exit(options(oopts), add = TRUE)
[15:32:35.981]                       }
[15:32:35.981]                       {
[15:32:35.981]                         lapply(seq_along(...future.elements_ii), 
[15:32:35.981]                           FUN = function(jj) {
[15:32:35.981]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:35.981]                             ...future.FUN(...future.X_jj, ...)
[15:32:35.981]                           })
[15:32:35.981]                       }
[15:32:35.981]                     }, args = future.call.arguments)
[15:32:35.981]                   }
[15:32:35.981]                 }, immediateCondition = function(cond) {
[15:32:35.981]                   sendCondition <- ...future.makeSendCondition()
[15:32:35.981]                   sendCondition(cond)
[15:32:35.981]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:35.981]                   {
[15:32:35.981]                     inherits <- base::inherits
[15:32:35.981]                     invokeRestart <- base::invokeRestart
[15:32:35.981]                     is.null <- base::is.null
[15:32:35.981]                     muffled <- FALSE
[15:32:35.981]                     if (inherits(cond, "message")) {
[15:32:35.981]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:35.981]                       if (muffled) 
[15:32:35.981]                         invokeRestart("muffleMessage")
[15:32:35.981]                     }
[15:32:35.981]                     else if (inherits(cond, "warning")) {
[15:32:35.981]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:35.981]                       if (muffled) 
[15:32:35.981]                         invokeRestart("muffleWarning")
[15:32:35.981]                     }
[15:32:35.981]                     else if (inherits(cond, "condition")) {
[15:32:35.981]                       if (!is.null(pattern)) {
[15:32:35.981]                         computeRestarts <- base::computeRestarts
[15:32:35.981]                         grepl <- base::grepl
[15:32:35.981]                         restarts <- computeRestarts(cond)
[15:32:35.981]                         for (restart in restarts) {
[15:32:35.981]                           name <- restart$name
[15:32:35.981]                           if (is.null(name)) 
[15:32:35.981]                             next
[15:32:35.981]                           if (!grepl(pattern, name)) 
[15:32:35.981]                             next
[15:32:35.981]                           invokeRestart(restart)
[15:32:35.981]                           muffled <- TRUE
[15:32:35.981]                           break
[15:32:35.981]                         }
[15:32:35.981]                       }
[15:32:35.981]                     }
[15:32:35.981]                     invisible(muffled)
[15:32:35.981]                   }
[15:32:35.981]                   muffleCondition(cond)
[15:32:35.981]                 })
[15:32:35.981]             }))
[15:32:35.981]             future::FutureResult(value = ...future.value$value, 
[15:32:35.981]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:35.981]                   ...future.rng), globalenv = if (FALSE) 
[15:32:35.981]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:35.981]                     ...future.globalenv.names))
[15:32:35.981]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:35.981]         }, condition = base::local({
[15:32:35.981]             c <- base::c
[15:32:35.981]             inherits <- base::inherits
[15:32:35.981]             invokeRestart <- base::invokeRestart
[15:32:35.981]             length <- base::length
[15:32:35.981]             list <- base::list
[15:32:35.981]             seq.int <- base::seq.int
[15:32:35.981]             signalCondition <- base::signalCondition
[15:32:35.981]             sys.calls <- base::sys.calls
[15:32:35.981]             `[[` <- base::`[[`
[15:32:35.981]             `+` <- base::`+`
[15:32:35.981]             `<<-` <- base::`<<-`
[15:32:35.981]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:35.981]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:35.981]                   3L)]
[15:32:35.981]             }
[15:32:35.981]             function(cond) {
[15:32:35.981]                 is_error <- inherits(cond, "error")
[15:32:35.981]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:35.981]                   NULL)
[15:32:35.981]                 if (is_error) {
[15:32:35.981]                   sessionInformation <- function() {
[15:32:35.981]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:35.981]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:35.981]                       search = base::search(), system = base::Sys.info())
[15:32:35.981]                   }
[15:32:35.981]                   ...future.conditions[[length(...future.conditions) + 
[15:32:35.981]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:35.981]                     cond$call), session = sessionInformation(), 
[15:32:35.981]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:35.981]                   signalCondition(cond)
[15:32:35.981]                 }
[15:32:35.981]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:35.981]                 "immediateCondition"))) {
[15:32:35.981]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:35.981]                   ...future.conditions[[length(...future.conditions) + 
[15:32:35.981]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:35.981]                   if (TRUE && !signal) {
[15:32:35.981]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:35.981]                     {
[15:32:35.981]                       inherits <- base::inherits
[15:32:35.981]                       invokeRestart <- base::invokeRestart
[15:32:35.981]                       is.null <- base::is.null
[15:32:35.981]                       muffled <- FALSE
[15:32:35.981]                       if (inherits(cond, "message")) {
[15:32:35.981]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:35.981]                         if (muffled) 
[15:32:35.981]                           invokeRestart("muffleMessage")
[15:32:35.981]                       }
[15:32:35.981]                       else if (inherits(cond, "warning")) {
[15:32:35.981]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:35.981]                         if (muffled) 
[15:32:35.981]                           invokeRestart("muffleWarning")
[15:32:35.981]                       }
[15:32:35.981]                       else if (inherits(cond, "condition")) {
[15:32:35.981]                         if (!is.null(pattern)) {
[15:32:35.981]                           computeRestarts <- base::computeRestarts
[15:32:35.981]                           grepl <- base::grepl
[15:32:35.981]                           restarts <- computeRestarts(cond)
[15:32:35.981]                           for (restart in restarts) {
[15:32:35.981]                             name <- restart$name
[15:32:35.981]                             if (is.null(name)) 
[15:32:35.981]                               next
[15:32:35.981]                             if (!grepl(pattern, name)) 
[15:32:35.981]                               next
[15:32:35.981]                             invokeRestart(restart)
[15:32:35.981]                             muffled <- TRUE
[15:32:35.981]                             break
[15:32:35.981]                           }
[15:32:35.981]                         }
[15:32:35.981]                       }
[15:32:35.981]                       invisible(muffled)
[15:32:35.981]                     }
[15:32:35.981]                     muffleCondition(cond, pattern = "^muffle")
[15:32:35.981]                   }
[15:32:35.981]                 }
[15:32:35.981]                 else {
[15:32:35.981]                   if (TRUE) {
[15:32:35.981]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:35.981]                     {
[15:32:35.981]                       inherits <- base::inherits
[15:32:35.981]                       invokeRestart <- base::invokeRestart
[15:32:35.981]                       is.null <- base::is.null
[15:32:35.981]                       muffled <- FALSE
[15:32:35.981]                       if (inherits(cond, "message")) {
[15:32:35.981]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:35.981]                         if (muffled) 
[15:32:35.981]                           invokeRestart("muffleMessage")
[15:32:35.981]                       }
[15:32:35.981]                       else if (inherits(cond, "warning")) {
[15:32:35.981]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:35.981]                         if (muffled) 
[15:32:35.981]                           invokeRestart("muffleWarning")
[15:32:35.981]                       }
[15:32:35.981]                       else if (inherits(cond, "condition")) {
[15:32:35.981]                         if (!is.null(pattern)) {
[15:32:35.981]                           computeRestarts <- base::computeRestarts
[15:32:35.981]                           grepl <- base::grepl
[15:32:35.981]                           restarts <- computeRestarts(cond)
[15:32:35.981]                           for (restart in restarts) {
[15:32:35.981]                             name <- restart$name
[15:32:35.981]                             if (is.null(name)) 
[15:32:35.981]                               next
[15:32:35.981]                             if (!grepl(pattern, name)) 
[15:32:35.981]                               next
[15:32:35.981]                             invokeRestart(restart)
[15:32:35.981]                             muffled <- TRUE
[15:32:35.981]                             break
[15:32:35.981]                           }
[15:32:35.981]                         }
[15:32:35.981]                       }
[15:32:35.981]                       invisible(muffled)
[15:32:35.981]                     }
[15:32:35.981]                     muffleCondition(cond, pattern = "^muffle")
[15:32:35.981]                   }
[15:32:35.981]                 }
[15:32:35.981]             }
[15:32:35.981]         }))
[15:32:35.981]     }, error = function(ex) {
[15:32:35.981]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:35.981]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:35.981]                 ...future.rng), started = ...future.startTime, 
[15:32:35.981]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:35.981]             version = "1.8"), class = "FutureResult")
[15:32:35.981]     }, finally = {
[15:32:35.981]         if (!identical(...future.workdir, getwd())) 
[15:32:35.981]             setwd(...future.workdir)
[15:32:35.981]         {
[15:32:35.981]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:35.981]                 ...future.oldOptions$nwarnings <- NULL
[15:32:35.981]             }
[15:32:35.981]             base::options(...future.oldOptions)
[15:32:35.981]             if (.Platform$OS.type == "windows") {
[15:32:35.981]                 old_names <- names(...future.oldEnvVars)
[15:32:35.981]                 envs <- base::Sys.getenv()
[15:32:35.981]                 names <- names(envs)
[15:32:35.981]                 common <- intersect(names, old_names)
[15:32:35.981]                 added <- setdiff(names, old_names)
[15:32:35.981]                 removed <- setdiff(old_names, names)
[15:32:35.981]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:35.981]                   envs[common]]
[15:32:35.981]                 NAMES <- toupper(changed)
[15:32:35.981]                 args <- list()
[15:32:35.981]                 for (kk in seq_along(NAMES)) {
[15:32:35.981]                   name <- changed[[kk]]
[15:32:35.981]                   NAME <- NAMES[[kk]]
[15:32:35.981]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:35.981]                     next
[15:32:35.981]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:35.981]                 }
[15:32:35.981]                 NAMES <- toupper(added)
[15:32:35.981]                 for (kk in seq_along(NAMES)) {
[15:32:35.981]                   name <- added[[kk]]
[15:32:35.981]                   NAME <- NAMES[[kk]]
[15:32:35.981]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:35.981]                     next
[15:32:35.981]                   args[[name]] <- ""
[15:32:35.981]                 }
[15:32:35.981]                 NAMES <- toupper(removed)
[15:32:35.981]                 for (kk in seq_along(NAMES)) {
[15:32:35.981]                   name <- removed[[kk]]
[15:32:35.981]                   NAME <- NAMES[[kk]]
[15:32:35.981]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:35.981]                     next
[15:32:35.981]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:35.981]                 }
[15:32:35.981]                 if (length(args) > 0) 
[15:32:35.981]                   base::do.call(base::Sys.setenv, args = args)
[15:32:35.981]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:35.981]             }
[15:32:35.981]             else {
[15:32:35.981]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:35.981]             }
[15:32:35.981]             {
[15:32:35.981]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:35.981]                   0L) {
[15:32:35.981]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:35.981]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:35.981]                   base::options(opts)
[15:32:35.981]                 }
[15:32:35.981]                 {
[15:32:35.981]                   {
[15:32:35.981]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:35.981]                     NULL
[15:32:35.981]                   }
[15:32:35.981]                   options(future.plan = NULL)
[15:32:35.981]                   if (is.na(NA_character_)) 
[15:32:35.981]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:35.981]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:35.981]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:35.981]                     .init = FALSE)
[15:32:35.981]                 }
[15:32:35.981]             }
[15:32:35.981]         }
[15:32:35.981]     })
[15:32:35.981]     if (TRUE) {
[15:32:35.981]         base::sink(type = "output", split = FALSE)
[15:32:35.981]         if (TRUE) {
[15:32:35.981]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:35.981]         }
[15:32:35.981]         else {
[15:32:35.981]             ...future.result["stdout"] <- base::list(NULL)
[15:32:35.981]         }
[15:32:35.981]         base::close(...future.stdout)
[15:32:35.981]         ...future.stdout <- NULL
[15:32:35.981]     }
[15:32:35.981]     ...future.result$conditions <- ...future.conditions
[15:32:35.981]     ...future.result$finished <- base::Sys.time()
[15:32:35.981]     ...future.result
[15:32:35.981] }
[15:32:35.988] Exporting 5 global objects (848 bytes) to cluster node #1 ...
[15:32:35.988] Exporting '...future.FUN' (848 bytes) to cluster node #1 ...
[15:32:35.989] Exporting '...future.FUN' (848 bytes) to cluster node #1 ... DONE
[15:32:35.989] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:35.990] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:35.990] Exporting '...future.elements_ii' (224 bytes) to cluster node #1 ...
[15:32:35.991] Exporting '...future.elements_ii' (224 bytes) to cluster node #1 ... DONE
[15:32:35.991] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:35.992] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:35.992] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:35.993] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:35.993] Exporting 5 global objects (848 bytes) to cluster node #1 ... DONE
[15:32:35.994] MultisessionFuture started
[15:32:35.995] - Launch lazy future ... done
[15:32:35.995] run() for 'MultisessionFuture' ... done
[15:32:35.995] Created future:
[15:32:36.024] receiveMessageFromWorker() for ClusterFuture ...
[15:32:36.024] - Validating connection of MultisessionFuture
[15:32:36.025] - received message: FutureResult
[15:32:36.025] - Received FutureResult
[15:32:36.025] - Erased future from FutureRegistry
[15:32:36.026] result() for ClusterFuture ...
[15:32:36.026] - result already collected: FutureResult
[15:32:36.026] result() for ClusterFuture ... done
[15:32:36.027] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:35.996] MultisessionFuture:
[15:32:35.996] Label: 'future_sapply-2'
[15:32:35.996] Expression:
[15:32:35.996] {
[15:32:35.996]     do.call(function(...) {
[15:32:35.996]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:35.996]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:35.996]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:35.996]             on.exit(options(oopts), add = TRUE)
[15:32:35.996]         }
[15:32:35.996]         {
[15:32:35.996]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:35.996]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:35.996]                 ...future.FUN(...future.X_jj, ...)
[15:32:35.996]             })
[15:32:35.996]         }
[15:32:35.996]     }, args = future.call.arguments)
[15:32:35.996] }
[15:32:35.996] Lazy evaluation: FALSE
[15:32:35.996] Asynchronous evaluation: TRUE
[15:32:35.996] Local evaluation: TRUE
[15:32:35.996] Environment: R_GlobalEnv
[15:32:35.996] Capture standard output: TRUE
[15:32:35.996] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:35.996] Globals: 5 objects totaling 1.05 KiB (function '...future.FUN' of 848 bytes, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 224 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:35.996] Packages: <none>
[15:32:35.996] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:35.996] Resolved: TRUE
[15:32:35.996] Value: <not collected>
[15:32:35.996] Conditions captured: <none>
[15:32:35.996] Early signaling: FALSE
[15:32:35.996] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:35.996] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:36.028] Chunk #2 of 2 ... DONE
[15:32:36.028] Launching 2 futures (chunks) ... DONE
[15:32:36.028] Resolving 2 futures (chunks) ...
[15:32:36.029] resolve() on list ...
[15:32:36.029]  recursive: 0
[15:32:36.029]  length: 2
[15:32:36.030] 
[15:32:36.030] Future #1
[15:32:36.030] result() for ClusterFuture ...
[15:32:36.031] - result already collected: FutureResult
[15:32:36.031] result() for ClusterFuture ... done
[15:32:36.031] result() for ClusterFuture ...
[15:32:36.031] - result already collected: FutureResult
[15:32:36.032] result() for ClusterFuture ... done
[15:32:36.032] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:36.032] - nx: 2
[15:32:36.033] - relay: TRUE
[15:32:36.033] - stdout: TRUE
[15:32:36.033] - signal: TRUE
[15:32:36.034] - resignal: FALSE
[15:32:36.034] - force: TRUE
[15:32:36.034] - relayed: [n=2] FALSE, FALSE
[15:32:36.034] - queued futures: [n=2] FALSE, FALSE
[15:32:36.035]  - until=1
[15:32:36.035]  - relaying element #1
[15:32:36.035] result() for ClusterFuture ...
[15:32:36.035] - result already collected: FutureResult
[15:32:36.036] result() for ClusterFuture ... done
[15:32:36.036] result() for ClusterFuture ...
[15:32:36.036] - result already collected: FutureResult
[15:32:36.036] result() for ClusterFuture ... done
[15:32:36.037] result() for ClusterFuture ...
[15:32:36.037] - result already collected: FutureResult
[15:32:36.037] result() for ClusterFuture ... done
[15:32:36.038] result() for ClusterFuture ...
[15:32:36.038] - result already collected: FutureResult
[15:32:36.038] result() for ClusterFuture ... done
[15:32:36.038] - relayed: [n=2] TRUE, FALSE
[15:32:36.039] - queued futures: [n=2] TRUE, FALSE
[15:32:36.039] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:36.039]  length: 1 (resolved future 1)
[15:32:36.040] Future #2
[15:32:36.040] result() for ClusterFuture ...
[15:32:36.040] - result already collected: FutureResult
[15:32:36.041] result() for ClusterFuture ... done
[15:32:36.041] result() for ClusterFuture ...
[15:32:36.041] - result already collected: FutureResult
[15:32:36.041] result() for ClusterFuture ... done
[15:32:36.042] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:36.042] - nx: 2
[15:32:36.042] - relay: TRUE
[15:32:36.042] - stdout: TRUE
[15:32:36.043] - signal: TRUE
[15:32:36.043] - resignal: FALSE
[15:32:36.043] - force: TRUE
[15:32:36.044] - relayed: [n=2] TRUE, FALSE
[15:32:36.044] - queued futures: [n=2] TRUE, FALSE
[15:32:36.044]  - until=2
[15:32:36.044]  - relaying element #2
[15:32:36.045] result() for ClusterFuture ...
[15:32:36.045] - result already collected: FutureResult
[15:32:36.045] result() for ClusterFuture ... done
[15:32:36.046] result() for ClusterFuture ...
[15:32:36.046] - result already collected: FutureResult
[15:32:36.046] result() for ClusterFuture ... done
[15:32:36.047] result() for ClusterFuture ...
[15:32:36.047] - result already collected: FutureResult
[15:32:36.047] result() for ClusterFuture ... done
[15:32:36.048] result() for ClusterFuture ...
[15:32:36.048] - result already collected: FutureResult
[15:32:36.048] result() for ClusterFuture ... done
[15:32:36.048] - relayed: [n=2] TRUE, TRUE
[15:32:36.049] - queued futures: [n=2] TRUE, TRUE
[15:32:36.049] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:36.049]  length: 0 (resolved future 2)
[15:32:36.050] Relaying remaining futures
[15:32:36.050] signalConditionsASAP(NULL, pos=0) ...
[15:32:36.050] - nx: 2
[15:32:36.050] - relay: TRUE
[15:32:36.051] - stdout: TRUE
[15:32:36.051] - signal: TRUE
[15:32:36.051] - resignal: FALSE
[15:32:36.052] - force: TRUE
[15:32:36.052] - relayed: [n=2] TRUE, TRUE
[15:32:36.052] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:36.053] - relayed: [n=2] TRUE, TRUE
[15:32:36.053] - queued futures: [n=2] TRUE, TRUE
[15:32:36.053] signalConditionsASAP(NULL, pos=0) ... done
[15:32:36.054] resolve() on list ... DONE
[15:32:36.054] result() for ClusterFuture ...
[15:32:36.054] - result already collected: FutureResult
[15:32:36.054] result() for ClusterFuture ... done
[15:32:36.055] result() for ClusterFuture ...
[15:32:36.055] - result already collected: FutureResult
[15:32:36.055] result() for ClusterFuture ... done
[15:32:36.056] result() for ClusterFuture ...
[15:32:36.056] - result already collected: FutureResult
[15:32:36.056] result() for ClusterFuture ... done
[15:32:36.057] result() for ClusterFuture ...
[15:32:36.057] - result already collected: FutureResult
[15:32:36.057] result() for ClusterFuture ... done
[15:32:36.058]  - Number of value chunks collected: 2
[15:32:36.058] Resolving 2 futures (chunks) ... DONE
[15:32:36.058] Reducing values from 2 chunks ...
[15:32:36.058]  - Number of values collected after concatenation: 3
[15:32:36.059]  - Number of values expected: 3
[15:32:36.059] Reducing values from 2 chunks ... DONE
[15:32:36.059] future_lapply() ... DONE
List of 2
 $ y0: chr [1:3] "a" "b" "c"
 $ y1: chr [1:3] "a" "b" "c"
[15:32:36.062] future_lapply() ...
[15:32:36.066] Number of chunks: 2
[15:32:36.067] getGlobalsAndPackagesXApply() ...
[15:32:36.067]  - future.globals: TRUE
[15:32:36.067] getGlobalsAndPackages() ...
[15:32:36.067] Searching for globals...
[15:32:36.070] - globals found: [2] 'FUN', 'UseMethod'
[15:32:36.070] Searching for globals ... DONE
[15:32:36.070] Resolving globals: FALSE
[15:32:36.071] The total size of the 1 globals is 1.22 KiB (1248 bytes)
[15:32:36.072] The total size of the 1 globals exported for future expression ('FUN()') is 1.22 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.22 KiB of class 'function')
[15:32:36.072] - globals: [1] 'FUN'
[15:32:36.072] 
[15:32:36.072] getGlobalsAndPackages() ... DONE
[15:32:36.073]  - globals found/used: [n=1] 'FUN'
[15:32:36.073]  - needed namespaces: [n=0] 
[15:32:36.073] Finding globals ... DONE
[15:32:36.073]  - use_args: TRUE
[15:32:36.074]  - Getting '...' globals ...
[15:32:36.074] resolve() on list ...
[15:32:36.075]  recursive: 0
[15:32:36.075]  length: 1
[15:32:36.075]  elements: '...'
[15:32:36.075]  length: 0 (resolved future 1)
[15:32:36.076] resolve() on list ... DONE
[15:32:36.076]    - '...' content: [n=0] 
[15:32:36.076] List of 1
[15:32:36.076]  $ ...: list()
[15:32:36.076]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:36.076]  - attr(*, "where")=List of 1
[15:32:36.076]   ..$ ...:<environment: 0x00000276e4cb2160> 
[15:32:36.076]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:36.076]  - attr(*, "resolved")= logi TRUE
[15:32:36.076]  - attr(*, "total_size")= num NA
[15:32:36.081]  - Getting '...' globals ... DONE
[15:32:36.081] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:36.081] List of 2
[15:32:36.081]  $ ...future.FUN:function (x, ...)  
[15:32:36.081]  $ ...          : list()
[15:32:36.081]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:36.081]  - attr(*, "where")=List of 2
[15:32:36.081]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:36.081]   ..$ ...          :<environment: 0x00000276e4cb2160> 
[15:32:36.081]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:36.081]  - attr(*, "resolved")= logi FALSE
[15:32:36.081]  - attr(*, "total_size")= num 1248
[15:32:36.093] Packages to be attached in all futures: [n=0] 
[15:32:36.094] getGlobalsAndPackagesXApply() ... DONE
[15:32:36.094] Number of futures (= number of chunks): 2
[15:32:36.094] Launching 2 futures (chunks) ...
[15:32:36.095] Chunk #1 of 2 ...
[15:32:36.095]  - Finding globals in 'X' for chunk #1 ...
[15:32:36.095] getGlobalsAndPackages() ...
[15:32:36.096] Searching for globals...
[15:32:36.096] 
[15:32:36.096] Searching for globals ... DONE
[15:32:36.097] - globals: [0] <none>
[15:32:36.097] getGlobalsAndPackages() ... DONE
[15:32:36.097]    + additional globals found: [n=0] 
[15:32:36.097]    + additional namespaces needed: [n=0] 
[15:32:36.098]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:36.098]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:36.098]  - seeds: <none>
[15:32:36.098]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:36.099] getGlobalsAndPackages() ...
[15:32:36.099] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:36.099] Resolving globals: FALSE
[15:32:36.100] Tweak future expression to call with '...' arguments ...
[15:32:36.100] {
[15:32:36.100]     do.call(function(...) {
[15:32:36.100]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:36.100]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:36.100]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:36.100]             on.exit(options(oopts), add = TRUE)
[15:32:36.100]         }
[15:32:36.100]         {
[15:32:36.100]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:36.100]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:36.100]                 ...future.FUN(...future.X_jj, ...)
[15:32:36.100]             })
[15:32:36.100]         }
[15:32:36.100]     }, args = future.call.arguments)
[15:32:36.100] }
[15:32:36.101] Tweak future expression to call with '...' arguments ... DONE
[15:32:36.101] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:36.102] 
[15:32:36.102] getGlobalsAndPackages() ... DONE
[15:32:36.102] run() for 'Future' ...
[15:32:36.102] - state: 'created'
[15:32:36.103] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:36.120] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:36.120] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:36.120]   - Field: 'node'
[15:32:36.121]   - Field: 'label'
[15:32:36.121]   - Field: 'local'
[15:32:36.121]   - Field: 'owner'
[15:32:36.122]   - Field: 'envir'
[15:32:36.122]   - Field: 'workers'
[15:32:36.122]   - Field: 'packages'
[15:32:36.122]   - Field: 'gc'
[15:32:36.123]   - Field: 'conditions'
[15:32:36.123]   - Field: 'persistent'
[15:32:36.123]   - Field: 'expr'
[15:32:36.124]   - Field: 'uuid'
[15:32:36.124]   - Field: 'seed'
[15:32:36.124]   - Field: 'version'
[15:32:36.125]   - Field: 'result'
[15:32:36.125]   - Field: 'asynchronous'
[15:32:36.125]   - Field: 'calls'
[15:32:36.125]   - Field: 'globals'
[15:32:36.126]   - Field: 'stdout'
[15:32:36.126]   - Field: 'earlySignal'
[15:32:36.126]   - Field: 'lazy'
[15:32:36.127]   - Field: 'state'
[15:32:36.127] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:36.127] - Launch lazy future ...
[15:32:36.128] Packages needed by the future expression (n = 0): <none>
[15:32:36.128] Packages needed by future strategies (n = 0): <none>
[15:32:36.129] {
[15:32:36.129]     {
[15:32:36.129]         {
[15:32:36.129]             ...future.startTime <- base::Sys.time()
[15:32:36.129]             {
[15:32:36.129]                 {
[15:32:36.129]                   {
[15:32:36.129]                     {
[15:32:36.129]                       base::local({
[15:32:36.129]                         has_future <- base::requireNamespace("future", 
[15:32:36.129]                           quietly = TRUE)
[15:32:36.129]                         if (has_future) {
[15:32:36.129]                           ns <- base::getNamespace("future")
[15:32:36.129]                           version <- ns[[".package"]][["version"]]
[15:32:36.129]                           if (is.null(version)) 
[15:32:36.129]                             version <- utils::packageVersion("future")
[15:32:36.129]                         }
[15:32:36.129]                         else {
[15:32:36.129]                           version <- NULL
[15:32:36.129]                         }
[15:32:36.129]                         if (!has_future || version < "1.8.0") {
[15:32:36.129]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:36.129]                             "", base::R.version$version.string), 
[15:32:36.129]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:36.129]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:36.129]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:36.129]                               "release", "version")], collapse = " "), 
[15:32:36.129]                             hostname = base::Sys.info()[["nodename"]])
[15:32:36.129]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:36.129]                             info)
[15:32:36.129]                           info <- base::paste(info, collapse = "; ")
[15:32:36.129]                           if (!has_future) {
[15:32:36.129]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:36.129]                               info)
[15:32:36.129]                           }
[15:32:36.129]                           else {
[15:32:36.129]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:36.129]                               info, version)
[15:32:36.129]                           }
[15:32:36.129]                           base::stop(msg)
[15:32:36.129]                         }
[15:32:36.129]                       })
[15:32:36.129]                     }
[15:32:36.129]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:36.129]                     base::options(mc.cores = 1L)
[15:32:36.129]                   }
[15:32:36.129]                   ...future.strategy.old <- future::plan("list")
[15:32:36.129]                   options(future.plan = NULL)
[15:32:36.129]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:36.129]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:36.129]                 }
[15:32:36.129]                 ...future.workdir <- getwd()
[15:32:36.129]             }
[15:32:36.129]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:36.129]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:36.129]         }
[15:32:36.129]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:36.129]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:36.129]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:36.129]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:36.129]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:36.129]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:36.129]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:36.129]             base::names(...future.oldOptions))
[15:32:36.129]     }
[15:32:36.129]     if (FALSE) {
[15:32:36.129]     }
[15:32:36.129]     else {
[15:32:36.129]         if (TRUE) {
[15:32:36.129]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:36.129]                 open = "w")
[15:32:36.129]         }
[15:32:36.129]         else {
[15:32:36.129]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:36.129]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:36.129]         }
[15:32:36.129]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:36.129]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:36.129]             base::sink(type = "output", split = FALSE)
[15:32:36.129]             base::close(...future.stdout)
[15:32:36.129]         }, add = TRUE)
[15:32:36.129]     }
[15:32:36.129]     ...future.frame <- base::sys.nframe()
[15:32:36.129]     ...future.conditions <- base::list()
[15:32:36.129]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:36.129]     if (FALSE) {
[15:32:36.129]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:36.129]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:36.129]     }
[15:32:36.129]     ...future.result <- base::tryCatch({
[15:32:36.129]         base::withCallingHandlers({
[15:32:36.129]             ...future.value <- base::withVisible(base::local({
[15:32:36.129]                 ...future.makeSendCondition <- base::local({
[15:32:36.129]                   sendCondition <- NULL
[15:32:36.129]                   function(frame = 1L) {
[15:32:36.129]                     if (is.function(sendCondition)) 
[15:32:36.129]                       return(sendCondition)
[15:32:36.129]                     ns <- getNamespace("parallel")
[15:32:36.129]                     if (exists("sendData", mode = "function", 
[15:32:36.129]                       envir = ns)) {
[15:32:36.129]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:36.129]                         envir = ns)
[15:32:36.129]                       envir <- sys.frame(frame)
[15:32:36.129]                       master <- NULL
[15:32:36.129]                       while (!identical(envir, .GlobalEnv) && 
[15:32:36.129]                         !identical(envir, emptyenv())) {
[15:32:36.129]                         if (exists("master", mode = "list", envir = envir, 
[15:32:36.129]                           inherits = FALSE)) {
[15:32:36.129]                           master <- get("master", mode = "list", 
[15:32:36.129]                             envir = envir, inherits = FALSE)
[15:32:36.129]                           if (inherits(master, c("SOCKnode", 
[15:32:36.129]                             "SOCK0node"))) {
[15:32:36.129]                             sendCondition <<- function(cond) {
[15:32:36.129]                               data <- list(type = "VALUE", value = cond, 
[15:32:36.129]                                 success = TRUE)
[15:32:36.129]                               parallel_sendData(master, data)
[15:32:36.129]                             }
[15:32:36.129]                             return(sendCondition)
[15:32:36.129]                           }
[15:32:36.129]                         }
[15:32:36.129]                         frame <- frame + 1L
[15:32:36.129]                         envir <- sys.frame(frame)
[15:32:36.129]                       }
[15:32:36.129]                     }
[15:32:36.129]                     sendCondition <<- function(cond) NULL
[15:32:36.129]                   }
[15:32:36.129]                 })
[15:32:36.129]                 withCallingHandlers({
[15:32:36.129]                   {
[15:32:36.129]                     do.call(function(...) {
[15:32:36.129]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:36.129]                       if (!identical(...future.globals.maxSize.org, 
[15:32:36.129]                         ...future.globals.maxSize)) {
[15:32:36.129]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:36.129]                         on.exit(options(oopts), add = TRUE)
[15:32:36.129]                       }
[15:32:36.129]                       {
[15:32:36.129]                         lapply(seq_along(...future.elements_ii), 
[15:32:36.129]                           FUN = function(jj) {
[15:32:36.129]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:36.129]                             ...future.FUN(...future.X_jj, ...)
[15:32:36.129]                           })
[15:32:36.129]                       }
[15:32:36.129]                     }, args = future.call.arguments)
[15:32:36.129]                   }
[15:32:36.129]                 }, immediateCondition = function(cond) {
[15:32:36.129]                   sendCondition <- ...future.makeSendCondition()
[15:32:36.129]                   sendCondition(cond)
[15:32:36.129]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:36.129]                   {
[15:32:36.129]                     inherits <- base::inherits
[15:32:36.129]                     invokeRestart <- base::invokeRestart
[15:32:36.129]                     is.null <- base::is.null
[15:32:36.129]                     muffled <- FALSE
[15:32:36.129]                     if (inherits(cond, "message")) {
[15:32:36.129]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:36.129]                       if (muffled) 
[15:32:36.129]                         invokeRestart("muffleMessage")
[15:32:36.129]                     }
[15:32:36.129]                     else if (inherits(cond, "warning")) {
[15:32:36.129]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:36.129]                       if (muffled) 
[15:32:36.129]                         invokeRestart("muffleWarning")
[15:32:36.129]                     }
[15:32:36.129]                     else if (inherits(cond, "condition")) {
[15:32:36.129]                       if (!is.null(pattern)) {
[15:32:36.129]                         computeRestarts <- base::computeRestarts
[15:32:36.129]                         grepl <- base::grepl
[15:32:36.129]                         restarts <- computeRestarts(cond)
[15:32:36.129]                         for (restart in restarts) {
[15:32:36.129]                           name <- restart$name
[15:32:36.129]                           if (is.null(name)) 
[15:32:36.129]                             next
[15:32:36.129]                           if (!grepl(pattern, name)) 
[15:32:36.129]                             next
[15:32:36.129]                           invokeRestart(restart)
[15:32:36.129]                           muffled <- TRUE
[15:32:36.129]                           break
[15:32:36.129]                         }
[15:32:36.129]                       }
[15:32:36.129]                     }
[15:32:36.129]                     invisible(muffled)
[15:32:36.129]                   }
[15:32:36.129]                   muffleCondition(cond)
[15:32:36.129]                 })
[15:32:36.129]             }))
[15:32:36.129]             future::FutureResult(value = ...future.value$value, 
[15:32:36.129]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:36.129]                   ...future.rng), globalenv = if (FALSE) 
[15:32:36.129]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:36.129]                     ...future.globalenv.names))
[15:32:36.129]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:36.129]         }, condition = base::local({
[15:32:36.129]             c <- base::c
[15:32:36.129]             inherits <- base::inherits
[15:32:36.129]             invokeRestart <- base::invokeRestart
[15:32:36.129]             length <- base::length
[15:32:36.129]             list <- base::list
[15:32:36.129]             seq.int <- base::seq.int
[15:32:36.129]             signalCondition <- base::signalCondition
[15:32:36.129]             sys.calls <- base::sys.calls
[15:32:36.129]             `[[` <- base::`[[`
[15:32:36.129]             `+` <- base::`+`
[15:32:36.129]             `<<-` <- base::`<<-`
[15:32:36.129]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:36.129]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:36.129]                   3L)]
[15:32:36.129]             }
[15:32:36.129]             function(cond) {
[15:32:36.129]                 is_error <- inherits(cond, "error")
[15:32:36.129]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:36.129]                   NULL)
[15:32:36.129]                 if (is_error) {
[15:32:36.129]                   sessionInformation <- function() {
[15:32:36.129]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:36.129]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:36.129]                       search = base::search(), system = base::Sys.info())
[15:32:36.129]                   }
[15:32:36.129]                   ...future.conditions[[length(...future.conditions) + 
[15:32:36.129]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:36.129]                     cond$call), session = sessionInformation(), 
[15:32:36.129]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:36.129]                   signalCondition(cond)
[15:32:36.129]                 }
[15:32:36.129]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:36.129]                 "immediateCondition"))) {
[15:32:36.129]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:36.129]                   ...future.conditions[[length(...future.conditions) + 
[15:32:36.129]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:36.129]                   if (TRUE && !signal) {
[15:32:36.129]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:36.129]                     {
[15:32:36.129]                       inherits <- base::inherits
[15:32:36.129]                       invokeRestart <- base::invokeRestart
[15:32:36.129]                       is.null <- base::is.null
[15:32:36.129]                       muffled <- FALSE
[15:32:36.129]                       if (inherits(cond, "message")) {
[15:32:36.129]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:36.129]                         if (muffled) 
[15:32:36.129]                           invokeRestart("muffleMessage")
[15:32:36.129]                       }
[15:32:36.129]                       else if (inherits(cond, "warning")) {
[15:32:36.129]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:36.129]                         if (muffled) 
[15:32:36.129]                           invokeRestart("muffleWarning")
[15:32:36.129]                       }
[15:32:36.129]                       else if (inherits(cond, "condition")) {
[15:32:36.129]                         if (!is.null(pattern)) {
[15:32:36.129]                           computeRestarts <- base::computeRestarts
[15:32:36.129]                           grepl <- base::grepl
[15:32:36.129]                           restarts <- computeRestarts(cond)
[15:32:36.129]                           for (restart in restarts) {
[15:32:36.129]                             name <- restart$name
[15:32:36.129]                             if (is.null(name)) 
[15:32:36.129]                               next
[15:32:36.129]                             if (!grepl(pattern, name)) 
[15:32:36.129]                               next
[15:32:36.129]                             invokeRestart(restart)
[15:32:36.129]                             muffled <- TRUE
[15:32:36.129]                             break
[15:32:36.129]                           }
[15:32:36.129]                         }
[15:32:36.129]                       }
[15:32:36.129]                       invisible(muffled)
[15:32:36.129]                     }
[15:32:36.129]                     muffleCondition(cond, pattern = "^muffle")
[15:32:36.129]                   }
[15:32:36.129]                 }
[15:32:36.129]                 else {
[15:32:36.129]                   if (TRUE) {
[15:32:36.129]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:36.129]                     {
[15:32:36.129]                       inherits <- base::inherits
[15:32:36.129]                       invokeRestart <- base::invokeRestart
[15:32:36.129]                       is.null <- base::is.null
[15:32:36.129]                       muffled <- FALSE
[15:32:36.129]                       if (inherits(cond, "message")) {
[15:32:36.129]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:36.129]                         if (muffled) 
[15:32:36.129]                           invokeRestart("muffleMessage")
[15:32:36.129]                       }
[15:32:36.129]                       else if (inherits(cond, "warning")) {
[15:32:36.129]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:36.129]                         if (muffled) 
[15:32:36.129]                           invokeRestart("muffleWarning")
[15:32:36.129]                       }
[15:32:36.129]                       else if (inherits(cond, "condition")) {
[15:32:36.129]                         if (!is.null(pattern)) {
[15:32:36.129]                           computeRestarts <- base::computeRestarts
[15:32:36.129]                           grepl <- base::grepl
[15:32:36.129]                           restarts <- computeRestarts(cond)
[15:32:36.129]                           for (restart in restarts) {
[15:32:36.129]                             name <- restart$name
[15:32:36.129]                             if (is.null(name)) 
[15:32:36.129]                               next
[15:32:36.129]                             if (!grepl(pattern, name)) 
[15:32:36.129]                               next
[15:32:36.129]                             invokeRestart(restart)
[15:32:36.129]                             muffled <- TRUE
[15:32:36.129]                             break
[15:32:36.129]                           }
[15:32:36.129]                         }
[15:32:36.129]                       }
[15:32:36.129]                       invisible(muffled)
[15:32:36.129]                     }
[15:32:36.129]                     muffleCondition(cond, pattern = "^muffle")
[15:32:36.129]                   }
[15:32:36.129]                 }
[15:32:36.129]             }
[15:32:36.129]         }))
[15:32:36.129]     }, error = function(ex) {
[15:32:36.129]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:36.129]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:36.129]                 ...future.rng), started = ...future.startTime, 
[15:32:36.129]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:36.129]             version = "1.8"), class = "FutureResult")
[15:32:36.129]     }, finally = {
[15:32:36.129]         if (!identical(...future.workdir, getwd())) 
[15:32:36.129]             setwd(...future.workdir)
[15:32:36.129]         {
[15:32:36.129]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:36.129]                 ...future.oldOptions$nwarnings <- NULL
[15:32:36.129]             }
[15:32:36.129]             base::options(...future.oldOptions)
[15:32:36.129]             if (.Platform$OS.type == "windows") {
[15:32:36.129]                 old_names <- names(...future.oldEnvVars)
[15:32:36.129]                 envs <- base::Sys.getenv()
[15:32:36.129]                 names <- names(envs)
[15:32:36.129]                 common <- intersect(names, old_names)
[15:32:36.129]                 added <- setdiff(names, old_names)
[15:32:36.129]                 removed <- setdiff(old_names, names)
[15:32:36.129]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:36.129]                   envs[common]]
[15:32:36.129]                 NAMES <- toupper(changed)
[15:32:36.129]                 args <- list()
[15:32:36.129]                 for (kk in seq_along(NAMES)) {
[15:32:36.129]                   name <- changed[[kk]]
[15:32:36.129]                   NAME <- NAMES[[kk]]
[15:32:36.129]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:36.129]                     next
[15:32:36.129]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:36.129]                 }
[15:32:36.129]                 NAMES <- toupper(added)
[15:32:36.129]                 for (kk in seq_along(NAMES)) {
[15:32:36.129]                   name <- added[[kk]]
[15:32:36.129]                   NAME <- NAMES[[kk]]
[15:32:36.129]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:36.129]                     next
[15:32:36.129]                   args[[name]] <- ""
[15:32:36.129]                 }
[15:32:36.129]                 NAMES <- toupper(removed)
[15:32:36.129]                 for (kk in seq_along(NAMES)) {
[15:32:36.129]                   name <- removed[[kk]]
[15:32:36.129]                   NAME <- NAMES[[kk]]
[15:32:36.129]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:36.129]                     next
[15:32:36.129]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:36.129]                 }
[15:32:36.129]                 if (length(args) > 0) 
[15:32:36.129]                   base::do.call(base::Sys.setenv, args = args)
[15:32:36.129]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:36.129]             }
[15:32:36.129]             else {
[15:32:36.129]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:36.129]             }
[15:32:36.129]             {
[15:32:36.129]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:36.129]                   0L) {
[15:32:36.129]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:36.129]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:36.129]                   base::options(opts)
[15:32:36.129]                 }
[15:32:36.129]                 {
[15:32:36.129]                   {
[15:32:36.129]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:36.129]                     NULL
[15:32:36.129]                   }
[15:32:36.129]                   options(future.plan = NULL)
[15:32:36.129]                   if (is.na(NA_character_)) 
[15:32:36.129]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:36.129]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:36.129]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:36.129]                     .init = FALSE)
[15:32:36.129]                 }
[15:32:36.129]             }
[15:32:36.129]         }
[15:32:36.129]     })
[15:32:36.129]     if (TRUE) {
[15:32:36.129]         base::sink(type = "output", split = FALSE)
[15:32:36.129]         if (TRUE) {
[15:32:36.129]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:36.129]         }
[15:32:36.129]         else {
[15:32:36.129]             ...future.result["stdout"] <- base::list(NULL)
[15:32:36.129]         }
[15:32:36.129]         base::close(...future.stdout)
[15:32:36.129]         ...future.stdout <- NULL
[15:32:36.129]     }
[15:32:36.129]     ...future.result$conditions <- ...future.conditions
[15:32:36.129]     ...future.result$finished <- base::Sys.time()
[15:32:36.129]     ...future.result
[15:32:36.129] }
[15:32:36.138] Exporting 5 global objects (1.22 KiB) to cluster node #1 ...
[15:32:36.139] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ...
[15:32:36.140] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ... DONE
[15:32:36.140] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:36.141] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:36.142] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:36.143] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:36.144] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:36.144] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:36.145] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:36.146] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:36.146] Exporting 5 global objects (1.22 KiB) to cluster node #1 ... DONE
[15:32:36.147] MultisessionFuture started
[15:32:36.147] - Launch lazy future ... done
[15:32:36.148] run() for 'MultisessionFuture' ... done
[15:32:36.148] Created future:
[15:32:36.174] receiveMessageFromWorker() for ClusterFuture ...
[15:32:36.175] - Validating connection of MultisessionFuture
[15:32:36.176] - received message: FutureResult
[15:32:36.176] - Received FutureResult
[15:32:36.177] - Erased future from FutureRegistry
[15:32:36.177] result() for ClusterFuture ...
[15:32:36.177] - result already collected: FutureResult
[15:32:36.178] result() for ClusterFuture ... done
[15:32:36.178] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:36.148] MultisessionFuture:
[15:32:36.148] Label: 'future_sapply-1'
[15:32:36.148] Expression:
[15:32:36.148] {
[15:32:36.148]     do.call(function(...) {
[15:32:36.148]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:36.148]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:36.148]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:36.148]             on.exit(options(oopts), add = TRUE)
[15:32:36.148]         }
[15:32:36.148]         {
[15:32:36.148]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:36.148]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:36.148]                 ...future.FUN(...future.X_jj, ...)
[15:32:36.148]             })
[15:32:36.148]         }
[15:32:36.148]     }, args = future.call.arguments)
[15:32:36.148] }
[15:32:36.148] Lazy evaluation: FALSE
[15:32:36.148] Asynchronous evaluation: TRUE
[15:32:36.148] Local evaluation: TRUE
[15:32:36.148] Environment: R_GlobalEnv
[15:32:36.148] Capture standard output: TRUE
[15:32:36.148] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:36.148] Globals: 5 objects totaling 1.33 KiB (function '...future.FUN' of 1.22 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)
[15:32:36.148] Packages: <none>
[15:32:36.148] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:36.148] Resolved: TRUE
[15:32:36.148] Value: <not collected>
[15:32:36.148] Conditions captured: <none>
[15:32:36.148] Early signaling: FALSE
[15:32:36.148] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:36.148] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:36.179] Chunk #1 of 2 ... DONE
[15:32:36.179] Chunk #2 of 2 ...
[15:32:36.180]  - Finding globals in 'X' for chunk #2 ...
[15:32:36.180] getGlobalsAndPackages() ...
[15:32:36.180] Searching for globals...
[15:32:36.181] 
[15:32:36.182] Searching for globals ... DONE
[15:32:36.182] - globals: [0] <none>
[15:32:36.182] getGlobalsAndPackages() ... DONE
[15:32:36.183]    + additional globals found: [n=0] 
[15:32:36.183]    + additional namespaces needed: [n=0] 
[15:32:36.183]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:36.184]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:36.184]  - seeds: <none>
[15:32:36.184]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:36.185] getGlobalsAndPackages() ...
[15:32:36.185] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:36.185] Resolving globals: FALSE
[15:32:36.186] Tweak future expression to call with '...' arguments ...
[15:32:36.186] {
[15:32:36.186]     do.call(function(...) {
[15:32:36.186]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:36.186]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:36.186]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:36.186]             on.exit(options(oopts), add = TRUE)
[15:32:36.186]         }
[15:32:36.186]         {
[15:32:36.186]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:36.186]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:36.186]                 ...future.FUN(...future.X_jj, ...)
[15:32:36.186]             })
[15:32:36.186]         }
[15:32:36.186]     }, args = future.call.arguments)
[15:32:36.186] }
[15:32:36.187] Tweak future expression to call with '...' arguments ... DONE
[15:32:36.188] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:36.188] 
[15:32:36.188] getGlobalsAndPackages() ... DONE
[15:32:36.189] run() for 'Future' ...
[15:32:36.189] - state: 'created'
[15:32:36.190] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:36.206] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:36.206] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:36.206]   - Field: 'node'
[15:32:36.207]   - Field: 'label'
[15:32:36.207]   - Field: 'local'
[15:32:36.207]   - Field: 'owner'
[15:32:36.207]   - Field: 'envir'
[15:32:36.208]   - Field: 'workers'
[15:32:36.208]   - Field: 'packages'
[15:32:36.208]   - Field: 'gc'
[15:32:36.209]   - Field: 'conditions'
[15:32:36.209]   - Field: 'persistent'
[15:32:36.209]   - Field: 'expr'
[15:32:36.209]   - Field: 'uuid'
[15:32:36.210]   - Field: 'seed'
[15:32:36.210]   - Field: 'version'
[15:32:36.210]   - Field: 'result'
[15:32:36.210]   - Field: 'asynchronous'
[15:32:36.211]   - Field: 'calls'
[15:32:36.211]   - Field: 'globals'
[15:32:36.211]   - Field: 'stdout'
[15:32:36.211]   - Field: 'earlySignal'
[15:32:36.212]   - Field: 'lazy'
[15:32:36.212]   - Field: 'state'
[15:32:36.212] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:36.212] - Launch lazy future ...
[15:32:36.213] Packages needed by the future expression (n = 0): <none>
[15:32:36.213] Packages needed by future strategies (n = 0): <none>
[15:32:36.214] {
[15:32:36.214]     {
[15:32:36.214]         {
[15:32:36.214]             ...future.startTime <- base::Sys.time()
[15:32:36.214]             {
[15:32:36.214]                 {
[15:32:36.214]                   {
[15:32:36.214]                     {
[15:32:36.214]                       base::local({
[15:32:36.214]                         has_future <- base::requireNamespace("future", 
[15:32:36.214]                           quietly = TRUE)
[15:32:36.214]                         if (has_future) {
[15:32:36.214]                           ns <- base::getNamespace("future")
[15:32:36.214]                           version <- ns[[".package"]][["version"]]
[15:32:36.214]                           if (is.null(version)) 
[15:32:36.214]                             version <- utils::packageVersion("future")
[15:32:36.214]                         }
[15:32:36.214]                         else {
[15:32:36.214]                           version <- NULL
[15:32:36.214]                         }
[15:32:36.214]                         if (!has_future || version < "1.8.0") {
[15:32:36.214]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:36.214]                             "", base::R.version$version.string), 
[15:32:36.214]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:36.214]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:36.214]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:36.214]                               "release", "version")], collapse = " "), 
[15:32:36.214]                             hostname = base::Sys.info()[["nodename"]])
[15:32:36.214]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:36.214]                             info)
[15:32:36.214]                           info <- base::paste(info, collapse = "; ")
[15:32:36.214]                           if (!has_future) {
[15:32:36.214]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:36.214]                               info)
[15:32:36.214]                           }
[15:32:36.214]                           else {
[15:32:36.214]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:36.214]                               info, version)
[15:32:36.214]                           }
[15:32:36.214]                           base::stop(msg)
[15:32:36.214]                         }
[15:32:36.214]                       })
[15:32:36.214]                     }
[15:32:36.214]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:36.214]                     base::options(mc.cores = 1L)
[15:32:36.214]                   }
[15:32:36.214]                   ...future.strategy.old <- future::plan("list")
[15:32:36.214]                   options(future.plan = NULL)
[15:32:36.214]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:36.214]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:36.214]                 }
[15:32:36.214]                 ...future.workdir <- getwd()
[15:32:36.214]             }
[15:32:36.214]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:36.214]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:36.214]         }
[15:32:36.214]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:36.214]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:36.214]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:36.214]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:36.214]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:36.214]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:36.214]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:36.214]             base::names(...future.oldOptions))
[15:32:36.214]     }
[15:32:36.214]     if (FALSE) {
[15:32:36.214]     }
[15:32:36.214]     else {
[15:32:36.214]         if (TRUE) {
[15:32:36.214]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:36.214]                 open = "w")
[15:32:36.214]         }
[15:32:36.214]         else {
[15:32:36.214]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:36.214]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:36.214]         }
[15:32:36.214]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:36.214]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:36.214]             base::sink(type = "output", split = FALSE)
[15:32:36.214]             base::close(...future.stdout)
[15:32:36.214]         }, add = TRUE)
[15:32:36.214]     }
[15:32:36.214]     ...future.frame <- base::sys.nframe()
[15:32:36.214]     ...future.conditions <- base::list()
[15:32:36.214]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:36.214]     if (FALSE) {
[15:32:36.214]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:36.214]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:36.214]     }
[15:32:36.214]     ...future.result <- base::tryCatch({
[15:32:36.214]         base::withCallingHandlers({
[15:32:36.214]             ...future.value <- base::withVisible(base::local({
[15:32:36.214]                 ...future.makeSendCondition <- base::local({
[15:32:36.214]                   sendCondition <- NULL
[15:32:36.214]                   function(frame = 1L) {
[15:32:36.214]                     if (is.function(sendCondition)) 
[15:32:36.214]                       return(sendCondition)
[15:32:36.214]                     ns <- getNamespace("parallel")
[15:32:36.214]                     if (exists("sendData", mode = "function", 
[15:32:36.214]                       envir = ns)) {
[15:32:36.214]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:36.214]                         envir = ns)
[15:32:36.214]                       envir <- sys.frame(frame)
[15:32:36.214]                       master <- NULL
[15:32:36.214]                       while (!identical(envir, .GlobalEnv) && 
[15:32:36.214]                         !identical(envir, emptyenv())) {
[15:32:36.214]                         if (exists("master", mode = "list", envir = envir, 
[15:32:36.214]                           inherits = FALSE)) {
[15:32:36.214]                           master <- get("master", mode = "list", 
[15:32:36.214]                             envir = envir, inherits = FALSE)
[15:32:36.214]                           if (inherits(master, c("SOCKnode", 
[15:32:36.214]                             "SOCK0node"))) {
[15:32:36.214]                             sendCondition <<- function(cond) {
[15:32:36.214]                               data <- list(type = "VALUE", value = cond, 
[15:32:36.214]                                 success = TRUE)
[15:32:36.214]                               parallel_sendData(master, data)
[15:32:36.214]                             }
[15:32:36.214]                             return(sendCondition)
[15:32:36.214]                           }
[15:32:36.214]                         }
[15:32:36.214]                         frame <- frame + 1L
[15:32:36.214]                         envir <- sys.frame(frame)
[15:32:36.214]                       }
[15:32:36.214]                     }
[15:32:36.214]                     sendCondition <<- function(cond) NULL
[15:32:36.214]                   }
[15:32:36.214]                 })
[15:32:36.214]                 withCallingHandlers({
[15:32:36.214]                   {
[15:32:36.214]                     do.call(function(...) {
[15:32:36.214]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:36.214]                       if (!identical(...future.globals.maxSize.org, 
[15:32:36.214]                         ...future.globals.maxSize)) {
[15:32:36.214]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:36.214]                         on.exit(options(oopts), add = TRUE)
[15:32:36.214]                       }
[15:32:36.214]                       {
[15:32:36.214]                         lapply(seq_along(...future.elements_ii), 
[15:32:36.214]                           FUN = function(jj) {
[15:32:36.214]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:36.214]                             ...future.FUN(...future.X_jj, ...)
[15:32:36.214]                           })
[15:32:36.214]                       }
[15:32:36.214]                     }, args = future.call.arguments)
[15:32:36.214]                   }
[15:32:36.214]                 }, immediateCondition = function(cond) {
[15:32:36.214]                   sendCondition <- ...future.makeSendCondition()
[15:32:36.214]                   sendCondition(cond)
[15:32:36.214]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:36.214]                   {
[15:32:36.214]                     inherits <- base::inherits
[15:32:36.214]                     invokeRestart <- base::invokeRestart
[15:32:36.214]                     is.null <- base::is.null
[15:32:36.214]                     muffled <- FALSE
[15:32:36.214]                     if (inherits(cond, "message")) {
[15:32:36.214]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:36.214]                       if (muffled) 
[15:32:36.214]                         invokeRestart("muffleMessage")
[15:32:36.214]                     }
[15:32:36.214]                     else if (inherits(cond, "warning")) {
[15:32:36.214]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:36.214]                       if (muffled) 
[15:32:36.214]                         invokeRestart("muffleWarning")
[15:32:36.214]                     }
[15:32:36.214]                     else if (inherits(cond, "condition")) {
[15:32:36.214]                       if (!is.null(pattern)) {
[15:32:36.214]                         computeRestarts <- base::computeRestarts
[15:32:36.214]                         grepl <- base::grepl
[15:32:36.214]                         restarts <- computeRestarts(cond)
[15:32:36.214]                         for (restart in restarts) {
[15:32:36.214]                           name <- restart$name
[15:32:36.214]                           if (is.null(name)) 
[15:32:36.214]                             next
[15:32:36.214]                           if (!grepl(pattern, name)) 
[15:32:36.214]                             next
[15:32:36.214]                           invokeRestart(restart)
[15:32:36.214]                           muffled <- TRUE
[15:32:36.214]                           break
[15:32:36.214]                         }
[15:32:36.214]                       }
[15:32:36.214]                     }
[15:32:36.214]                     invisible(muffled)
[15:32:36.214]                   }
[15:32:36.214]                   muffleCondition(cond)
[15:32:36.214]                 })
[15:32:36.214]             }))
[15:32:36.214]             future::FutureResult(value = ...future.value$value, 
[15:32:36.214]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:36.214]                   ...future.rng), globalenv = if (FALSE) 
[15:32:36.214]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:36.214]                     ...future.globalenv.names))
[15:32:36.214]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:36.214]         }, condition = base::local({
[15:32:36.214]             c <- base::c
[15:32:36.214]             inherits <- base::inherits
[15:32:36.214]             invokeRestart <- base::invokeRestart
[15:32:36.214]             length <- base::length
[15:32:36.214]             list <- base::list
[15:32:36.214]             seq.int <- base::seq.int
[15:32:36.214]             signalCondition <- base::signalCondition
[15:32:36.214]             sys.calls <- base::sys.calls
[15:32:36.214]             `[[` <- base::`[[`
[15:32:36.214]             `+` <- base::`+`
[15:32:36.214]             `<<-` <- base::`<<-`
[15:32:36.214]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:36.214]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:36.214]                   3L)]
[15:32:36.214]             }
[15:32:36.214]             function(cond) {
[15:32:36.214]                 is_error <- inherits(cond, "error")
[15:32:36.214]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:36.214]                   NULL)
[15:32:36.214]                 if (is_error) {
[15:32:36.214]                   sessionInformation <- function() {
[15:32:36.214]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:36.214]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:36.214]                       search = base::search(), system = base::Sys.info())
[15:32:36.214]                   }
[15:32:36.214]                   ...future.conditions[[length(...future.conditions) + 
[15:32:36.214]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:36.214]                     cond$call), session = sessionInformation(), 
[15:32:36.214]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:36.214]                   signalCondition(cond)
[15:32:36.214]                 }
[15:32:36.214]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:36.214]                 "immediateCondition"))) {
[15:32:36.214]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:36.214]                   ...future.conditions[[length(...future.conditions) + 
[15:32:36.214]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:36.214]                   if (TRUE && !signal) {
[15:32:36.214]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:36.214]                     {
[15:32:36.214]                       inherits <- base::inherits
[15:32:36.214]                       invokeRestart <- base::invokeRestart
[15:32:36.214]                       is.null <- base::is.null
[15:32:36.214]                       muffled <- FALSE
[15:32:36.214]                       if (inherits(cond, "message")) {
[15:32:36.214]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:36.214]                         if (muffled) 
[15:32:36.214]                           invokeRestart("muffleMessage")
[15:32:36.214]                       }
[15:32:36.214]                       else if (inherits(cond, "warning")) {
[15:32:36.214]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:36.214]                         if (muffled) 
[15:32:36.214]                           invokeRestart("muffleWarning")
[15:32:36.214]                       }
[15:32:36.214]                       else if (inherits(cond, "condition")) {
[15:32:36.214]                         if (!is.null(pattern)) {
[15:32:36.214]                           computeRestarts <- base::computeRestarts
[15:32:36.214]                           grepl <- base::grepl
[15:32:36.214]                           restarts <- computeRestarts(cond)
[15:32:36.214]                           for (restart in restarts) {
[15:32:36.214]                             name <- restart$name
[15:32:36.214]                             if (is.null(name)) 
[15:32:36.214]                               next
[15:32:36.214]                             if (!grepl(pattern, name)) 
[15:32:36.214]                               next
[15:32:36.214]                             invokeRestart(restart)
[15:32:36.214]                             muffled <- TRUE
[15:32:36.214]                             break
[15:32:36.214]                           }
[15:32:36.214]                         }
[15:32:36.214]                       }
[15:32:36.214]                       invisible(muffled)
[15:32:36.214]                     }
[15:32:36.214]                     muffleCondition(cond, pattern = "^muffle")
[15:32:36.214]                   }
[15:32:36.214]                 }
[15:32:36.214]                 else {
[15:32:36.214]                   if (TRUE) {
[15:32:36.214]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:36.214]                     {
[15:32:36.214]                       inherits <- base::inherits
[15:32:36.214]                       invokeRestart <- base::invokeRestart
[15:32:36.214]                       is.null <- base::is.null
[15:32:36.214]                       muffled <- FALSE
[15:32:36.214]                       if (inherits(cond, "message")) {
[15:32:36.214]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:36.214]                         if (muffled) 
[15:32:36.214]                           invokeRestart("muffleMessage")
[15:32:36.214]                       }
[15:32:36.214]                       else if (inherits(cond, "warning")) {
[15:32:36.214]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:36.214]                         if (muffled) 
[15:32:36.214]                           invokeRestart("muffleWarning")
[15:32:36.214]                       }
[15:32:36.214]                       else if (inherits(cond, "condition")) {
[15:32:36.214]                         if (!is.null(pattern)) {
[15:32:36.214]                           computeRestarts <- base::computeRestarts
[15:32:36.214]                           grepl <- base::grepl
[15:32:36.214]                           restarts <- computeRestarts(cond)
[15:32:36.214]                           for (restart in restarts) {
[15:32:36.214]                             name <- restart$name
[15:32:36.214]                             if (is.null(name)) 
[15:32:36.214]                               next
[15:32:36.214]                             if (!grepl(pattern, name)) 
[15:32:36.214]                               next
[15:32:36.214]                             invokeRestart(restart)
[15:32:36.214]                             muffled <- TRUE
[15:32:36.214]                             break
[15:32:36.214]                           }
[15:32:36.214]                         }
[15:32:36.214]                       }
[15:32:36.214]                       invisible(muffled)
[15:32:36.214]                     }
[15:32:36.214]                     muffleCondition(cond, pattern = "^muffle")
[15:32:36.214]                   }
[15:32:36.214]                 }
[15:32:36.214]             }
[15:32:36.214]         }))
[15:32:36.214]     }, error = function(ex) {
[15:32:36.214]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:36.214]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:36.214]                 ...future.rng), started = ...future.startTime, 
[15:32:36.214]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:36.214]             version = "1.8"), class = "FutureResult")
[15:32:36.214]     }, finally = {
[15:32:36.214]         if (!identical(...future.workdir, getwd())) 
[15:32:36.214]             setwd(...future.workdir)
[15:32:36.214]         {
[15:32:36.214]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:36.214]                 ...future.oldOptions$nwarnings <- NULL
[15:32:36.214]             }
[15:32:36.214]             base::options(...future.oldOptions)
[15:32:36.214]             if (.Platform$OS.type == "windows") {
[15:32:36.214]                 old_names <- names(...future.oldEnvVars)
[15:32:36.214]                 envs <- base::Sys.getenv()
[15:32:36.214]                 names <- names(envs)
[15:32:36.214]                 common <- intersect(names, old_names)
[15:32:36.214]                 added <- setdiff(names, old_names)
[15:32:36.214]                 removed <- setdiff(old_names, names)
[15:32:36.214]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:36.214]                   envs[common]]
[15:32:36.214]                 NAMES <- toupper(changed)
[15:32:36.214]                 args <- list()
[15:32:36.214]                 for (kk in seq_along(NAMES)) {
[15:32:36.214]                   name <- changed[[kk]]
[15:32:36.214]                   NAME <- NAMES[[kk]]
[15:32:36.214]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:36.214]                     next
[15:32:36.214]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:36.214]                 }
[15:32:36.214]                 NAMES <- toupper(added)
[15:32:36.214]                 for (kk in seq_along(NAMES)) {
[15:32:36.214]                   name <- added[[kk]]
[15:32:36.214]                   NAME <- NAMES[[kk]]
[15:32:36.214]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:36.214]                     next
[15:32:36.214]                   args[[name]] <- ""
[15:32:36.214]                 }
[15:32:36.214]                 NAMES <- toupper(removed)
[15:32:36.214]                 for (kk in seq_along(NAMES)) {
[15:32:36.214]                   name <- removed[[kk]]
[15:32:36.214]                   NAME <- NAMES[[kk]]
[15:32:36.214]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:36.214]                     next
[15:32:36.214]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:36.214]                 }
[15:32:36.214]                 if (length(args) > 0) 
[15:32:36.214]                   base::do.call(base::Sys.setenv, args = args)
[15:32:36.214]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:36.214]             }
[15:32:36.214]             else {
[15:32:36.214]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:36.214]             }
[15:32:36.214]             {
[15:32:36.214]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:36.214]                   0L) {
[15:32:36.214]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:36.214]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:36.214]                   base::options(opts)
[15:32:36.214]                 }
[15:32:36.214]                 {
[15:32:36.214]                   {
[15:32:36.214]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:36.214]                     NULL
[15:32:36.214]                   }
[15:32:36.214]                   options(future.plan = NULL)
[15:32:36.214]                   if (is.na(NA_character_)) 
[15:32:36.214]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:36.214]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:36.214]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:36.214]                     .init = FALSE)
[15:32:36.214]                 }
[15:32:36.214]             }
[15:32:36.214]         }
[15:32:36.214]     })
[15:32:36.214]     if (TRUE) {
[15:32:36.214]         base::sink(type = "output", split = FALSE)
[15:32:36.214]         if (TRUE) {
[15:32:36.214]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:36.214]         }
[15:32:36.214]         else {
[15:32:36.214]             ...future.result["stdout"] <- base::list(NULL)
[15:32:36.214]         }
[15:32:36.214]         base::close(...future.stdout)
[15:32:36.214]         ...future.stdout <- NULL
[15:32:36.214]     }
[15:32:36.214]     ...future.result$conditions <- ...future.conditions
[15:32:36.214]     ...future.result$finished <- base::Sys.time()
[15:32:36.214]     ...future.result
[15:32:36.214] }
[15:32:36.220] Exporting 5 global objects (1.22 KiB) to cluster node #1 ...
[15:32:36.221] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ...
[15:32:36.221] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ... DONE
[15:32:36.222] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:36.222] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:36.222] Exporting '...future.elements_ii' (224 bytes) to cluster node #1 ...
[15:32:36.223] Exporting '...future.elements_ii' (224 bytes) to cluster node #1 ... DONE
[15:32:36.223] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:36.223] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:36.224] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:36.224] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:36.224] Exporting 5 global objects (1.22 KiB) to cluster node #1 ... DONE
[15:32:36.225] MultisessionFuture started
[15:32:36.225] - Launch lazy future ... done
[15:32:36.226] run() for 'MultisessionFuture' ... done
[15:32:36.226] Created future:
[15:32:36.252] receiveMessageFromWorker() for ClusterFuture ...
[15:32:36.252] - Validating connection of MultisessionFuture
[15:32:36.253] - received message: FutureResult
[15:32:36.254] - Received FutureResult
[15:32:36.254] - Erased future from FutureRegistry
[15:32:36.254] result() for ClusterFuture ...
[15:32:36.255] - result already collected: FutureResult
[15:32:36.255] result() for ClusterFuture ... done
[15:32:36.255] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:36.226] MultisessionFuture:
[15:32:36.226] Label: 'future_sapply-2'
[15:32:36.226] Expression:
[15:32:36.226] {
[15:32:36.226]     do.call(function(...) {
[15:32:36.226]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:36.226]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:36.226]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:36.226]             on.exit(options(oopts), add = TRUE)
[15:32:36.226]         }
[15:32:36.226]         {
[15:32:36.226]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:36.226]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:36.226]                 ...future.FUN(...future.X_jj, ...)
[15:32:36.226]             })
[15:32:36.226]         }
[15:32:36.226]     }, args = future.call.arguments)
[15:32:36.226] }
[15:32:36.226] Lazy evaluation: FALSE
[15:32:36.226] Asynchronous evaluation: TRUE
[15:32:36.226] Local evaluation: TRUE
[15:32:36.226] Environment: R_GlobalEnv
[15:32:36.226] Capture standard output: TRUE
[15:32:36.226] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:36.226] Globals: 5 objects totaling 1.44 KiB (function '...future.FUN' of 1.22 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 224 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:36.226] Packages: <none>
[15:32:36.226] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:36.226] Resolved: TRUE
[15:32:36.226] Value: <not collected>
[15:32:36.226] Conditions captured: <none>
[15:32:36.226] Early signaling: FALSE
[15:32:36.226] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:36.226] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:36.256] Chunk #2 of 2 ... DONE
[15:32:36.257] Launching 2 futures (chunks) ... DONE
[15:32:36.257] Resolving 2 futures (chunks) ...
[15:32:36.258] resolve() on list ...
[15:32:36.258]  recursive: 0
[15:32:36.258]  length: 2
[15:32:36.259] 
[15:32:36.259] Future #1
[15:32:36.259] result() for ClusterFuture ...
[15:32:36.260] - result already collected: FutureResult
[15:32:36.260] result() for ClusterFuture ... done
[15:32:36.260] result() for ClusterFuture ...
[15:32:36.261] - result already collected: FutureResult
[15:32:36.261] result() for ClusterFuture ... done
[15:32:36.261] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:36.262] - nx: 2
[15:32:36.262] - relay: TRUE
[15:32:36.262] - stdout: TRUE
[15:32:36.263] - signal: TRUE
[15:32:36.263] - resignal: FALSE
[15:32:36.263] - force: TRUE
[15:32:36.264] - relayed: [n=2] FALSE, FALSE
[15:32:36.264] - queued futures: [n=2] FALSE, FALSE
[15:32:36.265]  - until=1
[15:32:36.265]  - relaying element #1
[15:32:36.265] result() for ClusterFuture ...
[15:32:36.266] - result already collected: FutureResult
[15:32:36.266] result() for ClusterFuture ... done
[15:32:36.266] result() for ClusterFuture ...
[15:32:36.267] - result already collected: FutureResult
[15:32:36.267] result() for ClusterFuture ... done
[15:32:36.267] result() for ClusterFuture ...
[15:32:36.268] - result already collected: FutureResult
[15:32:36.268] result() for ClusterFuture ... done
[15:32:36.268] result() for ClusterFuture ...
[15:32:36.269] - result already collected: FutureResult
[15:32:36.269] result() for ClusterFuture ... done
[15:32:36.269] - relayed: [n=2] TRUE, FALSE
[15:32:36.270] - queued futures: [n=2] TRUE, FALSE
[15:32:36.270] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:36.271]  length: 1 (resolved future 1)
[15:32:36.271] Future #2
[15:32:36.271] result() for ClusterFuture ...
[15:32:36.272] - result already collected: FutureResult
[15:32:36.272] result() for ClusterFuture ... done
[15:32:36.272] result() for ClusterFuture ...
[15:32:36.273] - result already collected: FutureResult
[15:32:36.273] result() for ClusterFuture ... done
[15:32:36.274] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:36.274] - nx: 2
[15:32:36.274] - relay: TRUE
[15:32:36.275] - stdout: TRUE
[15:32:36.275] - signal: TRUE
[15:32:36.275] - resignal: FALSE
[15:32:36.276] - force: TRUE
[15:32:36.276] - relayed: [n=2] TRUE, FALSE
[15:32:36.276] - queued futures: [n=2] TRUE, FALSE
[15:32:36.277]  - until=2
[15:32:36.277]  - relaying element #2
[15:32:36.277] result() for ClusterFuture ...
[15:32:36.278] - result already collected: FutureResult
[15:32:36.278] result() for ClusterFuture ... done
[15:32:36.278] result() for ClusterFuture ...
[15:32:36.279] - result already collected: FutureResult
[15:32:36.279] result() for ClusterFuture ... done
[15:32:36.280] result() for ClusterFuture ...
[15:32:36.280] - result already collected: FutureResult
[15:32:36.280] result() for ClusterFuture ... done
[15:32:36.281] result() for ClusterFuture ...
[15:32:36.281] - result already collected: FutureResult
[15:32:36.281] result() for ClusterFuture ... done
[15:32:36.282] - relayed: [n=2] TRUE, TRUE
[15:32:36.282] - queued futures: [n=2] TRUE, TRUE
[15:32:36.282] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:36.283]  length: 0 (resolved future 2)
[15:32:36.283] Relaying remaining futures
[15:32:36.283] signalConditionsASAP(NULL, pos=0) ...
[15:32:36.284] - nx: 2
[15:32:36.284] - relay: TRUE
[15:32:36.284] - stdout: TRUE
[15:32:36.285] - signal: TRUE
[15:32:36.285] - resignal: FALSE
[15:32:36.285] - force: TRUE
[15:32:36.286] - relayed: [n=2] TRUE, TRUE
[15:32:36.286] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:36.287] - relayed: [n=2] TRUE, TRUE
[15:32:36.287] - queued futures: [n=2] TRUE, TRUE
[15:32:36.287] signalConditionsASAP(NULL, pos=0) ... done
[15:32:36.288] resolve() on list ... DONE
[15:32:36.288] result() for ClusterFuture ...
[15:32:36.288] - result already collected: FutureResult
[15:32:36.289] result() for ClusterFuture ... done
[15:32:36.289] result() for ClusterFuture ...
[15:32:36.289] - result already collected: FutureResult
[15:32:36.290] result() for ClusterFuture ... done
[15:32:36.290] result() for ClusterFuture ...
[15:32:36.291] - result already collected: FutureResult
[15:32:36.291] result() for ClusterFuture ... done
[15:32:36.291] result() for ClusterFuture ...
[15:32:36.292] - result already collected: FutureResult
[15:32:36.292] result() for ClusterFuture ... done
[15:32:36.292]  - Number of value chunks collected: 2
[15:32:36.293] Resolving 2 futures (chunks) ... DONE
[15:32:36.293] Reducing values from 2 chunks ...
[15:32:36.293]  - Number of values collected after concatenation: 3
[15:32:36.294]  - Number of values expected: 3
[15:32:36.294] Reducing values from 2 chunks ... DONE
[15:32:36.294] future_lapply() ... DONE
List of 2
 $ y0: chr [1:3] "a" "b" "c"
 $ y1: chr [1:3] "a" "b" "c"
[15:32:36.297] future_lapply() ...
[15:32:36.303] Number of chunks: 2
[15:32:36.304] getGlobalsAndPackagesXApply() ...
[15:32:36.304]  - future.globals: TRUE
[15:32:36.304] getGlobalsAndPackages() ...
[15:32:36.305] Searching for globals...
[15:32:36.307] - globals found: [1] 'FUN'
[15:32:36.308] Searching for globals ... DONE
[15:32:36.308] Resolving globals: FALSE
[15:32:36.309] The total size of the 1 globals is 848 bytes (848 bytes)
[15:32:36.310] The total size of the 1 globals exported for future expression ('FUN()') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:32:36.310] - globals: [1] 'FUN'
[15:32:36.311] 
[15:32:36.311] getGlobalsAndPackages() ... DONE
[15:32:36.311]  - globals found/used: [n=1] 'FUN'
[15:32:36.311]  - needed namespaces: [n=0] 
[15:32:36.311] Finding globals ... DONE
[15:32:36.312]  - use_args: TRUE
[15:32:36.312]  - Getting '...' globals ...
[15:32:36.312] resolve() on list ...
[15:32:36.313]  recursive: 0
[15:32:36.313]  length: 1
[15:32:36.313]  elements: '...'
[15:32:36.313]  length: 0 (resolved future 1)
[15:32:36.313] resolve() on list ... DONE
[15:32:36.314]    - '...' content: [n=0] 
[15:32:36.314] List of 1
[15:32:36.314]  $ ...: list()
[15:32:36.314]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:36.314]  - attr(*, "where")=List of 1
[15:32:36.314]   ..$ ...:<environment: 0x00000276e5439530> 
[15:32:36.314]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:36.314]  - attr(*, "resolved")= logi TRUE
[15:32:36.314]  - attr(*, "total_size")= num NA
[15:32:36.318]  - Getting '...' globals ... DONE
[15:32:36.318] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:36.318] List of 2
[15:32:36.318]  $ ...future.FUN:function (x)  
[15:32:36.318]  $ ...          : list()
[15:32:36.318]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:36.318]  - attr(*, "where")=List of 2
[15:32:36.318]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:36.318]   ..$ ...          :<environment: 0x00000276e5439530> 
[15:32:36.318]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:36.318]  - attr(*, "resolved")= logi FALSE
[15:32:36.318]  - attr(*, "total_size")= num 848
[15:32:36.323] Packages to be attached in all futures: [n=0] 
[15:32:36.324] getGlobalsAndPackagesXApply() ... DONE
[15:32:36.324] Number of futures (= number of chunks): 2
[15:32:36.325] Launching 2 futures (chunks) ...
[15:32:36.325] Chunk #1 of 2 ...
[15:32:36.325]  - Finding globals in 'X' for chunk #1 ...
[15:32:36.325] getGlobalsAndPackages() ...
[15:32:36.326] Searching for globals...
[15:32:36.326] 
[15:32:36.327] Searching for globals ... DONE
[15:32:36.327] - globals: [0] <none>
[15:32:36.328] getGlobalsAndPackages() ... DONE
[15:32:36.328]    + additional globals found: [n=0] 
[15:32:36.328]    + additional namespaces needed: [n=0] 
[15:32:36.329]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:36.329]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:36.329]  - seeds: <none>
[15:32:36.330]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:36.330] getGlobalsAndPackages() ...
[15:32:36.331] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:36.331] Resolving globals: FALSE
[15:32:36.331] Tweak future expression to call with '...' arguments ...
[15:32:36.332] {
[15:32:36.332]     do.call(function(...) {
[15:32:36.332]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:36.332]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:36.332]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:36.332]             on.exit(options(oopts), add = TRUE)
[15:32:36.332]         }
[15:32:36.332]         {
[15:32:36.332]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:36.332]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:36.332]                 ...future.FUN(...future.X_jj, ...)
[15:32:36.332]             })
[15:32:36.332]         }
[15:32:36.332]     }, args = future.call.arguments)
[15:32:36.332] }
[15:32:36.333] Tweak future expression to call with '...' arguments ... DONE
[15:32:36.334] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:36.334] 
[15:32:36.335] getGlobalsAndPackages() ... DONE
[15:32:36.335] run() for 'Future' ...
[15:32:36.336] - state: 'created'
[15:32:36.336] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:36.356] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:36.356] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:36.357]   - Field: 'node'
[15:32:36.357]   - Field: 'label'
[15:32:36.357]   - Field: 'local'
[15:32:36.358]   - Field: 'owner'
[15:32:36.364]   - Field: 'envir'
[15:32:36.365]   - Field: 'workers'
[15:32:36.365]   - Field: 'packages'
[15:32:36.365]   - Field: 'gc'
[15:32:36.366]   - Field: 'conditions'
[15:32:36.366]   - Field: 'persistent'
[15:32:36.366]   - Field: 'expr'
[15:32:36.367]   - Field: 'uuid'
[15:32:36.367]   - Field: 'seed'
[15:32:36.368]   - Field: 'version'
[15:32:36.368]   - Field: 'result'
[15:32:36.368]   - Field: 'asynchronous'
[15:32:36.369]   - Field: 'calls'
[15:32:36.369]   - Field: 'globals'
[15:32:36.369]   - Field: 'stdout'
[15:32:36.370]   - Field: 'earlySignal'
[15:32:36.370]   - Field: 'lazy'
[15:32:36.371]   - Field: 'state'
[15:32:36.371] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:36.371] - Launch lazy future ...
[15:32:36.372] Packages needed by the future expression (n = 0): <none>
[15:32:36.373] Packages needed by future strategies (n = 0): <none>
[15:32:36.374] {
[15:32:36.374]     {
[15:32:36.374]         {
[15:32:36.374]             ...future.startTime <- base::Sys.time()
[15:32:36.374]             {
[15:32:36.374]                 {
[15:32:36.374]                   {
[15:32:36.374]                     {
[15:32:36.374]                       base::local({
[15:32:36.374]                         has_future <- base::requireNamespace("future", 
[15:32:36.374]                           quietly = TRUE)
[15:32:36.374]                         if (has_future) {
[15:32:36.374]                           ns <- base::getNamespace("future")
[15:32:36.374]                           version <- ns[[".package"]][["version"]]
[15:32:36.374]                           if (is.null(version)) 
[15:32:36.374]                             version <- utils::packageVersion("future")
[15:32:36.374]                         }
[15:32:36.374]                         else {
[15:32:36.374]                           version <- NULL
[15:32:36.374]                         }
[15:32:36.374]                         if (!has_future || version < "1.8.0") {
[15:32:36.374]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:36.374]                             "", base::R.version$version.string), 
[15:32:36.374]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:36.374]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:36.374]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:36.374]                               "release", "version")], collapse = " "), 
[15:32:36.374]                             hostname = base::Sys.info()[["nodename"]])
[15:32:36.374]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:36.374]                             info)
[15:32:36.374]                           info <- base::paste(info, collapse = "; ")
[15:32:36.374]                           if (!has_future) {
[15:32:36.374]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:36.374]                               info)
[15:32:36.374]                           }
[15:32:36.374]                           else {
[15:32:36.374]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:36.374]                               info, version)
[15:32:36.374]                           }
[15:32:36.374]                           base::stop(msg)
[15:32:36.374]                         }
[15:32:36.374]                       })
[15:32:36.374]                     }
[15:32:36.374]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:36.374]                     base::options(mc.cores = 1L)
[15:32:36.374]                   }
[15:32:36.374]                   ...future.strategy.old <- future::plan("list")
[15:32:36.374]                   options(future.plan = NULL)
[15:32:36.374]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:36.374]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:36.374]                 }
[15:32:36.374]                 ...future.workdir <- getwd()
[15:32:36.374]             }
[15:32:36.374]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:36.374]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:36.374]         }
[15:32:36.374]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:36.374]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:36.374]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:36.374]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:36.374]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:36.374]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:36.374]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:36.374]             base::names(...future.oldOptions))
[15:32:36.374]     }
[15:32:36.374]     if (FALSE) {
[15:32:36.374]     }
[15:32:36.374]     else {
[15:32:36.374]         if (TRUE) {
[15:32:36.374]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:36.374]                 open = "w")
[15:32:36.374]         }
[15:32:36.374]         else {
[15:32:36.374]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:36.374]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:36.374]         }
[15:32:36.374]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:36.374]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:36.374]             base::sink(type = "output", split = FALSE)
[15:32:36.374]             base::close(...future.stdout)
[15:32:36.374]         }, add = TRUE)
[15:32:36.374]     }
[15:32:36.374]     ...future.frame <- base::sys.nframe()
[15:32:36.374]     ...future.conditions <- base::list()
[15:32:36.374]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:36.374]     if (FALSE) {
[15:32:36.374]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:36.374]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:36.374]     }
[15:32:36.374]     ...future.result <- base::tryCatch({
[15:32:36.374]         base::withCallingHandlers({
[15:32:36.374]             ...future.value <- base::withVisible(base::local({
[15:32:36.374]                 ...future.makeSendCondition <- base::local({
[15:32:36.374]                   sendCondition <- NULL
[15:32:36.374]                   function(frame = 1L) {
[15:32:36.374]                     if (is.function(sendCondition)) 
[15:32:36.374]                       return(sendCondition)
[15:32:36.374]                     ns <- getNamespace("parallel")
[15:32:36.374]                     if (exists("sendData", mode = "function", 
[15:32:36.374]                       envir = ns)) {
[15:32:36.374]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:36.374]                         envir = ns)
[15:32:36.374]                       envir <- sys.frame(frame)
[15:32:36.374]                       master <- NULL
[15:32:36.374]                       while (!identical(envir, .GlobalEnv) && 
[15:32:36.374]                         !identical(envir, emptyenv())) {
[15:32:36.374]                         if (exists("master", mode = "list", envir = envir, 
[15:32:36.374]                           inherits = FALSE)) {
[15:32:36.374]                           master <- get("master", mode = "list", 
[15:32:36.374]                             envir = envir, inherits = FALSE)
[15:32:36.374]                           if (inherits(master, c("SOCKnode", 
[15:32:36.374]                             "SOCK0node"))) {
[15:32:36.374]                             sendCondition <<- function(cond) {
[15:32:36.374]                               data <- list(type = "VALUE", value = cond, 
[15:32:36.374]                                 success = TRUE)
[15:32:36.374]                               parallel_sendData(master, data)
[15:32:36.374]                             }
[15:32:36.374]                             return(sendCondition)
[15:32:36.374]                           }
[15:32:36.374]                         }
[15:32:36.374]                         frame <- frame + 1L
[15:32:36.374]                         envir <- sys.frame(frame)
[15:32:36.374]                       }
[15:32:36.374]                     }
[15:32:36.374]                     sendCondition <<- function(cond) NULL
[15:32:36.374]                   }
[15:32:36.374]                 })
[15:32:36.374]                 withCallingHandlers({
[15:32:36.374]                   {
[15:32:36.374]                     do.call(function(...) {
[15:32:36.374]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:36.374]                       if (!identical(...future.globals.maxSize.org, 
[15:32:36.374]                         ...future.globals.maxSize)) {
[15:32:36.374]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:36.374]                         on.exit(options(oopts), add = TRUE)
[15:32:36.374]                       }
[15:32:36.374]                       {
[15:32:36.374]                         lapply(seq_along(...future.elements_ii), 
[15:32:36.374]                           FUN = function(jj) {
[15:32:36.374]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:36.374]                             ...future.FUN(...future.X_jj, ...)
[15:32:36.374]                           })
[15:32:36.374]                       }
[15:32:36.374]                     }, args = future.call.arguments)
[15:32:36.374]                   }
[15:32:36.374]                 }, immediateCondition = function(cond) {
[15:32:36.374]                   sendCondition <- ...future.makeSendCondition()
[15:32:36.374]                   sendCondition(cond)
[15:32:36.374]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:36.374]                   {
[15:32:36.374]                     inherits <- base::inherits
[15:32:36.374]                     invokeRestart <- base::invokeRestart
[15:32:36.374]                     is.null <- base::is.null
[15:32:36.374]                     muffled <- FALSE
[15:32:36.374]                     if (inherits(cond, "message")) {
[15:32:36.374]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:36.374]                       if (muffled) 
[15:32:36.374]                         invokeRestart("muffleMessage")
[15:32:36.374]                     }
[15:32:36.374]                     else if (inherits(cond, "warning")) {
[15:32:36.374]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:36.374]                       if (muffled) 
[15:32:36.374]                         invokeRestart("muffleWarning")
[15:32:36.374]                     }
[15:32:36.374]                     else if (inherits(cond, "condition")) {
[15:32:36.374]                       if (!is.null(pattern)) {
[15:32:36.374]                         computeRestarts <- base::computeRestarts
[15:32:36.374]                         grepl <- base::grepl
[15:32:36.374]                         restarts <- computeRestarts(cond)
[15:32:36.374]                         for (restart in restarts) {
[15:32:36.374]                           name <- restart$name
[15:32:36.374]                           if (is.null(name)) 
[15:32:36.374]                             next
[15:32:36.374]                           if (!grepl(pattern, name)) 
[15:32:36.374]                             next
[15:32:36.374]                           invokeRestart(restart)
[15:32:36.374]                           muffled <- TRUE
[15:32:36.374]                           break
[15:32:36.374]                         }
[15:32:36.374]                       }
[15:32:36.374]                     }
[15:32:36.374]                     invisible(muffled)
[15:32:36.374]                   }
[15:32:36.374]                   muffleCondition(cond)
[15:32:36.374]                 })
[15:32:36.374]             }))
[15:32:36.374]             future::FutureResult(value = ...future.value$value, 
[15:32:36.374]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:36.374]                   ...future.rng), globalenv = if (FALSE) 
[15:32:36.374]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:36.374]                     ...future.globalenv.names))
[15:32:36.374]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:36.374]         }, condition = base::local({
[15:32:36.374]             c <- base::c
[15:32:36.374]             inherits <- base::inherits
[15:32:36.374]             invokeRestart <- base::invokeRestart
[15:32:36.374]             length <- base::length
[15:32:36.374]             list <- base::list
[15:32:36.374]             seq.int <- base::seq.int
[15:32:36.374]             signalCondition <- base::signalCondition
[15:32:36.374]             sys.calls <- base::sys.calls
[15:32:36.374]             `[[` <- base::`[[`
[15:32:36.374]             `+` <- base::`+`
[15:32:36.374]             `<<-` <- base::`<<-`
[15:32:36.374]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:36.374]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:36.374]                   3L)]
[15:32:36.374]             }
[15:32:36.374]             function(cond) {
[15:32:36.374]                 is_error <- inherits(cond, "error")
[15:32:36.374]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:36.374]                   NULL)
[15:32:36.374]                 if (is_error) {
[15:32:36.374]                   sessionInformation <- function() {
[15:32:36.374]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:36.374]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:36.374]                       search = base::search(), system = base::Sys.info())
[15:32:36.374]                   }
[15:32:36.374]                   ...future.conditions[[length(...future.conditions) + 
[15:32:36.374]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:36.374]                     cond$call), session = sessionInformation(), 
[15:32:36.374]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:36.374]                   signalCondition(cond)
[15:32:36.374]                 }
[15:32:36.374]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:36.374]                 "immediateCondition"))) {
[15:32:36.374]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:36.374]                   ...future.conditions[[length(...future.conditions) + 
[15:32:36.374]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:36.374]                   if (TRUE && !signal) {
[15:32:36.374]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:36.374]                     {
[15:32:36.374]                       inherits <- base::inherits
[15:32:36.374]                       invokeRestart <- base::invokeRestart
[15:32:36.374]                       is.null <- base::is.null
[15:32:36.374]                       muffled <- FALSE
[15:32:36.374]                       if (inherits(cond, "message")) {
[15:32:36.374]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:36.374]                         if (muffled) 
[15:32:36.374]                           invokeRestart("muffleMessage")
[15:32:36.374]                       }
[15:32:36.374]                       else if (inherits(cond, "warning")) {
[15:32:36.374]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:36.374]                         if (muffled) 
[15:32:36.374]                           invokeRestart("muffleWarning")
[15:32:36.374]                       }
[15:32:36.374]                       else if (inherits(cond, "condition")) {
[15:32:36.374]                         if (!is.null(pattern)) {
[15:32:36.374]                           computeRestarts <- base::computeRestarts
[15:32:36.374]                           grepl <- base::grepl
[15:32:36.374]                           restarts <- computeRestarts(cond)
[15:32:36.374]                           for (restart in restarts) {
[15:32:36.374]                             name <- restart$name
[15:32:36.374]                             if (is.null(name)) 
[15:32:36.374]                               next
[15:32:36.374]                             if (!grepl(pattern, name)) 
[15:32:36.374]                               next
[15:32:36.374]                             invokeRestart(restart)
[15:32:36.374]                             muffled <- TRUE
[15:32:36.374]                             break
[15:32:36.374]                           }
[15:32:36.374]                         }
[15:32:36.374]                       }
[15:32:36.374]                       invisible(muffled)
[15:32:36.374]                     }
[15:32:36.374]                     muffleCondition(cond, pattern = "^muffle")
[15:32:36.374]                   }
[15:32:36.374]                 }
[15:32:36.374]                 else {
[15:32:36.374]                   if (TRUE) {
[15:32:36.374]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:36.374]                     {
[15:32:36.374]                       inherits <- base::inherits
[15:32:36.374]                       invokeRestart <- base::invokeRestart
[15:32:36.374]                       is.null <- base::is.null
[15:32:36.374]                       muffled <- FALSE
[15:32:36.374]                       if (inherits(cond, "message")) {
[15:32:36.374]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:36.374]                         if (muffled) 
[15:32:36.374]                           invokeRestart("muffleMessage")
[15:32:36.374]                       }
[15:32:36.374]                       else if (inherits(cond, "warning")) {
[15:32:36.374]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:36.374]                         if (muffled) 
[15:32:36.374]                           invokeRestart("muffleWarning")
[15:32:36.374]                       }
[15:32:36.374]                       else if (inherits(cond, "condition")) {
[15:32:36.374]                         if (!is.null(pattern)) {
[15:32:36.374]                           computeRestarts <- base::computeRestarts
[15:32:36.374]                           grepl <- base::grepl
[15:32:36.374]                           restarts <- computeRestarts(cond)
[15:32:36.374]                           for (restart in restarts) {
[15:32:36.374]                             name <- restart$name
[15:32:36.374]                             if (is.null(name)) 
[15:32:36.374]                               next
[15:32:36.374]                             if (!grepl(pattern, name)) 
[15:32:36.374]                               next
[15:32:36.374]                             invokeRestart(restart)
[15:32:36.374]                             muffled <- TRUE
[15:32:36.374]                             break
[15:32:36.374]                           }
[15:32:36.374]                         }
[15:32:36.374]                       }
[15:32:36.374]                       invisible(muffled)
[15:32:36.374]                     }
[15:32:36.374]                     muffleCondition(cond, pattern = "^muffle")
[15:32:36.374]                   }
[15:32:36.374]                 }
[15:32:36.374]             }
[15:32:36.374]         }))
[15:32:36.374]     }, error = function(ex) {
[15:32:36.374]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:36.374]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:36.374]                 ...future.rng), started = ...future.startTime, 
[15:32:36.374]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:36.374]             version = "1.8"), class = "FutureResult")
[15:32:36.374]     }, finally = {
[15:32:36.374]         if (!identical(...future.workdir, getwd())) 
[15:32:36.374]             setwd(...future.workdir)
[15:32:36.374]         {
[15:32:36.374]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:36.374]                 ...future.oldOptions$nwarnings <- NULL
[15:32:36.374]             }
[15:32:36.374]             base::options(...future.oldOptions)
[15:32:36.374]             if (.Platform$OS.type == "windows") {
[15:32:36.374]                 old_names <- names(...future.oldEnvVars)
[15:32:36.374]                 envs <- base::Sys.getenv()
[15:32:36.374]                 names <- names(envs)
[15:32:36.374]                 common <- intersect(names, old_names)
[15:32:36.374]                 added <- setdiff(names, old_names)
[15:32:36.374]                 removed <- setdiff(old_names, names)
[15:32:36.374]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:36.374]                   envs[common]]
[15:32:36.374]                 NAMES <- toupper(changed)
[15:32:36.374]                 args <- list()
[15:32:36.374]                 for (kk in seq_along(NAMES)) {
[15:32:36.374]                   name <- changed[[kk]]
[15:32:36.374]                   NAME <- NAMES[[kk]]
[15:32:36.374]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:36.374]                     next
[15:32:36.374]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:36.374]                 }
[15:32:36.374]                 NAMES <- toupper(added)
[15:32:36.374]                 for (kk in seq_along(NAMES)) {
[15:32:36.374]                   name <- added[[kk]]
[15:32:36.374]                   NAME <- NAMES[[kk]]
[15:32:36.374]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:36.374]                     next
[15:32:36.374]                   args[[name]] <- ""
[15:32:36.374]                 }
[15:32:36.374]                 NAMES <- toupper(removed)
[15:32:36.374]                 for (kk in seq_along(NAMES)) {
[15:32:36.374]                   name <- removed[[kk]]
[15:32:36.374]                   NAME <- NAMES[[kk]]
[15:32:36.374]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:36.374]                     next
[15:32:36.374]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:36.374]                 }
[15:32:36.374]                 if (length(args) > 0) 
[15:32:36.374]                   base::do.call(base::Sys.setenv, args = args)
[15:32:36.374]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:36.374]             }
[15:32:36.374]             else {
[15:32:36.374]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:36.374]             }
[15:32:36.374]             {
[15:32:36.374]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:36.374]                   0L) {
[15:32:36.374]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:36.374]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:36.374]                   base::options(opts)
[15:32:36.374]                 }
[15:32:36.374]                 {
[15:32:36.374]                   {
[15:32:36.374]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:36.374]                     NULL
[15:32:36.374]                   }
[15:32:36.374]                   options(future.plan = NULL)
[15:32:36.374]                   if (is.na(NA_character_)) 
[15:32:36.374]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:36.374]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:36.374]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:36.374]                     .init = FALSE)
[15:32:36.374]                 }
[15:32:36.374]             }
[15:32:36.374]         }
[15:32:36.374]     })
[15:32:36.374]     if (TRUE) {
[15:32:36.374]         base::sink(type = "output", split = FALSE)
[15:32:36.374]         if (TRUE) {
[15:32:36.374]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:36.374]         }
[15:32:36.374]         else {
[15:32:36.374]             ...future.result["stdout"] <- base::list(NULL)
[15:32:36.374]         }
[15:32:36.374]         base::close(...future.stdout)
[15:32:36.374]         ...future.stdout <- NULL
[15:32:36.374]     }
[15:32:36.374]     ...future.result$conditions <- ...future.conditions
[15:32:36.374]     ...future.result$finished <- base::Sys.time()
[15:32:36.374]     ...future.result
[15:32:36.374] }
[15:32:36.385] Exporting 5 global objects (848 bytes) to cluster node #1 ...
[15:32:36.385] Exporting '...future.FUN' (848 bytes) to cluster node #1 ...
[15:32:36.386] Exporting '...future.FUN' (848 bytes) to cluster node #1 ... DONE
[15:32:36.387] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:36.387] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:36.388] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:36.389] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:36.389] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:36.390] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:36.390] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:36.391] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:36.391] Exporting 5 global objects (848 bytes) to cluster node #1 ... DONE
[15:32:36.392] MultisessionFuture started
[15:32:36.393] - Launch lazy future ... done
[15:32:36.393] run() for 'MultisessionFuture' ... done
[15:32:36.393] Created future:
[15:32:36.425] receiveMessageFromWorker() for ClusterFuture ...
[15:32:36.426] - Validating connection of MultisessionFuture
[15:32:36.426] - received message: FutureResult
[15:32:36.427] - Received FutureResult
[15:32:36.427] - Erased future from FutureRegistry
[15:32:36.427] result() for ClusterFuture ...
[15:32:36.427] - result already collected: FutureResult
[15:32:36.428] result() for ClusterFuture ... done
[15:32:36.428] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:36.394] MultisessionFuture:
[15:32:36.394] Label: 'future_sapply-1'
[15:32:36.394] Expression:
[15:32:36.394] {
[15:32:36.394]     do.call(function(...) {
[15:32:36.394]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:36.394]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:36.394]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:36.394]             on.exit(options(oopts), add = TRUE)
[15:32:36.394]         }
[15:32:36.394]         {
[15:32:36.394]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:36.394]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:36.394]                 ...future.FUN(...future.X_jj, ...)
[15:32:36.394]             })
[15:32:36.394]         }
[15:32:36.394]     }, args = future.call.arguments)
[15:32:36.394] }
[15:32:36.394] Lazy evaluation: FALSE
[15:32:36.394] Asynchronous evaluation: TRUE
[15:32:36.394] Local evaluation: TRUE
[15:32:36.394] Environment: R_GlobalEnv
[15:32:36.394] Capture standard output: TRUE
[15:32:36.394] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:36.394] Globals: 5 objects totaling 960 bytes (function '...future.FUN' of 848 bytes, 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)
[15:32:36.394] Packages: <none>
[15:32:36.394] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:36.394] Resolved: TRUE
[15:32:36.394] Value: <not collected>
[15:32:36.394] Conditions captured: <none>
[15:32:36.394] Early signaling: FALSE
[15:32:36.394] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:36.394] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:36.428] Chunk #1 of 2 ... DONE
[15:32:36.429] Chunk #2 of 2 ...
[15:32:36.429]  - Finding globals in 'X' for chunk #2 ...
[15:32:36.429] getGlobalsAndPackages() ...
[15:32:36.429] Searching for globals...
[15:32:36.430] 
[15:32:36.430] Searching for globals ... DONE
[15:32:36.430] - globals: [0] <none>
[15:32:36.430] getGlobalsAndPackages() ... DONE
[15:32:36.431]    + additional globals found: [n=0] 
[15:32:36.431]    + additional namespaces needed: [n=0] 
[15:32:36.431]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:36.431]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:36.431]  - seeds: <none>
[15:32:36.432]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:36.432] getGlobalsAndPackages() ...
[15:32:36.432] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:36.432] Resolving globals: FALSE
[15:32:36.432] Tweak future expression to call with '...' arguments ...
[15:32:36.433] {
[15:32:36.433]     do.call(function(...) {
[15:32:36.433]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:36.433]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:36.433]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:36.433]             on.exit(options(oopts), add = TRUE)
[15:32:36.433]         }
[15:32:36.433]         {
[15:32:36.433]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:36.433]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:36.433]                 ...future.FUN(...future.X_jj, ...)
[15:32:36.433]             })
[15:32:36.433]         }
[15:32:36.433]     }, args = future.call.arguments)
[15:32:36.433] }
[15:32:36.433] Tweak future expression to call with '...' arguments ... DONE
[15:32:36.434] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:36.434] 
[15:32:36.434] getGlobalsAndPackages() ... DONE
[15:32:36.435] run() for 'Future' ...
[15:32:36.435] - state: 'created'
[15:32:36.435] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:36.454] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:36.454] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:36.454]   - Field: 'node'
[15:32:36.454]   - Field: 'label'
[15:32:36.455]   - Field: 'local'
[15:32:36.455]   - Field: 'owner'
[15:32:36.455]   - Field: 'envir'
[15:32:36.455]   - Field: 'workers'
[15:32:36.456]   - Field: 'packages'
[15:32:36.456]   - Field: 'gc'
[15:32:36.456]   - Field: 'conditions'
[15:32:36.456]   - Field: 'persistent'
[15:32:36.456]   - Field: 'expr'
[15:32:36.457]   - Field: 'uuid'
[15:32:36.457]   - Field: 'seed'
[15:32:36.457]   - Field: 'version'
[15:32:36.457]   - Field: 'result'
[15:32:36.457]   - Field: 'asynchronous'
[15:32:36.458]   - Field: 'calls'
[15:32:36.458]   - Field: 'globals'
[15:32:36.458]   - Field: 'stdout'
[15:32:36.458]   - Field: 'earlySignal'
[15:32:36.458]   - Field: 'lazy'
[15:32:36.459]   - Field: 'state'
[15:32:36.459] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:36.459] - Launch lazy future ...
[15:32:36.460] Packages needed by the future expression (n = 0): <none>
[15:32:36.460] Packages needed by future strategies (n = 0): <none>
[15:32:36.460] {
[15:32:36.460]     {
[15:32:36.460]         {
[15:32:36.460]             ...future.startTime <- base::Sys.time()
[15:32:36.460]             {
[15:32:36.460]                 {
[15:32:36.460]                   {
[15:32:36.460]                     {
[15:32:36.460]                       base::local({
[15:32:36.460]                         has_future <- base::requireNamespace("future", 
[15:32:36.460]                           quietly = TRUE)
[15:32:36.460]                         if (has_future) {
[15:32:36.460]                           ns <- base::getNamespace("future")
[15:32:36.460]                           version <- ns[[".package"]][["version"]]
[15:32:36.460]                           if (is.null(version)) 
[15:32:36.460]                             version <- utils::packageVersion("future")
[15:32:36.460]                         }
[15:32:36.460]                         else {
[15:32:36.460]                           version <- NULL
[15:32:36.460]                         }
[15:32:36.460]                         if (!has_future || version < "1.8.0") {
[15:32:36.460]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:36.460]                             "", base::R.version$version.string), 
[15:32:36.460]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:36.460]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:36.460]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:36.460]                               "release", "version")], collapse = " "), 
[15:32:36.460]                             hostname = base::Sys.info()[["nodename"]])
[15:32:36.460]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:36.460]                             info)
[15:32:36.460]                           info <- base::paste(info, collapse = "; ")
[15:32:36.460]                           if (!has_future) {
[15:32:36.460]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:36.460]                               info)
[15:32:36.460]                           }
[15:32:36.460]                           else {
[15:32:36.460]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:36.460]                               info, version)
[15:32:36.460]                           }
[15:32:36.460]                           base::stop(msg)
[15:32:36.460]                         }
[15:32:36.460]                       })
[15:32:36.460]                     }
[15:32:36.460]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:36.460]                     base::options(mc.cores = 1L)
[15:32:36.460]                   }
[15:32:36.460]                   ...future.strategy.old <- future::plan("list")
[15:32:36.460]                   options(future.plan = NULL)
[15:32:36.460]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:36.460]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:36.460]                 }
[15:32:36.460]                 ...future.workdir <- getwd()
[15:32:36.460]             }
[15:32:36.460]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:36.460]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:36.460]         }
[15:32:36.460]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:36.460]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:36.460]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:36.460]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:36.460]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:36.460]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:36.460]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:36.460]             base::names(...future.oldOptions))
[15:32:36.460]     }
[15:32:36.460]     if (FALSE) {
[15:32:36.460]     }
[15:32:36.460]     else {
[15:32:36.460]         if (TRUE) {
[15:32:36.460]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:36.460]                 open = "w")
[15:32:36.460]         }
[15:32:36.460]         else {
[15:32:36.460]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:36.460]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:36.460]         }
[15:32:36.460]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:36.460]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:36.460]             base::sink(type = "output", split = FALSE)
[15:32:36.460]             base::close(...future.stdout)
[15:32:36.460]         }, add = TRUE)
[15:32:36.460]     }
[15:32:36.460]     ...future.frame <- base::sys.nframe()
[15:32:36.460]     ...future.conditions <- base::list()
[15:32:36.460]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:36.460]     if (FALSE) {
[15:32:36.460]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:36.460]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:36.460]     }
[15:32:36.460]     ...future.result <- base::tryCatch({
[15:32:36.460]         base::withCallingHandlers({
[15:32:36.460]             ...future.value <- base::withVisible(base::local({
[15:32:36.460]                 ...future.makeSendCondition <- base::local({
[15:32:36.460]                   sendCondition <- NULL
[15:32:36.460]                   function(frame = 1L) {
[15:32:36.460]                     if (is.function(sendCondition)) 
[15:32:36.460]                       return(sendCondition)
[15:32:36.460]                     ns <- getNamespace("parallel")
[15:32:36.460]                     if (exists("sendData", mode = "function", 
[15:32:36.460]                       envir = ns)) {
[15:32:36.460]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:36.460]                         envir = ns)
[15:32:36.460]                       envir <- sys.frame(frame)
[15:32:36.460]                       master <- NULL
[15:32:36.460]                       while (!identical(envir, .GlobalEnv) && 
[15:32:36.460]                         !identical(envir, emptyenv())) {
[15:32:36.460]                         if (exists("master", mode = "list", envir = envir, 
[15:32:36.460]                           inherits = FALSE)) {
[15:32:36.460]                           master <- get("master", mode = "list", 
[15:32:36.460]                             envir = envir, inherits = FALSE)
[15:32:36.460]                           if (inherits(master, c("SOCKnode", 
[15:32:36.460]                             "SOCK0node"))) {
[15:32:36.460]                             sendCondition <<- function(cond) {
[15:32:36.460]                               data <- list(type = "VALUE", value = cond, 
[15:32:36.460]                                 success = TRUE)
[15:32:36.460]                               parallel_sendData(master, data)
[15:32:36.460]                             }
[15:32:36.460]                             return(sendCondition)
[15:32:36.460]                           }
[15:32:36.460]                         }
[15:32:36.460]                         frame <- frame + 1L
[15:32:36.460]                         envir <- sys.frame(frame)
[15:32:36.460]                       }
[15:32:36.460]                     }
[15:32:36.460]                     sendCondition <<- function(cond) NULL
[15:32:36.460]                   }
[15:32:36.460]                 })
[15:32:36.460]                 withCallingHandlers({
[15:32:36.460]                   {
[15:32:36.460]                     do.call(function(...) {
[15:32:36.460]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:36.460]                       if (!identical(...future.globals.maxSize.org, 
[15:32:36.460]                         ...future.globals.maxSize)) {
[15:32:36.460]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:36.460]                         on.exit(options(oopts), add = TRUE)
[15:32:36.460]                       }
[15:32:36.460]                       {
[15:32:36.460]                         lapply(seq_along(...future.elements_ii), 
[15:32:36.460]                           FUN = function(jj) {
[15:32:36.460]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:36.460]                             ...future.FUN(...future.X_jj, ...)
[15:32:36.460]                           })
[15:32:36.460]                       }
[15:32:36.460]                     }, args = future.call.arguments)
[15:32:36.460]                   }
[15:32:36.460]                 }, immediateCondition = function(cond) {
[15:32:36.460]                   sendCondition <- ...future.makeSendCondition()
[15:32:36.460]                   sendCondition(cond)
[15:32:36.460]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:36.460]                   {
[15:32:36.460]                     inherits <- base::inherits
[15:32:36.460]                     invokeRestart <- base::invokeRestart
[15:32:36.460]                     is.null <- base::is.null
[15:32:36.460]                     muffled <- FALSE
[15:32:36.460]                     if (inherits(cond, "message")) {
[15:32:36.460]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:36.460]                       if (muffled) 
[15:32:36.460]                         invokeRestart("muffleMessage")
[15:32:36.460]                     }
[15:32:36.460]                     else if (inherits(cond, "warning")) {
[15:32:36.460]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:36.460]                       if (muffled) 
[15:32:36.460]                         invokeRestart("muffleWarning")
[15:32:36.460]                     }
[15:32:36.460]                     else if (inherits(cond, "condition")) {
[15:32:36.460]                       if (!is.null(pattern)) {
[15:32:36.460]                         computeRestarts <- base::computeRestarts
[15:32:36.460]                         grepl <- base::grepl
[15:32:36.460]                         restarts <- computeRestarts(cond)
[15:32:36.460]                         for (restart in restarts) {
[15:32:36.460]                           name <- restart$name
[15:32:36.460]                           if (is.null(name)) 
[15:32:36.460]                             next
[15:32:36.460]                           if (!grepl(pattern, name)) 
[15:32:36.460]                             next
[15:32:36.460]                           invokeRestart(restart)
[15:32:36.460]                           muffled <- TRUE
[15:32:36.460]                           break
[15:32:36.460]                         }
[15:32:36.460]                       }
[15:32:36.460]                     }
[15:32:36.460]                     invisible(muffled)
[15:32:36.460]                   }
[15:32:36.460]                   muffleCondition(cond)
[15:32:36.460]                 })
[15:32:36.460]             }))
[15:32:36.460]             future::FutureResult(value = ...future.value$value, 
[15:32:36.460]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:36.460]                   ...future.rng), globalenv = if (FALSE) 
[15:32:36.460]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:36.460]                     ...future.globalenv.names))
[15:32:36.460]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:36.460]         }, condition = base::local({
[15:32:36.460]             c <- base::c
[15:32:36.460]             inherits <- base::inherits
[15:32:36.460]             invokeRestart <- base::invokeRestart
[15:32:36.460]             length <- base::length
[15:32:36.460]             list <- base::list
[15:32:36.460]             seq.int <- base::seq.int
[15:32:36.460]             signalCondition <- base::signalCondition
[15:32:36.460]             sys.calls <- base::sys.calls
[15:32:36.460]             `[[` <- base::`[[`
[15:32:36.460]             `+` <- base::`+`
[15:32:36.460]             `<<-` <- base::`<<-`
[15:32:36.460]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:36.460]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:36.460]                   3L)]
[15:32:36.460]             }
[15:32:36.460]             function(cond) {
[15:32:36.460]                 is_error <- inherits(cond, "error")
[15:32:36.460]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:36.460]                   NULL)
[15:32:36.460]                 if (is_error) {
[15:32:36.460]                   sessionInformation <- function() {
[15:32:36.460]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:36.460]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:36.460]                       search = base::search(), system = base::Sys.info())
[15:32:36.460]                   }
[15:32:36.460]                   ...future.conditions[[length(...future.conditions) + 
[15:32:36.460]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:36.460]                     cond$call), session = sessionInformation(), 
[15:32:36.460]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:36.460]                   signalCondition(cond)
[15:32:36.460]                 }
[15:32:36.460]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:36.460]                 "immediateCondition"))) {
[15:32:36.460]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:36.460]                   ...future.conditions[[length(...future.conditions) + 
[15:32:36.460]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:36.460]                   if (TRUE && !signal) {
[15:32:36.460]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:36.460]                     {
[15:32:36.460]                       inherits <- base::inherits
[15:32:36.460]                       invokeRestart <- base::invokeRestart
[15:32:36.460]                       is.null <- base::is.null
[15:32:36.460]                       muffled <- FALSE
[15:32:36.460]                       if (inherits(cond, "message")) {
[15:32:36.460]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:36.460]                         if (muffled) 
[15:32:36.460]                           invokeRestart("muffleMessage")
[15:32:36.460]                       }
[15:32:36.460]                       else if (inherits(cond, "warning")) {
[15:32:36.460]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:36.460]                         if (muffled) 
[15:32:36.460]                           invokeRestart("muffleWarning")
[15:32:36.460]                       }
[15:32:36.460]                       else if (inherits(cond, "condition")) {
[15:32:36.460]                         if (!is.null(pattern)) {
[15:32:36.460]                           computeRestarts <- base::computeRestarts
[15:32:36.460]                           grepl <- base::grepl
[15:32:36.460]                           restarts <- computeRestarts(cond)
[15:32:36.460]                           for (restart in restarts) {
[15:32:36.460]                             name <- restart$name
[15:32:36.460]                             if (is.null(name)) 
[15:32:36.460]                               next
[15:32:36.460]                             if (!grepl(pattern, name)) 
[15:32:36.460]                               next
[15:32:36.460]                             invokeRestart(restart)
[15:32:36.460]                             muffled <- TRUE
[15:32:36.460]                             break
[15:32:36.460]                           }
[15:32:36.460]                         }
[15:32:36.460]                       }
[15:32:36.460]                       invisible(muffled)
[15:32:36.460]                     }
[15:32:36.460]                     muffleCondition(cond, pattern = "^muffle")
[15:32:36.460]                   }
[15:32:36.460]                 }
[15:32:36.460]                 else {
[15:32:36.460]                   if (TRUE) {
[15:32:36.460]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:36.460]                     {
[15:32:36.460]                       inherits <- base::inherits
[15:32:36.460]                       invokeRestart <- base::invokeRestart
[15:32:36.460]                       is.null <- base::is.null
[15:32:36.460]                       muffled <- FALSE
[15:32:36.460]                       if (inherits(cond, "message")) {
[15:32:36.460]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:36.460]                         if (muffled) 
[15:32:36.460]                           invokeRestart("muffleMessage")
[15:32:36.460]                       }
[15:32:36.460]                       else if (inherits(cond, "warning")) {
[15:32:36.460]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:36.460]                         if (muffled) 
[15:32:36.460]                           invokeRestart("muffleWarning")
[15:32:36.460]                       }
[15:32:36.460]                       else if (inherits(cond, "condition")) {
[15:32:36.460]                         if (!is.null(pattern)) {
[15:32:36.460]                           computeRestarts <- base::computeRestarts
[15:32:36.460]                           grepl <- base::grepl
[15:32:36.460]                           restarts <- computeRestarts(cond)
[15:32:36.460]                           for (restart in restarts) {
[15:32:36.460]                             name <- restart$name
[15:32:36.460]                             if (is.null(name)) 
[15:32:36.460]                               next
[15:32:36.460]                             if (!grepl(pattern, name)) 
[15:32:36.460]                               next
[15:32:36.460]                             invokeRestart(restart)
[15:32:36.460]                             muffled <- TRUE
[15:32:36.460]                             break
[15:32:36.460]                           }
[15:32:36.460]                         }
[15:32:36.460]                       }
[15:32:36.460]                       invisible(muffled)
[15:32:36.460]                     }
[15:32:36.460]                     muffleCondition(cond, pattern = "^muffle")
[15:32:36.460]                   }
[15:32:36.460]                 }
[15:32:36.460]             }
[15:32:36.460]         }))
[15:32:36.460]     }, error = function(ex) {
[15:32:36.460]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:36.460]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:36.460]                 ...future.rng), started = ...future.startTime, 
[15:32:36.460]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:36.460]             version = "1.8"), class = "FutureResult")
[15:32:36.460]     }, finally = {
[15:32:36.460]         if (!identical(...future.workdir, getwd())) 
[15:32:36.460]             setwd(...future.workdir)
[15:32:36.460]         {
[15:32:36.460]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:36.460]                 ...future.oldOptions$nwarnings <- NULL
[15:32:36.460]             }
[15:32:36.460]             base::options(...future.oldOptions)
[15:32:36.460]             if (.Platform$OS.type == "windows") {
[15:32:36.460]                 old_names <- names(...future.oldEnvVars)
[15:32:36.460]                 envs <- base::Sys.getenv()
[15:32:36.460]                 names <- names(envs)
[15:32:36.460]                 common <- intersect(names, old_names)
[15:32:36.460]                 added <- setdiff(names, old_names)
[15:32:36.460]                 removed <- setdiff(old_names, names)
[15:32:36.460]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:36.460]                   envs[common]]
[15:32:36.460]                 NAMES <- toupper(changed)
[15:32:36.460]                 args <- list()
[15:32:36.460]                 for (kk in seq_along(NAMES)) {
[15:32:36.460]                   name <- changed[[kk]]
[15:32:36.460]                   NAME <- NAMES[[kk]]
[15:32:36.460]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:36.460]                     next
[15:32:36.460]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:36.460]                 }
[15:32:36.460]                 NAMES <- toupper(added)
[15:32:36.460]                 for (kk in seq_along(NAMES)) {
[15:32:36.460]                   name <- added[[kk]]
[15:32:36.460]                   NAME <- NAMES[[kk]]
[15:32:36.460]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:36.460]                     next
[15:32:36.460]                   args[[name]] <- ""
[15:32:36.460]                 }
[15:32:36.460]                 NAMES <- toupper(removed)
[15:32:36.460]                 for (kk in seq_along(NAMES)) {
[15:32:36.460]                   name <- removed[[kk]]
[15:32:36.460]                   NAME <- NAMES[[kk]]
[15:32:36.460]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:36.460]                     next
[15:32:36.460]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:36.460]                 }
[15:32:36.460]                 if (length(args) > 0) 
[15:32:36.460]                   base::do.call(base::Sys.setenv, args = args)
[15:32:36.460]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:36.460]             }
[15:32:36.460]             else {
[15:32:36.460]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:36.460]             }
[15:32:36.460]             {
[15:32:36.460]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:36.460]                   0L) {
[15:32:36.460]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:36.460]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:36.460]                   base::options(opts)
[15:32:36.460]                 }
[15:32:36.460]                 {
[15:32:36.460]                   {
[15:32:36.460]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:36.460]                     NULL
[15:32:36.460]                   }
[15:32:36.460]                   options(future.plan = NULL)
[15:32:36.460]                   if (is.na(NA_character_)) 
[15:32:36.460]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:36.460]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:36.460]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:36.460]                     .init = FALSE)
[15:32:36.460]                 }
[15:32:36.460]             }
[15:32:36.460]         }
[15:32:36.460]     })
[15:32:36.460]     if (TRUE) {
[15:32:36.460]         base::sink(type = "output", split = FALSE)
[15:32:36.460]         if (TRUE) {
[15:32:36.460]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:36.460]         }
[15:32:36.460]         else {
[15:32:36.460]             ...future.result["stdout"] <- base::list(NULL)
[15:32:36.460]         }
[15:32:36.460]         base::close(...future.stdout)
[15:32:36.460]         ...future.stdout <- NULL
[15:32:36.460]     }
[15:32:36.460]     ...future.result$conditions <- ...future.conditions
[15:32:36.460]     ...future.result$finished <- base::Sys.time()
[15:32:36.460]     ...future.result
[15:32:36.460] }
[15:32:36.467] Exporting 5 global objects (848 bytes) to cluster node #1 ...
[15:32:36.467] Exporting '...future.FUN' (848 bytes) to cluster node #1 ...
[15:32:36.468] Exporting '...future.FUN' (848 bytes) to cluster node #1 ... DONE
[15:32:36.469] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:36.469] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:36.470] Exporting '...future.elements_ii' (224 bytes) to cluster node #1 ...
[15:32:36.471] Exporting '...future.elements_ii' (224 bytes) to cluster node #1 ... DONE
[15:32:36.471] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:36.472] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:36.472] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:36.473] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:36.473] Exporting 5 global objects (848 bytes) to cluster node #1 ... DONE
[15:32:36.474] MultisessionFuture started
[15:32:36.475] - Launch lazy future ... done
[15:32:36.475] run() for 'MultisessionFuture' ... done
[15:32:36.475] Created future:
[15:32:36.505] receiveMessageFromWorker() for ClusterFuture ...
[15:32:36.506] - Validating connection of MultisessionFuture
[15:32:36.506] - received message: FutureResult
[15:32:36.507] - Received FutureResult
[15:32:36.507] - Erased future from FutureRegistry
[15:32:36.507] result() for ClusterFuture ...
[15:32:36.508] - result already collected: FutureResult
[15:32:36.508] result() for ClusterFuture ... done
[15:32:36.508] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:36.476] MultisessionFuture:
[15:32:36.476] Label: 'future_sapply-2'
[15:32:36.476] Expression:
[15:32:36.476] {
[15:32:36.476]     do.call(function(...) {
[15:32:36.476]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:36.476]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:36.476]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:36.476]             on.exit(options(oopts), add = TRUE)
[15:32:36.476]         }
[15:32:36.476]         {
[15:32:36.476]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:36.476]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:36.476]                 ...future.FUN(...future.X_jj, ...)
[15:32:36.476]             })
[15:32:36.476]         }
[15:32:36.476]     }, args = future.call.arguments)
[15:32:36.476] }
[15:32:36.476] Lazy evaluation: FALSE
[15:32:36.476] Asynchronous evaluation: TRUE
[15:32:36.476] Local evaluation: TRUE
[15:32:36.476] Environment: R_GlobalEnv
[15:32:36.476] Capture standard output: TRUE
[15:32:36.476] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:36.476] Globals: 5 objects totaling 1.05 KiB (function '...future.FUN' of 848 bytes, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 224 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:36.476] Packages: <none>
[15:32:36.476] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:36.476] Resolved: TRUE
[15:32:36.476] Value: <not collected>
[15:32:36.476] Conditions captured: <none>
[15:32:36.476] Early signaling: FALSE
[15:32:36.476] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:36.476] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:36.509] Chunk #2 of 2 ... DONE
[15:32:36.509] Launching 2 futures (chunks) ... DONE
[15:32:36.509] Resolving 2 futures (chunks) ...
[15:32:36.510] resolve() on list ...
[15:32:36.510]  recursive: 0
[15:32:36.510]  length: 2
[15:32:36.510] 
[15:32:36.511] Future #1
[15:32:36.511] result() for ClusterFuture ...
[15:32:36.511] - result already collected: FutureResult
[15:32:36.512] result() for ClusterFuture ... done
[15:32:36.512] result() for ClusterFuture ...
[15:32:36.512] - result already collected: FutureResult
[15:32:36.512] result() for ClusterFuture ... done
[15:32:36.513] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:36.513] - nx: 2
[15:32:36.513] - relay: TRUE
[15:32:36.513] - stdout: TRUE
[15:32:36.514] - signal: TRUE
[15:32:36.514] - resignal: FALSE
[15:32:36.514] - force: TRUE
[15:32:36.514] - relayed: [n=2] FALSE, FALSE
[15:32:36.515] - queued futures: [n=2] FALSE, FALSE
[15:32:36.515]  - until=1
[15:32:36.515]  - relaying element #1
[15:32:36.516] result() for ClusterFuture ...
[15:32:36.516] - result already collected: FutureResult
[15:32:36.516] result() for ClusterFuture ... done
[15:32:36.516] result() for ClusterFuture ...
[15:32:36.517] - result already collected: FutureResult
[15:32:36.517] result() for ClusterFuture ... done
[15:32:36.517] result() for ClusterFuture ...
[15:32:36.517] - result already collected: FutureResult
[15:32:36.518] result() for ClusterFuture ... done
[15:32:36.518] result() for ClusterFuture ...
[15:32:36.518] - result already collected: FutureResult
[15:32:36.518] result() for ClusterFuture ... done
[15:32:36.519] - relayed: [n=2] TRUE, FALSE
[15:32:36.519] - queued futures: [n=2] TRUE, FALSE
[15:32:36.519] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:36.520]  length: 1 (resolved future 1)
[15:32:36.520] Future #2
[15:32:36.520] result() for ClusterFuture ...
[15:32:36.520] - result already collected: FutureResult
[15:32:36.521] result() for ClusterFuture ... done
[15:32:36.521] result() for ClusterFuture ...
[15:32:36.521] - result already collected: FutureResult
[15:32:36.521] result() for ClusterFuture ... done
[15:32:36.522] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:36.522] - nx: 2
[15:32:36.522] - relay: TRUE
[15:32:36.523] - stdout: TRUE
[15:32:36.523] - signal: TRUE
[15:32:36.523] - resignal: FALSE
[15:32:36.523] - force: TRUE
[15:32:36.524] - relayed: [n=2] TRUE, FALSE
[15:32:36.524] - queued futures: [n=2] TRUE, FALSE
[15:32:36.524]  - until=2
[15:32:36.524]  - relaying element #2
[15:32:36.525] result() for ClusterFuture ...
[15:32:36.525] - result already collected: FutureResult
[15:32:36.525] result() for ClusterFuture ... done
[15:32:36.525] result() for ClusterFuture ...
[15:32:36.526] - result already collected: FutureResult
[15:32:36.526] result() for ClusterFuture ... done
[15:32:36.526] result() for ClusterFuture ...
[15:32:36.526] - result already collected: FutureResult
[15:32:36.527] result() for ClusterFuture ... done
[15:32:36.527] result() for ClusterFuture ...
[15:32:36.527] - result already collected: FutureResult
[15:32:36.527] result() for ClusterFuture ... done
[15:32:36.528] - relayed: [n=2] TRUE, TRUE
[15:32:36.528] - queued futures: [n=2] TRUE, TRUE
[15:32:36.528] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:36.529]  length: 0 (resolved future 2)
[15:32:36.529] Relaying remaining futures
[15:32:36.529] signalConditionsASAP(NULL, pos=0) ...
[15:32:36.529] - nx: 2
[15:32:36.530] - relay: TRUE
[15:32:36.530] - stdout: TRUE
[15:32:36.530] - signal: TRUE
[15:32:36.530] - resignal: FALSE
[15:32:36.531] - force: TRUE
[15:32:36.531] - relayed: [n=2] TRUE, TRUE
[15:32:36.531] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:36.532] - relayed: [n=2] TRUE, TRUE
[15:32:36.532] - queued futures: [n=2] TRUE, TRUE
[15:32:36.532] signalConditionsASAP(NULL, pos=0) ... done
[15:32:36.532] resolve() on list ... DONE
[15:32:36.533] result() for ClusterFuture ...
[15:32:36.533] - result already collected: FutureResult
[15:32:36.533] result() for ClusterFuture ... done
[15:32:36.534] result() for ClusterFuture ...
[15:32:36.534] - result already collected: FutureResult
[15:32:36.534] result() for ClusterFuture ... done
[15:32:36.534] result() for ClusterFuture ...
[15:32:36.535] - result already collected: FutureResult
[15:32:36.535] result() for ClusterFuture ... done
[15:32:36.535] result() for ClusterFuture ...
[15:32:36.535] - result already collected: FutureResult
[15:32:36.536] result() for ClusterFuture ... done
[15:32:36.536]  - Number of value chunks collected: 2
[15:32:36.536] Resolving 2 futures (chunks) ... DONE
[15:32:36.537] Reducing values from 2 chunks ...
[15:32:36.537]  - Number of values collected after concatenation: 3
[15:32:36.537]  - Number of values expected: 3
[15:32:36.537] Reducing values from 2 chunks ... DONE
[15:32:36.538] future_lapply() ... DONE
List of 2
 $ y0:List of 3
  ..$ a: chr "a"
  ..$ b: chr "b"
  ..$ c: chr "c"
 $ y1:List of 3
  ..$ a: chr "a"
  ..$ b: chr "b"
  ..$ c: chr "c"
List of 2
 $ y0:List of 3
  ..$ a: chr "a"
  ..$ b: chr "b"
  ..$ c: chr "c"
 $ y2:List of 3
  ..$ : chr "a"
  ..$ : chr "b"
  ..$ : chr "c"
[15:32:36.547] future_lapply() ...
[15:32:36.552] Number of chunks: 2
[15:32:36.552] getGlobalsAndPackagesXApply() ...
[15:32:36.552]  - future.globals: TRUE
[15:32:36.553] getGlobalsAndPackages() ...
[15:32:36.553] Searching for globals...
[15:32:36.555] - globals found: [2] 'FUN', 'UseMethod'
[15:32:36.556] Searching for globals ... DONE
[15:32:36.556] Resolving globals: FALSE
[15:32:36.557] The total size of the 1 globals is 1.22 KiB (1248 bytes)
[15:32:36.557] The total size of the 1 globals exported for future expression ('FUN()') is 1.22 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.22 KiB of class 'function')
[15:32:36.558] - globals: [1] 'FUN'
[15:32:36.558] 
[15:32:36.558] getGlobalsAndPackages() ... DONE
[15:32:36.558]  - globals found/used: [n=1] 'FUN'
[15:32:36.559]  - needed namespaces: [n=0] 
[15:32:36.559] Finding globals ... DONE
[15:32:36.559]  - use_args: TRUE
[15:32:36.559]  - Getting '...' globals ...
[15:32:36.560] resolve() on list ...
[15:32:36.560]  recursive: 0
[15:32:36.561]  length: 1
[15:32:36.561]  elements: '...'
[15:32:36.561]  length: 0 (resolved future 1)
[15:32:36.561] resolve() on list ... DONE
[15:32:36.562]    - '...' content: [n=0] 
[15:32:36.562] List of 1
[15:32:36.562]  $ ...: list()
[15:32:36.562]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:36.562]  - attr(*, "where")=List of 1
[15:32:36.562]   ..$ ...:<environment: 0x00000276e564a820> 
[15:32:36.562]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:36.562]  - attr(*, "resolved")= logi TRUE
[15:32:36.562]  - attr(*, "total_size")= num NA
[15:32:36.568]  - Getting '...' globals ... DONE
[15:32:36.568] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:36.569] List of 2
[15:32:36.569]  $ ...future.FUN:function (x, ...)  
[15:32:36.569]  $ ...          : list()
[15:32:36.569]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:36.569]  - attr(*, "where")=List of 2
[15:32:36.569]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:36.569]   ..$ ...          :<environment: 0x00000276e564a820> 
[15:32:36.569]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:36.569]  - attr(*, "resolved")= logi FALSE
[15:32:36.569]  - attr(*, "total_size")= num 1248
[15:32:36.575] Packages to be attached in all futures: [n=0] 
[15:32:36.576] getGlobalsAndPackagesXApply() ... DONE
[15:32:36.576] Number of futures (= number of chunks): 2
[15:32:36.577] Launching 2 futures (chunks) ...
[15:32:36.577] Chunk #1 of 2 ...
[15:32:36.577]  - Finding globals in 'X' for chunk #1 ...
[15:32:36.578] getGlobalsAndPackages() ...
[15:32:36.578] Searching for globals...
[15:32:36.579] 
[15:32:36.579] Searching for globals ... DONE
[15:32:36.580] - globals: [0] <none>
[15:32:36.580] getGlobalsAndPackages() ... DONE
[15:32:36.580]    + additional globals found: [n=0] 
[15:32:36.581]    + additional namespaces needed: [n=0] 
[15:32:36.581]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:36.581]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:36.582]  - seeds: <none>
[15:32:36.582]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:36.582] getGlobalsAndPackages() ...
[15:32:36.583] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:36.583] Resolving globals: FALSE
[15:32:36.583] Tweak future expression to call with '...' arguments ...
[15:32:36.584] {
[15:32:36.584]     do.call(function(...) {
[15:32:36.584]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:36.584]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:36.584]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:36.584]             on.exit(options(oopts), add = TRUE)
[15:32:36.584]         }
[15:32:36.584]         {
[15:32:36.584]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:36.584]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:36.584]                 ...future.FUN(...future.X_jj, ...)
[15:32:36.584]             })
[15:32:36.584]         }
[15:32:36.584]     }, args = future.call.arguments)
[15:32:36.584] }
[15:32:36.585] Tweak future expression to call with '...' arguments ... DONE
[15:32:36.586] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:36.586] 
[15:32:36.586] getGlobalsAndPackages() ... DONE
[15:32:36.587] run() for 'Future' ...
[15:32:36.588] - state: 'created'
[15:32:36.588] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:36.610] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:36.611] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:36.611]   - Field: 'node'
[15:32:36.612]   - Field: 'label'
[15:32:36.612]   - Field: 'local'
[15:32:36.612]   - Field: 'owner'
[15:32:36.613]   - Field: 'envir'
[15:32:36.613]   - Field: 'workers'
[15:32:36.614]   - Field: 'packages'
[15:32:36.614]   - Field: 'gc'
[15:32:36.614]   - Field: 'conditions'
[15:32:36.615]   - Field: 'persistent'
[15:32:36.615]   - Field: 'expr'
[15:32:36.616]   - Field: 'uuid'
[15:32:36.616]   - Field: 'seed'
[15:32:36.616]   - Field: 'version'
[15:32:36.617]   - Field: 'result'
[15:32:36.617]   - Field: 'asynchronous'
[15:32:36.617]   - Field: 'calls'
[15:32:36.618]   - Field: 'globals'
[15:32:36.618]   - Field: 'stdout'
[15:32:36.619]   - Field: 'earlySignal'
[15:32:36.619]   - Field: 'lazy'
[15:32:36.619]   - Field: 'state'
[15:32:36.620] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:36.620] - Launch lazy future ...
[15:32:36.621] Packages needed by the future expression (n = 0): <none>
[15:32:36.621] Packages needed by future strategies (n = 0): <none>
[15:32:36.623] {
[15:32:36.623]     {
[15:32:36.623]         {
[15:32:36.623]             ...future.startTime <- base::Sys.time()
[15:32:36.623]             {
[15:32:36.623]                 {
[15:32:36.623]                   {
[15:32:36.623]                     {
[15:32:36.623]                       base::local({
[15:32:36.623]                         has_future <- base::requireNamespace("future", 
[15:32:36.623]                           quietly = TRUE)
[15:32:36.623]                         if (has_future) {
[15:32:36.623]                           ns <- base::getNamespace("future")
[15:32:36.623]                           version <- ns[[".package"]][["version"]]
[15:32:36.623]                           if (is.null(version)) 
[15:32:36.623]                             version <- utils::packageVersion("future")
[15:32:36.623]                         }
[15:32:36.623]                         else {
[15:32:36.623]                           version <- NULL
[15:32:36.623]                         }
[15:32:36.623]                         if (!has_future || version < "1.8.0") {
[15:32:36.623]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:36.623]                             "", base::R.version$version.string), 
[15:32:36.623]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:36.623]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:36.623]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:36.623]                               "release", "version")], collapse = " "), 
[15:32:36.623]                             hostname = base::Sys.info()[["nodename"]])
[15:32:36.623]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:36.623]                             info)
[15:32:36.623]                           info <- base::paste(info, collapse = "; ")
[15:32:36.623]                           if (!has_future) {
[15:32:36.623]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:36.623]                               info)
[15:32:36.623]                           }
[15:32:36.623]                           else {
[15:32:36.623]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:36.623]                               info, version)
[15:32:36.623]                           }
[15:32:36.623]                           base::stop(msg)
[15:32:36.623]                         }
[15:32:36.623]                       })
[15:32:36.623]                     }
[15:32:36.623]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:36.623]                     base::options(mc.cores = 1L)
[15:32:36.623]                   }
[15:32:36.623]                   ...future.strategy.old <- future::plan("list")
[15:32:36.623]                   options(future.plan = NULL)
[15:32:36.623]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:36.623]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:36.623]                 }
[15:32:36.623]                 ...future.workdir <- getwd()
[15:32:36.623]             }
[15:32:36.623]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:36.623]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:36.623]         }
[15:32:36.623]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:36.623]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:36.623]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:36.623]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:36.623]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:36.623]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:36.623]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:36.623]             base::names(...future.oldOptions))
[15:32:36.623]     }
[15:32:36.623]     if (FALSE) {
[15:32:36.623]     }
[15:32:36.623]     else {
[15:32:36.623]         if (TRUE) {
[15:32:36.623]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:36.623]                 open = "w")
[15:32:36.623]         }
[15:32:36.623]         else {
[15:32:36.623]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:36.623]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:36.623]         }
[15:32:36.623]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:36.623]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:36.623]             base::sink(type = "output", split = FALSE)
[15:32:36.623]             base::close(...future.stdout)
[15:32:36.623]         }, add = TRUE)
[15:32:36.623]     }
[15:32:36.623]     ...future.frame <- base::sys.nframe()
[15:32:36.623]     ...future.conditions <- base::list()
[15:32:36.623]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:36.623]     if (FALSE) {
[15:32:36.623]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:36.623]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:36.623]     }
[15:32:36.623]     ...future.result <- base::tryCatch({
[15:32:36.623]         base::withCallingHandlers({
[15:32:36.623]             ...future.value <- base::withVisible(base::local({
[15:32:36.623]                 ...future.makeSendCondition <- base::local({
[15:32:36.623]                   sendCondition <- NULL
[15:32:36.623]                   function(frame = 1L) {
[15:32:36.623]                     if (is.function(sendCondition)) 
[15:32:36.623]                       return(sendCondition)
[15:32:36.623]                     ns <- getNamespace("parallel")
[15:32:36.623]                     if (exists("sendData", mode = "function", 
[15:32:36.623]                       envir = ns)) {
[15:32:36.623]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:36.623]                         envir = ns)
[15:32:36.623]                       envir <- sys.frame(frame)
[15:32:36.623]                       master <- NULL
[15:32:36.623]                       while (!identical(envir, .GlobalEnv) && 
[15:32:36.623]                         !identical(envir, emptyenv())) {
[15:32:36.623]                         if (exists("master", mode = "list", envir = envir, 
[15:32:36.623]                           inherits = FALSE)) {
[15:32:36.623]                           master <- get("master", mode = "list", 
[15:32:36.623]                             envir = envir, inherits = FALSE)
[15:32:36.623]                           if (inherits(master, c("SOCKnode", 
[15:32:36.623]                             "SOCK0node"))) {
[15:32:36.623]                             sendCondition <<- function(cond) {
[15:32:36.623]                               data <- list(type = "VALUE", value = cond, 
[15:32:36.623]                                 success = TRUE)
[15:32:36.623]                               parallel_sendData(master, data)
[15:32:36.623]                             }
[15:32:36.623]                             return(sendCondition)
[15:32:36.623]                           }
[15:32:36.623]                         }
[15:32:36.623]                         frame <- frame + 1L
[15:32:36.623]                         envir <- sys.frame(frame)
[15:32:36.623]                       }
[15:32:36.623]                     }
[15:32:36.623]                     sendCondition <<- function(cond) NULL
[15:32:36.623]                   }
[15:32:36.623]                 })
[15:32:36.623]                 withCallingHandlers({
[15:32:36.623]                   {
[15:32:36.623]                     do.call(function(...) {
[15:32:36.623]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:36.623]                       if (!identical(...future.globals.maxSize.org, 
[15:32:36.623]                         ...future.globals.maxSize)) {
[15:32:36.623]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:36.623]                         on.exit(options(oopts), add = TRUE)
[15:32:36.623]                       }
[15:32:36.623]                       {
[15:32:36.623]                         lapply(seq_along(...future.elements_ii), 
[15:32:36.623]                           FUN = function(jj) {
[15:32:36.623]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:36.623]                             ...future.FUN(...future.X_jj, ...)
[15:32:36.623]                           })
[15:32:36.623]                       }
[15:32:36.623]                     }, args = future.call.arguments)
[15:32:36.623]                   }
[15:32:36.623]                 }, immediateCondition = function(cond) {
[15:32:36.623]                   sendCondition <- ...future.makeSendCondition()
[15:32:36.623]                   sendCondition(cond)
[15:32:36.623]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:36.623]                   {
[15:32:36.623]                     inherits <- base::inherits
[15:32:36.623]                     invokeRestart <- base::invokeRestart
[15:32:36.623]                     is.null <- base::is.null
[15:32:36.623]                     muffled <- FALSE
[15:32:36.623]                     if (inherits(cond, "message")) {
[15:32:36.623]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:36.623]                       if (muffled) 
[15:32:36.623]                         invokeRestart("muffleMessage")
[15:32:36.623]                     }
[15:32:36.623]                     else if (inherits(cond, "warning")) {
[15:32:36.623]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:36.623]                       if (muffled) 
[15:32:36.623]                         invokeRestart("muffleWarning")
[15:32:36.623]                     }
[15:32:36.623]                     else if (inherits(cond, "condition")) {
[15:32:36.623]                       if (!is.null(pattern)) {
[15:32:36.623]                         computeRestarts <- base::computeRestarts
[15:32:36.623]                         grepl <- base::grepl
[15:32:36.623]                         restarts <- computeRestarts(cond)
[15:32:36.623]                         for (restart in restarts) {
[15:32:36.623]                           name <- restart$name
[15:32:36.623]                           if (is.null(name)) 
[15:32:36.623]                             next
[15:32:36.623]                           if (!grepl(pattern, name)) 
[15:32:36.623]                             next
[15:32:36.623]                           invokeRestart(restart)
[15:32:36.623]                           muffled <- TRUE
[15:32:36.623]                           break
[15:32:36.623]                         }
[15:32:36.623]                       }
[15:32:36.623]                     }
[15:32:36.623]                     invisible(muffled)
[15:32:36.623]                   }
[15:32:36.623]                   muffleCondition(cond)
[15:32:36.623]                 })
[15:32:36.623]             }))
[15:32:36.623]             future::FutureResult(value = ...future.value$value, 
[15:32:36.623]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:36.623]                   ...future.rng), globalenv = if (FALSE) 
[15:32:36.623]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:36.623]                     ...future.globalenv.names))
[15:32:36.623]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:36.623]         }, condition = base::local({
[15:32:36.623]             c <- base::c
[15:32:36.623]             inherits <- base::inherits
[15:32:36.623]             invokeRestart <- base::invokeRestart
[15:32:36.623]             length <- base::length
[15:32:36.623]             list <- base::list
[15:32:36.623]             seq.int <- base::seq.int
[15:32:36.623]             signalCondition <- base::signalCondition
[15:32:36.623]             sys.calls <- base::sys.calls
[15:32:36.623]             `[[` <- base::`[[`
[15:32:36.623]             `+` <- base::`+`
[15:32:36.623]             `<<-` <- base::`<<-`
[15:32:36.623]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:36.623]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:36.623]                   3L)]
[15:32:36.623]             }
[15:32:36.623]             function(cond) {
[15:32:36.623]                 is_error <- inherits(cond, "error")
[15:32:36.623]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:36.623]                   NULL)
[15:32:36.623]                 if (is_error) {
[15:32:36.623]                   sessionInformation <- function() {
[15:32:36.623]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:36.623]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:36.623]                       search = base::search(), system = base::Sys.info())
[15:32:36.623]                   }
[15:32:36.623]                   ...future.conditions[[length(...future.conditions) + 
[15:32:36.623]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:36.623]                     cond$call), session = sessionInformation(), 
[15:32:36.623]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:36.623]                   signalCondition(cond)
[15:32:36.623]                 }
[15:32:36.623]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:36.623]                 "immediateCondition"))) {
[15:32:36.623]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:36.623]                   ...future.conditions[[length(...future.conditions) + 
[15:32:36.623]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:36.623]                   if (TRUE && !signal) {
[15:32:36.623]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:36.623]                     {
[15:32:36.623]                       inherits <- base::inherits
[15:32:36.623]                       invokeRestart <- base::invokeRestart
[15:32:36.623]                       is.null <- base::is.null
[15:32:36.623]                       muffled <- FALSE
[15:32:36.623]                       if (inherits(cond, "message")) {
[15:32:36.623]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:36.623]                         if (muffled) 
[15:32:36.623]                           invokeRestart("muffleMessage")
[15:32:36.623]                       }
[15:32:36.623]                       else if (inherits(cond, "warning")) {
[15:32:36.623]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:36.623]                         if (muffled) 
[15:32:36.623]                           invokeRestart("muffleWarning")
[15:32:36.623]                       }
[15:32:36.623]                       else if (inherits(cond, "condition")) {
[15:32:36.623]                         if (!is.null(pattern)) {
[15:32:36.623]                           computeRestarts <- base::computeRestarts
[15:32:36.623]                           grepl <- base::grepl
[15:32:36.623]                           restarts <- computeRestarts(cond)
[15:32:36.623]                           for (restart in restarts) {
[15:32:36.623]                             name <- restart$name
[15:32:36.623]                             if (is.null(name)) 
[15:32:36.623]                               next
[15:32:36.623]                             if (!grepl(pattern, name)) 
[15:32:36.623]                               next
[15:32:36.623]                             invokeRestart(restart)
[15:32:36.623]                             muffled <- TRUE
[15:32:36.623]                             break
[15:32:36.623]                           }
[15:32:36.623]                         }
[15:32:36.623]                       }
[15:32:36.623]                       invisible(muffled)
[15:32:36.623]                     }
[15:32:36.623]                     muffleCondition(cond, pattern = "^muffle")
[15:32:36.623]                   }
[15:32:36.623]                 }
[15:32:36.623]                 else {
[15:32:36.623]                   if (TRUE) {
[15:32:36.623]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:36.623]                     {
[15:32:36.623]                       inherits <- base::inherits
[15:32:36.623]                       invokeRestart <- base::invokeRestart
[15:32:36.623]                       is.null <- base::is.null
[15:32:36.623]                       muffled <- FALSE
[15:32:36.623]                       if (inherits(cond, "message")) {
[15:32:36.623]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:36.623]                         if (muffled) 
[15:32:36.623]                           invokeRestart("muffleMessage")
[15:32:36.623]                       }
[15:32:36.623]                       else if (inherits(cond, "warning")) {
[15:32:36.623]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:36.623]                         if (muffled) 
[15:32:36.623]                           invokeRestart("muffleWarning")
[15:32:36.623]                       }
[15:32:36.623]                       else if (inherits(cond, "condition")) {
[15:32:36.623]                         if (!is.null(pattern)) {
[15:32:36.623]                           computeRestarts <- base::computeRestarts
[15:32:36.623]                           grepl <- base::grepl
[15:32:36.623]                           restarts <- computeRestarts(cond)
[15:32:36.623]                           for (restart in restarts) {
[15:32:36.623]                             name <- restart$name
[15:32:36.623]                             if (is.null(name)) 
[15:32:36.623]                               next
[15:32:36.623]                             if (!grepl(pattern, name)) 
[15:32:36.623]                               next
[15:32:36.623]                             invokeRestart(restart)
[15:32:36.623]                             muffled <- TRUE
[15:32:36.623]                             break
[15:32:36.623]                           }
[15:32:36.623]                         }
[15:32:36.623]                       }
[15:32:36.623]                       invisible(muffled)
[15:32:36.623]                     }
[15:32:36.623]                     muffleCondition(cond, pattern = "^muffle")
[15:32:36.623]                   }
[15:32:36.623]                 }
[15:32:36.623]             }
[15:32:36.623]         }))
[15:32:36.623]     }, error = function(ex) {
[15:32:36.623]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:36.623]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:36.623]                 ...future.rng), started = ...future.startTime, 
[15:32:36.623]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:36.623]             version = "1.8"), class = "FutureResult")
[15:32:36.623]     }, finally = {
[15:32:36.623]         if (!identical(...future.workdir, getwd())) 
[15:32:36.623]             setwd(...future.workdir)
[15:32:36.623]         {
[15:32:36.623]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:36.623]                 ...future.oldOptions$nwarnings <- NULL
[15:32:36.623]             }
[15:32:36.623]             base::options(...future.oldOptions)
[15:32:36.623]             if (.Platform$OS.type == "windows") {
[15:32:36.623]                 old_names <- names(...future.oldEnvVars)
[15:32:36.623]                 envs <- base::Sys.getenv()
[15:32:36.623]                 names <- names(envs)
[15:32:36.623]                 common <- intersect(names, old_names)
[15:32:36.623]                 added <- setdiff(names, old_names)
[15:32:36.623]                 removed <- setdiff(old_names, names)
[15:32:36.623]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:36.623]                   envs[common]]
[15:32:36.623]                 NAMES <- toupper(changed)
[15:32:36.623]                 args <- list()
[15:32:36.623]                 for (kk in seq_along(NAMES)) {
[15:32:36.623]                   name <- changed[[kk]]
[15:32:36.623]                   NAME <- NAMES[[kk]]
[15:32:36.623]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:36.623]                     next
[15:32:36.623]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:36.623]                 }
[15:32:36.623]                 NAMES <- toupper(added)
[15:32:36.623]                 for (kk in seq_along(NAMES)) {
[15:32:36.623]                   name <- added[[kk]]
[15:32:36.623]                   NAME <- NAMES[[kk]]
[15:32:36.623]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:36.623]                     next
[15:32:36.623]                   args[[name]] <- ""
[15:32:36.623]                 }
[15:32:36.623]                 NAMES <- toupper(removed)
[15:32:36.623]                 for (kk in seq_along(NAMES)) {
[15:32:36.623]                   name <- removed[[kk]]
[15:32:36.623]                   NAME <- NAMES[[kk]]
[15:32:36.623]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:36.623]                     next
[15:32:36.623]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:36.623]                 }
[15:32:36.623]                 if (length(args) > 0) 
[15:32:36.623]                   base::do.call(base::Sys.setenv, args = args)
[15:32:36.623]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:36.623]             }
[15:32:36.623]             else {
[15:32:36.623]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:36.623]             }
[15:32:36.623]             {
[15:32:36.623]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:36.623]                   0L) {
[15:32:36.623]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:36.623]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:36.623]                   base::options(opts)
[15:32:36.623]                 }
[15:32:36.623]                 {
[15:32:36.623]                   {
[15:32:36.623]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:36.623]                     NULL
[15:32:36.623]                   }
[15:32:36.623]                   options(future.plan = NULL)
[15:32:36.623]                   if (is.na(NA_character_)) 
[15:32:36.623]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:36.623]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:36.623]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:36.623]                     .init = FALSE)
[15:32:36.623]                 }
[15:32:36.623]             }
[15:32:36.623]         }
[15:32:36.623]     })
[15:32:36.623]     if (TRUE) {
[15:32:36.623]         base::sink(type = "output", split = FALSE)
[15:32:36.623]         if (TRUE) {
[15:32:36.623]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:36.623]         }
[15:32:36.623]         else {
[15:32:36.623]             ...future.result["stdout"] <- base::list(NULL)
[15:32:36.623]         }
[15:32:36.623]         base::close(...future.stdout)
[15:32:36.623]         ...future.stdout <- NULL
[15:32:36.623]     }
[15:32:36.623]     ...future.result$conditions <- ...future.conditions
[15:32:36.623]     ...future.result$finished <- base::Sys.time()
[15:32:36.623]     ...future.result
[15:32:36.623] }
[15:32:36.632] Exporting 5 global objects (1.22 KiB) to cluster node #1 ...
[15:32:36.632] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ...
[15:32:36.633] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ... DONE
[15:32:36.638] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:36.639] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:36.640] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:36.640] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:36.641] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:36.642] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:36.642] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:36.643] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:36.643] Exporting 5 global objects (1.22 KiB) to cluster node #1 ... DONE
[15:32:36.644] MultisessionFuture started
[15:32:36.644] - Launch lazy future ... done
[15:32:36.645] run() for 'MultisessionFuture' ... done
[15:32:36.645] Created future:
[15:32:36.669] receiveMessageFromWorker() for ClusterFuture ...
[15:32:36.670] - Validating connection of MultisessionFuture
[15:32:36.670] - received message: FutureResult
[15:32:36.671] - Received FutureResult
[15:32:36.671] - Erased future from FutureRegistry
[15:32:36.671] result() for ClusterFuture ...
[15:32:36.672] - result already collected: FutureResult
[15:32:36.672] result() for ClusterFuture ... done
[15:32:36.672] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:36.646] MultisessionFuture:
[15:32:36.646] Label: 'future_sapply-1'
[15:32:36.646] Expression:
[15:32:36.646] {
[15:32:36.646]     do.call(function(...) {
[15:32:36.646]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:36.646]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:36.646]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:36.646]             on.exit(options(oopts), add = TRUE)
[15:32:36.646]         }
[15:32:36.646]         {
[15:32:36.646]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:36.646]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:36.646]                 ...future.FUN(...future.X_jj, ...)
[15:32:36.646]             })
[15:32:36.646]         }
[15:32:36.646]     }, args = future.call.arguments)
[15:32:36.646] }
[15:32:36.646] Lazy evaluation: FALSE
[15:32:36.646] Asynchronous evaluation: TRUE
[15:32:36.646] Local evaluation: TRUE
[15:32:36.646] Environment: R_GlobalEnv
[15:32:36.646] Capture standard output: TRUE
[15:32:36.646] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:36.646] Globals: 5 objects totaling 1.33 KiB (function '...future.FUN' of 1.22 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)
[15:32:36.646] Packages: <none>
[15:32:36.646] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:36.646] Resolved: TRUE
[15:32:36.646] Value: <not collected>
[15:32:36.646] Conditions captured: <none>
[15:32:36.646] Early signaling: FALSE
[15:32:36.646] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:36.646] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:36.673] Chunk #1 of 2 ... DONE
[15:32:36.674] Chunk #2 of 2 ...
[15:32:36.674]  - Finding globals in 'X' for chunk #2 ...
[15:32:36.674] getGlobalsAndPackages() ...
[15:32:36.675] Searching for globals...
[15:32:36.675] 
[15:32:36.676] Searching for globals ... DONE
[15:32:36.676] - globals: [0] <none>
[15:32:36.676] getGlobalsAndPackages() ... DONE
[15:32:36.677]    + additional globals found: [n=0] 
[15:32:36.677]    + additional namespaces needed: [n=0] 
[15:32:36.677]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:36.678]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:36.678]  - seeds: <none>
[15:32:36.678]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:36.679] getGlobalsAndPackages() ...
[15:32:36.679] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:36.679] Resolving globals: FALSE
[15:32:36.680] Tweak future expression to call with '...' arguments ...
[15:32:36.680] {
[15:32:36.680]     do.call(function(...) {
[15:32:36.680]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:36.680]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:36.680]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:36.680]             on.exit(options(oopts), add = TRUE)
[15:32:36.680]         }
[15:32:36.680]         {
[15:32:36.680]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:36.680]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:36.680]                 ...future.FUN(...future.X_jj, ...)
[15:32:36.680]             })
[15:32:36.680]         }
[15:32:36.680]     }, args = future.call.arguments)
[15:32:36.680] }
[15:32:36.681] Tweak future expression to call with '...' arguments ... DONE
[15:32:36.682] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:36.683] 
[15:32:36.683] getGlobalsAndPackages() ... DONE
[15:32:36.684] run() for 'Future' ...
[15:32:36.684] - state: 'created'
[15:32:36.684] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:36.706] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:36.707] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:36.707]   - Field: 'node'
[15:32:36.707]   - Field: 'label'
[15:32:36.708]   - Field: 'local'
[15:32:36.708]   - Field: 'owner'
[15:32:36.708]   - Field: 'envir'
[15:32:36.708]   - Field: 'workers'
[15:32:36.709]   - Field: 'packages'
[15:32:36.709]   - Field: 'gc'
[15:32:36.709]   - Field: 'conditions'
[15:32:36.709]   - Field: 'persistent'
[15:32:36.710]   - Field: 'expr'
[15:32:36.710]   - Field: 'uuid'
[15:32:36.710]   - Field: 'seed'
[15:32:36.710]   - Field: 'version'
[15:32:36.710]   - Field: 'result'
[15:32:36.711]   - Field: 'asynchronous'
[15:32:36.711]   - Field: 'calls'
[15:32:36.711]   - Field: 'globals'
[15:32:36.711]   - Field: 'stdout'
[15:32:36.711]   - Field: 'earlySignal'
[15:32:36.712]   - Field: 'lazy'
[15:32:36.712]   - Field: 'state'
[15:32:36.712] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:36.712] - Launch lazy future ...
[15:32:36.713] Packages needed by the future expression (n = 0): <none>
[15:32:36.713] Packages needed by future strategies (n = 0): <none>
[15:32:36.714] {
[15:32:36.714]     {
[15:32:36.714]         {
[15:32:36.714]             ...future.startTime <- base::Sys.time()
[15:32:36.714]             {
[15:32:36.714]                 {
[15:32:36.714]                   {
[15:32:36.714]                     {
[15:32:36.714]                       base::local({
[15:32:36.714]                         has_future <- base::requireNamespace("future", 
[15:32:36.714]                           quietly = TRUE)
[15:32:36.714]                         if (has_future) {
[15:32:36.714]                           ns <- base::getNamespace("future")
[15:32:36.714]                           version <- ns[[".package"]][["version"]]
[15:32:36.714]                           if (is.null(version)) 
[15:32:36.714]                             version <- utils::packageVersion("future")
[15:32:36.714]                         }
[15:32:36.714]                         else {
[15:32:36.714]                           version <- NULL
[15:32:36.714]                         }
[15:32:36.714]                         if (!has_future || version < "1.8.0") {
[15:32:36.714]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:36.714]                             "", base::R.version$version.string), 
[15:32:36.714]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:36.714]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:36.714]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:36.714]                               "release", "version")], collapse = " "), 
[15:32:36.714]                             hostname = base::Sys.info()[["nodename"]])
[15:32:36.714]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:36.714]                             info)
[15:32:36.714]                           info <- base::paste(info, collapse = "; ")
[15:32:36.714]                           if (!has_future) {
[15:32:36.714]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:36.714]                               info)
[15:32:36.714]                           }
[15:32:36.714]                           else {
[15:32:36.714]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:36.714]                               info, version)
[15:32:36.714]                           }
[15:32:36.714]                           base::stop(msg)
[15:32:36.714]                         }
[15:32:36.714]                       })
[15:32:36.714]                     }
[15:32:36.714]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:36.714]                     base::options(mc.cores = 1L)
[15:32:36.714]                   }
[15:32:36.714]                   ...future.strategy.old <- future::plan("list")
[15:32:36.714]                   options(future.plan = NULL)
[15:32:36.714]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:36.714]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:36.714]                 }
[15:32:36.714]                 ...future.workdir <- getwd()
[15:32:36.714]             }
[15:32:36.714]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:36.714]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:36.714]         }
[15:32:36.714]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:36.714]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:36.714]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:36.714]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:36.714]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:36.714]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:36.714]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:36.714]             base::names(...future.oldOptions))
[15:32:36.714]     }
[15:32:36.714]     if (FALSE) {
[15:32:36.714]     }
[15:32:36.714]     else {
[15:32:36.714]         if (TRUE) {
[15:32:36.714]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:36.714]                 open = "w")
[15:32:36.714]         }
[15:32:36.714]         else {
[15:32:36.714]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:36.714]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:36.714]         }
[15:32:36.714]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:36.714]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:36.714]             base::sink(type = "output", split = FALSE)
[15:32:36.714]             base::close(...future.stdout)
[15:32:36.714]         }, add = TRUE)
[15:32:36.714]     }
[15:32:36.714]     ...future.frame <- base::sys.nframe()
[15:32:36.714]     ...future.conditions <- base::list()
[15:32:36.714]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:36.714]     if (FALSE) {
[15:32:36.714]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:36.714]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:36.714]     }
[15:32:36.714]     ...future.result <- base::tryCatch({
[15:32:36.714]         base::withCallingHandlers({
[15:32:36.714]             ...future.value <- base::withVisible(base::local({
[15:32:36.714]                 ...future.makeSendCondition <- base::local({
[15:32:36.714]                   sendCondition <- NULL
[15:32:36.714]                   function(frame = 1L) {
[15:32:36.714]                     if (is.function(sendCondition)) 
[15:32:36.714]                       return(sendCondition)
[15:32:36.714]                     ns <- getNamespace("parallel")
[15:32:36.714]                     if (exists("sendData", mode = "function", 
[15:32:36.714]                       envir = ns)) {
[15:32:36.714]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:36.714]                         envir = ns)
[15:32:36.714]                       envir <- sys.frame(frame)
[15:32:36.714]                       master <- NULL
[15:32:36.714]                       while (!identical(envir, .GlobalEnv) && 
[15:32:36.714]                         !identical(envir, emptyenv())) {
[15:32:36.714]                         if (exists("master", mode = "list", envir = envir, 
[15:32:36.714]                           inherits = FALSE)) {
[15:32:36.714]                           master <- get("master", mode = "list", 
[15:32:36.714]                             envir = envir, inherits = FALSE)
[15:32:36.714]                           if (inherits(master, c("SOCKnode", 
[15:32:36.714]                             "SOCK0node"))) {
[15:32:36.714]                             sendCondition <<- function(cond) {
[15:32:36.714]                               data <- list(type = "VALUE", value = cond, 
[15:32:36.714]                                 success = TRUE)
[15:32:36.714]                               parallel_sendData(master, data)
[15:32:36.714]                             }
[15:32:36.714]                             return(sendCondition)
[15:32:36.714]                           }
[15:32:36.714]                         }
[15:32:36.714]                         frame <- frame + 1L
[15:32:36.714]                         envir <- sys.frame(frame)
[15:32:36.714]                       }
[15:32:36.714]                     }
[15:32:36.714]                     sendCondition <<- function(cond) NULL
[15:32:36.714]                   }
[15:32:36.714]                 })
[15:32:36.714]                 withCallingHandlers({
[15:32:36.714]                   {
[15:32:36.714]                     do.call(function(...) {
[15:32:36.714]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:36.714]                       if (!identical(...future.globals.maxSize.org, 
[15:32:36.714]                         ...future.globals.maxSize)) {
[15:32:36.714]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:36.714]                         on.exit(options(oopts), add = TRUE)
[15:32:36.714]                       }
[15:32:36.714]                       {
[15:32:36.714]                         lapply(seq_along(...future.elements_ii), 
[15:32:36.714]                           FUN = function(jj) {
[15:32:36.714]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:36.714]                             ...future.FUN(...future.X_jj, ...)
[15:32:36.714]                           })
[15:32:36.714]                       }
[15:32:36.714]                     }, args = future.call.arguments)
[15:32:36.714]                   }
[15:32:36.714]                 }, immediateCondition = function(cond) {
[15:32:36.714]                   sendCondition <- ...future.makeSendCondition()
[15:32:36.714]                   sendCondition(cond)
[15:32:36.714]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:36.714]                   {
[15:32:36.714]                     inherits <- base::inherits
[15:32:36.714]                     invokeRestart <- base::invokeRestart
[15:32:36.714]                     is.null <- base::is.null
[15:32:36.714]                     muffled <- FALSE
[15:32:36.714]                     if (inherits(cond, "message")) {
[15:32:36.714]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:36.714]                       if (muffled) 
[15:32:36.714]                         invokeRestart("muffleMessage")
[15:32:36.714]                     }
[15:32:36.714]                     else if (inherits(cond, "warning")) {
[15:32:36.714]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:36.714]                       if (muffled) 
[15:32:36.714]                         invokeRestart("muffleWarning")
[15:32:36.714]                     }
[15:32:36.714]                     else if (inherits(cond, "condition")) {
[15:32:36.714]                       if (!is.null(pattern)) {
[15:32:36.714]                         computeRestarts <- base::computeRestarts
[15:32:36.714]                         grepl <- base::grepl
[15:32:36.714]                         restarts <- computeRestarts(cond)
[15:32:36.714]                         for (restart in restarts) {
[15:32:36.714]                           name <- restart$name
[15:32:36.714]                           if (is.null(name)) 
[15:32:36.714]                             next
[15:32:36.714]                           if (!grepl(pattern, name)) 
[15:32:36.714]                             next
[15:32:36.714]                           invokeRestart(restart)
[15:32:36.714]                           muffled <- TRUE
[15:32:36.714]                           break
[15:32:36.714]                         }
[15:32:36.714]                       }
[15:32:36.714]                     }
[15:32:36.714]                     invisible(muffled)
[15:32:36.714]                   }
[15:32:36.714]                   muffleCondition(cond)
[15:32:36.714]                 })
[15:32:36.714]             }))
[15:32:36.714]             future::FutureResult(value = ...future.value$value, 
[15:32:36.714]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:36.714]                   ...future.rng), globalenv = if (FALSE) 
[15:32:36.714]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:36.714]                     ...future.globalenv.names))
[15:32:36.714]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:36.714]         }, condition = base::local({
[15:32:36.714]             c <- base::c
[15:32:36.714]             inherits <- base::inherits
[15:32:36.714]             invokeRestart <- base::invokeRestart
[15:32:36.714]             length <- base::length
[15:32:36.714]             list <- base::list
[15:32:36.714]             seq.int <- base::seq.int
[15:32:36.714]             signalCondition <- base::signalCondition
[15:32:36.714]             sys.calls <- base::sys.calls
[15:32:36.714]             `[[` <- base::`[[`
[15:32:36.714]             `+` <- base::`+`
[15:32:36.714]             `<<-` <- base::`<<-`
[15:32:36.714]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:36.714]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:36.714]                   3L)]
[15:32:36.714]             }
[15:32:36.714]             function(cond) {
[15:32:36.714]                 is_error <- inherits(cond, "error")
[15:32:36.714]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:36.714]                   NULL)
[15:32:36.714]                 if (is_error) {
[15:32:36.714]                   sessionInformation <- function() {
[15:32:36.714]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:36.714]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:36.714]                       search = base::search(), system = base::Sys.info())
[15:32:36.714]                   }
[15:32:36.714]                   ...future.conditions[[length(...future.conditions) + 
[15:32:36.714]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:36.714]                     cond$call), session = sessionInformation(), 
[15:32:36.714]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:36.714]                   signalCondition(cond)
[15:32:36.714]                 }
[15:32:36.714]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:36.714]                 "immediateCondition"))) {
[15:32:36.714]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:36.714]                   ...future.conditions[[length(...future.conditions) + 
[15:32:36.714]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:36.714]                   if (TRUE && !signal) {
[15:32:36.714]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:36.714]                     {
[15:32:36.714]                       inherits <- base::inherits
[15:32:36.714]                       invokeRestart <- base::invokeRestart
[15:32:36.714]                       is.null <- base::is.null
[15:32:36.714]                       muffled <- FALSE
[15:32:36.714]                       if (inherits(cond, "message")) {
[15:32:36.714]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:36.714]                         if (muffled) 
[15:32:36.714]                           invokeRestart("muffleMessage")
[15:32:36.714]                       }
[15:32:36.714]                       else if (inherits(cond, "warning")) {
[15:32:36.714]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:36.714]                         if (muffled) 
[15:32:36.714]                           invokeRestart("muffleWarning")
[15:32:36.714]                       }
[15:32:36.714]                       else if (inherits(cond, "condition")) {
[15:32:36.714]                         if (!is.null(pattern)) {
[15:32:36.714]                           computeRestarts <- base::computeRestarts
[15:32:36.714]                           grepl <- base::grepl
[15:32:36.714]                           restarts <- computeRestarts(cond)
[15:32:36.714]                           for (restart in restarts) {
[15:32:36.714]                             name <- restart$name
[15:32:36.714]                             if (is.null(name)) 
[15:32:36.714]                               next
[15:32:36.714]                             if (!grepl(pattern, name)) 
[15:32:36.714]                               next
[15:32:36.714]                             invokeRestart(restart)
[15:32:36.714]                             muffled <- TRUE
[15:32:36.714]                             break
[15:32:36.714]                           }
[15:32:36.714]                         }
[15:32:36.714]                       }
[15:32:36.714]                       invisible(muffled)
[15:32:36.714]                     }
[15:32:36.714]                     muffleCondition(cond, pattern = "^muffle")
[15:32:36.714]                   }
[15:32:36.714]                 }
[15:32:36.714]                 else {
[15:32:36.714]                   if (TRUE) {
[15:32:36.714]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:36.714]                     {
[15:32:36.714]                       inherits <- base::inherits
[15:32:36.714]                       invokeRestart <- base::invokeRestart
[15:32:36.714]                       is.null <- base::is.null
[15:32:36.714]                       muffled <- FALSE
[15:32:36.714]                       if (inherits(cond, "message")) {
[15:32:36.714]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:36.714]                         if (muffled) 
[15:32:36.714]                           invokeRestart("muffleMessage")
[15:32:36.714]                       }
[15:32:36.714]                       else if (inherits(cond, "warning")) {
[15:32:36.714]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:36.714]                         if (muffled) 
[15:32:36.714]                           invokeRestart("muffleWarning")
[15:32:36.714]                       }
[15:32:36.714]                       else if (inherits(cond, "condition")) {
[15:32:36.714]                         if (!is.null(pattern)) {
[15:32:36.714]                           computeRestarts <- base::computeRestarts
[15:32:36.714]                           grepl <- base::grepl
[15:32:36.714]                           restarts <- computeRestarts(cond)
[15:32:36.714]                           for (restart in restarts) {
[15:32:36.714]                             name <- restart$name
[15:32:36.714]                             if (is.null(name)) 
[15:32:36.714]                               next
[15:32:36.714]                             if (!grepl(pattern, name)) 
[15:32:36.714]                               next
[15:32:36.714]                             invokeRestart(restart)
[15:32:36.714]                             muffled <- TRUE
[15:32:36.714]                             break
[15:32:36.714]                           }
[15:32:36.714]                         }
[15:32:36.714]                       }
[15:32:36.714]                       invisible(muffled)
[15:32:36.714]                     }
[15:32:36.714]                     muffleCondition(cond, pattern = "^muffle")
[15:32:36.714]                   }
[15:32:36.714]                 }
[15:32:36.714]             }
[15:32:36.714]         }))
[15:32:36.714]     }, error = function(ex) {
[15:32:36.714]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:36.714]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:36.714]                 ...future.rng), started = ...future.startTime, 
[15:32:36.714]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:36.714]             version = "1.8"), class = "FutureResult")
[15:32:36.714]     }, finally = {
[15:32:36.714]         if (!identical(...future.workdir, getwd())) 
[15:32:36.714]             setwd(...future.workdir)
[15:32:36.714]         {
[15:32:36.714]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:36.714]                 ...future.oldOptions$nwarnings <- NULL
[15:32:36.714]             }
[15:32:36.714]             base::options(...future.oldOptions)
[15:32:36.714]             if (.Platform$OS.type == "windows") {
[15:32:36.714]                 old_names <- names(...future.oldEnvVars)
[15:32:36.714]                 envs <- base::Sys.getenv()
[15:32:36.714]                 names <- names(envs)
[15:32:36.714]                 common <- intersect(names, old_names)
[15:32:36.714]                 added <- setdiff(names, old_names)
[15:32:36.714]                 removed <- setdiff(old_names, names)
[15:32:36.714]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:36.714]                   envs[common]]
[15:32:36.714]                 NAMES <- toupper(changed)
[15:32:36.714]                 args <- list()
[15:32:36.714]                 for (kk in seq_along(NAMES)) {
[15:32:36.714]                   name <- changed[[kk]]
[15:32:36.714]                   NAME <- NAMES[[kk]]
[15:32:36.714]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:36.714]                     next
[15:32:36.714]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:36.714]                 }
[15:32:36.714]                 NAMES <- toupper(added)
[15:32:36.714]                 for (kk in seq_along(NAMES)) {
[15:32:36.714]                   name <- added[[kk]]
[15:32:36.714]                   NAME <- NAMES[[kk]]
[15:32:36.714]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:36.714]                     next
[15:32:36.714]                   args[[name]] <- ""
[15:32:36.714]                 }
[15:32:36.714]                 NAMES <- toupper(removed)
[15:32:36.714]                 for (kk in seq_along(NAMES)) {
[15:32:36.714]                   name <- removed[[kk]]
[15:32:36.714]                   NAME <- NAMES[[kk]]
[15:32:36.714]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:36.714]                     next
[15:32:36.714]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:36.714]                 }
[15:32:36.714]                 if (length(args) > 0) 
[15:32:36.714]                   base::do.call(base::Sys.setenv, args = args)
[15:32:36.714]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:36.714]             }
[15:32:36.714]             else {
[15:32:36.714]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:36.714]             }
[15:32:36.714]             {
[15:32:36.714]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:36.714]                   0L) {
[15:32:36.714]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:36.714]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:36.714]                   base::options(opts)
[15:32:36.714]                 }
[15:32:36.714]                 {
[15:32:36.714]                   {
[15:32:36.714]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:36.714]                     NULL
[15:32:36.714]                   }
[15:32:36.714]                   options(future.plan = NULL)
[15:32:36.714]                   if (is.na(NA_character_)) 
[15:32:36.714]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:36.714]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:36.714]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:36.714]                     .init = FALSE)
[15:32:36.714]                 }
[15:32:36.714]             }
[15:32:36.714]         }
[15:32:36.714]     })
[15:32:36.714]     if (TRUE) {
[15:32:36.714]         base::sink(type = "output", split = FALSE)
[15:32:36.714]         if (TRUE) {
[15:32:36.714]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:36.714]         }
[15:32:36.714]         else {
[15:32:36.714]             ...future.result["stdout"] <- base::list(NULL)
[15:32:36.714]         }
[15:32:36.714]         base::close(...future.stdout)
[15:32:36.714]         ...future.stdout <- NULL
[15:32:36.714]     }
[15:32:36.714]     ...future.result$conditions <- ...future.conditions
[15:32:36.714]     ...future.result$finished <- base::Sys.time()
[15:32:36.714]     ...future.result
[15:32:36.714] }
[15:32:36.722] Exporting 5 global objects (1.22 KiB) to cluster node #1 ...
[15:32:36.723] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ...
[15:32:36.724] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ... DONE
[15:32:36.724] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:36.725] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:36.726] Exporting '...future.elements_ii' (224 bytes) to cluster node #1 ...
[15:32:36.726] Exporting '...future.elements_ii' (224 bytes) to cluster node #1 ... DONE
[15:32:36.727] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:36.728] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:36.728] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:36.729] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:36.729] Exporting 5 global objects (1.22 KiB) to cluster node #1 ... DONE
[15:32:36.730] MultisessionFuture started
[15:32:36.731] - Launch lazy future ... done
[15:32:36.731] run() for 'MultisessionFuture' ... done
[15:32:36.731] Created future:
[15:32:36.762] receiveMessageFromWorker() for ClusterFuture ...
[15:32:36.763] - Validating connection of MultisessionFuture
[15:32:36.763] - received message: FutureResult
[15:32:36.764] - Received FutureResult
[15:32:36.764] - Erased future from FutureRegistry
[15:32:36.764] result() for ClusterFuture ...
[15:32:36.764] - result already collected: FutureResult
[15:32:36.765] result() for ClusterFuture ... done
[15:32:36.765] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:36.732] MultisessionFuture:
[15:32:36.732] Label: 'future_sapply-2'
[15:32:36.732] Expression:
[15:32:36.732] {
[15:32:36.732]     do.call(function(...) {
[15:32:36.732]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:36.732]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:36.732]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:36.732]             on.exit(options(oopts), add = TRUE)
[15:32:36.732]         }
[15:32:36.732]         {
[15:32:36.732]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:36.732]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:36.732]                 ...future.FUN(...future.X_jj, ...)
[15:32:36.732]             })
[15:32:36.732]         }
[15:32:36.732]     }, args = future.call.arguments)
[15:32:36.732] }
[15:32:36.732] Lazy evaluation: FALSE
[15:32:36.732] Asynchronous evaluation: TRUE
[15:32:36.732] Local evaluation: TRUE
[15:32:36.732] Environment: R_GlobalEnv
[15:32:36.732] Capture standard output: TRUE
[15:32:36.732] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:36.732] Globals: 5 objects totaling 1.44 KiB (function '...future.FUN' of 1.22 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 224 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:36.732] Packages: <none>
[15:32:36.732] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:36.732] Resolved: TRUE
[15:32:36.732] Value: <not collected>
[15:32:36.732] Conditions captured: <none>
[15:32:36.732] Early signaling: FALSE
[15:32:36.732] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:36.732] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:36.766] Chunk #2 of 2 ... DONE
[15:32:36.766] Launching 2 futures (chunks) ... DONE
[15:32:36.766] Resolving 2 futures (chunks) ...
[15:32:36.767] resolve() on list ...
[15:32:36.767]  recursive: 0
[15:32:36.767]  length: 2
[15:32:36.768] 
[15:32:36.768] Future #1
[15:32:36.768] result() for ClusterFuture ...
[15:32:36.768] - result already collected: FutureResult
[15:32:36.769] result() for ClusterFuture ... done
[15:32:36.769] result() for ClusterFuture ...
[15:32:36.769] - result already collected: FutureResult
[15:32:36.769] result() for ClusterFuture ... done
[15:32:36.770] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:36.770] - nx: 2
[15:32:36.770] - relay: TRUE
[15:32:36.771] - stdout: TRUE
[15:32:36.771] - signal: TRUE
[15:32:36.771] - resignal: FALSE
[15:32:36.771] - force: TRUE
[15:32:36.772] - relayed: [n=2] FALSE, FALSE
[15:32:36.772] - queued futures: [n=2] FALSE, FALSE
[15:32:36.772]  - until=1
[15:32:36.772]  - relaying element #1
[15:32:36.773] result() for ClusterFuture ...
[15:32:36.773] - result already collected: FutureResult
[15:32:36.773] result() for ClusterFuture ... done
[15:32:36.773] result() for ClusterFuture ...
[15:32:36.774] - result already collected: FutureResult
[15:32:36.774] result() for ClusterFuture ... done
[15:32:36.774] result() for ClusterFuture ...
[15:32:36.775] - result already collected: FutureResult
[15:32:36.775] result() for ClusterFuture ... done
[15:32:36.775] result() for ClusterFuture ...
[15:32:36.775] - result already collected: FutureResult
[15:32:36.776] result() for ClusterFuture ... done
[15:32:36.776] - relayed: [n=2] TRUE, FALSE
[15:32:36.776] - queued futures: [n=2] TRUE, FALSE
[15:32:36.776] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:36.777]  length: 1 (resolved future 1)
[15:32:36.777] Future #2
[15:32:36.777] result() for ClusterFuture ...
[15:32:36.778] - result already collected: FutureResult
[15:32:36.778] result() for ClusterFuture ... done
[15:32:36.778] result() for ClusterFuture ...
[15:32:36.778] - result already collected: FutureResult
[15:32:36.779] result() for ClusterFuture ... done
[15:32:36.779] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:36.779] - nx: 2
[15:32:36.779] - relay: TRUE
[15:32:36.780] - stdout: TRUE
[15:32:36.780] - signal: TRUE
[15:32:36.780] - resignal: FALSE
[15:32:36.781] - force: TRUE
[15:32:36.781] - relayed: [n=2] TRUE, FALSE
[15:32:36.781] - queued futures: [n=2] TRUE, FALSE
[15:32:36.781]  - until=2
[15:32:36.782]  - relaying element #2
[15:32:36.782] result() for ClusterFuture ...
[15:32:36.782] - result already collected: FutureResult
[15:32:36.782] result() for ClusterFuture ... done
[15:32:36.783] result() for ClusterFuture ...
[15:32:36.783] - result already collected: FutureResult
[15:32:36.783] result() for ClusterFuture ... done
[15:32:36.784] result() for ClusterFuture ...
[15:32:36.784] - result already collected: FutureResult
[15:32:36.784] result() for ClusterFuture ... done
[15:32:36.784] result() for ClusterFuture ...
[15:32:36.785] - result already collected: FutureResult
[15:32:36.785] result() for ClusterFuture ... done
[15:32:36.785] - relayed: [n=2] TRUE, TRUE
[15:32:36.785] - queued futures: [n=2] TRUE, TRUE
[15:32:36.786] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:36.786]  length: 0 (resolved future 2)
[15:32:36.786] Relaying remaining futures
[15:32:36.787] signalConditionsASAP(NULL, pos=0) ...
[15:32:36.787] - nx: 2
[15:32:36.787] - relay: TRUE
[15:32:36.787] - stdout: TRUE
[15:32:36.788] - signal: TRUE
[15:32:36.788] - resignal: FALSE
[15:32:36.788] - force: TRUE
[15:32:36.788] - relayed: [n=2] TRUE, TRUE
[15:32:36.789] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:36.789] - relayed: [n=2] TRUE, TRUE
[15:32:36.789] - queued futures: [n=2] TRUE, TRUE
[15:32:36.790] signalConditionsASAP(NULL, pos=0) ... done
[15:32:36.790] resolve() on list ... DONE
[15:32:36.790] result() for ClusterFuture ...
[15:32:36.790] - result already collected: FutureResult
[15:32:36.791] result() for ClusterFuture ... done
[15:32:36.791] result() for ClusterFuture ...
[15:32:36.791] - result already collected: FutureResult
[15:32:36.791] result() for ClusterFuture ... done
[15:32:36.792] result() for ClusterFuture ...
[15:32:36.792] - result already collected: FutureResult
[15:32:36.792] result() for ClusterFuture ... done
[15:32:36.793] result() for ClusterFuture ...
[15:32:36.793] - result already collected: FutureResult
[15:32:36.793] result() for ClusterFuture ... done
[15:32:36.793]  - Number of value chunks collected: 2
[15:32:36.794] Resolving 2 futures (chunks) ... DONE
[15:32:36.794] Reducing values from 2 chunks ...
[15:32:36.794]  - Number of values collected after concatenation: 3
[15:32:36.794]  - Number of values expected: 3
[15:32:36.795] Reducing values from 2 chunks ... DONE
[15:32:36.795] future_lapply() ... DONE
List of 2
 $ y0:List of 3
  ..$ a: chr [1, 1] "a"
  ..$ b: chr [1, 1] "b"
  ..$ c: chr [1, 1] "c"
 $ y1:List of 3
  ..$ a: chr [1, 1] "a"
  ..$ b: chr [1, 1] "b"
  ..$ c: chr [1, 1] "c"
List of 2
 $ y0:List of 3
  ..$ a: chr [1, 1] "a"
  ..$ b: chr [1, 1] "b"
  ..$ c: chr [1, 1] "c"
 $ y2:List of 3
  ..$ : chr [1, 1] "a"
  ..$ : chr [1, 1] "b"
  ..$ : chr [1, 1] "c"
[15:32:36.804] future_lapply() ...
[15:32:36.807] Number of chunks: 2
[15:32:36.808] getGlobalsAndPackagesXApply() ...
[15:32:36.808]  - future.globals: TRUE
[15:32:36.808] getGlobalsAndPackages() ...
[15:32:36.808] Searching for globals...
[15:32:36.810] - globals found: [1] 'FUN'
[15:32:36.810] Searching for globals ... DONE
[15:32:36.810] Resolving globals: FALSE
[15:32:36.810] The total size of the 1 globals is 848 bytes (848 bytes)
[15:32:36.811] The total size of the 1 globals exported for future expression ('FUN()') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:32:36.811] - globals: [1] 'FUN'
[15:32:36.811] 
[15:32:36.811] getGlobalsAndPackages() ... DONE
[15:32:36.812]  - globals found/used: [n=1] 'FUN'
[15:32:36.812]  - needed namespaces: [n=0] 
[15:32:36.812] Finding globals ... DONE
[15:32:36.812]  - use_args: TRUE
[15:32:36.812]  - Getting '...' globals ...
[15:32:36.813] resolve() on list ...
[15:32:36.813]  recursive: 0
[15:32:36.813]  length: 1
[15:32:36.813]  elements: '...'
[15:32:36.814]  length: 0 (resolved future 1)
[15:32:36.814] resolve() on list ... DONE
[15:32:36.814]    - '...' content: [n=0] 
[15:32:36.814] List of 1
[15:32:36.814]  $ ...: list()
[15:32:36.814]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:36.814]  - attr(*, "where")=List of 1
[15:32:36.814]   ..$ ...:<environment: 0x00000276e5947848> 
[15:32:36.814]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:36.814]  - attr(*, "resolved")= logi TRUE
[15:32:36.814]  - attr(*, "total_size")= num NA
[15:32:36.817]  - Getting '...' globals ... DONE
[15:32:36.818] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:36.818] List of 2
[15:32:36.818]  $ ...future.FUN:function (x)  
[15:32:36.818]  $ ...          : list()
[15:32:36.818]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:36.818]  - attr(*, "where")=List of 2
[15:32:36.818]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:36.818]   ..$ ...          :<environment: 0x00000276e5947848> 
[15:32:36.818]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:36.818]  - attr(*, "resolved")= logi FALSE
[15:32:36.818]  - attr(*, "total_size")= num 848
[15:32:36.822] Packages to be attached in all futures: [n=0] 
[15:32:36.822] getGlobalsAndPackagesXApply() ... DONE
[15:32:36.822] Number of futures (= number of chunks): 2
[15:32:36.822] Launching 2 futures (chunks) ...
[15:32:36.823] Chunk #1 of 2 ...
[15:32:36.823]  - Finding globals in 'X' for chunk #1 ...
[15:32:36.823] getGlobalsAndPackages() ...
[15:32:36.823] Searching for globals...
[15:32:36.824] 
[15:32:36.824] Searching for globals ... DONE
[15:32:36.824] - globals: [0] <none>
[15:32:36.824] getGlobalsAndPackages() ... DONE
[15:32:36.824]    + additional globals found: [n=0] 
[15:32:36.824]    + additional namespaces needed: [n=0] 
[15:32:36.825]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:36.825]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:36.825]  - seeds: <none>
[15:32:36.825]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:36.825] getGlobalsAndPackages() ...
[15:32:36.825] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:36.826] Resolving globals: FALSE
[15:32:36.826] Tweak future expression to call with '...' arguments ...
[15:32:36.826] {
[15:32:36.826]     do.call(function(...) {
[15:32:36.826]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:36.826]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:36.826]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:36.826]             on.exit(options(oopts), add = TRUE)
[15:32:36.826]         }
[15:32:36.826]         {
[15:32:36.826]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:36.826]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:36.826]                 ...future.FUN(...future.X_jj, ...)
[15:32:36.826]             })
[15:32:36.826]         }
[15:32:36.826]     }, args = future.call.arguments)
[15:32:36.826] }
[15:32:36.826] Tweak future expression to call with '...' arguments ... DONE
[15:32:36.827] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:36.827] 
[15:32:36.827] getGlobalsAndPackages() ... DONE
[15:32:36.828] run() for 'Future' ...
[15:32:36.828] - state: 'created'
[15:32:36.828] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:36.843] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:36.844] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:36.844]   - Field: 'node'
[15:32:36.844]   - Field: 'label'
[15:32:36.844]   - Field: 'local'
[15:32:36.845]   - Field: 'owner'
[15:32:36.845]   - Field: 'envir'
[15:32:36.845]   - Field: 'workers'
[15:32:36.845]   - Field: 'packages'
[15:32:36.845]   - Field: 'gc'
[15:32:36.845]   - Field: 'conditions'
[15:32:36.846]   - Field: 'persistent'
[15:32:36.846]   - Field: 'expr'
[15:32:36.846]   - Field: 'uuid'
[15:32:36.846]   - Field: 'seed'
[15:32:36.846]   - Field: 'version'
[15:32:36.847]   - Field: 'result'
[15:32:36.847]   - Field: 'asynchronous'
[15:32:36.847]   - Field: 'calls'
[15:32:36.847]   - Field: 'globals'
[15:32:36.847]   - Field: 'stdout'
[15:32:36.848]   - Field: 'earlySignal'
[15:32:36.848]   - Field: 'lazy'
[15:32:36.848]   - Field: 'state'
[15:32:36.848] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:36.848] - Launch lazy future ...
[15:32:36.849] Packages needed by the future expression (n = 0): <none>
[15:32:36.849] Packages needed by future strategies (n = 0): <none>
[15:32:36.850] {
[15:32:36.850]     {
[15:32:36.850]         {
[15:32:36.850]             ...future.startTime <- base::Sys.time()
[15:32:36.850]             {
[15:32:36.850]                 {
[15:32:36.850]                   {
[15:32:36.850]                     {
[15:32:36.850]                       base::local({
[15:32:36.850]                         has_future <- base::requireNamespace("future", 
[15:32:36.850]                           quietly = TRUE)
[15:32:36.850]                         if (has_future) {
[15:32:36.850]                           ns <- base::getNamespace("future")
[15:32:36.850]                           version <- ns[[".package"]][["version"]]
[15:32:36.850]                           if (is.null(version)) 
[15:32:36.850]                             version <- utils::packageVersion("future")
[15:32:36.850]                         }
[15:32:36.850]                         else {
[15:32:36.850]                           version <- NULL
[15:32:36.850]                         }
[15:32:36.850]                         if (!has_future || version < "1.8.0") {
[15:32:36.850]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:36.850]                             "", base::R.version$version.string), 
[15:32:36.850]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:36.850]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:36.850]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:36.850]                               "release", "version")], collapse = " "), 
[15:32:36.850]                             hostname = base::Sys.info()[["nodename"]])
[15:32:36.850]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:36.850]                             info)
[15:32:36.850]                           info <- base::paste(info, collapse = "; ")
[15:32:36.850]                           if (!has_future) {
[15:32:36.850]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:36.850]                               info)
[15:32:36.850]                           }
[15:32:36.850]                           else {
[15:32:36.850]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:36.850]                               info, version)
[15:32:36.850]                           }
[15:32:36.850]                           base::stop(msg)
[15:32:36.850]                         }
[15:32:36.850]                       })
[15:32:36.850]                     }
[15:32:36.850]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:36.850]                     base::options(mc.cores = 1L)
[15:32:36.850]                   }
[15:32:36.850]                   ...future.strategy.old <- future::plan("list")
[15:32:36.850]                   options(future.plan = NULL)
[15:32:36.850]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:36.850]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:36.850]                 }
[15:32:36.850]                 ...future.workdir <- getwd()
[15:32:36.850]             }
[15:32:36.850]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:36.850]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:36.850]         }
[15:32:36.850]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:36.850]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:36.850]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:36.850]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:36.850]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:36.850]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:36.850]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:36.850]             base::names(...future.oldOptions))
[15:32:36.850]     }
[15:32:36.850]     if (FALSE) {
[15:32:36.850]     }
[15:32:36.850]     else {
[15:32:36.850]         if (TRUE) {
[15:32:36.850]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:36.850]                 open = "w")
[15:32:36.850]         }
[15:32:36.850]         else {
[15:32:36.850]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:36.850]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:36.850]         }
[15:32:36.850]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:36.850]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:36.850]             base::sink(type = "output", split = FALSE)
[15:32:36.850]             base::close(...future.stdout)
[15:32:36.850]         }, add = TRUE)
[15:32:36.850]     }
[15:32:36.850]     ...future.frame <- base::sys.nframe()
[15:32:36.850]     ...future.conditions <- base::list()
[15:32:36.850]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:36.850]     if (FALSE) {
[15:32:36.850]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:36.850]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:36.850]     }
[15:32:36.850]     ...future.result <- base::tryCatch({
[15:32:36.850]         base::withCallingHandlers({
[15:32:36.850]             ...future.value <- base::withVisible(base::local({
[15:32:36.850]                 ...future.makeSendCondition <- base::local({
[15:32:36.850]                   sendCondition <- NULL
[15:32:36.850]                   function(frame = 1L) {
[15:32:36.850]                     if (is.function(sendCondition)) 
[15:32:36.850]                       return(sendCondition)
[15:32:36.850]                     ns <- getNamespace("parallel")
[15:32:36.850]                     if (exists("sendData", mode = "function", 
[15:32:36.850]                       envir = ns)) {
[15:32:36.850]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:36.850]                         envir = ns)
[15:32:36.850]                       envir <- sys.frame(frame)
[15:32:36.850]                       master <- NULL
[15:32:36.850]                       while (!identical(envir, .GlobalEnv) && 
[15:32:36.850]                         !identical(envir, emptyenv())) {
[15:32:36.850]                         if (exists("master", mode = "list", envir = envir, 
[15:32:36.850]                           inherits = FALSE)) {
[15:32:36.850]                           master <- get("master", mode = "list", 
[15:32:36.850]                             envir = envir, inherits = FALSE)
[15:32:36.850]                           if (inherits(master, c("SOCKnode", 
[15:32:36.850]                             "SOCK0node"))) {
[15:32:36.850]                             sendCondition <<- function(cond) {
[15:32:36.850]                               data <- list(type = "VALUE", value = cond, 
[15:32:36.850]                                 success = TRUE)
[15:32:36.850]                               parallel_sendData(master, data)
[15:32:36.850]                             }
[15:32:36.850]                             return(sendCondition)
[15:32:36.850]                           }
[15:32:36.850]                         }
[15:32:36.850]                         frame <- frame + 1L
[15:32:36.850]                         envir <- sys.frame(frame)
[15:32:36.850]                       }
[15:32:36.850]                     }
[15:32:36.850]                     sendCondition <<- function(cond) NULL
[15:32:36.850]                   }
[15:32:36.850]                 })
[15:32:36.850]                 withCallingHandlers({
[15:32:36.850]                   {
[15:32:36.850]                     do.call(function(...) {
[15:32:36.850]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:36.850]                       if (!identical(...future.globals.maxSize.org, 
[15:32:36.850]                         ...future.globals.maxSize)) {
[15:32:36.850]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:36.850]                         on.exit(options(oopts), add = TRUE)
[15:32:36.850]                       }
[15:32:36.850]                       {
[15:32:36.850]                         lapply(seq_along(...future.elements_ii), 
[15:32:36.850]                           FUN = function(jj) {
[15:32:36.850]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:36.850]                             ...future.FUN(...future.X_jj, ...)
[15:32:36.850]                           })
[15:32:36.850]                       }
[15:32:36.850]                     }, args = future.call.arguments)
[15:32:36.850]                   }
[15:32:36.850]                 }, immediateCondition = function(cond) {
[15:32:36.850]                   sendCondition <- ...future.makeSendCondition()
[15:32:36.850]                   sendCondition(cond)
[15:32:36.850]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:36.850]                   {
[15:32:36.850]                     inherits <- base::inherits
[15:32:36.850]                     invokeRestart <- base::invokeRestart
[15:32:36.850]                     is.null <- base::is.null
[15:32:36.850]                     muffled <- FALSE
[15:32:36.850]                     if (inherits(cond, "message")) {
[15:32:36.850]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:36.850]                       if (muffled) 
[15:32:36.850]                         invokeRestart("muffleMessage")
[15:32:36.850]                     }
[15:32:36.850]                     else if (inherits(cond, "warning")) {
[15:32:36.850]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:36.850]                       if (muffled) 
[15:32:36.850]                         invokeRestart("muffleWarning")
[15:32:36.850]                     }
[15:32:36.850]                     else if (inherits(cond, "condition")) {
[15:32:36.850]                       if (!is.null(pattern)) {
[15:32:36.850]                         computeRestarts <- base::computeRestarts
[15:32:36.850]                         grepl <- base::grepl
[15:32:36.850]                         restarts <- computeRestarts(cond)
[15:32:36.850]                         for (restart in restarts) {
[15:32:36.850]                           name <- restart$name
[15:32:36.850]                           if (is.null(name)) 
[15:32:36.850]                             next
[15:32:36.850]                           if (!grepl(pattern, name)) 
[15:32:36.850]                             next
[15:32:36.850]                           invokeRestart(restart)
[15:32:36.850]                           muffled <- TRUE
[15:32:36.850]                           break
[15:32:36.850]                         }
[15:32:36.850]                       }
[15:32:36.850]                     }
[15:32:36.850]                     invisible(muffled)
[15:32:36.850]                   }
[15:32:36.850]                   muffleCondition(cond)
[15:32:36.850]                 })
[15:32:36.850]             }))
[15:32:36.850]             future::FutureResult(value = ...future.value$value, 
[15:32:36.850]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:36.850]                   ...future.rng), globalenv = if (FALSE) 
[15:32:36.850]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:36.850]                     ...future.globalenv.names))
[15:32:36.850]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:36.850]         }, condition = base::local({
[15:32:36.850]             c <- base::c
[15:32:36.850]             inherits <- base::inherits
[15:32:36.850]             invokeRestart <- base::invokeRestart
[15:32:36.850]             length <- base::length
[15:32:36.850]             list <- base::list
[15:32:36.850]             seq.int <- base::seq.int
[15:32:36.850]             signalCondition <- base::signalCondition
[15:32:36.850]             sys.calls <- base::sys.calls
[15:32:36.850]             `[[` <- base::`[[`
[15:32:36.850]             `+` <- base::`+`
[15:32:36.850]             `<<-` <- base::`<<-`
[15:32:36.850]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:36.850]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:36.850]                   3L)]
[15:32:36.850]             }
[15:32:36.850]             function(cond) {
[15:32:36.850]                 is_error <- inherits(cond, "error")
[15:32:36.850]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:36.850]                   NULL)
[15:32:36.850]                 if (is_error) {
[15:32:36.850]                   sessionInformation <- function() {
[15:32:36.850]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:36.850]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:36.850]                       search = base::search(), system = base::Sys.info())
[15:32:36.850]                   }
[15:32:36.850]                   ...future.conditions[[length(...future.conditions) + 
[15:32:36.850]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:36.850]                     cond$call), session = sessionInformation(), 
[15:32:36.850]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:36.850]                   signalCondition(cond)
[15:32:36.850]                 }
[15:32:36.850]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:36.850]                 "immediateCondition"))) {
[15:32:36.850]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:36.850]                   ...future.conditions[[length(...future.conditions) + 
[15:32:36.850]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:36.850]                   if (TRUE && !signal) {
[15:32:36.850]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:36.850]                     {
[15:32:36.850]                       inherits <- base::inherits
[15:32:36.850]                       invokeRestart <- base::invokeRestart
[15:32:36.850]                       is.null <- base::is.null
[15:32:36.850]                       muffled <- FALSE
[15:32:36.850]                       if (inherits(cond, "message")) {
[15:32:36.850]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:36.850]                         if (muffled) 
[15:32:36.850]                           invokeRestart("muffleMessage")
[15:32:36.850]                       }
[15:32:36.850]                       else if (inherits(cond, "warning")) {
[15:32:36.850]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:36.850]                         if (muffled) 
[15:32:36.850]                           invokeRestart("muffleWarning")
[15:32:36.850]                       }
[15:32:36.850]                       else if (inherits(cond, "condition")) {
[15:32:36.850]                         if (!is.null(pattern)) {
[15:32:36.850]                           computeRestarts <- base::computeRestarts
[15:32:36.850]                           grepl <- base::grepl
[15:32:36.850]                           restarts <- computeRestarts(cond)
[15:32:36.850]                           for (restart in restarts) {
[15:32:36.850]                             name <- restart$name
[15:32:36.850]                             if (is.null(name)) 
[15:32:36.850]                               next
[15:32:36.850]                             if (!grepl(pattern, name)) 
[15:32:36.850]                               next
[15:32:36.850]                             invokeRestart(restart)
[15:32:36.850]                             muffled <- TRUE
[15:32:36.850]                             break
[15:32:36.850]                           }
[15:32:36.850]                         }
[15:32:36.850]                       }
[15:32:36.850]                       invisible(muffled)
[15:32:36.850]                     }
[15:32:36.850]                     muffleCondition(cond, pattern = "^muffle")
[15:32:36.850]                   }
[15:32:36.850]                 }
[15:32:36.850]                 else {
[15:32:36.850]                   if (TRUE) {
[15:32:36.850]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:36.850]                     {
[15:32:36.850]                       inherits <- base::inherits
[15:32:36.850]                       invokeRestart <- base::invokeRestart
[15:32:36.850]                       is.null <- base::is.null
[15:32:36.850]                       muffled <- FALSE
[15:32:36.850]                       if (inherits(cond, "message")) {
[15:32:36.850]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:36.850]                         if (muffled) 
[15:32:36.850]                           invokeRestart("muffleMessage")
[15:32:36.850]                       }
[15:32:36.850]                       else if (inherits(cond, "warning")) {
[15:32:36.850]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:36.850]                         if (muffled) 
[15:32:36.850]                           invokeRestart("muffleWarning")
[15:32:36.850]                       }
[15:32:36.850]                       else if (inherits(cond, "condition")) {
[15:32:36.850]                         if (!is.null(pattern)) {
[15:32:36.850]                           computeRestarts <- base::computeRestarts
[15:32:36.850]                           grepl <- base::grepl
[15:32:36.850]                           restarts <- computeRestarts(cond)
[15:32:36.850]                           for (restart in restarts) {
[15:32:36.850]                             name <- restart$name
[15:32:36.850]                             if (is.null(name)) 
[15:32:36.850]                               next
[15:32:36.850]                             if (!grepl(pattern, name)) 
[15:32:36.850]                               next
[15:32:36.850]                             invokeRestart(restart)
[15:32:36.850]                             muffled <- TRUE
[15:32:36.850]                             break
[15:32:36.850]                           }
[15:32:36.850]                         }
[15:32:36.850]                       }
[15:32:36.850]                       invisible(muffled)
[15:32:36.850]                     }
[15:32:36.850]                     muffleCondition(cond, pattern = "^muffle")
[15:32:36.850]                   }
[15:32:36.850]                 }
[15:32:36.850]             }
[15:32:36.850]         }))
[15:32:36.850]     }, error = function(ex) {
[15:32:36.850]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:36.850]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:36.850]                 ...future.rng), started = ...future.startTime, 
[15:32:36.850]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:36.850]             version = "1.8"), class = "FutureResult")
[15:32:36.850]     }, finally = {
[15:32:36.850]         if (!identical(...future.workdir, getwd())) 
[15:32:36.850]             setwd(...future.workdir)
[15:32:36.850]         {
[15:32:36.850]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:36.850]                 ...future.oldOptions$nwarnings <- NULL
[15:32:36.850]             }
[15:32:36.850]             base::options(...future.oldOptions)
[15:32:36.850]             if (.Platform$OS.type == "windows") {
[15:32:36.850]                 old_names <- names(...future.oldEnvVars)
[15:32:36.850]                 envs <- base::Sys.getenv()
[15:32:36.850]                 names <- names(envs)
[15:32:36.850]                 common <- intersect(names, old_names)
[15:32:36.850]                 added <- setdiff(names, old_names)
[15:32:36.850]                 removed <- setdiff(old_names, names)
[15:32:36.850]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:36.850]                   envs[common]]
[15:32:36.850]                 NAMES <- toupper(changed)
[15:32:36.850]                 args <- list()
[15:32:36.850]                 for (kk in seq_along(NAMES)) {
[15:32:36.850]                   name <- changed[[kk]]
[15:32:36.850]                   NAME <- NAMES[[kk]]
[15:32:36.850]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:36.850]                     next
[15:32:36.850]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:36.850]                 }
[15:32:36.850]                 NAMES <- toupper(added)
[15:32:36.850]                 for (kk in seq_along(NAMES)) {
[15:32:36.850]                   name <- added[[kk]]
[15:32:36.850]                   NAME <- NAMES[[kk]]
[15:32:36.850]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:36.850]                     next
[15:32:36.850]                   args[[name]] <- ""
[15:32:36.850]                 }
[15:32:36.850]                 NAMES <- toupper(removed)
[15:32:36.850]                 for (kk in seq_along(NAMES)) {
[15:32:36.850]                   name <- removed[[kk]]
[15:32:36.850]                   NAME <- NAMES[[kk]]
[15:32:36.850]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:36.850]                     next
[15:32:36.850]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:36.850]                 }
[15:32:36.850]                 if (length(args) > 0) 
[15:32:36.850]                   base::do.call(base::Sys.setenv, args = args)
[15:32:36.850]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:36.850]             }
[15:32:36.850]             else {
[15:32:36.850]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:36.850]             }
[15:32:36.850]             {
[15:32:36.850]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:36.850]                   0L) {
[15:32:36.850]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:36.850]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:36.850]                   base::options(opts)
[15:32:36.850]                 }
[15:32:36.850]                 {
[15:32:36.850]                   {
[15:32:36.850]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:36.850]                     NULL
[15:32:36.850]                   }
[15:32:36.850]                   options(future.plan = NULL)
[15:32:36.850]                   if (is.na(NA_character_)) 
[15:32:36.850]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:36.850]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:36.850]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:36.850]                     .init = FALSE)
[15:32:36.850]                 }
[15:32:36.850]             }
[15:32:36.850]         }
[15:32:36.850]     })
[15:32:36.850]     if (TRUE) {
[15:32:36.850]         base::sink(type = "output", split = FALSE)
[15:32:36.850]         if (TRUE) {
[15:32:36.850]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:36.850]         }
[15:32:36.850]         else {
[15:32:36.850]             ...future.result["stdout"] <- base::list(NULL)
[15:32:36.850]         }
[15:32:36.850]         base::close(...future.stdout)
[15:32:36.850]         ...future.stdout <- NULL
[15:32:36.850]     }
[15:32:36.850]     ...future.result$conditions <- ...future.conditions
[15:32:36.850]     ...future.result$finished <- base::Sys.time()
[15:32:36.850]     ...future.result
[15:32:36.850] }
[15:32:36.856] Exporting 5 global objects (848 bytes) to cluster node #1 ...
[15:32:36.856] Exporting '...future.FUN' (848 bytes) to cluster node #1 ...
[15:32:36.857] Exporting '...future.FUN' (848 bytes) to cluster node #1 ... DONE
[15:32:36.857] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:36.857] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:36.858] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:36.858] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:36.858] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:36.859] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:36.859] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:36.859] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:36.860] Exporting 5 global objects (848 bytes) to cluster node #1 ... DONE
[15:32:36.860] MultisessionFuture started
[15:32:36.860] - Launch lazy future ... done
[15:32:36.861] run() for 'MultisessionFuture' ... done
[15:32:36.861] Created future:
[15:32:36.879] receiveMessageFromWorker() for ClusterFuture ...
[15:32:36.879] - Validating connection of MultisessionFuture
[15:32:36.883] - received message: FutureResult
[15:32:36.884] - Received FutureResult
[15:32:36.884] - Erased future from FutureRegistry
[15:32:36.884] result() for ClusterFuture ...
[15:32:36.884] - result already collected: FutureResult
[15:32:36.884] result() for ClusterFuture ... done
[15:32:36.885] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:36.861] MultisessionFuture:
[15:32:36.861] Label: 'future_sapply-1'
[15:32:36.861] Expression:
[15:32:36.861] {
[15:32:36.861]     do.call(function(...) {
[15:32:36.861]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:36.861]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:36.861]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:36.861]             on.exit(options(oopts), add = TRUE)
[15:32:36.861]         }
[15:32:36.861]         {
[15:32:36.861]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:36.861]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:36.861]                 ...future.FUN(...future.X_jj, ...)
[15:32:36.861]             })
[15:32:36.861]         }
[15:32:36.861]     }, args = future.call.arguments)
[15:32:36.861] }
[15:32:36.861] Lazy evaluation: FALSE
[15:32:36.861] Asynchronous evaluation: TRUE
[15:32:36.861] Local evaluation: TRUE
[15:32:36.861] Environment: R_GlobalEnv
[15:32:36.861] Capture standard output: TRUE
[15:32:36.861] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:36.861] Globals: 5 objects totaling 960 bytes (function '...future.FUN' of 848 bytes, 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)
[15:32:36.861] Packages: <none>
[15:32:36.861] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:36.861] Resolved: TRUE
[15:32:36.861] Value: <not collected>
[15:32:36.861] Conditions captured: <none>
[15:32:36.861] Early signaling: FALSE
[15:32:36.861] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:36.861] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:36.885] Chunk #1 of 2 ... DONE
[15:32:36.886] Chunk #2 of 2 ...
[15:32:36.886]  - Finding globals in 'X' for chunk #2 ...
[15:32:36.886] getGlobalsAndPackages() ...
[15:32:36.886] Searching for globals...
[15:32:36.887] 
[15:32:36.887] Searching for globals ... DONE
[15:32:36.887] - globals: [0] <none>
[15:32:36.887] getGlobalsAndPackages() ... DONE
[15:32:36.887]    + additional globals found: [n=0] 
[15:32:36.888]    + additional namespaces needed: [n=0] 
[15:32:36.888]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:36.888]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:36.888]  - seeds: <none>
[15:32:36.888]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:36.888] getGlobalsAndPackages() ...
[15:32:36.889] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:36.889] Resolving globals: FALSE
[15:32:36.889] Tweak future expression to call with '...' arguments ...
[15:32:36.889] {
[15:32:36.889]     do.call(function(...) {
[15:32:36.889]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:36.889]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:36.889]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:36.889]             on.exit(options(oopts), add = TRUE)
[15:32:36.889]         }
[15:32:36.889]         {
[15:32:36.889]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:36.889]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:36.889]                 ...future.FUN(...future.X_jj, ...)
[15:32:36.889]             })
[15:32:36.889]         }
[15:32:36.889]     }, args = future.call.arguments)
[15:32:36.889] }
[15:32:36.890] Tweak future expression to call with '...' arguments ... DONE
[15:32:36.890] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:36.891] 
[15:32:36.891] getGlobalsAndPackages() ... DONE
[15:32:36.891] run() for 'Future' ...
[15:32:36.891] - state: 'created'
[15:32:36.892] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:36.907] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:36.907] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:36.908]   - Field: 'node'
[15:32:36.908]   - Field: 'label'
[15:32:36.908]   - Field: 'local'
[15:32:36.909]   - Field: 'owner'
[15:32:36.909]   - Field: 'envir'
[15:32:36.909]   - Field: 'workers'
[15:32:36.909]   - Field: 'packages'
[15:32:36.910]   - Field: 'gc'
[15:32:36.910]   - Field: 'conditions'
[15:32:36.910]   - Field: 'persistent'
[15:32:36.911]   - Field: 'expr'
[15:32:36.911]   - Field: 'uuid'
[15:32:36.911]   - Field: 'seed'
[15:32:36.912]   - Field: 'version'
[15:32:36.912]   - Field: 'result'
[15:32:36.912]   - Field: 'asynchronous'
[15:32:36.913]   - Field: 'calls'
[15:32:36.913]   - Field: 'globals'
[15:32:36.913]   - Field: 'stdout'
[15:32:36.914]   - Field: 'earlySignal'
[15:32:36.914]   - Field: 'lazy'
[15:32:36.914]   - Field: 'state'
[15:32:36.915] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:36.915] - Launch lazy future ...
[15:32:36.915] Packages needed by the future expression (n = 0): <none>
[15:32:36.916] Packages needed by future strategies (n = 0): <none>
[15:32:36.917] {
[15:32:36.917]     {
[15:32:36.917]         {
[15:32:36.917]             ...future.startTime <- base::Sys.time()
[15:32:36.917]             {
[15:32:36.917]                 {
[15:32:36.917]                   {
[15:32:36.917]                     {
[15:32:36.917]                       base::local({
[15:32:36.917]                         has_future <- base::requireNamespace("future", 
[15:32:36.917]                           quietly = TRUE)
[15:32:36.917]                         if (has_future) {
[15:32:36.917]                           ns <- base::getNamespace("future")
[15:32:36.917]                           version <- ns[[".package"]][["version"]]
[15:32:36.917]                           if (is.null(version)) 
[15:32:36.917]                             version <- utils::packageVersion("future")
[15:32:36.917]                         }
[15:32:36.917]                         else {
[15:32:36.917]                           version <- NULL
[15:32:36.917]                         }
[15:32:36.917]                         if (!has_future || version < "1.8.0") {
[15:32:36.917]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:36.917]                             "", base::R.version$version.string), 
[15:32:36.917]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:36.917]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:36.917]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:36.917]                               "release", "version")], collapse = " "), 
[15:32:36.917]                             hostname = base::Sys.info()[["nodename"]])
[15:32:36.917]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:36.917]                             info)
[15:32:36.917]                           info <- base::paste(info, collapse = "; ")
[15:32:36.917]                           if (!has_future) {
[15:32:36.917]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:36.917]                               info)
[15:32:36.917]                           }
[15:32:36.917]                           else {
[15:32:36.917]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:36.917]                               info, version)
[15:32:36.917]                           }
[15:32:36.917]                           base::stop(msg)
[15:32:36.917]                         }
[15:32:36.917]                       })
[15:32:36.917]                     }
[15:32:36.917]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:36.917]                     base::options(mc.cores = 1L)
[15:32:36.917]                   }
[15:32:36.917]                   ...future.strategy.old <- future::plan("list")
[15:32:36.917]                   options(future.plan = NULL)
[15:32:36.917]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:36.917]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:36.917]                 }
[15:32:36.917]                 ...future.workdir <- getwd()
[15:32:36.917]             }
[15:32:36.917]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:36.917]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:36.917]         }
[15:32:36.917]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:36.917]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:36.917]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:36.917]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:36.917]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:36.917]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:36.917]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:36.917]             base::names(...future.oldOptions))
[15:32:36.917]     }
[15:32:36.917]     if (FALSE) {
[15:32:36.917]     }
[15:32:36.917]     else {
[15:32:36.917]         if (TRUE) {
[15:32:36.917]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:36.917]                 open = "w")
[15:32:36.917]         }
[15:32:36.917]         else {
[15:32:36.917]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:36.917]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:36.917]         }
[15:32:36.917]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:36.917]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:36.917]             base::sink(type = "output", split = FALSE)
[15:32:36.917]             base::close(...future.stdout)
[15:32:36.917]         }, add = TRUE)
[15:32:36.917]     }
[15:32:36.917]     ...future.frame <- base::sys.nframe()
[15:32:36.917]     ...future.conditions <- base::list()
[15:32:36.917]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:36.917]     if (FALSE) {
[15:32:36.917]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:36.917]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:36.917]     }
[15:32:36.917]     ...future.result <- base::tryCatch({
[15:32:36.917]         base::withCallingHandlers({
[15:32:36.917]             ...future.value <- base::withVisible(base::local({
[15:32:36.917]                 ...future.makeSendCondition <- base::local({
[15:32:36.917]                   sendCondition <- NULL
[15:32:36.917]                   function(frame = 1L) {
[15:32:36.917]                     if (is.function(sendCondition)) 
[15:32:36.917]                       return(sendCondition)
[15:32:36.917]                     ns <- getNamespace("parallel")
[15:32:36.917]                     if (exists("sendData", mode = "function", 
[15:32:36.917]                       envir = ns)) {
[15:32:36.917]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:36.917]                         envir = ns)
[15:32:36.917]                       envir <- sys.frame(frame)
[15:32:36.917]                       master <- NULL
[15:32:36.917]                       while (!identical(envir, .GlobalEnv) && 
[15:32:36.917]                         !identical(envir, emptyenv())) {
[15:32:36.917]                         if (exists("master", mode = "list", envir = envir, 
[15:32:36.917]                           inherits = FALSE)) {
[15:32:36.917]                           master <- get("master", mode = "list", 
[15:32:36.917]                             envir = envir, inherits = FALSE)
[15:32:36.917]                           if (inherits(master, c("SOCKnode", 
[15:32:36.917]                             "SOCK0node"))) {
[15:32:36.917]                             sendCondition <<- function(cond) {
[15:32:36.917]                               data <- list(type = "VALUE", value = cond, 
[15:32:36.917]                                 success = TRUE)
[15:32:36.917]                               parallel_sendData(master, data)
[15:32:36.917]                             }
[15:32:36.917]                             return(sendCondition)
[15:32:36.917]                           }
[15:32:36.917]                         }
[15:32:36.917]                         frame <- frame + 1L
[15:32:36.917]                         envir <- sys.frame(frame)
[15:32:36.917]                       }
[15:32:36.917]                     }
[15:32:36.917]                     sendCondition <<- function(cond) NULL
[15:32:36.917]                   }
[15:32:36.917]                 })
[15:32:36.917]                 withCallingHandlers({
[15:32:36.917]                   {
[15:32:36.917]                     do.call(function(...) {
[15:32:36.917]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:36.917]                       if (!identical(...future.globals.maxSize.org, 
[15:32:36.917]                         ...future.globals.maxSize)) {
[15:32:36.917]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:36.917]                         on.exit(options(oopts), add = TRUE)
[15:32:36.917]                       }
[15:32:36.917]                       {
[15:32:36.917]                         lapply(seq_along(...future.elements_ii), 
[15:32:36.917]                           FUN = function(jj) {
[15:32:36.917]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:36.917]                             ...future.FUN(...future.X_jj, ...)
[15:32:36.917]                           })
[15:32:36.917]                       }
[15:32:36.917]                     }, args = future.call.arguments)
[15:32:36.917]                   }
[15:32:36.917]                 }, immediateCondition = function(cond) {
[15:32:36.917]                   sendCondition <- ...future.makeSendCondition()
[15:32:36.917]                   sendCondition(cond)
[15:32:36.917]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:36.917]                   {
[15:32:36.917]                     inherits <- base::inherits
[15:32:36.917]                     invokeRestart <- base::invokeRestart
[15:32:36.917]                     is.null <- base::is.null
[15:32:36.917]                     muffled <- FALSE
[15:32:36.917]                     if (inherits(cond, "message")) {
[15:32:36.917]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:36.917]                       if (muffled) 
[15:32:36.917]                         invokeRestart("muffleMessage")
[15:32:36.917]                     }
[15:32:36.917]                     else if (inherits(cond, "warning")) {
[15:32:36.917]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:36.917]                       if (muffled) 
[15:32:36.917]                         invokeRestart("muffleWarning")
[15:32:36.917]                     }
[15:32:36.917]                     else if (inherits(cond, "condition")) {
[15:32:36.917]                       if (!is.null(pattern)) {
[15:32:36.917]                         computeRestarts <- base::computeRestarts
[15:32:36.917]                         grepl <- base::grepl
[15:32:36.917]                         restarts <- computeRestarts(cond)
[15:32:36.917]                         for (restart in restarts) {
[15:32:36.917]                           name <- restart$name
[15:32:36.917]                           if (is.null(name)) 
[15:32:36.917]                             next
[15:32:36.917]                           if (!grepl(pattern, name)) 
[15:32:36.917]                             next
[15:32:36.917]                           invokeRestart(restart)
[15:32:36.917]                           muffled <- TRUE
[15:32:36.917]                           break
[15:32:36.917]                         }
[15:32:36.917]                       }
[15:32:36.917]                     }
[15:32:36.917]                     invisible(muffled)
[15:32:36.917]                   }
[15:32:36.917]                   muffleCondition(cond)
[15:32:36.917]                 })
[15:32:36.917]             }))
[15:32:36.917]             future::FutureResult(value = ...future.value$value, 
[15:32:36.917]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:36.917]                   ...future.rng), globalenv = if (FALSE) 
[15:32:36.917]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:36.917]                     ...future.globalenv.names))
[15:32:36.917]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:36.917]         }, condition = base::local({
[15:32:36.917]             c <- base::c
[15:32:36.917]             inherits <- base::inherits
[15:32:36.917]             invokeRestart <- base::invokeRestart
[15:32:36.917]             length <- base::length
[15:32:36.917]             list <- base::list
[15:32:36.917]             seq.int <- base::seq.int
[15:32:36.917]             signalCondition <- base::signalCondition
[15:32:36.917]             sys.calls <- base::sys.calls
[15:32:36.917]             `[[` <- base::`[[`
[15:32:36.917]             `+` <- base::`+`
[15:32:36.917]             `<<-` <- base::`<<-`
[15:32:36.917]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:36.917]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:36.917]                   3L)]
[15:32:36.917]             }
[15:32:36.917]             function(cond) {
[15:32:36.917]                 is_error <- inherits(cond, "error")
[15:32:36.917]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:36.917]                   NULL)
[15:32:36.917]                 if (is_error) {
[15:32:36.917]                   sessionInformation <- function() {
[15:32:36.917]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:36.917]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:36.917]                       search = base::search(), system = base::Sys.info())
[15:32:36.917]                   }
[15:32:36.917]                   ...future.conditions[[length(...future.conditions) + 
[15:32:36.917]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:36.917]                     cond$call), session = sessionInformation(), 
[15:32:36.917]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:36.917]                   signalCondition(cond)
[15:32:36.917]                 }
[15:32:36.917]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:36.917]                 "immediateCondition"))) {
[15:32:36.917]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:36.917]                   ...future.conditions[[length(...future.conditions) + 
[15:32:36.917]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:36.917]                   if (TRUE && !signal) {
[15:32:36.917]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:36.917]                     {
[15:32:36.917]                       inherits <- base::inherits
[15:32:36.917]                       invokeRestart <- base::invokeRestart
[15:32:36.917]                       is.null <- base::is.null
[15:32:36.917]                       muffled <- FALSE
[15:32:36.917]                       if (inherits(cond, "message")) {
[15:32:36.917]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:36.917]                         if (muffled) 
[15:32:36.917]                           invokeRestart("muffleMessage")
[15:32:36.917]                       }
[15:32:36.917]                       else if (inherits(cond, "warning")) {
[15:32:36.917]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:36.917]                         if (muffled) 
[15:32:36.917]                           invokeRestart("muffleWarning")
[15:32:36.917]                       }
[15:32:36.917]                       else if (inherits(cond, "condition")) {
[15:32:36.917]                         if (!is.null(pattern)) {
[15:32:36.917]                           computeRestarts <- base::computeRestarts
[15:32:36.917]                           grepl <- base::grepl
[15:32:36.917]                           restarts <- computeRestarts(cond)
[15:32:36.917]                           for (restart in restarts) {
[15:32:36.917]                             name <- restart$name
[15:32:36.917]                             if (is.null(name)) 
[15:32:36.917]                               next
[15:32:36.917]                             if (!grepl(pattern, name)) 
[15:32:36.917]                               next
[15:32:36.917]                             invokeRestart(restart)
[15:32:36.917]                             muffled <- TRUE
[15:32:36.917]                             break
[15:32:36.917]                           }
[15:32:36.917]                         }
[15:32:36.917]                       }
[15:32:36.917]                       invisible(muffled)
[15:32:36.917]                     }
[15:32:36.917]                     muffleCondition(cond, pattern = "^muffle")
[15:32:36.917]                   }
[15:32:36.917]                 }
[15:32:36.917]                 else {
[15:32:36.917]                   if (TRUE) {
[15:32:36.917]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:36.917]                     {
[15:32:36.917]                       inherits <- base::inherits
[15:32:36.917]                       invokeRestart <- base::invokeRestart
[15:32:36.917]                       is.null <- base::is.null
[15:32:36.917]                       muffled <- FALSE
[15:32:36.917]                       if (inherits(cond, "message")) {
[15:32:36.917]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:36.917]                         if (muffled) 
[15:32:36.917]                           invokeRestart("muffleMessage")
[15:32:36.917]                       }
[15:32:36.917]                       else if (inherits(cond, "warning")) {
[15:32:36.917]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:36.917]                         if (muffled) 
[15:32:36.917]                           invokeRestart("muffleWarning")
[15:32:36.917]                       }
[15:32:36.917]                       else if (inherits(cond, "condition")) {
[15:32:36.917]                         if (!is.null(pattern)) {
[15:32:36.917]                           computeRestarts <- base::computeRestarts
[15:32:36.917]                           grepl <- base::grepl
[15:32:36.917]                           restarts <- computeRestarts(cond)
[15:32:36.917]                           for (restart in restarts) {
[15:32:36.917]                             name <- restart$name
[15:32:36.917]                             if (is.null(name)) 
[15:32:36.917]                               next
[15:32:36.917]                             if (!grepl(pattern, name)) 
[15:32:36.917]                               next
[15:32:36.917]                             invokeRestart(restart)
[15:32:36.917]                             muffled <- TRUE
[15:32:36.917]                             break
[15:32:36.917]                           }
[15:32:36.917]                         }
[15:32:36.917]                       }
[15:32:36.917]                       invisible(muffled)
[15:32:36.917]                     }
[15:32:36.917]                     muffleCondition(cond, pattern = "^muffle")
[15:32:36.917]                   }
[15:32:36.917]                 }
[15:32:36.917]             }
[15:32:36.917]         }))
[15:32:36.917]     }, error = function(ex) {
[15:32:36.917]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:36.917]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:36.917]                 ...future.rng), started = ...future.startTime, 
[15:32:36.917]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:36.917]             version = "1.8"), class = "FutureResult")
[15:32:36.917]     }, finally = {
[15:32:36.917]         if (!identical(...future.workdir, getwd())) 
[15:32:36.917]             setwd(...future.workdir)
[15:32:36.917]         {
[15:32:36.917]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:36.917]                 ...future.oldOptions$nwarnings <- NULL
[15:32:36.917]             }
[15:32:36.917]             base::options(...future.oldOptions)
[15:32:36.917]             if (.Platform$OS.type == "windows") {
[15:32:36.917]                 old_names <- names(...future.oldEnvVars)
[15:32:36.917]                 envs <- base::Sys.getenv()
[15:32:36.917]                 names <- names(envs)
[15:32:36.917]                 common <- intersect(names, old_names)
[15:32:36.917]                 added <- setdiff(names, old_names)
[15:32:36.917]                 removed <- setdiff(old_names, names)
[15:32:36.917]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:36.917]                   envs[common]]
[15:32:36.917]                 NAMES <- toupper(changed)
[15:32:36.917]                 args <- list()
[15:32:36.917]                 for (kk in seq_along(NAMES)) {
[15:32:36.917]                   name <- changed[[kk]]
[15:32:36.917]                   NAME <- NAMES[[kk]]
[15:32:36.917]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:36.917]                     next
[15:32:36.917]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:36.917]                 }
[15:32:36.917]                 NAMES <- toupper(added)
[15:32:36.917]                 for (kk in seq_along(NAMES)) {
[15:32:36.917]                   name <- added[[kk]]
[15:32:36.917]                   NAME <- NAMES[[kk]]
[15:32:36.917]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:36.917]                     next
[15:32:36.917]                   args[[name]] <- ""
[15:32:36.917]                 }
[15:32:36.917]                 NAMES <- toupper(removed)
[15:32:36.917]                 for (kk in seq_along(NAMES)) {
[15:32:36.917]                   name <- removed[[kk]]
[15:32:36.917]                   NAME <- NAMES[[kk]]
[15:32:36.917]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:36.917]                     next
[15:32:36.917]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:36.917]                 }
[15:32:36.917]                 if (length(args) > 0) 
[15:32:36.917]                   base::do.call(base::Sys.setenv, args = args)
[15:32:36.917]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:36.917]             }
[15:32:36.917]             else {
[15:32:36.917]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:36.917]             }
[15:32:36.917]             {
[15:32:36.917]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:36.917]                   0L) {
[15:32:36.917]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:36.917]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:36.917]                   base::options(opts)
[15:32:36.917]                 }
[15:32:36.917]                 {
[15:32:36.917]                   {
[15:32:36.917]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:36.917]                     NULL
[15:32:36.917]                   }
[15:32:36.917]                   options(future.plan = NULL)
[15:32:36.917]                   if (is.na(NA_character_)) 
[15:32:36.917]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:36.917]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:36.917]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:36.917]                     .init = FALSE)
[15:32:36.917]                 }
[15:32:36.917]             }
[15:32:36.917]         }
[15:32:36.917]     })
[15:32:36.917]     if (TRUE) {
[15:32:36.917]         base::sink(type = "output", split = FALSE)
[15:32:36.917]         if (TRUE) {
[15:32:36.917]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:36.917]         }
[15:32:36.917]         else {
[15:32:36.917]             ...future.result["stdout"] <- base::list(NULL)
[15:32:36.917]         }
[15:32:36.917]         base::close(...future.stdout)
[15:32:36.917]         ...future.stdout <- NULL
[15:32:36.917]     }
[15:32:36.917]     ...future.result$conditions <- ...future.conditions
[15:32:36.917]     ...future.result$finished <- base::Sys.time()
[15:32:36.917]     ...future.result
[15:32:36.917] }
[15:32:36.926] Exporting 5 global objects (848 bytes) to cluster node #1 ...
[15:32:36.926] Exporting '...future.FUN' (848 bytes) to cluster node #1 ...
[15:32:36.927] Exporting '...future.FUN' (848 bytes) to cluster node #1 ... DONE
[15:32:36.928] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:36.928] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:36.929] Exporting '...future.elements_ii' (224 bytes) to cluster node #1 ...
[15:32:36.929] Exporting '...future.elements_ii' (224 bytes) to cluster node #1 ... DONE
[15:32:36.930] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:36.931] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:36.931] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:36.932] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:36.933] Exporting 5 global objects (848 bytes) to cluster node #1 ... DONE
[15:32:36.934] MultisessionFuture started
[15:32:36.934] - Launch lazy future ... done
[15:32:36.934] run() for 'MultisessionFuture' ... done
[15:32:36.935] Created future:
[15:32:36.964] receiveMessageFromWorker() for ClusterFuture ...
[15:32:36.965] - Validating connection of MultisessionFuture
[15:32:36.966] - received message: FutureResult
[15:32:36.966] - Received FutureResult
[15:32:36.966] - Erased future from FutureRegistry
[15:32:36.967] result() for ClusterFuture ...
[15:32:36.967] - result already collected: FutureResult
[15:32:36.967] result() for ClusterFuture ... done
[15:32:36.967] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:36.935] MultisessionFuture:
[15:32:36.935] Label: 'future_sapply-2'
[15:32:36.935] Expression:
[15:32:36.935] {
[15:32:36.935]     do.call(function(...) {
[15:32:36.935]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:36.935]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:36.935]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:36.935]             on.exit(options(oopts), add = TRUE)
[15:32:36.935]         }
[15:32:36.935]         {
[15:32:36.935]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:36.935]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:36.935]                 ...future.FUN(...future.X_jj, ...)
[15:32:36.935]             })
[15:32:36.935]         }
[15:32:36.935]     }, args = future.call.arguments)
[15:32:36.935] }
[15:32:36.935] Lazy evaluation: FALSE
[15:32:36.935] Asynchronous evaluation: TRUE
[15:32:36.935] Local evaluation: TRUE
[15:32:36.935] Environment: R_GlobalEnv
[15:32:36.935] Capture standard output: TRUE
[15:32:36.935] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:36.935] Globals: 5 objects totaling 1.05 KiB (function '...future.FUN' of 848 bytes, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 224 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:36.935] Packages: <none>
[15:32:36.935] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:36.935] Resolved: TRUE
[15:32:36.935] Value: <not collected>
[15:32:36.935] Conditions captured: <none>
[15:32:36.935] Early signaling: FALSE
[15:32:36.935] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:36.935] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:36.968] Chunk #2 of 2 ... DONE
[15:32:36.969] Launching 2 futures (chunks) ... DONE
[15:32:36.969] Resolving 2 futures (chunks) ...
[15:32:36.969] resolve() on list ...
[15:32:36.970]  recursive: 0
[15:32:36.970]  length: 2
[15:32:36.970] 
[15:32:36.971] Future #1
[15:32:36.971] result() for ClusterFuture ...
[15:32:36.971] - result already collected: FutureResult
[15:32:36.971] result() for ClusterFuture ... done
[15:32:36.972] result() for ClusterFuture ...
[15:32:36.972] - result already collected: FutureResult
[15:32:36.972] result() for ClusterFuture ... done
[15:32:36.973] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:36.973] - nx: 2
[15:32:36.973] - relay: TRUE
[15:32:36.974] - stdout: TRUE
[15:32:36.974] - signal: TRUE
[15:32:36.974] - resignal: FALSE
[15:32:36.974] - force: TRUE
[15:32:36.975] - relayed: [n=2] FALSE, FALSE
[15:32:36.975] - queued futures: [n=2] FALSE, FALSE
[15:32:36.975]  - until=1
[15:32:36.976]  - relaying element #1
[15:32:36.976] result() for ClusterFuture ...
[15:32:36.976] - result already collected: FutureResult
[15:32:36.976] result() for ClusterFuture ... done
[15:32:36.977] result() for ClusterFuture ...
[15:32:36.977] - result already collected: FutureResult
[15:32:36.977] result() for ClusterFuture ... done
[15:32:36.978] result() for ClusterFuture ...
[15:32:36.978] - result already collected: FutureResult
[15:32:36.978] result() for ClusterFuture ... done
[15:32:36.979] result() for ClusterFuture ...
[15:32:36.979] - result already collected: FutureResult
[15:32:36.979] result() for ClusterFuture ... done
[15:32:36.980] - relayed: [n=2] TRUE, FALSE
[15:32:36.980] - queued futures: [n=2] TRUE, FALSE
[15:32:36.980] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:36.980]  length: 1 (resolved future 1)
[15:32:36.981] Future #2
[15:32:36.981] result() for ClusterFuture ...
[15:32:36.981] - result already collected: FutureResult
[15:32:36.982] result() for ClusterFuture ... done
[15:32:36.982] result() for ClusterFuture ...
[15:32:36.982] - result already collected: FutureResult
[15:32:36.983] result() for ClusterFuture ... done
[15:32:36.983] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:36.983] - nx: 2
[15:32:36.983] - relay: TRUE
[15:32:36.984] - stdout: TRUE
[15:32:36.984] - signal: TRUE
[15:32:36.984] - resignal: FALSE
[15:32:36.985] - force: TRUE
[15:32:36.985] - relayed: [n=2] TRUE, FALSE
[15:32:36.985] - queued futures: [n=2] TRUE, FALSE
[15:32:36.985]  - until=2
[15:32:36.986]  - relaying element #2
[15:32:36.986] result() for ClusterFuture ...
[15:32:36.986] - result already collected: FutureResult
[15:32:36.987] result() for ClusterFuture ... done
[15:32:36.987] result() for ClusterFuture ...
[15:32:36.987] - result already collected: FutureResult
[15:32:36.987] result() for ClusterFuture ... done
[15:32:36.988] result() for ClusterFuture ...
[15:32:36.988] - result already collected: FutureResult
[15:32:36.988] result() for ClusterFuture ... done
[15:32:36.989] result() for ClusterFuture ...
[15:32:36.989] - result already collected: FutureResult
[15:32:36.989] result() for ClusterFuture ... done
[15:32:36.990] - relayed: [n=2] TRUE, TRUE
[15:32:36.990] - queued futures: [n=2] TRUE, TRUE
[15:32:36.990] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:36.991]  length: 0 (resolved future 2)
[15:32:36.991] Relaying remaining futures
[15:32:36.991] signalConditionsASAP(NULL, pos=0) ...
[15:32:36.991] - nx: 2
[15:32:36.992] - relay: TRUE
[15:32:36.992] - stdout: TRUE
[15:32:36.992] - signal: TRUE
[15:32:36.993] - resignal: FALSE
[15:32:36.993] - force: TRUE
[15:32:36.993] - relayed: [n=2] TRUE, TRUE
[15:32:36.993] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:36.994] - relayed: [n=2] TRUE, TRUE
[15:32:36.994] - queued futures: [n=2] TRUE, TRUE
[15:32:36.995] signalConditionsASAP(NULL, pos=0) ... done
[15:32:36.995] resolve() on list ... DONE
[15:32:36.995] result() for ClusterFuture ...
[15:32:36.995] - result already collected: FutureResult
[15:32:36.996] result() for ClusterFuture ... done
[15:32:36.996] result() for ClusterFuture ...
[15:32:36.996] - result already collected: FutureResult
[15:32:36.997] result() for ClusterFuture ... done
[15:32:36.997] result() for ClusterFuture ...
[15:32:36.997] - result already collected: FutureResult
[15:32:36.998] result() for ClusterFuture ... done
[15:32:36.998] result() for ClusterFuture ...
[15:32:36.998] - result already collected: FutureResult
[15:32:36.998] result() for ClusterFuture ... done
[15:32:36.998]  - Number of value chunks collected: 2
[15:32:36.999] Resolving 2 futures (chunks) ... DONE
[15:32:36.999] Reducing values from 2 chunks ...
[15:32:36.999]  - Number of values collected after concatenation: 3
[15:32:36.999]  - Number of values expected: 3
[15:32:36.999] Reducing values from 2 chunks ... DONE
[15:32:37.000] future_lapply() ... DONE
List of 2
 $ y0: Named chr [1:3] "a" "b" "c"
  ..- attr(*, "names")= chr [1:3] "a" "b" "c"
 $ y1: Named chr [1:3] "a" "b" "c"
  ..- attr(*, "names")= chr [1:3] "a" "b" "c"
[15:32:37.002] future_lapply() ...
[15:32:37.005] Number of chunks: 2
[15:32:37.006] getGlobalsAndPackagesXApply() ...
[15:32:37.006]  - future.globals: TRUE
[15:32:37.006] getGlobalsAndPackages() ...
[15:32:37.006] Searching for globals...
[15:32:37.008] - globals found: [2] 'FUN', 'UseMethod'
[15:32:37.008] Searching for globals ... DONE
[15:32:37.008] Resolving globals: FALSE
[15:32:37.009] The total size of the 1 globals is 1.22 KiB (1248 bytes)
[15:32:37.010] The total size of the 1 globals exported for future expression ('FUN()') is 1.22 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.22 KiB of class 'function')
[15:32:37.010] - globals: [1] 'FUN'
[15:32:37.010] 
[15:32:37.010] getGlobalsAndPackages() ... DONE
[15:32:37.011]  - globals found/used: [n=1] 'FUN'
[15:32:37.011]  - needed namespaces: [n=0] 
[15:32:37.011] Finding globals ... DONE
[15:32:37.011]  - use_args: TRUE
[15:32:37.012]  - Getting '...' globals ...
[15:32:37.012] resolve() on list ...
[15:32:37.013]  recursive: 0
[15:32:37.013]  length: 1
[15:32:37.013]  elements: '...'
[15:32:37.014]  length: 0 (resolved future 1)
[15:32:37.014] resolve() on list ... DONE
[15:32:37.014]    - '...' content: [n=0] 
[15:32:37.014] List of 1
[15:32:37.014]  $ ...: list()
[15:32:37.014]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:37.014]  - attr(*, "where")=List of 1
[15:32:37.014]   ..$ ...:<environment: 0x00000276e5e4fbc8> 
[15:32:37.014]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:37.014]  - attr(*, "resolved")= logi TRUE
[15:32:37.014]  - attr(*, "total_size")= num NA
[15:32:37.019]  - Getting '...' globals ... DONE
[15:32:37.020] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:37.020] List of 2
[15:32:37.020]  $ ...future.FUN:function (x, ...)  
[15:32:37.020]  $ ...          : list()
[15:32:37.020]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:37.020]  - attr(*, "where")=List of 2
[15:32:37.020]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:37.020]   ..$ ...          :<environment: 0x00000276e5e4fbc8> 
[15:32:37.020]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:37.020]  - attr(*, "resolved")= logi FALSE
[15:32:37.020]  - attr(*, "total_size")= num 1248
[15:32:37.025] Packages to be attached in all futures: [n=0] 
[15:32:37.025] getGlobalsAndPackagesXApply() ... DONE
[15:32:37.026] Number of futures (= number of chunks): 2
[15:32:37.026] Launching 2 futures (chunks) ...
[15:32:37.026] Chunk #1 of 2 ...
[15:32:37.027]  - Finding globals in 'X' for chunk #1 ...
[15:32:37.027] getGlobalsAndPackages() ...
[15:32:37.027] Searching for globals...
[15:32:37.028] 
[15:32:37.028] Searching for globals ... DONE
[15:32:37.028] - globals: [0] <none>
[15:32:37.029] getGlobalsAndPackages() ... DONE
[15:32:37.029]    + additional globals found: [n=0] 
[15:32:37.029]    + additional namespaces needed: [n=0] 
[15:32:37.030]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:37.030]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:37.030]  - seeds: <none>
[15:32:37.030]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:37.031] getGlobalsAndPackages() ...
[15:32:37.031] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:37.031] Resolving globals: FALSE
[15:32:37.031] Tweak future expression to call with '...' arguments ...
[15:32:37.032] {
[15:32:37.032]     do.call(function(...) {
[15:32:37.032]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:37.032]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:37.032]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:37.032]             on.exit(options(oopts), add = TRUE)
[15:32:37.032]         }
[15:32:37.032]         {
[15:32:37.032]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:37.032]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:37.032]                 ...future.FUN(...future.X_jj, ...)
[15:32:37.032]             })
[15:32:37.032]         }
[15:32:37.032]     }, args = future.call.arguments)
[15:32:37.032] }
[15:32:37.033] Tweak future expression to call with '...' arguments ... DONE
[15:32:37.033] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:37.034] 
[15:32:37.034] getGlobalsAndPackages() ... DONE
[15:32:37.035] run() for 'Future' ...
[15:32:37.035] - state: 'created'
[15:32:37.035] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:37.053] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:37.054] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:37.054]   - Field: 'node'
[15:32:37.055]   - Field: 'label'
[15:32:37.055]   - Field: 'local'
[15:32:37.055]   - Field: 'owner'
[15:32:37.056]   - Field: 'envir'
[15:32:37.056]   - Field: 'workers'
[15:32:37.056]   - Field: 'packages'
[15:32:37.057]   - Field: 'gc'
[15:32:37.057]   - Field: 'conditions'
[15:32:37.057]   - Field: 'persistent'
[15:32:37.058]   - Field: 'expr'
[15:32:37.058]   - Field: 'uuid'
[15:32:37.058]   - Field: 'seed'
[15:32:37.058]   - Field: 'version'
[15:32:37.059]   - Field: 'result'
[15:32:37.059]   - Field: 'asynchronous'
[15:32:37.059]   - Field: 'calls'
[15:32:37.060]   - Field: 'globals'
[15:32:37.060]   - Field: 'stdout'
[15:32:37.060]   - Field: 'earlySignal'
[15:32:37.061]   - Field: 'lazy'
[15:32:37.061]   - Field: 'state'
[15:32:37.061] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:37.062] - Launch lazy future ...
[15:32:37.062] Packages needed by the future expression (n = 0): <none>
[15:32:37.063] Packages needed by future strategies (n = 0): <none>
[15:32:37.064] {
[15:32:37.064]     {
[15:32:37.064]         {
[15:32:37.064]             ...future.startTime <- base::Sys.time()
[15:32:37.064]             {
[15:32:37.064]                 {
[15:32:37.064]                   {
[15:32:37.064]                     {
[15:32:37.064]                       base::local({
[15:32:37.064]                         has_future <- base::requireNamespace("future", 
[15:32:37.064]                           quietly = TRUE)
[15:32:37.064]                         if (has_future) {
[15:32:37.064]                           ns <- base::getNamespace("future")
[15:32:37.064]                           version <- ns[[".package"]][["version"]]
[15:32:37.064]                           if (is.null(version)) 
[15:32:37.064]                             version <- utils::packageVersion("future")
[15:32:37.064]                         }
[15:32:37.064]                         else {
[15:32:37.064]                           version <- NULL
[15:32:37.064]                         }
[15:32:37.064]                         if (!has_future || version < "1.8.0") {
[15:32:37.064]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:37.064]                             "", base::R.version$version.string), 
[15:32:37.064]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:37.064]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:37.064]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:37.064]                               "release", "version")], collapse = " "), 
[15:32:37.064]                             hostname = base::Sys.info()[["nodename"]])
[15:32:37.064]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:37.064]                             info)
[15:32:37.064]                           info <- base::paste(info, collapse = "; ")
[15:32:37.064]                           if (!has_future) {
[15:32:37.064]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:37.064]                               info)
[15:32:37.064]                           }
[15:32:37.064]                           else {
[15:32:37.064]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:37.064]                               info, version)
[15:32:37.064]                           }
[15:32:37.064]                           base::stop(msg)
[15:32:37.064]                         }
[15:32:37.064]                       })
[15:32:37.064]                     }
[15:32:37.064]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:37.064]                     base::options(mc.cores = 1L)
[15:32:37.064]                   }
[15:32:37.064]                   ...future.strategy.old <- future::plan("list")
[15:32:37.064]                   options(future.plan = NULL)
[15:32:37.064]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:37.064]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:37.064]                 }
[15:32:37.064]                 ...future.workdir <- getwd()
[15:32:37.064]             }
[15:32:37.064]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:37.064]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:37.064]         }
[15:32:37.064]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:37.064]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:37.064]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:37.064]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:37.064]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:37.064]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:37.064]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:37.064]             base::names(...future.oldOptions))
[15:32:37.064]     }
[15:32:37.064]     if (FALSE) {
[15:32:37.064]     }
[15:32:37.064]     else {
[15:32:37.064]         if (TRUE) {
[15:32:37.064]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:37.064]                 open = "w")
[15:32:37.064]         }
[15:32:37.064]         else {
[15:32:37.064]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:37.064]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:37.064]         }
[15:32:37.064]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:37.064]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:37.064]             base::sink(type = "output", split = FALSE)
[15:32:37.064]             base::close(...future.stdout)
[15:32:37.064]         }, add = TRUE)
[15:32:37.064]     }
[15:32:37.064]     ...future.frame <- base::sys.nframe()
[15:32:37.064]     ...future.conditions <- base::list()
[15:32:37.064]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:37.064]     if (FALSE) {
[15:32:37.064]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:37.064]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:37.064]     }
[15:32:37.064]     ...future.result <- base::tryCatch({
[15:32:37.064]         base::withCallingHandlers({
[15:32:37.064]             ...future.value <- base::withVisible(base::local({
[15:32:37.064]                 ...future.makeSendCondition <- base::local({
[15:32:37.064]                   sendCondition <- NULL
[15:32:37.064]                   function(frame = 1L) {
[15:32:37.064]                     if (is.function(sendCondition)) 
[15:32:37.064]                       return(sendCondition)
[15:32:37.064]                     ns <- getNamespace("parallel")
[15:32:37.064]                     if (exists("sendData", mode = "function", 
[15:32:37.064]                       envir = ns)) {
[15:32:37.064]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:37.064]                         envir = ns)
[15:32:37.064]                       envir <- sys.frame(frame)
[15:32:37.064]                       master <- NULL
[15:32:37.064]                       while (!identical(envir, .GlobalEnv) && 
[15:32:37.064]                         !identical(envir, emptyenv())) {
[15:32:37.064]                         if (exists("master", mode = "list", envir = envir, 
[15:32:37.064]                           inherits = FALSE)) {
[15:32:37.064]                           master <- get("master", mode = "list", 
[15:32:37.064]                             envir = envir, inherits = FALSE)
[15:32:37.064]                           if (inherits(master, c("SOCKnode", 
[15:32:37.064]                             "SOCK0node"))) {
[15:32:37.064]                             sendCondition <<- function(cond) {
[15:32:37.064]                               data <- list(type = "VALUE", value = cond, 
[15:32:37.064]                                 success = TRUE)
[15:32:37.064]                               parallel_sendData(master, data)
[15:32:37.064]                             }
[15:32:37.064]                             return(sendCondition)
[15:32:37.064]                           }
[15:32:37.064]                         }
[15:32:37.064]                         frame <- frame + 1L
[15:32:37.064]                         envir <- sys.frame(frame)
[15:32:37.064]                       }
[15:32:37.064]                     }
[15:32:37.064]                     sendCondition <<- function(cond) NULL
[15:32:37.064]                   }
[15:32:37.064]                 })
[15:32:37.064]                 withCallingHandlers({
[15:32:37.064]                   {
[15:32:37.064]                     do.call(function(...) {
[15:32:37.064]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:37.064]                       if (!identical(...future.globals.maxSize.org, 
[15:32:37.064]                         ...future.globals.maxSize)) {
[15:32:37.064]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:37.064]                         on.exit(options(oopts), add = TRUE)
[15:32:37.064]                       }
[15:32:37.064]                       {
[15:32:37.064]                         lapply(seq_along(...future.elements_ii), 
[15:32:37.064]                           FUN = function(jj) {
[15:32:37.064]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:37.064]                             ...future.FUN(...future.X_jj, ...)
[15:32:37.064]                           })
[15:32:37.064]                       }
[15:32:37.064]                     }, args = future.call.arguments)
[15:32:37.064]                   }
[15:32:37.064]                 }, immediateCondition = function(cond) {
[15:32:37.064]                   sendCondition <- ...future.makeSendCondition()
[15:32:37.064]                   sendCondition(cond)
[15:32:37.064]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:37.064]                   {
[15:32:37.064]                     inherits <- base::inherits
[15:32:37.064]                     invokeRestart <- base::invokeRestart
[15:32:37.064]                     is.null <- base::is.null
[15:32:37.064]                     muffled <- FALSE
[15:32:37.064]                     if (inherits(cond, "message")) {
[15:32:37.064]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:37.064]                       if (muffled) 
[15:32:37.064]                         invokeRestart("muffleMessage")
[15:32:37.064]                     }
[15:32:37.064]                     else if (inherits(cond, "warning")) {
[15:32:37.064]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:37.064]                       if (muffled) 
[15:32:37.064]                         invokeRestart("muffleWarning")
[15:32:37.064]                     }
[15:32:37.064]                     else if (inherits(cond, "condition")) {
[15:32:37.064]                       if (!is.null(pattern)) {
[15:32:37.064]                         computeRestarts <- base::computeRestarts
[15:32:37.064]                         grepl <- base::grepl
[15:32:37.064]                         restarts <- computeRestarts(cond)
[15:32:37.064]                         for (restart in restarts) {
[15:32:37.064]                           name <- restart$name
[15:32:37.064]                           if (is.null(name)) 
[15:32:37.064]                             next
[15:32:37.064]                           if (!grepl(pattern, name)) 
[15:32:37.064]                             next
[15:32:37.064]                           invokeRestart(restart)
[15:32:37.064]                           muffled <- TRUE
[15:32:37.064]                           break
[15:32:37.064]                         }
[15:32:37.064]                       }
[15:32:37.064]                     }
[15:32:37.064]                     invisible(muffled)
[15:32:37.064]                   }
[15:32:37.064]                   muffleCondition(cond)
[15:32:37.064]                 })
[15:32:37.064]             }))
[15:32:37.064]             future::FutureResult(value = ...future.value$value, 
[15:32:37.064]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:37.064]                   ...future.rng), globalenv = if (FALSE) 
[15:32:37.064]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:37.064]                     ...future.globalenv.names))
[15:32:37.064]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:37.064]         }, condition = base::local({
[15:32:37.064]             c <- base::c
[15:32:37.064]             inherits <- base::inherits
[15:32:37.064]             invokeRestart <- base::invokeRestart
[15:32:37.064]             length <- base::length
[15:32:37.064]             list <- base::list
[15:32:37.064]             seq.int <- base::seq.int
[15:32:37.064]             signalCondition <- base::signalCondition
[15:32:37.064]             sys.calls <- base::sys.calls
[15:32:37.064]             `[[` <- base::`[[`
[15:32:37.064]             `+` <- base::`+`
[15:32:37.064]             `<<-` <- base::`<<-`
[15:32:37.064]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:37.064]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:37.064]                   3L)]
[15:32:37.064]             }
[15:32:37.064]             function(cond) {
[15:32:37.064]                 is_error <- inherits(cond, "error")
[15:32:37.064]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:37.064]                   NULL)
[15:32:37.064]                 if (is_error) {
[15:32:37.064]                   sessionInformation <- function() {
[15:32:37.064]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:37.064]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:37.064]                       search = base::search(), system = base::Sys.info())
[15:32:37.064]                   }
[15:32:37.064]                   ...future.conditions[[length(...future.conditions) + 
[15:32:37.064]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:37.064]                     cond$call), session = sessionInformation(), 
[15:32:37.064]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:37.064]                   signalCondition(cond)
[15:32:37.064]                 }
[15:32:37.064]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:37.064]                 "immediateCondition"))) {
[15:32:37.064]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:37.064]                   ...future.conditions[[length(...future.conditions) + 
[15:32:37.064]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:37.064]                   if (TRUE && !signal) {
[15:32:37.064]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:37.064]                     {
[15:32:37.064]                       inherits <- base::inherits
[15:32:37.064]                       invokeRestart <- base::invokeRestart
[15:32:37.064]                       is.null <- base::is.null
[15:32:37.064]                       muffled <- FALSE
[15:32:37.064]                       if (inherits(cond, "message")) {
[15:32:37.064]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:37.064]                         if (muffled) 
[15:32:37.064]                           invokeRestart("muffleMessage")
[15:32:37.064]                       }
[15:32:37.064]                       else if (inherits(cond, "warning")) {
[15:32:37.064]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:37.064]                         if (muffled) 
[15:32:37.064]                           invokeRestart("muffleWarning")
[15:32:37.064]                       }
[15:32:37.064]                       else if (inherits(cond, "condition")) {
[15:32:37.064]                         if (!is.null(pattern)) {
[15:32:37.064]                           computeRestarts <- base::computeRestarts
[15:32:37.064]                           grepl <- base::grepl
[15:32:37.064]                           restarts <- computeRestarts(cond)
[15:32:37.064]                           for (restart in restarts) {
[15:32:37.064]                             name <- restart$name
[15:32:37.064]                             if (is.null(name)) 
[15:32:37.064]                               next
[15:32:37.064]                             if (!grepl(pattern, name)) 
[15:32:37.064]                               next
[15:32:37.064]                             invokeRestart(restart)
[15:32:37.064]                             muffled <- TRUE
[15:32:37.064]                             break
[15:32:37.064]                           }
[15:32:37.064]                         }
[15:32:37.064]                       }
[15:32:37.064]                       invisible(muffled)
[15:32:37.064]                     }
[15:32:37.064]                     muffleCondition(cond, pattern = "^muffle")
[15:32:37.064]                   }
[15:32:37.064]                 }
[15:32:37.064]                 else {
[15:32:37.064]                   if (TRUE) {
[15:32:37.064]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:37.064]                     {
[15:32:37.064]                       inherits <- base::inherits
[15:32:37.064]                       invokeRestart <- base::invokeRestart
[15:32:37.064]                       is.null <- base::is.null
[15:32:37.064]                       muffled <- FALSE
[15:32:37.064]                       if (inherits(cond, "message")) {
[15:32:37.064]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:37.064]                         if (muffled) 
[15:32:37.064]                           invokeRestart("muffleMessage")
[15:32:37.064]                       }
[15:32:37.064]                       else if (inherits(cond, "warning")) {
[15:32:37.064]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:37.064]                         if (muffled) 
[15:32:37.064]                           invokeRestart("muffleWarning")
[15:32:37.064]                       }
[15:32:37.064]                       else if (inherits(cond, "condition")) {
[15:32:37.064]                         if (!is.null(pattern)) {
[15:32:37.064]                           computeRestarts <- base::computeRestarts
[15:32:37.064]                           grepl <- base::grepl
[15:32:37.064]                           restarts <- computeRestarts(cond)
[15:32:37.064]                           for (restart in restarts) {
[15:32:37.064]                             name <- restart$name
[15:32:37.064]                             if (is.null(name)) 
[15:32:37.064]                               next
[15:32:37.064]                             if (!grepl(pattern, name)) 
[15:32:37.064]                               next
[15:32:37.064]                             invokeRestart(restart)
[15:32:37.064]                             muffled <- TRUE
[15:32:37.064]                             break
[15:32:37.064]                           }
[15:32:37.064]                         }
[15:32:37.064]                       }
[15:32:37.064]                       invisible(muffled)
[15:32:37.064]                     }
[15:32:37.064]                     muffleCondition(cond, pattern = "^muffle")
[15:32:37.064]                   }
[15:32:37.064]                 }
[15:32:37.064]             }
[15:32:37.064]         }))
[15:32:37.064]     }, error = function(ex) {
[15:32:37.064]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:37.064]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:37.064]                 ...future.rng), started = ...future.startTime, 
[15:32:37.064]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:37.064]             version = "1.8"), class = "FutureResult")
[15:32:37.064]     }, finally = {
[15:32:37.064]         if (!identical(...future.workdir, getwd())) 
[15:32:37.064]             setwd(...future.workdir)
[15:32:37.064]         {
[15:32:37.064]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:37.064]                 ...future.oldOptions$nwarnings <- NULL
[15:32:37.064]             }
[15:32:37.064]             base::options(...future.oldOptions)
[15:32:37.064]             if (.Platform$OS.type == "windows") {
[15:32:37.064]                 old_names <- names(...future.oldEnvVars)
[15:32:37.064]                 envs <- base::Sys.getenv()
[15:32:37.064]                 names <- names(envs)
[15:32:37.064]                 common <- intersect(names, old_names)
[15:32:37.064]                 added <- setdiff(names, old_names)
[15:32:37.064]                 removed <- setdiff(old_names, names)
[15:32:37.064]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:37.064]                   envs[common]]
[15:32:37.064]                 NAMES <- toupper(changed)
[15:32:37.064]                 args <- list()
[15:32:37.064]                 for (kk in seq_along(NAMES)) {
[15:32:37.064]                   name <- changed[[kk]]
[15:32:37.064]                   NAME <- NAMES[[kk]]
[15:32:37.064]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:37.064]                     next
[15:32:37.064]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:37.064]                 }
[15:32:37.064]                 NAMES <- toupper(added)
[15:32:37.064]                 for (kk in seq_along(NAMES)) {
[15:32:37.064]                   name <- added[[kk]]
[15:32:37.064]                   NAME <- NAMES[[kk]]
[15:32:37.064]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:37.064]                     next
[15:32:37.064]                   args[[name]] <- ""
[15:32:37.064]                 }
[15:32:37.064]                 NAMES <- toupper(removed)
[15:32:37.064]                 for (kk in seq_along(NAMES)) {
[15:32:37.064]                   name <- removed[[kk]]
[15:32:37.064]                   NAME <- NAMES[[kk]]
[15:32:37.064]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:37.064]                     next
[15:32:37.064]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:37.064]                 }
[15:32:37.064]                 if (length(args) > 0) 
[15:32:37.064]                   base::do.call(base::Sys.setenv, args = args)
[15:32:37.064]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:37.064]             }
[15:32:37.064]             else {
[15:32:37.064]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:37.064]             }
[15:32:37.064]             {
[15:32:37.064]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:37.064]                   0L) {
[15:32:37.064]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:37.064]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:37.064]                   base::options(opts)
[15:32:37.064]                 }
[15:32:37.064]                 {
[15:32:37.064]                   {
[15:32:37.064]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:37.064]                     NULL
[15:32:37.064]                   }
[15:32:37.064]                   options(future.plan = NULL)
[15:32:37.064]                   if (is.na(NA_character_)) 
[15:32:37.064]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:37.064]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:37.064]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:37.064]                     .init = FALSE)
[15:32:37.064]                 }
[15:32:37.064]             }
[15:32:37.064]         }
[15:32:37.064]     })
[15:32:37.064]     if (TRUE) {
[15:32:37.064]         base::sink(type = "output", split = FALSE)
[15:32:37.064]         if (TRUE) {
[15:32:37.064]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:37.064]         }
[15:32:37.064]         else {
[15:32:37.064]             ...future.result["stdout"] <- base::list(NULL)
[15:32:37.064]         }
[15:32:37.064]         base::close(...future.stdout)
[15:32:37.064]         ...future.stdout <- NULL
[15:32:37.064]     }
[15:32:37.064]     ...future.result$conditions <- ...future.conditions
[15:32:37.064]     ...future.result$finished <- base::Sys.time()
[15:32:37.064]     ...future.result
[15:32:37.064] }
[15:32:37.073] Exporting 5 global objects (1.22 KiB) to cluster node #1 ...
[15:32:37.073] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ...
[15:32:37.074] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ... DONE
[15:32:37.074] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:37.075] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:37.075] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:37.076] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:37.076] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:37.077] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:37.077] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:37.078] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:37.078] Exporting 5 global objects (1.22 KiB) to cluster node #1 ... DONE
[15:32:37.079] MultisessionFuture started
[15:32:37.079] - Launch lazy future ... done
[15:32:37.079] run() for 'MultisessionFuture' ... done
[15:32:37.079] Created future:
[15:32:37.107] receiveMessageFromWorker() for ClusterFuture ...
[15:32:37.108] - Validating connection of MultisessionFuture
[15:32:37.109] - received message: FutureResult
[15:32:37.109] - Received FutureResult
[15:32:37.109] - Erased future from FutureRegistry
[15:32:37.110] result() for ClusterFuture ...
[15:32:37.110] - result already collected: FutureResult
[15:32:37.110] result() for ClusterFuture ... done
[15:32:37.110] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:37.079] MultisessionFuture:
[15:32:37.079] Label: 'future_sapply-1'
[15:32:37.079] Expression:
[15:32:37.079] {
[15:32:37.079]     do.call(function(...) {
[15:32:37.079]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:37.079]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:37.079]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:37.079]             on.exit(options(oopts), add = TRUE)
[15:32:37.079]         }
[15:32:37.079]         {
[15:32:37.079]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:37.079]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:37.079]                 ...future.FUN(...future.X_jj, ...)
[15:32:37.079]             })
[15:32:37.079]         }
[15:32:37.079]     }, args = future.call.arguments)
[15:32:37.079] }
[15:32:37.079] Lazy evaluation: FALSE
[15:32:37.079] Asynchronous evaluation: TRUE
[15:32:37.079] Local evaluation: TRUE
[15:32:37.079] Environment: R_GlobalEnv
[15:32:37.079] Capture standard output: TRUE
[15:32:37.079] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:37.079] Globals: 5 objects totaling 1.33 KiB (function '...future.FUN' of 1.22 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)
[15:32:37.079] Packages: <none>
[15:32:37.079] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:37.079] Resolved: TRUE
[15:32:37.079] Value: <not collected>
[15:32:37.079] Conditions captured: <none>
[15:32:37.079] Early signaling: FALSE
[15:32:37.079] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:37.079] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:37.111] Chunk #1 of 2 ... DONE
[15:32:37.112] Chunk #2 of 2 ...
[15:32:37.112]  - Finding globals in 'X' for chunk #2 ...
[15:32:37.112] getGlobalsAndPackages() ...
[15:32:37.112] Searching for globals...
[15:32:37.113] 
[15:32:37.113] Searching for globals ... DONE
[15:32:37.114] - globals: [0] <none>
[15:32:37.114] getGlobalsAndPackages() ... DONE
[15:32:37.114]    + additional globals found: [n=0] 
[15:32:37.114]    + additional namespaces needed: [n=0] 
[15:32:37.115]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:37.115]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:37.115]  - seeds: <none>
[15:32:37.115]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:37.116] getGlobalsAndPackages() ...
[15:32:37.116] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:37.116] Resolving globals: FALSE
[15:32:37.117] Tweak future expression to call with '...' arguments ...
[15:32:37.117] {
[15:32:37.117]     do.call(function(...) {
[15:32:37.117]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:37.117]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:37.117]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:37.117]             on.exit(options(oopts), add = TRUE)
[15:32:37.117]         }
[15:32:37.117]         {
[15:32:37.117]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:37.117]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:37.117]                 ...future.FUN(...future.X_jj, ...)
[15:32:37.117]             })
[15:32:37.117]         }
[15:32:37.117]     }, args = future.call.arguments)
[15:32:37.117] }
[15:32:37.118] Tweak future expression to call with '...' arguments ... DONE
[15:32:37.119] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:37.119] 
[15:32:37.119] getGlobalsAndPackages() ... DONE
[15:32:37.120] run() for 'Future' ...
[15:32:37.120] - state: 'created'
[15:32:37.121] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:37.161] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:37.161] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:37.161]   - Field: 'node'
[15:32:37.162]   - Field: 'label'
[15:32:37.162]   - Field: 'local'
[15:32:37.163]   - Field: 'owner'
[15:32:37.163]   - Field: 'envir'
[15:32:37.163]   - Field: 'workers'
[15:32:37.164]   - Field: 'packages'
[15:32:37.164]   - Field: 'gc'
[15:32:37.164]   - Field: 'conditions'
[15:32:37.165]   - Field: 'persistent'
[15:32:37.165]   - Field: 'expr'
[15:32:37.165]   - Field: 'uuid'
[15:32:37.166]   - Field: 'seed'
[15:32:37.166]   - Field: 'version'
[15:32:37.166]   - Field: 'result'
[15:32:37.166]   - Field: 'asynchronous'
[15:32:37.167]   - Field: 'calls'
[15:32:37.167]   - Field: 'globals'
[15:32:37.167]   - Field: 'stdout'
[15:32:37.168]   - Field: 'earlySignal'
[15:32:37.168]   - Field: 'lazy'
[15:32:37.168]   - Field: 'state'
[15:32:37.169] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:37.169] - Launch lazy future ...
[15:32:37.170] Packages needed by the future expression (n = 0): <none>
[15:32:37.170] Packages needed by future strategies (n = 0): <none>
[15:32:37.171] {
[15:32:37.171]     {
[15:32:37.171]         {
[15:32:37.171]             ...future.startTime <- base::Sys.time()
[15:32:37.171]             {
[15:32:37.171]                 {
[15:32:37.171]                   {
[15:32:37.171]                     {
[15:32:37.171]                       base::local({
[15:32:37.171]                         has_future <- base::requireNamespace("future", 
[15:32:37.171]                           quietly = TRUE)
[15:32:37.171]                         if (has_future) {
[15:32:37.171]                           ns <- base::getNamespace("future")
[15:32:37.171]                           version <- ns[[".package"]][["version"]]
[15:32:37.171]                           if (is.null(version)) 
[15:32:37.171]                             version <- utils::packageVersion("future")
[15:32:37.171]                         }
[15:32:37.171]                         else {
[15:32:37.171]                           version <- NULL
[15:32:37.171]                         }
[15:32:37.171]                         if (!has_future || version < "1.8.0") {
[15:32:37.171]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:37.171]                             "", base::R.version$version.string), 
[15:32:37.171]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:37.171]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:37.171]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:37.171]                               "release", "version")], collapse = " "), 
[15:32:37.171]                             hostname = base::Sys.info()[["nodename"]])
[15:32:37.171]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:37.171]                             info)
[15:32:37.171]                           info <- base::paste(info, collapse = "; ")
[15:32:37.171]                           if (!has_future) {
[15:32:37.171]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:37.171]                               info)
[15:32:37.171]                           }
[15:32:37.171]                           else {
[15:32:37.171]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:37.171]                               info, version)
[15:32:37.171]                           }
[15:32:37.171]                           base::stop(msg)
[15:32:37.171]                         }
[15:32:37.171]                       })
[15:32:37.171]                     }
[15:32:37.171]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:37.171]                     base::options(mc.cores = 1L)
[15:32:37.171]                   }
[15:32:37.171]                   ...future.strategy.old <- future::plan("list")
[15:32:37.171]                   options(future.plan = NULL)
[15:32:37.171]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:37.171]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:37.171]                 }
[15:32:37.171]                 ...future.workdir <- getwd()
[15:32:37.171]             }
[15:32:37.171]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:37.171]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:37.171]         }
[15:32:37.171]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:37.171]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:37.171]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:37.171]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:37.171]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:37.171]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:37.171]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:37.171]             base::names(...future.oldOptions))
[15:32:37.171]     }
[15:32:37.171]     if (FALSE) {
[15:32:37.171]     }
[15:32:37.171]     else {
[15:32:37.171]         if (TRUE) {
[15:32:37.171]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:37.171]                 open = "w")
[15:32:37.171]         }
[15:32:37.171]         else {
[15:32:37.171]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:37.171]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:37.171]         }
[15:32:37.171]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:37.171]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:37.171]             base::sink(type = "output", split = FALSE)
[15:32:37.171]             base::close(...future.stdout)
[15:32:37.171]         }, add = TRUE)
[15:32:37.171]     }
[15:32:37.171]     ...future.frame <- base::sys.nframe()
[15:32:37.171]     ...future.conditions <- base::list()
[15:32:37.171]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:37.171]     if (FALSE) {
[15:32:37.171]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:37.171]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:37.171]     }
[15:32:37.171]     ...future.result <- base::tryCatch({
[15:32:37.171]         base::withCallingHandlers({
[15:32:37.171]             ...future.value <- base::withVisible(base::local({
[15:32:37.171]                 ...future.makeSendCondition <- base::local({
[15:32:37.171]                   sendCondition <- NULL
[15:32:37.171]                   function(frame = 1L) {
[15:32:37.171]                     if (is.function(sendCondition)) 
[15:32:37.171]                       return(sendCondition)
[15:32:37.171]                     ns <- getNamespace("parallel")
[15:32:37.171]                     if (exists("sendData", mode = "function", 
[15:32:37.171]                       envir = ns)) {
[15:32:37.171]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:37.171]                         envir = ns)
[15:32:37.171]                       envir <- sys.frame(frame)
[15:32:37.171]                       master <- NULL
[15:32:37.171]                       while (!identical(envir, .GlobalEnv) && 
[15:32:37.171]                         !identical(envir, emptyenv())) {
[15:32:37.171]                         if (exists("master", mode = "list", envir = envir, 
[15:32:37.171]                           inherits = FALSE)) {
[15:32:37.171]                           master <- get("master", mode = "list", 
[15:32:37.171]                             envir = envir, inherits = FALSE)
[15:32:37.171]                           if (inherits(master, c("SOCKnode", 
[15:32:37.171]                             "SOCK0node"))) {
[15:32:37.171]                             sendCondition <<- function(cond) {
[15:32:37.171]                               data <- list(type = "VALUE", value = cond, 
[15:32:37.171]                                 success = TRUE)
[15:32:37.171]                               parallel_sendData(master, data)
[15:32:37.171]                             }
[15:32:37.171]                             return(sendCondition)
[15:32:37.171]                           }
[15:32:37.171]                         }
[15:32:37.171]                         frame <- frame + 1L
[15:32:37.171]                         envir <- sys.frame(frame)
[15:32:37.171]                       }
[15:32:37.171]                     }
[15:32:37.171]                     sendCondition <<- function(cond) NULL
[15:32:37.171]                   }
[15:32:37.171]                 })
[15:32:37.171]                 withCallingHandlers({
[15:32:37.171]                   {
[15:32:37.171]                     do.call(function(...) {
[15:32:37.171]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:37.171]                       if (!identical(...future.globals.maxSize.org, 
[15:32:37.171]                         ...future.globals.maxSize)) {
[15:32:37.171]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:37.171]                         on.exit(options(oopts), add = TRUE)
[15:32:37.171]                       }
[15:32:37.171]                       {
[15:32:37.171]                         lapply(seq_along(...future.elements_ii), 
[15:32:37.171]                           FUN = function(jj) {
[15:32:37.171]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:37.171]                             ...future.FUN(...future.X_jj, ...)
[15:32:37.171]                           })
[15:32:37.171]                       }
[15:32:37.171]                     }, args = future.call.arguments)
[15:32:37.171]                   }
[15:32:37.171]                 }, immediateCondition = function(cond) {
[15:32:37.171]                   sendCondition <- ...future.makeSendCondition()
[15:32:37.171]                   sendCondition(cond)
[15:32:37.171]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:37.171]                   {
[15:32:37.171]                     inherits <- base::inherits
[15:32:37.171]                     invokeRestart <- base::invokeRestart
[15:32:37.171]                     is.null <- base::is.null
[15:32:37.171]                     muffled <- FALSE
[15:32:37.171]                     if (inherits(cond, "message")) {
[15:32:37.171]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:37.171]                       if (muffled) 
[15:32:37.171]                         invokeRestart("muffleMessage")
[15:32:37.171]                     }
[15:32:37.171]                     else if (inherits(cond, "warning")) {
[15:32:37.171]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:37.171]                       if (muffled) 
[15:32:37.171]                         invokeRestart("muffleWarning")
[15:32:37.171]                     }
[15:32:37.171]                     else if (inherits(cond, "condition")) {
[15:32:37.171]                       if (!is.null(pattern)) {
[15:32:37.171]                         computeRestarts <- base::computeRestarts
[15:32:37.171]                         grepl <- base::grepl
[15:32:37.171]                         restarts <- computeRestarts(cond)
[15:32:37.171]                         for (restart in restarts) {
[15:32:37.171]                           name <- restart$name
[15:32:37.171]                           if (is.null(name)) 
[15:32:37.171]                             next
[15:32:37.171]                           if (!grepl(pattern, name)) 
[15:32:37.171]                             next
[15:32:37.171]                           invokeRestart(restart)
[15:32:37.171]                           muffled <- TRUE
[15:32:37.171]                           break
[15:32:37.171]                         }
[15:32:37.171]                       }
[15:32:37.171]                     }
[15:32:37.171]                     invisible(muffled)
[15:32:37.171]                   }
[15:32:37.171]                   muffleCondition(cond)
[15:32:37.171]                 })
[15:32:37.171]             }))
[15:32:37.171]             future::FutureResult(value = ...future.value$value, 
[15:32:37.171]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:37.171]                   ...future.rng), globalenv = if (FALSE) 
[15:32:37.171]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:37.171]                     ...future.globalenv.names))
[15:32:37.171]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:37.171]         }, condition = base::local({
[15:32:37.171]             c <- base::c
[15:32:37.171]             inherits <- base::inherits
[15:32:37.171]             invokeRestart <- base::invokeRestart
[15:32:37.171]             length <- base::length
[15:32:37.171]             list <- base::list
[15:32:37.171]             seq.int <- base::seq.int
[15:32:37.171]             signalCondition <- base::signalCondition
[15:32:37.171]             sys.calls <- base::sys.calls
[15:32:37.171]             `[[` <- base::`[[`
[15:32:37.171]             `+` <- base::`+`
[15:32:37.171]             `<<-` <- base::`<<-`
[15:32:37.171]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:37.171]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:37.171]                   3L)]
[15:32:37.171]             }
[15:32:37.171]             function(cond) {
[15:32:37.171]                 is_error <- inherits(cond, "error")
[15:32:37.171]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:37.171]                   NULL)
[15:32:37.171]                 if (is_error) {
[15:32:37.171]                   sessionInformation <- function() {
[15:32:37.171]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:37.171]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:37.171]                       search = base::search(), system = base::Sys.info())
[15:32:37.171]                   }
[15:32:37.171]                   ...future.conditions[[length(...future.conditions) + 
[15:32:37.171]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:37.171]                     cond$call), session = sessionInformation(), 
[15:32:37.171]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:37.171]                   signalCondition(cond)
[15:32:37.171]                 }
[15:32:37.171]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:37.171]                 "immediateCondition"))) {
[15:32:37.171]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:37.171]                   ...future.conditions[[length(...future.conditions) + 
[15:32:37.171]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:37.171]                   if (TRUE && !signal) {
[15:32:37.171]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:37.171]                     {
[15:32:37.171]                       inherits <- base::inherits
[15:32:37.171]                       invokeRestart <- base::invokeRestart
[15:32:37.171]                       is.null <- base::is.null
[15:32:37.171]                       muffled <- FALSE
[15:32:37.171]                       if (inherits(cond, "message")) {
[15:32:37.171]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:37.171]                         if (muffled) 
[15:32:37.171]                           invokeRestart("muffleMessage")
[15:32:37.171]                       }
[15:32:37.171]                       else if (inherits(cond, "warning")) {
[15:32:37.171]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:37.171]                         if (muffled) 
[15:32:37.171]                           invokeRestart("muffleWarning")
[15:32:37.171]                       }
[15:32:37.171]                       else if (inherits(cond, "condition")) {
[15:32:37.171]                         if (!is.null(pattern)) {
[15:32:37.171]                           computeRestarts <- base::computeRestarts
[15:32:37.171]                           grepl <- base::grepl
[15:32:37.171]                           restarts <- computeRestarts(cond)
[15:32:37.171]                           for (restart in restarts) {
[15:32:37.171]                             name <- restart$name
[15:32:37.171]                             if (is.null(name)) 
[15:32:37.171]                               next
[15:32:37.171]                             if (!grepl(pattern, name)) 
[15:32:37.171]                               next
[15:32:37.171]                             invokeRestart(restart)
[15:32:37.171]                             muffled <- TRUE
[15:32:37.171]                             break
[15:32:37.171]                           }
[15:32:37.171]                         }
[15:32:37.171]                       }
[15:32:37.171]                       invisible(muffled)
[15:32:37.171]                     }
[15:32:37.171]                     muffleCondition(cond, pattern = "^muffle")
[15:32:37.171]                   }
[15:32:37.171]                 }
[15:32:37.171]                 else {
[15:32:37.171]                   if (TRUE) {
[15:32:37.171]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:37.171]                     {
[15:32:37.171]                       inherits <- base::inherits
[15:32:37.171]                       invokeRestart <- base::invokeRestart
[15:32:37.171]                       is.null <- base::is.null
[15:32:37.171]                       muffled <- FALSE
[15:32:37.171]                       if (inherits(cond, "message")) {
[15:32:37.171]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:37.171]                         if (muffled) 
[15:32:37.171]                           invokeRestart("muffleMessage")
[15:32:37.171]                       }
[15:32:37.171]                       else if (inherits(cond, "warning")) {
[15:32:37.171]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:37.171]                         if (muffled) 
[15:32:37.171]                           invokeRestart("muffleWarning")
[15:32:37.171]                       }
[15:32:37.171]                       else if (inherits(cond, "condition")) {
[15:32:37.171]                         if (!is.null(pattern)) {
[15:32:37.171]                           computeRestarts <- base::computeRestarts
[15:32:37.171]                           grepl <- base::grepl
[15:32:37.171]                           restarts <- computeRestarts(cond)
[15:32:37.171]                           for (restart in restarts) {
[15:32:37.171]                             name <- restart$name
[15:32:37.171]                             if (is.null(name)) 
[15:32:37.171]                               next
[15:32:37.171]                             if (!grepl(pattern, name)) 
[15:32:37.171]                               next
[15:32:37.171]                             invokeRestart(restart)
[15:32:37.171]                             muffled <- TRUE
[15:32:37.171]                             break
[15:32:37.171]                           }
[15:32:37.171]                         }
[15:32:37.171]                       }
[15:32:37.171]                       invisible(muffled)
[15:32:37.171]                     }
[15:32:37.171]                     muffleCondition(cond, pattern = "^muffle")
[15:32:37.171]                   }
[15:32:37.171]                 }
[15:32:37.171]             }
[15:32:37.171]         }))
[15:32:37.171]     }, error = function(ex) {
[15:32:37.171]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:37.171]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:37.171]                 ...future.rng), started = ...future.startTime, 
[15:32:37.171]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:37.171]             version = "1.8"), class = "FutureResult")
[15:32:37.171]     }, finally = {
[15:32:37.171]         if (!identical(...future.workdir, getwd())) 
[15:32:37.171]             setwd(...future.workdir)
[15:32:37.171]         {
[15:32:37.171]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:37.171]                 ...future.oldOptions$nwarnings <- NULL
[15:32:37.171]             }
[15:32:37.171]             base::options(...future.oldOptions)
[15:32:37.171]             if (.Platform$OS.type == "windows") {
[15:32:37.171]                 old_names <- names(...future.oldEnvVars)
[15:32:37.171]                 envs <- base::Sys.getenv()
[15:32:37.171]                 names <- names(envs)
[15:32:37.171]                 common <- intersect(names, old_names)
[15:32:37.171]                 added <- setdiff(names, old_names)
[15:32:37.171]                 removed <- setdiff(old_names, names)
[15:32:37.171]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:37.171]                   envs[common]]
[15:32:37.171]                 NAMES <- toupper(changed)
[15:32:37.171]                 args <- list()
[15:32:37.171]                 for (kk in seq_along(NAMES)) {
[15:32:37.171]                   name <- changed[[kk]]
[15:32:37.171]                   NAME <- NAMES[[kk]]
[15:32:37.171]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:37.171]                     next
[15:32:37.171]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:37.171]                 }
[15:32:37.171]                 NAMES <- toupper(added)
[15:32:37.171]                 for (kk in seq_along(NAMES)) {
[15:32:37.171]                   name <- added[[kk]]
[15:32:37.171]                   NAME <- NAMES[[kk]]
[15:32:37.171]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:37.171]                     next
[15:32:37.171]                   args[[name]] <- ""
[15:32:37.171]                 }
[15:32:37.171]                 NAMES <- toupper(removed)
[15:32:37.171]                 for (kk in seq_along(NAMES)) {
[15:32:37.171]                   name <- removed[[kk]]
[15:32:37.171]                   NAME <- NAMES[[kk]]
[15:32:37.171]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:37.171]                     next
[15:32:37.171]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:37.171]                 }
[15:32:37.171]                 if (length(args) > 0) 
[15:32:37.171]                   base::do.call(base::Sys.setenv, args = args)
[15:32:37.171]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:37.171]             }
[15:32:37.171]             else {
[15:32:37.171]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:37.171]             }
[15:32:37.171]             {
[15:32:37.171]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:37.171]                   0L) {
[15:32:37.171]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:37.171]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:37.171]                   base::options(opts)
[15:32:37.171]                 }
[15:32:37.171]                 {
[15:32:37.171]                   {
[15:32:37.171]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:37.171]                     NULL
[15:32:37.171]                   }
[15:32:37.171]                   options(future.plan = NULL)
[15:32:37.171]                   if (is.na(NA_character_)) 
[15:32:37.171]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:37.171]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:37.171]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:37.171]                     .init = FALSE)
[15:32:37.171]                 }
[15:32:37.171]             }
[15:32:37.171]         }
[15:32:37.171]     })
[15:32:37.171]     if (TRUE) {
[15:32:37.171]         base::sink(type = "output", split = FALSE)
[15:32:37.171]         if (TRUE) {
[15:32:37.171]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:37.171]         }
[15:32:37.171]         else {
[15:32:37.171]             ...future.result["stdout"] <- base::list(NULL)
[15:32:37.171]         }
[15:32:37.171]         base::close(...future.stdout)
[15:32:37.171]         ...future.stdout <- NULL
[15:32:37.171]     }
[15:32:37.171]     ...future.result$conditions <- ...future.conditions
[15:32:37.171]     ...future.result$finished <- base::Sys.time()
[15:32:37.171]     ...future.result
[15:32:37.171] }
[15:32:37.181] Exporting 5 global objects (1.22 KiB) to cluster node #1 ...
[15:32:37.181] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ...
[15:32:37.182] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ... DONE
[15:32:37.183] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:37.183] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:37.184] Exporting '...future.elements_ii' (224 bytes) to cluster node #1 ...
[15:32:37.184] Exporting '...future.elements_ii' (224 bytes) to cluster node #1 ... DONE
[15:32:37.185] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:37.185] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:37.186] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:37.186] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:37.187] Exporting 5 global objects (1.22 KiB) to cluster node #1 ... DONE
[15:32:37.188] MultisessionFuture started
[15:32:37.188] - Launch lazy future ... done
[15:32:37.188] run() for 'MultisessionFuture' ... done
[15:32:37.189] Created future:
[15:32:37.214] receiveMessageFromWorker() for ClusterFuture ...
[15:32:37.214] - Validating connection of MultisessionFuture
[15:32:37.215] - received message: FutureResult
[15:32:37.215] - Received FutureResult
[15:32:37.215] - Erased future from FutureRegistry
[15:32:37.215] result() for ClusterFuture ...
[15:32:37.215] - result already collected: FutureResult
[15:32:37.216] result() for ClusterFuture ... done
[15:32:37.216] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:37.189] MultisessionFuture:
[15:32:37.189] Label: 'future_sapply-2'
[15:32:37.189] Expression:
[15:32:37.189] {
[15:32:37.189]     do.call(function(...) {
[15:32:37.189]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:37.189]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:37.189]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:37.189]             on.exit(options(oopts), add = TRUE)
[15:32:37.189]         }
[15:32:37.189]         {
[15:32:37.189]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:37.189]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:37.189]                 ...future.FUN(...future.X_jj, ...)
[15:32:37.189]             })
[15:32:37.189]         }
[15:32:37.189]     }, args = future.call.arguments)
[15:32:37.189] }
[15:32:37.189] Lazy evaluation: FALSE
[15:32:37.189] Asynchronous evaluation: TRUE
[15:32:37.189] Local evaluation: TRUE
[15:32:37.189] Environment: R_GlobalEnv
[15:32:37.189] Capture standard output: TRUE
[15:32:37.189] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:37.189] Globals: 5 objects totaling 1.44 KiB (function '...future.FUN' of 1.22 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 224 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:37.189] Packages: <none>
[15:32:37.189] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:37.189] Resolved: TRUE
[15:32:37.189] Value: <not collected>
[15:32:37.189] Conditions captured: <none>
[15:32:37.189] Early signaling: FALSE
[15:32:37.189] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:37.189] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:37.216] Chunk #2 of 2 ... DONE
[15:32:37.216] Launching 2 futures (chunks) ... DONE
[15:32:37.217] Resolving 2 futures (chunks) ...
[15:32:37.217] resolve() on list ...
[15:32:37.217]  recursive: 0
[15:32:37.217]  length: 2
[15:32:37.217] 
[15:32:37.217] Future #1
[15:32:37.218] result() for ClusterFuture ...
[15:32:37.218] - result already collected: FutureResult
[15:32:37.218] result() for ClusterFuture ... done
[15:32:37.218] result() for ClusterFuture ...
[15:32:37.218] - result already collected: FutureResult
[15:32:37.219] result() for ClusterFuture ... done
[15:32:37.219] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:37.219] - nx: 2
[15:32:37.219] - relay: TRUE
[15:32:37.219] - stdout: TRUE
[15:32:37.219] - signal: TRUE
[15:32:37.220] - resignal: FALSE
[15:32:37.220] - force: TRUE
[15:32:37.220] - relayed: [n=2] FALSE, FALSE
[15:32:37.220] - queued futures: [n=2] FALSE, FALSE
[15:32:37.220]  - until=1
[15:32:37.220]  - relaying element #1
[15:32:37.221] result() for ClusterFuture ...
[15:32:37.221] - result already collected: FutureResult
[15:32:37.221] result() for ClusterFuture ... done
[15:32:37.221] result() for ClusterFuture ...
[15:32:37.221] - result already collected: FutureResult
[15:32:37.221] result() for ClusterFuture ... done
[15:32:37.222] result() for ClusterFuture ...
[15:32:37.222] - result already collected: FutureResult
[15:32:37.222] result() for ClusterFuture ... done
[15:32:37.222] result() for ClusterFuture ...
[15:32:37.222] - result already collected: FutureResult
[15:32:37.222] result() for ClusterFuture ... done
[15:32:37.223] - relayed: [n=2] TRUE, FALSE
[15:32:37.223] - queued futures: [n=2] TRUE, FALSE
[15:32:37.223] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:37.223]  length: 1 (resolved future 1)
[15:32:37.223] Future #2
[15:32:37.223] result() for ClusterFuture ...
[15:32:37.224] - result already collected: FutureResult
[15:32:37.224] result() for ClusterFuture ... done
[15:32:37.224] result() for ClusterFuture ...
[15:32:37.224] - result already collected: FutureResult
[15:32:37.224] result() for ClusterFuture ... done
[15:32:37.224] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:37.225] - nx: 2
[15:32:37.225] - relay: TRUE
[15:32:37.225] - stdout: TRUE
[15:32:37.225] - signal: TRUE
[15:32:37.225] - resignal: FALSE
[15:32:37.225] - force: TRUE
[15:32:37.225] - relayed: [n=2] TRUE, FALSE
[15:32:37.226] - queued futures: [n=2] TRUE, FALSE
[15:32:37.226]  - until=2
[15:32:37.226]  - relaying element #2
[15:32:37.226] result() for ClusterFuture ...
[15:32:37.226] - result already collected: FutureResult
[15:32:37.226] result() for ClusterFuture ... done
[15:32:37.227] result() for ClusterFuture ...
[15:32:37.227] - result already collected: FutureResult
[15:32:37.227] result() for ClusterFuture ... done
[15:32:37.227] result() for ClusterFuture ...
[15:32:37.227] - result already collected: FutureResult
[15:32:37.227] result() for ClusterFuture ... done
[15:32:37.228] result() for ClusterFuture ...
[15:32:37.228] - result already collected: FutureResult
[15:32:37.228] result() for ClusterFuture ... done
[15:32:37.228] - relayed: [n=2] TRUE, TRUE
[15:32:37.228] - queued futures: [n=2] TRUE, TRUE
[15:32:37.228] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:37.229]  length: 0 (resolved future 2)
[15:32:37.229] Relaying remaining futures
[15:32:37.229] signalConditionsASAP(NULL, pos=0) ...
[15:32:37.229] - nx: 2
[15:32:37.230] - relay: TRUE
[15:32:37.230] - stdout: TRUE
[15:32:37.230] - signal: TRUE
[15:32:37.230] - resignal: FALSE
[15:32:37.231] - force: TRUE
[15:32:37.231] - relayed: [n=2] TRUE, TRUE
[15:32:37.231] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:37.232] - relayed: [n=2] TRUE, TRUE
[15:32:37.232] - queued futures: [n=2] TRUE, TRUE
[15:32:37.232] signalConditionsASAP(NULL, pos=0) ... done
[15:32:37.232] resolve() on list ... DONE
[15:32:37.233] result() for ClusterFuture ...
[15:32:37.233] - result already collected: FutureResult
[15:32:37.233] result() for ClusterFuture ... done
[15:32:37.233] result() for ClusterFuture ...
[15:32:37.234] - result already collected: FutureResult
[15:32:37.234] result() for ClusterFuture ... done
[15:32:37.234] result() for ClusterFuture ...
[15:32:37.234] - result already collected: FutureResult
[15:32:37.235] result() for ClusterFuture ... done
[15:32:37.235] result() for ClusterFuture ...
[15:32:37.235] - result already collected: FutureResult
[15:32:37.235] result() for ClusterFuture ... done
[15:32:37.236]  - Number of value chunks collected: 2
[15:32:37.236] Resolving 2 futures (chunks) ... DONE
[15:32:37.236] Reducing values from 2 chunks ...
[15:32:37.237]  - Number of values collected after concatenation: 3
[15:32:37.237]  - Number of values expected: 3
[15:32:37.237] Reducing values from 2 chunks ... DONE
[15:32:37.237] future_lapply() ... DONE
List of 2
 $ y0: Named chr [1:3] "a" "b" "c"
  ..- attr(*, "names")= chr [1:3] "a" "b" "c"
 $ y1: Named chr [1:3] "a" "b" "c"
  ..- attr(*, "names")= chr [1:3] "a" "b" "c"
[15:32:37.240] future_lapply() ...
[15:32:37.245] Number of chunks: 2
[15:32:37.245] getGlobalsAndPackagesXApply() ...
[15:32:37.246]  - future.globals: TRUE
[15:32:37.246] getGlobalsAndPackages() ...
[15:32:37.246] Searching for globals...
[15:32:37.248] - globals found: [1] 'FUN'
[15:32:37.248] Searching for globals ... DONE
[15:32:37.249] Resolving globals: FALSE
[15:32:37.249] The total size of the 1 globals is 848 bytes (848 bytes)
[15:32:37.250] The total size of the 1 globals exported for future expression ('FUN()') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:32:37.251] - globals: [1] 'FUN'
[15:32:37.251] 
[15:32:37.251] getGlobalsAndPackages() ... DONE
[15:32:37.252]  - globals found/used: [n=1] 'FUN'
[15:32:37.252]  - needed namespaces: [n=0] 
[15:32:37.252] Finding globals ... DONE
[15:32:37.253]  - use_args: TRUE
[15:32:37.253]  - Getting '...' globals ...
[15:32:37.254] resolve() on list ...
[15:32:37.254]  recursive: 0
[15:32:37.254]  length: 1
[15:32:37.255]  elements: '...'
[15:32:37.255]  length: 0 (resolved future 1)
[15:32:37.255] resolve() on list ... DONE
[15:32:37.256]    - '...' content: [n=0] 
[15:32:37.256] List of 1
[15:32:37.256]  $ ...: list()
[15:32:37.256]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:37.256]  - attr(*, "where")=List of 1
[15:32:37.256]   ..$ ...:<environment: 0x00000276e04b6f48> 
[15:32:37.256]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:37.256]  - attr(*, "resolved")= logi TRUE
[15:32:37.256]  - attr(*, "total_size")= num NA
[15:32:37.261]  - Getting '...' globals ... DONE
[15:32:37.262] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:37.262] List of 2
[15:32:37.262]  $ ...future.FUN:function (x)  
[15:32:37.262]  $ ...          : list()
[15:32:37.262]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:37.262]  - attr(*, "where")=List of 2
[15:32:37.262]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:37.262]   ..$ ...          :<environment: 0x00000276e04b6f48> 
[15:32:37.262]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:37.262]  - attr(*, "resolved")= logi FALSE
[15:32:37.262]  - attr(*, "total_size")= num 848
[15:32:37.268] Packages to be attached in all futures: [n=0] 
[15:32:37.268] getGlobalsAndPackagesXApply() ... DONE
[15:32:37.268] Number of futures (= number of chunks): 2
[15:32:37.269] Launching 2 futures (chunks) ...
[15:32:37.269] Chunk #1 of 2 ...
[15:32:37.269]  - Finding globals in 'X' for chunk #1 ...
[15:32:37.270] getGlobalsAndPackages() ...
[15:32:37.270] Searching for globals...
[15:32:37.271] 
[15:32:37.271] Searching for globals ... DONE
[15:32:37.271] - globals: [0] <none>
[15:32:37.272] getGlobalsAndPackages() ... DONE
[15:32:37.272]    + additional globals found: [n=0] 
[15:32:37.272]    + additional namespaces needed: [n=0] 
[15:32:37.272]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:37.273]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:37.273]  - seeds: <none>
[15:32:37.273]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:37.273] getGlobalsAndPackages() ...
[15:32:37.274] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:37.274] Resolving globals: FALSE
[15:32:37.274] Tweak future expression to call with '...' arguments ...
[15:32:37.275] {
[15:32:37.275]     do.call(function(...) {
[15:32:37.275]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:37.275]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:37.275]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:37.275]             on.exit(options(oopts), add = TRUE)
[15:32:37.275]         }
[15:32:37.275]         {
[15:32:37.275]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:37.275]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:37.275]                 ...future.FUN(...future.X_jj, ...)
[15:32:37.275]             })
[15:32:37.275]         }
[15:32:37.275]     }, args = future.call.arguments)
[15:32:37.275] }
[15:32:37.275] Tweak future expression to call with '...' arguments ... DONE
[15:32:37.276] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:37.277] 
[15:32:37.277] getGlobalsAndPackages() ... DONE
[15:32:37.278] run() for 'Future' ...
[15:32:37.278] - state: 'created'
[15:32:37.278] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:37.297] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:37.298] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:37.298]   - Field: 'node'
[15:32:37.298]   - Field: 'label'
[15:32:37.299]   - Field: 'local'
[15:32:37.299]   - Field: 'owner'
[15:32:37.299]   - Field: 'envir'
[15:32:37.299]   - Field: 'workers'
[15:32:37.300]   - Field: 'packages'
[15:32:37.300]   - Field: 'gc'
[15:32:37.300]   - Field: 'conditions'
[15:32:37.301]   - Field: 'persistent'
[15:32:37.301]   - Field: 'expr'
[15:32:37.301]   - Field: 'uuid'
[15:32:37.302]   - Field: 'seed'
[15:32:37.302]   - Field: 'version'
[15:32:37.302]   - Field: 'result'
[15:32:37.302]   - Field: 'asynchronous'
[15:32:37.303]   - Field: 'calls'
[15:32:37.303]   - Field: 'globals'
[15:32:37.303]   - Field: 'stdout'
[15:32:37.304]   - Field: 'earlySignal'
[15:32:37.304]   - Field: 'lazy'
[15:32:37.304]   - Field: 'state'
[15:32:37.305] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:37.305] - Launch lazy future ...
[15:32:37.306] Packages needed by the future expression (n = 0): <none>
[15:32:37.306] Packages needed by future strategies (n = 0): <none>
[15:32:37.307] {
[15:32:37.307]     {
[15:32:37.307]         {
[15:32:37.307]             ...future.startTime <- base::Sys.time()
[15:32:37.307]             {
[15:32:37.307]                 {
[15:32:37.307]                   {
[15:32:37.307]                     {
[15:32:37.307]                       base::local({
[15:32:37.307]                         has_future <- base::requireNamespace("future", 
[15:32:37.307]                           quietly = TRUE)
[15:32:37.307]                         if (has_future) {
[15:32:37.307]                           ns <- base::getNamespace("future")
[15:32:37.307]                           version <- ns[[".package"]][["version"]]
[15:32:37.307]                           if (is.null(version)) 
[15:32:37.307]                             version <- utils::packageVersion("future")
[15:32:37.307]                         }
[15:32:37.307]                         else {
[15:32:37.307]                           version <- NULL
[15:32:37.307]                         }
[15:32:37.307]                         if (!has_future || version < "1.8.0") {
[15:32:37.307]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:37.307]                             "", base::R.version$version.string), 
[15:32:37.307]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:37.307]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:37.307]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:37.307]                               "release", "version")], collapse = " "), 
[15:32:37.307]                             hostname = base::Sys.info()[["nodename"]])
[15:32:37.307]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:37.307]                             info)
[15:32:37.307]                           info <- base::paste(info, collapse = "; ")
[15:32:37.307]                           if (!has_future) {
[15:32:37.307]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:37.307]                               info)
[15:32:37.307]                           }
[15:32:37.307]                           else {
[15:32:37.307]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:37.307]                               info, version)
[15:32:37.307]                           }
[15:32:37.307]                           base::stop(msg)
[15:32:37.307]                         }
[15:32:37.307]                       })
[15:32:37.307]                     }
[15:32:37.307]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:37.307]                     base::options(mc.cores = 1L)
[15:32:37.307]                   }
[15:32:37.307]                   ...future.strategy.old <- future::plan("list")
[15:32:37.307]                   options(future.plan = NULL)
[15:32:37.307]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:37.307]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:37.307]                 }
[15:32:37.307]                 ...future.workdir <- getwd()
[15:32:37.307]             }
[15:32:37.307]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:37.307]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:37.307]         }
[15:32:37.307]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:37.307]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:37.307]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:37.307]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:37.307]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:37.307]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:37.307]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:37.307]             base::names(...future.oldOptions))
[15:32:37.307]     }
[15:32:37.307]     if (FALSE) {
[15:32:37.307]     }
[15:32:37.307]     else {
[15:32:37.307]         if (TRUE) {
[15:32:37.307]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:37.307]                 open = "w")
[15:32:37.307]         }
[15:32:37.307]         else {
[15:32:37.307]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:37.307]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:37.307]         }
[15:32:37.307]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:37.307]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:37.307]             base::sink(type = "output", split = FALSE)
[15:32:37.307]             base::close(...future.stdout)
[15:32:37.307]         }, add = TRUE)
[15:32:37.307]     }
[15:32:37.307]     ...future.frame <- base::sys.nframe()
[15:32:37.307]     ...future.conditions <- base::list()
[15:32:37.307]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:37.307]     if (FALSE) {
[15:32:37.307]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:37.307]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:37.307]     }
[15:32:37.307]     ...future.result <- base::tryCatch({
[15:32:37.307]         base::withCallingHandlers({
[15:32:37.307]             ...future.value <- base::withVisible(base::local({
[15:32:37.307]                 ...future.makeSendCondition <- base::local({
[15:32:37.307]                   sendCondition <- NULL
[15:32:37.307]                   function(frame = 1L) {
[15:32:37.307]                     if (is.function(sendCondition)) 
[15:32:37.307]                       return(sendCondition)
[15:32:37.307]                     ns <- getNamespace("parallel")
[15:32:37.307]                     if (exists("sendData", mode = "function", 
[15:32:37.307]                       envir = ns)) {
[15:32:37.307]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:37.307]                         envir = ns)
[15:32:37.307]                       envir <- sys.frame(frame)
[15:32:37.307]                       master <- NULL
[15:32:37.307]                       while (!identical(envir, .GlobalEnv) && 
[15:32:37.307]                         !identical(envir, emptyenv())) {
[15:32:37.307]                         if (exists("master", mode = "list", envir = envir, 
[15:32:37.307]                           inherits = FALSE)) {
[15:32:37.307]                           master <- get("master", mode = "list", 
[15:32:37.307]                             envir = envir, inherits = FALSE)
[15:32:37.307]                           if (inherits(master, c("SOCKnode", 
[15:32:37.307]                             "SOCK0node"))) {
[15:32:37.307]                             sendCondition <<- function(cond) {
[15:32:37.307]                               data <- list(type = "VALUE", value = cond, 
[15:32:37.307]                                 success = TRUE)
[15:32:37.307]                               parallel_sendData(master, data)
[15:32:37.307]                             }
[15:32:37.307]                             return(sendCondition)
[15:32:37.307]                           }
[15:32:37.307]                         }
[15:32:37.307]                         frame <- frame + 1L
[15:32:37.307]                         envir <- sys.frame(frame)
[15:32:37.307]                       }
[15:32:37.307]                     }
[15:32:37.307]                     sendCondition <<- function(cond) NULL
[15:32:37.307]                   }
[15:32:37.307]                 })
[15:32:37.307]                 withCallingHandlers({
[15:32:37.307]                   {
[15:32:37.307]                     do.call(function(...) {
[15:32:37.307]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:37.307]                       if (!identical(...future.globals.maxSize.org, 
[15:32:37.307]                         ...future.globals.maxSize)) {
[15:32:37.307]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:37.307]                         on.exit(options(oopts), add = TRUE)
[15:32:37.307]                       }
[15:32:37.307]                       {
[15:32:37.307]                         lapply(seq_along(...future.elements_ii), 
[15:32:37.307]                           FUN = function(jj) {
[15:32:37.307]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:37.307]                             ...future.FUN(...future.X_jj, ...)
[15:32:37.307]                           })
[15:32:37.307]                       }
[15:32:37.307]                     }, args = future.call.arguments)
[15:32:37.307]                   }
[15:32:37.307]                 }, immediateCondition = function(cond) {
[15:32:37.307]                   sendCondition <- ...future.makeSendCondition()
[15:32:37.307]                   sendCondition(cond)
[15:32:37.307]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:37.307]                   {
[15:32:37.307]                     inherits <- base::inherits
[15:32:37.307]                     invokeRestart <- base::invokeRestart
[15:32:37.307]                     is.null <- base::is.null
[15:32:37.307]                     muffled <- FALSE
[15:32:37.307]                     if (inherits(cond, "message")) {
[15:32:37.307]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:37.307]                       if (muffled) 
[15:32:37.307]                         invokeRestart("muffleMessage")
[15:32:37.307]                     }
[15:32:37.307]                     else if (inherits(cond, "warning")) {
[15:32:37.307]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:37.307]                       if (muffled) 
[15:32:37.307]                         invokeRestart("muffleWarning")
[15:32:37.307]                     }
[15:32:37.307]                     else if (inherits(cond, "condition")) {
[15:32:37.307]                       if (!is.null(pattern)) {
[15:32:37.307]                         computeRestarts <- base::computeRestarts
[15:32:37.307]                         grepl <- base::grepl
[15:32:37.307]                         restarts <- computeRestarts(cond)
[15:32:37.307]                         for (restart in restarts) {
[15:32:37.307]                           name <- restart$name
[15:32:37.307]                           if (is.null(name)) 
[15:32:37.307]                             next
[15:32:37.307]                           if (!grepl(pattern, name)) 
[15:32:37.307]                             next
[15:32:37.307]                           invokeRestart(restart)
[15:32:37.307]                           muffled <- TRUE
[15:32:37.307]                           break
[15:32:37.307]                         }
[15:32:37.307]                       }
[15:32:37.307]                     }
[15:32:37.307]                     invisible(muffled)
[15:32:37.307]                   }
[15:32:37.307]                   muffleCondition(cond)
[15:32:37.307]                 })
[15:32:37.307]             }))
[15:32:37.307]             future::FutureResult(value = ...future.value$value, 
[15:32:37.307]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:37.307]                   ...future.rng), globalenv = if (FALSE) 
[15:32:37.307]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:37.307]                     ...future.globalenv.names))
[15:32:37.307]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:37.307]         }, condition = base::local({
[15:32:37.307]             c <- base::c
[15:32:37.307]             inherits <- base::inherits
[15:32:37.307]             invokeRestart <- base::invokeRestart
[15:32:37.307]             length <- base::length
[15:32:37.307]             list <- base::list
[15:32:37.307]             seq.int <- base::seq.int
[15:32:37.307]             signalCondition <- base::signalCondition
[15:32:37.307]             sys.calls <- base::sys.calls
[15:32:37.307]             `[[` <- base::`[[`
[15:32:37.307]             `+` <- base::`+`
[15:32:37.307]             `<<-` <- base::`<<-`
[15:32:37.307]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:37.307]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:37.307]                   3L)]
[15:32:37.307]             }
[15:32:37.307]             function(cond) {
[15:32:37.307]                 is_error <- inherits(cond, "error")
[15:32:37.307]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:37.307]                   NULL)
[15:32:37.307]                 if (is_error) {
[15:32:37.307]                   sessionInformation <- function() {
[15:32:37.307]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:37.307]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:37.307]                       search = base::search(), system = base::Sys.info())
[15:32:37.307]                   }
[15:32:37.307]                   ...future.conditions[[length(...future.conditions) + 
[15:32:37.307]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:37.307]                     cond$call), session = sessionInformation(), 
[15:32:37.307]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:37.307]                   signalCondition(cond)
[15:32:37.307]                 }
[15:32:37.307]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:37.307]                 "immediateCondition"))) {
[15:32:37.307]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:37.307]                   ...future.conditions[[length(...future.conditions) + 
[15:32:37.307]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:37.307]                   if (TRUE && !signal) {
[15:32:37.307]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:37.307]                     {
[15:32:37.307]                       inherits <- base::inherits
[15:32:37.307]                       invokeRestart <- base::invokeRestart
[15:32:37.307]                       is.null <- base::is.null
[15:32:37.307]                       muffled <- FALSE
[15:32:37.307]                       if (inherits(cond, "message")) {
[15:32:37.307]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:37.307]                         if (muffled) 
[15:32:37.307]                           invokeRestart("muffleMessage")
[15:32:37.307]                       }
[15:32:37.307]                       else if (inherits(cond, "warning")) {
[15:32:37.307]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:37.307]                         if (muffled) 
[15:32:37.307]                           invokeRestart("muffleWarning")
[15:32:37.307]                       }
[15:32:37.307]                       else if (inherits(cond, "condition")) {
[15:32:37.307]                         if (!is.null(pattern)) {
[15:32:37.307]                           computeRestarts <- base::computeRestarts
[15:32:37.307]                           grepl <- base::grepl
[15:32:37.307]                           restarts <- computeRestarts(cond)
[15:32:37.307]                           for (restart in restarts) {
[15:32:37.307]                             name <- restart$name
[15:32:37.307]                             if (is.null(name)) 
[15:32:37.307]                               next
[15:32:37.307]                             if (!grepl(pattern, name)) 
[15:32:37.307]                               next
[15:32:37.307]                             invokeRestart(restart)
[15:32:37.307]                             muffled <- TRUE
[15:32:37.307]                             break
[15:32:37.307]                           }
[15:32:37.307]                         }
[15:32:37.307]                       }
[15:32:37.307]                       invisible(muffled)
[15:32:37.307]                     }
[15:32:37.307]                     muffleCondition(cond, pattern = "^muffle")
[15:32:37.307]                   }
[15:32:37.307]                 }
[15:32:37.307]                 else {
[15:32:37.307]                   if (TRUE) {
[15:32:37.307]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:37.307]                     {
[15:32:37.307]                       inherits <- base::inherits
[15:32:37.307]                       invokeRestart <- base::invokeRestart
[15:32:37.307]                       is.null <- base::is.null
[15:32:37.307]                       muffled <- FALSE
[15:32:37.307]                       if (inherits(cond, "message")) {
[15:32:37.307]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:37.307]                         if (muffled) 
[15:32:37.307]                           invokeRestart("muffleMessage")
[15:32:37.307]                       }
[15:32:37.307]                       else if (inherits(cond, "warning")) {
[15:32:37.307]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:37.307]                         if (muffled) 
[15:32:37.307]                           invokeRestart("muffleWarning")
[15:32:37.307]                       }
[15:32:37.307]                       else if (inherits(cond, "condition")) {
[15:32:37.307]                         if (!is.null(pattern)) {
[15:32:37.307]                           computeRestarts <- base::computeRestarts
[15:32:37.307]                           grepl <- base::grepl
[15:32:37.307]                           restarts <- computeRestarts(cond)
[15:32:37.307]                           for (restart in restarts) {
[15:32:37.307]                             name <- restart$name
[15:32:37.307]                             if (is.null(name)) 
[15:32:37.307]                               next
[15:32:37.307]                             if (!grepl(pattern, name)) 
[15:32:37.307]                               next
[15:32:37.307]                             invokeRestart(restart)
[15:32:37.307]                             muffled <- TRUE
[15:32:37.307]                             break
[15:32:37.307]                           }
[15:32:37.307]                         }
[15:32:37.307]                       }
[15:32:37.307]                       invisible(muffled)
[15:32:37.307]                     }
[15:32:37.307]                     muffleCondition(cond, pattern = "^muffle")
[15:32:37.307]                   }
[15:32:37.307]                 }
[15:32:37.307]             }
[15:32:37.307]         }))
[15:32:37.307]     }, error = function(ex) {
[15:32:37.307]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:37.307]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:37.307]                 ...future.rng), started = ...future.startTime, 
[15:32:37.307]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:37.307]             version = "1.8"), class = "FutureResult")
[15:32:37.307]     }, finally = {
[15:32:37.307]         if (!identical(...future.workdir, getwd())) 
[15:32:37.307]             setwd(...future.workdir)
[15:32:37.307]         {
[15:32:37.307]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:37.307]                 ...future.oldOptions$nwarnings <- NULL
[15:32:37.307]             }
[15:32:37.307]             base::options(...future.oldOptions)
[15:32:37.307]             if (.Platform$OS.type == "windows") {
[15:32:37.307]                 old_names <- names(...future.oldEnvVars)
[15:32:37.307]                 envs <- base::Sys.getenv()
[15:32:37.307]                 names <- names(envs)
[15:32:37.307]                 common <- intersect(names, old_names)
[15:32:37.307]                 added <- setdiff(names, old_names)
[15:32:37.307]                 removed <- setdiff(old_names, names)
[15:32:37.307]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:37.307]                   envs[common]]
[15:32:37.307]                 NAMES <- toupper(changed)
[15:32:37.307]                 args <- list()
[15:32:37.307]                 for (kk in seq_along(NAMES)) {
[15:32:37.307]                   name <- changed[[kk]]
[15:32:37.307]                   NAME <- NAMES[[kk]]
[15:32:37.307]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:37.307]                     next
[15:32:37.307]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:37.307]                 }
[15:32:37.307]                 NAMES <- toupper(added)
[15:32:37.307]                 for (kk in seq_along(NAMES)) {
[15:32:37.307]                   name <- added[[kk]]
[15:32:37.307]                   NAME <- NAMES[[kk]]
[15:32:37.307]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:37.307]                     next
[15:32:37.307]                   args[[name]] <- ""
[15:32:37.307]                 }
[15:32:37.307]                 NAMES <- toupper(removed)
[15:32:37.307]                 for (kk in seq_along(NAMES)) {
[15:32:37.307]                   name <- removed[[kk]]
[15:32:37.307]                   NAME <- NAMES[[kk]]
[15:32:37.307]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:37.307]                     next
[15:32:37.307]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:37.307]                 }
[15:32:37.307]                 if (length(args) > 0) 
[15:32:37.307]                   base::do.call(base::Sys.setenv, args = args)
[15:32:37.307]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:37.307]             }
[15:32:37.307]             else {
[15:32:37.307]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:37.307]             }
[15:32:37.307]             {
[15:32:37.307]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:37.307]                   0L) {
[15:32:37.307]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:37.307]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:37.307]                   base::options(opts)
[15:32:37.307]                 }
[15:32:37.307]                 {
[15:32:37.307]                   {
[15:32:37.307]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:37.307]                     NULL
[15:32:37.307]                   }
[15:32:37.307]                   options(future.plan = NULL)
[15:32:37.307]                   if (is.na(NA_character_)) 
[15:32:37.307]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:37.307]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:37.307]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:37.307]                     .init = FALSE)
[15:32:37.307]                 }
[15:32:37.307]             }
[15:32:37.307]         }
[15:32:37.307]     })
[15:32:37.307]     if (TRUE) {
[15:32:37.307]         base::sink(type = "output", split = FALSE)
[15:32:37.307]         if (TRUE) {
[15:32:37.307]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:37.307]         }
[15:32:37.307]         else {
[15:32:37.307]             ...future.result["stdout"] <- base::list(NULL)
[15:32:37.307]         }
[15:32:37.307]         base::close(...future.stdout)
[15:32:37.307]         ...future.stdout <- NULL
[15:32:37.307]     }
[15:32:37.307]     ...future.result$conditions <- ...future.conditions
[15:32:37.307]     ...future.result$finished <- base::Sys.time()
[15:32:37.307]     ...future.result
[15:32:37.307] }
[15:32:37.317] Exporting 5 global objects (848 bytes) to cluster node #1 ...
[15:32:37.317] Exporting '...future.FUN' (848 bytes) to cluster node #1 ...
[15:32:37.318] Exporting '...future.FUN' (848 bytes) to cluster node #1 ... DONE
[15:32:37.319] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:37.320] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:37.320] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:37.321] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:37.321] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:37.322] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:37.322] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:37.323] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:37.323] Exporting 5 global objects (848 bytes) to cluster node #1 ... DONE
[15:32:37.324] MultisessionFuture started
[15:32:37.324] - Launch lazy future ... done
[15:32:37.325] run() for 'MultisessionFuture' ... done
[15:32:37.325] Created future:
[15:32:37.350] receiveMessageFromWorker() for ClusterFuture ...
[15:32:37.351] - Validating connection of MultisessionFuture
[15:32:37.352] - received message: FutureResult
[15:32:37.352] - Received FutureResult
[15:32:37.352] - Erased future from FutureRegistry
[15:32:37.353] result() for ClusterFuture ...
[15:32:37.353] - result already collected: FutureResult
[15:32:37.353] result() for ClusterFuture ... done
[15:32:37.353] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:37.325] MultisessionFuture:
[15:32:37.325] Label: 'future_sapply-1'
[15:32:37.325] Expression:
[15:32:37.325] {
[15:32:37.325]     do.call(function(...) {
[15:32:37.325]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:37.325]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:37.325]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:37.325]             on.exit(options(oopts), add = TRUE)
[15:32:37.325]         }
[15:32:37.325]         {
[15:32:37.325]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:37.325]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:37.325]                 ...future.FUN(...future.X_jj, ...)
[15:32:37.325]             })
[15:32:37.325]         }
[15:32:37.325]     }, args = future.call.arguments)
[15:32:37.325] }
[15:32:37.325] Lazy evaluation: FALSE
[15:32:37.325] Asynchronous evaluation: TRUE
[15:32:37.325] Local evaluation: TRUE
[15:32:37.325] Environment: R_GlobalEnv
[15:32:37.325] Capture standard output: TRUE
[15:32:37.325] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:37.325] Globals: 5 objects totaling 960 bytes (function '...future.FUN' of 848 bytes, 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)
[15:32:37.325] Packages: <none>
[15:32:37.325] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:37.325] Resolved: TRUE
[15:32:37.325] Value: <not collected>
[15:32:37.325] Conditions captured: <none>
[15:32:37.325] Early signaling: FALSE
[15:32:37.325] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:37.325] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:37.354] Chunk #1 of 2 ... DONE
[15:32:37.355] Chunk #2 of 2 ...
[15:32:37.355]  - Finding globals in 'X' for chunk #2 ...
[15:32:37.355] getGlobalsAndPackages() ...
[15:32:37.355] Searching for globals...
[15:32:37.356] 
[15:32:37.356] Searching for globals ... DONE
[15:32:37.357] - globals: [0] <none>
[15:32:37.357] getGlobalsAndPackages() ... DONE
[15:32:37.357]    + additional globals found: [n=0] 
[15:32:37.358]    + additional namespaces needed: [n=0] 
[15:32:37.358]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:37.358]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:37.358]  - seeds: <none>
[15:32:37.359]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:37.359] getGlobalsAndPackages() ...
[15:32:37.359] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:37.360] Resolving globals: FALSE
[15:32:37.360] Tweak future expression to call with '...' arguments ...
[15:32:37.360] {
[15:32:37.360]     do.call(function(...) {
[15:32:37.360]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:37.360]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:37.360]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:37.360]             on.exit(options(oopts), add = TRUE)
[15:32:37.360]         }
[15:32:37.360]         {
[15:32:37.360]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:37.360]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:37.360]                 ...future.FUN(...future.X_jj, ...)
[15:32:37.360]             })
[15:32:37.360]         }
[15:32:37.360]     }, args = future.call.arguments)
[15:32:37.360] }
[15:32:37.361] Tweak future expression to call with '...' arguments ... DONE
[15:32:37.362] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:37.362] 
[15:32:37.363] getGlobalsAndPackages() ... DONE
[15:32:37.363] run() for 'Future' ...
[15:32:37.364] - state: 'created'
[15:32:37.364] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:37.384] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:37.385] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:37.385]   - Field: 'node'
[15:32:37.386]   - Field: 'label'
[15:32:37.386]   - Field: 'local'
[15:32:37.386]   - Field: 'owner'
[15:32:37.387]   - Field: 'envir'
[15:32:37.387]   - Field: 'workers'
[15:32:37.387]   - Field: 'packages'
[15:32:37.388]   - Field: 'gc'
[15:32:37.388]   - Field: 'conditions'
[15:32:37.388]   - Field: 'persistent'
[15:32:37.388]   - Field: 'expr'
[15:32:37.389]   - Field: 'uuid'
[15:32:37.389]   - Field: 'seed'
[15:32:37.389]   - Field: 'version'
[15:32:37.390]   - Field: 'result'
[15:32:37.390]   - Field: 'asynchronous'
[15:32:37.390]   - Field: 'calls'
[15:32:37.391]   - Field: 'globals'
[15:32:37.391]   - Field: 'stdout'
[15:32:37.391]   - Field: 'earlySignal'
[15:32:37.392]   - Field: 'lazy'
[15:32:37.392]   - Field: 'state'
[15:32:37.392] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:37.393] - Launch lazy future ...
[15:32:37.393] Packages needed by the future expression (n = 0): <none>
[15:32:37.394] Packages needed by future strategies (n = 0): <none>
[15:32:37.395] {
[15:32:37.395]     {
[15:32:37.395]         {
[15:32:37.395]             ...future.startTime <- base::Sys.time()
[15:32:37.395]             {
[15:32:37.395]                 {
[15:32:37.395]                   {
[15:32:37.395]                     {
[15:32:37.395]                       base::local({
[15:32:37.395]                         has_future <- base::requireNamespace("future", 
[15:32:37.395]                           quietly = TRUE)
[15:32:37.395]                         if (has_future) {
[15:32:37.395]                           ns <- base::getNamespace("future")
[15:32:37.395]                           version <- ns[[".package"]][["version"]]
[15:32:37.395]                           if (is.null(version)) 
[15:32:37.395]                             version <- utils::packageVersion("future")
[15:32:37.395]                         }
[15:32:37.395]                         else {
[15:32:37.395]                           version <- NULL
[15:32:37.395]                         }
[15:32:37.395]                         if (!has_future || version < "1.8.0") {
[15:32:37.395]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:37.395]                             "", base::R.version$version.string), 
[15:32:37.395]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:37.395]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:37.395]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:37.395]                               "release", "version")], collapse = " "), 
[15:32:37.395]                             hostname = base::Sys.info()[["nodename"]])
[15:32:37.395]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:37.395]                             info)
[15:32:37.395]                           info <- base::paste(info, collapse = "; ")
[15:32:37.395]                           if (!has_future) {
[15:32:37.395]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:37.395]                               info)
[15:32:37.395]                           }
[15:32:37.395]                           else {
[15:32:37.395]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:37.395]                               info, version)
[15:32:37.395]                           }
[15:32:37.395]                           base::stop(msg)
[15:32:37.395]                         }
[15:32:37.395]                       })
[15:32:37.395]                     }
[15:32:37.395]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:37.395]                     base::options(mc.cores = 1L)
[15:32:37.395]                   }
[15:32:37.395]                   ...future.strategy.old <- future::plan("list")
[15:32:37.395]                   options(future.plan = NULL)
[15:32:37.395]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:37.395]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:37.395]                 }
[15:32:37.395]                 ...future.workdir <- getwd()
[15:32:37.395]             }
[15:32:37.395]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:37.395]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:37.395]         }
[15:32:37.395]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:37.395]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:37.395]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:37.395]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:37.395]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:37.395]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:37.395]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:37.395]             base::names(...future.oldOptions))
[15:32:37.395]     }
[15:32:37.395]     if (FALSE) {
[15:32:37.395]     }
[15:32:37.395]     else {
[15:32:37.395]         if (TRUE) {
[15:32:37.395]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:37.395]                 open = "w")
[15:32:37.395]         }
[15:32:37.395]         else {
[15:32:37.395]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:37.395]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:37.395]         }
[15:32:37.395]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:37.395]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:37.395]             base::sink(type = "output", split = FALSE)
[15:32:37.395]             base::close(...future.stdout)
[15:32:37.395]         }, add = TRUE)
[15:32:37.395]     }
[15:32:37.395]     ...future.frame <- base::sys.nframe()
[15:32:37.395]     ...future.conditions <- base::list()
[15:32:37.395]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:37.395]     if (FALSE) {
[15:32:37.395]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:37.395]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:37.395]     }
[15:32:37.395]     ...future.result <- base::tryCatch({
[15:32:37.395]         base::withCallingHandlers({
[15:32:37.395]             ...future.value <- base::withVisible(base::local({
[15:32:37.395]                 ...future.makeSendCondition <- base::local({
[15:32:37.395]                   sendCondition <- NULL
[15:32:37.395]                   function(frame = 1L) {
[15:32:37.395]                     if (is.function(sendCondition)) 
[15:32:37.395]                       return(sendCondition)
[15:32:37.395]                     ns <- getNamespace("parallel")
[15:32:37.395]                     if (exists("sendData", mode = "function", 
[15:32:37.395]                       envir = ns)) {
[15:32:37.395]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:37.395]                         envir = ns)
[15:32:37.395]                       envir <- sys.frame(frame)
[15:32:37.395]                       master <- NULL
[15:32:37.395]                       while (!identical(envir, .GlobalEnv) && 
[15:32:37.395]                         !identical(envir, emptyenv())) {
[15:32:37.395]                         if (exists("master", mode = "list", envir = envir, 
[15:32:37.395]                           inherits = FALSE)) {
[15:32:37.395]                           master <- get("master", mode = "list", 
[15:32:37.395]                             envir = envir, inherits = FALSE)
[15:32:37.395]                           if (inherits(master, c("SOCKnode", 
[15:32:37.395]                             "SOCK0node"))) {
[15:32:37.395]                             sendCondition <<- function(cond) {
[15:32:37.395]                               data <- list(type = "VALUE", value = cond, 
[15:32:37.395]                                 success = TRUE)
[15:32:37.395]                               parallel_sendData(master, data)
[15:32:37.395]                             }
[15:32:37.395]                             return(sendCondition)
[15:32:37.395]                           }
[15:32:37.395]                         }
[15:32:37.395]                         frame <- frame + 1L
[15:32:37.395]                         envir <- sys.frame(frame)
[15:32:37.395]                       }
[15:32:37.395]                     }
[15:32:37.395]                     sendCondition <<- function(cond) NULL
[15:32:37.395]                   }
[15:32:37.395]                 })
[15:32:37.395]                 withCallingHandlers({
[15:32:37.395]                   {
[15:32:37.395]                     do.call(function(...) {
[15:32:37.395]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:37.395]                       if (!identical(...future.globals.maxSize.org, 
[15:32:37.395]                         ...future.globals.maxSize)) {
[15:32:37.395]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:37.395]                         on.exit(options(oopts), add = TRUE)
[15:32:37.395]                       }
[15:32:37.395]                       {
[15:32:37.395]                         lapply(seq_along(...future.elements_ii), 
[15:32:37.395]                           FUN = function(jj) {
[15:32:37.395]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:37.395]                             ...future.FUN(...future.X_jj, ...)
[15:32:37.395]                           })
[15:32:37.395]                       }
[15:32:37.395]                     }, args = future.call.arguments)
[15:32:37.395]                   }
[15:32:37.395]                 }, immediateCondition = function(cond) {
[15:32:37.395]                   sendCondition <- ...future.makeSendCondition()
[15:32:37.395]                   sendCondition(cond)
[15:32:37.395]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:37.395]                   {
[15:32:37.395]                     inherits <- base::inherits
[15:32:37.395]                     invokeRestart <- base::invokeRestart
[15:32:37.395]                     is.null <- base::is.null
[15:32:37.395]                     muffled <- FALSE
[15:32:37.395]                     if (inherits(cond, "message")) {
[15:32:37.395]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:37.395]                       if (muffled) 
[15:32:37.395]                         invokeRestart("muffleMessage")
[15:32:37.395]                     }
[15:32:37.395]                     else if (inherits(cond, "warning")) {
[15:32:37.395]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:37.395]                       if (muffled) 
[15:32:37.395]                         invokeRestart("muffleWarning")
[15:32:37.395]                     }
[15:32:37.395]                     else if (inherits(cond, "condition")) {
[15:32:37.395]                       if (!is.null(pattern)) {
[15:32:37.395]                         computeRestarts <- base::computeRestarts
[15:32:37.395]                         grepl <- base::grepl
[15:32:37.395]                         restarts <- computeRestarts(cond)
[15:32:37.395]                         for (restart in restarts) {
[15:32:37.395]                           name <- restart$name
[15:32:37.395]                           if (is.null(name)) 
[15:32:37.395]                             next
[15:32:37.395]                           if (!grepl(pattern, name)) 
[15:32:37.395]                             next
[15:32:37.395]                           invokeRestart(restart)
[15:32:37.395]                           muffled <- TRUE
[15:32:37.395]                           break
[15:32:37.395]                         }
[15:32:37.395]                       }
[15:32:37.395]                     }
[15:32:37.395]                     invisible(muffled)
[15:32:37.395]                   }
[15:32:37.395]                   muffleCondition(cond)
[15:32:37.395]                 })
[15:32:37.395]             }))
[15:32:37.395]             future::FutureResult(value = ...future.value$value, 
[15:32:37.395]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:37.395]                   ...future.rng), globalenv = if (FALSE) 
[15:32:37.395]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:37.395]                     ...future.globalenv.names))
[15:32:37.395]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:37.395]         }, condition = base::local({
[15:32:37.395]             c <- base::c
[15:32:37.395]             inherits <- base::inherits
[15:32:37.395]             invokeRestart <- base::invokeRestart
[15:32:37.395]             length <- base::length
[15:32:37.395]             list <- base::list
[15:32:37.395]             seq.int <- base::seq.int
[15:32:37.395]             signalCondition <- base::signalCondition
[15:32:37.395]             sys.calls <- base::sys.calls
[15:32:37.395]             `[[` <- base::`[[`
[15:32:37.395]             `+` <- base::`+`
[15:32:37.395]             `<<-` <- base::`<<-`
[15:32:37.395]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:37.395]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:37.395]                   3L)]
[15:32:37.395]             }
[15:32:37.395]             function(cond) {
[15:32:37.395]                 is_error <- inherits(cond, "error")
[15:32:37.395]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:37.395]                   NULL)
[15:32:37.395]                 if (is_error) {
[15:32:37.395]                   sessionInformation <- function() {
[15:32:37.395]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:37.395]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:37.395]                       search = base::search(), system = base::Sys.info())
[15:32:37.395]                   }
[15:32:37.395]                   ...future.conditions[[length(...future.conditions) + 
[15:32:37.395]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:37.395]                     cond$call), session = sessionInformation(), 
[15:32:37.395]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:37.395]                   signalCondition(cond)
[15:32:37.395]                 }
[15:32:37.395]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:37.395]                 "immediateCondition"))) {
[15:32:37.395]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:37.395]                   ...future.conditions[[length(...future.conditions) + 
[15:32:37.395]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:37.395]                   if (TRUE && !signal) {
[15:32:37.395]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:37.395]                     {
[15:32:37.395]                       inherits <- base::inherits
[15:32:37.395]                       invokeRestart <- base::invokeRestart
[15:32:37.395]                       is.null <- base::is.null
[15:32:37.395]                       muffled <- FALSE
[15:32:37.395]                       if (inherits(cond, "message")) {
[15:32:37.395]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:37.395]                         if (muffled) 
[15:32:37.395]                           invokeRestart("muffleMessage")
[15:32:37.395]                       }
[15:32:37.395]                       else if (inherits(cond, "warning")) {
[15:32:37.395]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:37.395]                         if (muffled) 
[15:32:37.395]                           invokeRestart("muffleWarning")
[15:32:37.395]                       }
[15:32:37.395]                       else if (inherits(cond, "condition")) {
[15:32:37.395]                         if (!is.null(pattern)) {
[15:32:37.395]                           computeRestarts <- base::computeRestarts
[15:32:37.395]                           grepl <- base::grepl
[15:32:37.395]                           restarts <- computeRestarts(cond)
[15:32:37.395]                           for (restart in restarts) {
[15:32:37.395]                             name <- restart$name
[15:32:37.395]                             if (is.null(name)) 
[15:32:37.395]                               next
[15:32:37.395]                             if (!grepl(pattern, name)) 
[15:32:37.395]                               next
[15:32:37.395]                             invokeRestart(restart)
[15:32:37.395]                             muffled <- TRUE
[15:32:37.395]                             break
[15:32:37.395]                           }
[15:32:37.395]                         }
[15:32:37.395]                       }
[15:32:37.395]                       invisible(muffled)
[15:32:37.395]                     }
[15:32:37.395]                     muffleCondition(cond, pattern = "^muffle")
[15:32:37.395]                   }
[15:32:37.395]                 }
[15:32:37.395]                 else {
[15:32:37.395]                   if (TRUE) {
[15:32:37.395]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:37.395]                     {
[15:32:37.395]                       inherits <- base::inherits
[15:32:37.395]                       invokeRestart <- base::invokeRestart
[15:32:37.395]                       is.null <- base::is.null
[15:32:37.395]                       muffled <- FALSE
[15:32:37.395]                       if (inherits(cond, "message")) {
[15:32:37.395]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:37.395]                         if (muffled) 
[15:32:37.395]                           invokeRestart("muffleMessage")
[15:32:37.395]                       }
[15:32:37.395]                       else if (inherits(cond, "warning")) {
[15:32:37.395]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:37.395]                         if (muffled) 
[15:32:37.395]                           invokeRestart("muffleWarning")
[15:32:37.395]                       }
[15:32:37.395]                       else if (inherits(cond, "condition")) {
[15:32:37.395]                         if (!is.null(pattern)) {
[15:32:37.395]                           computeRestarts <- base::computeRestarts
[15:32:37.395]                           grepl <- base::grepl
[15:32:37.395]                           restarts <- computeRestarts(cond)
[15:32:37.395]                           for (restart in restarts) {
[15:32:37.395]                             name <- restart$name
[15:32:37.395]                             if (is.null(name)) 
[15:32:37.395]                               next
[15:32:37.395]                             if (!grepl(pattern, name)) 
[15:32:37.395]                               next
[15:32:37.395]                             invokeRestart(restart)
[15:32:37.395]                             muffled <- TRUE
[15:32:37.395]                             break
[15:32:37.395]                           }
[15:32:37.395]                         }
[15:32:37.395]                       }
[15:32:37.395]                       invisible(muffled)
[15:32:37.395]                     }
[15:32:37.395]                     muffleCondition(cond, pattern = "^muffle")
[15:32:37.395]                   }
[15:32:37.395]                 }
[15:32:37.395]             }
[15:32:37.395]         }))
[15:32:37.395]     }, error = function(ex) {
[15:32:37.395]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:37.395]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:37.395]                 ...future.rng), started = ...future.startTime, 
[15:32:37.395]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:37.395]             version = "1.8"), class = "FutureResult")
[15:32:37.395]     }, finally = {
[15:32:37.395]         if (!identical(...future.workdir, getwd())) 
[15:32:37.395]             setwd(...future.workdir)
[15:32:37.395]         {
[15:32:37.395]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:37.395]                 ...future.oldOptions$nwarnings <- NULL
[15:32:37.395]             }
[15:32:37.395]             base::options(...future.oldOptions)
[15:32:37.395]             if (.Platform$OS.type == "windows") {
[15:32:37.395]                 old_names <- names(...future.oldEnvVars)
[15:32:37.395]                 envs <- base::Sys.getenv()
[15:32:37.395]                 names <- names(envs)
[15:32:37.395]                 common <- intersect(names, old_names)
[15:32:37.395]                 added <- setdiff(names, old_names)
[15:32:37.395]                 removed <- setdiff(old_names, names)
[15:32:37.395]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:37.395]                   envs[common]]
[15:32:37.395]                 NAMES <- toupper(changed)
[15:32:37.395]                 args <- list()
[15:32:37.395]                 for (kk in seq_along(NAMES)) {
[15:32:37.395]                   name <- changed[[kk]]
[15:32:37.395]                   NAME <- NAMES[[kk]]
[15:32:37.395]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:37.395]                     next
[15:32:37.395]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:37.395]                 }
[15:32:37.395]                 NAMES <- toupper(added)
[15:32:37.395]                 for (kk in seq_along(NAMES)) {
[15:32:37.395]                   name <- added[[kk]]
[15:32:37.395]                   NAME <- NAMES[[kk]]
[15:32:37.395]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:37.395]                     next
[15:32:37.395]                   args[[name]] <- ""
[15:32:37.395]                 }
[15:32:37.395]                 NAMES <- toupper(removed)
[15:32:37.395]                 for (kk in seq_along(NAMES)) {
[15:32:37.395]                   name <- removed[[kk]]
[15:32:37.395]                   NAME <- NAMES[[kk]]
[15:32:37.395]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:37.395]                     next
[15:32:37.395]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:37.395]                 }
[15:32:37.395]                 if (length(args) > 0) 
[15:32:37.395]                   base::do.call(base::Sys.setenv, args = args)
[15:32:37.395]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:37.395]             }
[15:32:37.395]             else {
[15:32:37.395]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:37.395]             }
[15:32:37.395]             {
[15:32:37.395]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:37.395]                   0L) {
[15:32:37.395]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:37.395]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:37.395]                   base::options(opts)
[15:32:37.395]                 }
[15:32:37.395]                 {
[15:32:37.395]                   {
[15:32:37.395]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:37.395]                     NULL
[15:32:37.395]                   }
[15:32:37.395]                   options(future.plan = NULL)
[15:32:37.395]                   if (is.na(NA_character_)) 
[15:32:37.395]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:37.395]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:37.395]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:37.395]                     .init = FALSE)
[15:32:37.395]                 }
[15:32:37.395]             }
[15:32:37.395]         }
[15:32:37.395]     })
[15:32:37.395]     if (TRUE) {
[15:32:37.395]         base::sink(type = "output", split = FALSE)
[15:32:37.395]         if (TRUE) {
[15:32:37.395]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:37.395]         }
[15:32:37.395]         else {
[15:32:37.395]             ...future.result["stdout"] <- base::list(NULL)
[15:32:37.395]         }
[15:32:37.395]         base::close(...future.stdout)
[15:32:37.395]         ...future.stdout <- NULL
[15:32:37.395]     }
[15:32:37.395]     ...future.result$conditions <- ...future.conditions
[15:32:37.395]     ...future.result$finished <- base::Sys.time()
[15:32:37.395]     ...future.result
[15:32:37.395] }
[15:32:37.405] Exporting 5 global objects (848 bytes) to cluster node #1 ...
[15:32:37.406] Exporting '...future.FUN' (848 bytes) to cluster node #1 ...
[15:32:37.407] Exporting '...future.FUN' (848 bytes) to cluster node #1 ... DONE
[15:32:37.407] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:37.408] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:37.409] Exporting '...future.elements_ii' (224 bytes) to cluster node #1 ...
[15:32:37.409] Exporting '...future.elements_ii' (224 bytes) to cluster node #1 ... DONE
[15:32:37.410] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:37.410] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:37.411] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:37.411] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:37.412] Exporting 5 global objects (848 bytes) to cluster node #1 ... DONE
[15:32:37.413] MultisessionFuture started
[15:32:37.413] - Launch lazy future ... done
[15:32:37.413] run() for 'MultisessionFuture' ... done
[15:32:37.414] Created future:
[15:32:37.441] receiveMessageFromWorker() for ClusterFuture ...
[15:32:37.442] - Validating connection of MultisessionFuture
[15:32:37.443] - received message: FutureResult
[15:32:37.443] - Received FutureResult
[15:32:37.443] - Erased future from FutureRegistry
[15:32:37.443] result() for ClusterFuture ...
[15:32:37.444] - result already collected: FutureResult
[15:32:37.444] result() for ClusterFuture ... done
[15:32:37.444] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:37.414] MultisessionFuture:
[15:32:37.414] Label: 'future_sapply-2'
[15:32:37.414] Expression:
[15:32:37.414] {
[15:32:37.414]     do.call(function(...) {
[15:32:37.414]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:37.414]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:37.414]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:37.414]             on.exit(options(oopts), add = TRUE)
[15:32:37.414]         }
[15:32:37.414]         {
[15:32:37.414]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:37.414]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:37.414]                 ...future.FUN(...future.X_jj, ...)
[15:32:37.414]             })
[15:32:37.414]         }
[15:32:37.414]     }, args = future.call.arguments)
[15:32:37.414] }
[15:32:37.414] Lazy evaluation: FALSE
[15:32:37.414] Asynchronous evaluation: TRUE
[15:32:37.414] Local evaluation: TRUE
[15:32:37.414] Environment: R_GlobalEnv
[15:32:37.414] Capture standard output: TRUE
[15:32:37.414] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:37.414] Globals: 5 objects totaling 1.05 KiB (function '...future.FUN' of 848 bytes, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 224 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:37.414] Packages: <none>
[15:32:37.414] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:37.414] Resolved: TRUE
[15:32:37.414] Value: <not collected>
[15:32:37.414] Conditions captured: <none>
[15:32:37.414] Early signaling: FALSE
[15:32:37.414] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:37.414] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:37.445] Chunk #2 of 2 ... DONE
[15:32:37.445] Launching 2 futures (chunks) ... DONE
[15:32:37.446] Resolving 2 futures (chunks) ...
[15:32:37.446] resolve() on list ...
[15:32:37.446]  recursive: 0
[15:32:37.446]  length: 2
[15:32:37.447] 
[15:32:37.454] Future #1
[15:32:37.454] result() for ClusterFuture ...
[15:32:37.454] - result already collected: FutureResult
[15:32:37.455] result() for ClusterFuture ... done
[15:32:37.455] result() for ClusterFuture ...
[15:32:37.455] - result already collected: FutureResult
[15:32:37.455] result() for ClusterFuture ... done
[15:32:37.456] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:37.456] - nx: 2
[15:32:37.456] - relay: TRUE
[15:32:37.457] - stdout: TRUE
[15:32:37.457] - signal: TRUE
[15:32:37.457] - resignal: FALSE
[15:32:37.457] - force: TRUE
[15:32:37.458] - relayed: [n=2] FALSE, FALSE
[15:32:37.458] - queued futures: [n=2] FALSE, FALSE
[15:32:37.458]  - until=1
[15:32:37.458]  - relaying element #1
[15:32:37.459] result() for ClusterFuture ...
[15:32:37.459] - result already collected: FutureResult
[15:32:37.459] result() for ClusterFuture ... done
[15:32:37.459] result() for ClusterFuture ...
[15:32:37.460] - result already collected: FutureResult
[15:32:37.460] result() for ClusterFuture ... done
[15:32:37.460] result() for ClusterFuture ...
[15:32:37.460] - result already collected: FutureResult
[15:32:37.461] result() for ClusterFuture ... done
[15:32:37.461] result() for ClusterFuture ...
[15:32:37.461] - result already collected: FutureResult
[15:32:37.461] result() for ClusterFuture ... done
[15:32:37.462] - relayed: [n=2] TRUE, FALSE
[15:32:37.462] - queued futures: [n=2] TRUE, FALSE
[15:32:37.462] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:37.462]  length: 1 (resolved future 1)
[15:32:37.463] Future #2
[15:32:37.463] result() for ClusterFuture ...
[15:32:37.463] - result already collected: FutureResult
[15:32:37.463] result() for ClusterFuture ... done
[15:32:37.464] result() for ClusterFuture ...
[15:32:37.464] - result already collected: FutureResult
[15:32:37.464] result() for ClusterFuture ... done
[15:32:37.464] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:37.465] - nx: 2
[15:32:37.465] - relay: TRUE
[15:32:37.465] - stdout: TRUE
[15:32:37.465] - signal: TRUE
[15:32:37.466] - resignal: FALSE
[15:32:37.466] - force: TRUE
[15:32:37.466] - relayed: [n=2] TRUE, FALSE
[15:32:37.466] - queued futures: [n=2] TRUE, FALSE
[15:32:37.467]  - until=2
[15:32:37.467]  - relaying element #2
[15:32:37.467] result() for ClusterFuture ...
[15:32:37.467] - result already collected: FutureResult
[15:32:37.468] result() for ClusterFuture ... done
[15:32:37.468] result() for ClusterFuture ...
[15:32:37.468] - result already collected: FutureResult
[15:32:37.468] result() for ClusterFuture ... done
[15:32:37.469] result() for ClusterFuture ...
[15:32:37.469] - result already collected: FutureResult
[15:32:37.469] result() for ClusterFuture ... done
[15:32:37.469] result() for ClusterFuture ...
[15:32:37.470] - result already collected: FutureResult
[15:32:37.470] result() for ClusterFuture ... done
[15:32:37.470] - relayed: [n=2] TRUE, TRUE
[15:32:37.470] - queued futures: [n=2] TRUE, TRUE
[15:32:37.471] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:37.471]  length: 0 (resolved future 2)
[15:32:37.471] Relaying remaining futures
[15:32:37.471] signalConditionsASAP(NULL, pos=0) ...
[15:32:37.472] - nx: 2
[15:32:37.472] - relay: TRUE
[15:32:37.472] - stdout: TRUE
[15:32:37.472] - signal: TRUE
[15:32:37.472] - resignal: FALSE
[15:32:37.473] - force: TRUE
[15:32:37.473] - relayed: [n=2] TRUE, TRUE
[15:32:37.473] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:37.474] - relayed: [n=2] TRUE, TRUE
[15:32:37.474] - queued futures: [n=2] TRUE, TRUE
[15:32:37.474] signalConditionsASAP(NULL, pos=0) ... done
[15:32:37.474] resolve() on list ... DONE
[15:32:37.475] result() for ClusterFuture ...
[15:32:37.475] - result already collected: FutureResult
[15:32:37.475] result() for ClusterFuture ... done
[15:32:37.475] result() for ClusterFuture ...
[15:32:37.476] - result already collected: FutureResult
[15:32:37.476] result() for ClusterFuture ... done
[15:32:37.476] result() for ClusterFuture ...
[15:32:37.476] - result already collected: FutureResult
[15:32:37.477] result() for ClusterFuture ... done
[15:32:37.477] result() for ClusterFuture ...
[15:32:37.477] - result already collected: FutureResult
[15:32:37.477] result() for ClusterFuture ... done
[15:32:37.478]  - Number of value chunks collected: 2
[15:32:37.478] Resolving 2 futures (chunks) ... DONE
[15:32:37.478] Reducing values from 2 chunks ...
[15:32:37.478]  - Number of values collected after concatenation: 3
[15:32:37.479]  - Number of values expected: 3
[15:32:37.479] Reducing values from 2 chunks ... DONE
[15:32:37.479] future_lapply() ... DONE
List of 2
 $ y0: Named chr [1:3] "a" "b" "c"
  ..- attr(*, "names")= chr [1:3] "a" "b" "c"
 $ y1: Named chr [1:3] "a" "b" "c"
  ..- attr(*, "names")= chr [1:3] "a" "b" "c"
[15:32:37.482] future_lapply() ...
[15:32:37.487] Number of chunks: 2
[15:32:37.487] getGlobalsAndPackagesXApply() ...
[15:32:37.488]  - future.globals: TRUE
[15:32:37.488] getGlobalsAndPackages() ...
[15:32:37.488] Searching for globals...
[15:32:37.490] - globals found: [2] 'FUN', 'UseMethod'
[15:32:37.491] Searching for globals ... DONE
[15:32:37.491] Resolving globals: FALSE
[15:32:37.492] The total size of the 1 globals is 1.22 KiB (1248 bytes)
[15:32:37.492] The total size of the 1 globals exported for future expression ('FUN()') is 1.22 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.22 KiB of class 'function')
[15:32:37.493] - globals: [1] 'FUN'
[15:32:37.493] 
[15:32:37.493] getGlobalsAndPackages() ... DONE
[15:32:37.493]  - globals found/used: [n=1] 'FUN'
[15:32:37.494]  - needed namespaces: [n=0] 
[15:32:37.494] Finding globals ... DONE
[15:32:37.494]  - use_args: TRUE
[15:32:37.494]  - Getting '...' globals ...
[15:32:37.495] resolve() on list ...
[15:32:37.495]  recursive: 0
[15:32:37.496]  length: 1
[15:32:37.496]  elements: '...'
[15:32:37.496]  length: 0 (resolved future 1)
[15:32:37.496] resolve() on list ... DONE
[15:32:37.497]    - '...' content: [n=0] 
[15:32:37.497] List of 1
[15:32:37.497]  $ ...: list()
[15:32:37.497]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:37.497]  - attr(*, "where")=List of 1
[15:32:37.497]   ..$ ...:<environment: 0x00000276e23371e8> 
[15:32:37.497]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:37.497]  - attr(*, "resolved")= logi TRUE
[15:32:37.497]  - attr(*, "total_size")= num NA
[15:32:37.502]  - Getting '...' globals ... DONE
[15:32:37.503] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:37.503] List of 2
[15:32:37.503]  $ ...future.FUN:function (x, ...)  
[15:32:37.503]  $ ...          : list()
[15:32:37.503]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:37.503]  - attr(*, "where")=List of 2
[15:32:37.503]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:37.503]   ..$ ...          :<environment: 0x00000276e23371e8> 
[15:32:37.503]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:37.503]  - attr(*, "resolved")= logi FALSE
[15:32:37.503]  - attr(*, "total_size")= num 1248
[15:32:37.508] Packages to be attached in all futures: [n=0] 
[15:32:37.509] getGlobalsAndPackagesXApply() ... DONE
[15:32:37.509] Number of futures (= number of chunks): 2
[15:32:37.510] Launching 2 futures (chunks) ...
[15:32:37.510] Chunk #1 of 2 ...
[15:32:37.510]  - Finding globals in 'X' for chunk #1 ...
[15:32:37.511] getGlobalsAndPackages() ...
[15:32:37.511] Searching for globals...
[15:32:37.511] 
[15:32:37.512] Searching for globals ... DONE
[15:32:37.512] - globals: [0] <none>
[15:32:37.512] getGlobalsAndPackages() ... DONE
[15:32:37.512]    + additional globals found: [n=0] 
[15:32:37.513]    + additional namespaces needed: [n=0] 
[15:32:37.513]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:37.513]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:37.514]  - seeds: <none>
[15:32:37.514]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:37.514] getGlobalsAndPackages() ...
[15:32:37.514] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:37.515] Resolving globals: FALSE
[15:32:37.515] Tweak future expression to call with '...' arguments ...
[15:32:37.515] {
[15:32:37.515]     do.call(function(...) {
[15:32:37.515]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:37.515]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:37.515]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:37.515]             on.exit(options(oopts), add = TRUE)
[15:32:37.515]         }
[15:32:37.515]         {
[15:32:37.515]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:37.515]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:37.515]                 ...future.FUN(...future.X_jj, ...)
[15:32:37.515]             })
[15:32:37.515]         }
[15:32:37.515]     }, args = future.call.arguments)
[15:32:37.515] }
[15:32:37.516] Tweak future expression to call with '...' arguments ... DONE
[15:32:37.517] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:37.517] 
[15:32:37.518] getGlobalsAndPackages() ... DONE
[15:32:37.518] run() for 'Future' ...
[15:32:37.519] - state: 'created'
[15:32:37.519] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:37.536] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:37.537] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:37.537]   - Field: 'node'
[15:32:37.538]   - Field: 'label'
[15:32:37.538]   - Field: 'local'
[15:32:37.538]   - Field: 'owner'
[15:32:37.538]   - Field: 'envir'
[15:32:37.539]   - Field: 'workers'
[15:32:37.539]   - Field: 'packages'
[15:32:37.539]   - Field: 'gc'
[15:32:37.540]   - Field: 'conditions'
[15:32:37.540]   - Field: 'persistent'
[15:32:37.540]   - Field: 'expr'
[15:32:37.540]   - Field: 'uuid'
[15:32:37.541]   - Field: 'seed'
[15:32:37.541]   - Field: 'version'
[15:32:37.541]   - Field: 'result'
[15:32:37.542]   - Field: 'asynchronous'
[15:32:37.542]   - Field: 'calls'
[15:32:37.542]   - Field: 'globals'
[15:32:37.542]   - Field: 'stdout'
[15:32:37.543]   - Field: 'earlySignal'
[15:32:37.543]   - Field: 'lazy'
[15:32:37.543]   - Field: 'state'
[15:32:37.544] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:37.544] - Launch lazy future ...
[15:32:37.544] Packages needed by the future expression (n = 0): <none>
[15:32:37.545] Packages needed by future strategies (n = 0): <none>
[15:32:37.546] {
[15:32:37.546]     {
[15:32:37.546]         {
[15:32:37.546]             ...future.startTime <- base::Sys.time()
[15:32:37.546]             {
[15:32:37.546]                 {
[15:32:37.546]                   {
[15:32:37.546]                     {
[15:32:37.546]                       base::local({
[15:32:37.546]                         has_future <- base::requireNamespace("future", 
[15:32:37.546]                           quietly = TRUE)
[15:32:37.546]                         if (has_future) {
[15:32:37.546]                           ns <- base::getNamespace("future")
[15:32:37.546]                           version <- ns[[".package"]][["version"]]
[15:32:37.546]                           if (is.null(version)) 
[15:32:37.546]                             version <- utils::packageVersion("future")
[15:32:37.546]                         }
[15:32:37.546]                         else {
[15:32:37.546]                           version <- NULL
[15:32:37.546]                         }
[15:32:37.546]                         if (!has_future || version < "1.8.0") {
[15:32:37.546]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:37.546]                             "", base::R.version$version.string), 
[15:32:37.546]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:37.546]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:37.546]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:37.546]                               "release", "version")], collapse = " "), 
[15:32:37.546]                             hostname = base::Sys.info()[["nodename"]])
[15:32:37.546]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:37.546]                             info)
[15:32:37.546]                           info <- base::paste(info, collapse = "; ")
[15:32:37.546]                           if (!has_future) {
[15:32:37.546]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:37.546]                               info)
[15:32:37.546]                           }
[15:32:37.546]                           else {
[15:32:37.546]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:37.546]                               info, version)
[15:32:37.546]                           }
[15:32:37.546]                           base::stop(msg)
[15:32:37.546]                         }
[15:32:37.546]                       })
[15:32:37.546]                     }
[15:32:37.546]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:37.546]                     base::options(mc.cores = 1L)
[15:32:37.546]                   }
[15:32:37.546]                   ...future.strategy.old <- future::plan("list")
[15:32:37.546]                   options(future.plan = NULL)
[15:32:37.546]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:37.546]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:37.546]                 }
[15:32:37.546]                 ...future.workdir <- getwd()
[15:32:37.546]             }
[15:32:37.546]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:37.546]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:37.546]         }
[15:32:37.546]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:37.546]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:37.546]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:37.546]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:37.546]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:37.546]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:37.546]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:37.546]             base::names(...future.oldOptions))
[15:32:37.546]     }
[15:32:37.546]     if (FALSE) {
[15:32:37.546]     }
[15:32:37.546]     else {
[15:32:37.546]         if (TRUE) {
[15:32:37.546]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:37.546]                 open = "w")
[15:32:37.546]         }
[15:32:37.546]         else {
[15:32:37.546]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:37.546]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:37.546]         }
[15:32:37.546]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:37.546]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:37.546]             base::sink(type = "output", split = FALSE)
[15:32:37.546]             base::close(...future.stdout)
[15:32:37.546]         }, add = TRUE)
[15:32:37.546]     }
[15:32:37.546]     ...future.frame <- base::sys.nframe()
[15:32:37.546]     ...future.conditions <- base::list()
[15:32:37.546]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:37.546]     if (FALSE) {
[15:32:37.546]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:37.546]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:37.546]     }
[15:32:37.546]     ...future.result <- base::tryCatch({
[15:32:37.546]         base::withCallingHandlers({
[15:32:37.546]             ...future.value <- base::withVisible(base::local({
[15:32:37.546]                 ...future.makeSendCondition <- base::local({
[15:32:37.546]                   sendCondition <- NULL
[15:32:37.546]                   function(frame = 1L) {
[15:32:37.546]                     if (is.function(sendCondition)) 
[15:32:37.546]                       return(sendCondition)
[15:32:37.546]                     ns <- getNamespace("parallel")
[15:32:37.546]                     if (exists("sendData", mode = "function", 
[15:32:37.546]                       envir = ns)) {
[15:32:37.546]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:37.546]                         envir = ns)
[15:32:37.546]                       envir <- sys.frame(frame)
[15:32:37.546]                       master <- NULL
[15:32:37.546]                       while (!identical(envir, .GlobalEnv) && 
[15:32:37.546]                         !identical(envir, emptyenv())) {
[15:32:37.546]                         if (exists("master", mode = "list", envir = envir, 
[15:32:37.546]                           inherits = FALSE)) {
[15:32:37.546]                           master <- get("master", mode = "list", 
[15:32:37.546]                             envir = envir, inherits = FALSE)
[15:32:37.546]                           if (inherits(master, c("SOCKnode", 
[15:32:37.546]                             "SOCK0node"))) {
[15:32:37.546]                             sendCondition <<- function(cond) {
[15:32:37.546]                               data <- list(type = "VALUE", value = cond, 
[15:32:37.546]                                 success = TRUE)
[15:32:37.546]                               parallel_sendData(master, data)
[15:32:37.546]                             }
[15:32:37.546]                             return(sendCondition)
[15:32:37.546]                           }
[15:32:37.546]                         }
[15:32:37.546]                         frame <- frame + 1L
[15:32:37.546]                         envir <- sys.frame(frame)
[15:32:37.546]                       }
[15:32:37.546]                     }
[15:32:37.546]                     sendCondition <<- function(cond) NULL
[15:32:37.546]                   }
[15:32:37.546]                 })
[15:32:37.546]                 withCallingHandlers({
[15:32:37.546]                   {
[15:32:37.546]                     do.call(function(...) {
[15:32:37.546]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:37.546]                       if (!identical(...future.globals.maxSize.org, 
[15:32:37.546]                         ...future.globals.maxSize)) {
[15:32:37.546]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:37.546]                         on.exit(options(oopts), add = TRUE)
[15:32:37.546]                       }
[15:32:37.546]                       {
[15:32:37.546]                         lapply(seq_along(...future.elements_ii), 
[15:32:37.546]                           FUN = function(jj) {
[15:32:37.546]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:37.546]                             ...future.FUN(...future.X_jj, ...)
[15:32:37.546]                           })
[15:32:37.546]                       }
[15:32:37.546]                     }, args = future.call.arguments)
[15:32:37.546]                   }
[15:32:37.546]                 }, immediateCondition = function(cond) {
[15:32:37.546]                   sendCondition <- ...future.makeSendCondition()
[15:32:37.546]                   sendCondition(cond)
[15:32:37.546]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:37.546]                   {
[15:32:37.546]                     inherits <- base::inherits
[15:32:37.546]                     invokeRestart <- base::invokeRestart
[15:32:37.546]                     is.null <- base::is.null
[15:32:37.546]                     muffled <- FALSE
[15:32:37.546]                     if (inherits(cond, "message")) {
[15:32:37.546]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:37.546]                       if (muffled) 
[15:32:37.546]                         invokeRestart("muffleMessage")
[15:32:37.546]                     }
[15:32:37.546]                     else if (inherits(cond, "warning")) {
[15:32:37.546]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:37.546]                       if (muffled) 
[15:32:37.546]                         invokeRestart("muffleWarning")
[15:32:37.546]                     }
[15:32:37.546]                     else if (inherits(cond, "condition")) {
[15:32:37.546]                       if (!is.null(pattern)) {
[15:32:37.546]                         computeRestarts <- base::computeRestarts
[15:32:37.546]                         grepl <- base::grepl
[15:32:37.546]                         restarts <- computeRestarts(cond)
[15:32:37.546]                         for (restart in restarts) {
[15:32:37.546]                           name <- restart$name
[15:32:37.546]                           if (is.null(name)) 
[15:32:37.546]                             next
[15:32:37.546]                           if (!grepl(pattern, name)) 
[15:32:37.546]                             next
[15:32:37.546]                           invokeRestart(restart)
[15:32:37.546]                           muffled <- TRUE
[15:32:37.546]                           break
[15:32:37.546]                         }
[15:32:37.546]                       }
[15:32:37.546]                     }
[15:32:37.546]                     invisible(muffled)
[15:32:37.546]                   }
[15:32:37.546]                   muffleCondition(cond)
[15:32:37.546]                 })
[15:32:37.546]             }))
[15:32:37.546]             future::FutureResult(value = ...future.value$value, 
[15:32:37.546]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:37.546]                   ...future.rng), globalenv = if (FALSE) 
[15:32:37.546]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:37.546]                     ...future.globalenv.names))
[15:32:37.546]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:37.546]         }, condition = base::local({
[15:32:37.546]             c <- base::c
[15:32:37.546]             inherits <- base::inherits
[15:32:37.546]             invokeRestart <- base::invokeRestart
[15:32:37.546]             length <- base::length
[15:32:37.546]             list <- base::list
[15:32:37.546]             seq.int <- base::seq.int
[15:32:37.546]             signalCondition <- base::signalCondition
[15:32:37.546]             sys.calls <- base::sys.calls
[15:32:37.546]             `[[` <- base::`[[`
[15:32:37.546]             `+` <- base::`+`
[15:32:37.546]             `<<-` <- base::`<<-`
[15:32:37.546]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:37.546]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:37.546]                   3L)]
[15:32:37.546]             }
[15:32:37.546]             function(cond) {
[15:32:37.546]                 is_error <- inherits(cond, "error")
[15:32:37.546]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:37.546]                   NULL)
[15:32:37.546]                 if (is_error) {
[15:32:37.546]                   sessionInformation <- function() {
[15:32:37.546]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:37.546]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:37.546]                       search = base::search(), system = base::Sys.info())
[15:32:37.546]                   }
[15:32:37.546]                   ...future.conditions[[length(...future.conditions) + 
[15:32:37.546]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:37.546]                     cond$call), session = sessionInformation(), 
[15:32:37.546]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:37.546]                   signalCondition(cond)
[15:32:37.546]                 }
[15:32:37.546]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:37.546]                 "immediateCondition"))) {
[15:32:37.546]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:37.546]                   ...future.conditions[[length(...future.conditions) + 
[15:32:37.546]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:37.546]                   if (TRUE && !signal) {
[15:32:37.546]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:37.546]                     {
[15:32:37.546]                       inherits <- base::inherits
[15:32:37.546]                       invokeRestart <- base::invokeRestart
[15:32:37.546]                       is.null <- base::is.null
[15:32:37.546]                       muffled <- FALSE
[15:32:37.546]                       if (inherits(cond, "message")) {
[15:32:37.546]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:37.546]                         if (muffled) 
[15:32:37.546]                           invokeRestart("muffleMessage")
[15:32:37.546]                       }
[15:32:37.546]                       else if (inherits(cond, "warning")) {
[15:32:37.546]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:37.546]                         if (muffled) 
[15:32:37.546]                           invokeRestart("muffleWarning")
[15:32:37.546]                       }
[15:32:37.546]                       else if (inherits(cond, "condition")) {
[15:32:37.546]                         if (!is.null(pattern)) {
[15:32:37.546]                           computeRestarts <- base::computeRestarts
[15:32:37.546]                           grepl <- base::grepl
[15:32:37.546]                           restarts <- computeRestarts(cond)
[15:32:37.546]                           for (restart in restarts) {
[15:32:37.546]                             name <- restart$name
[15:32:37.546]                             if (is.null(name)) 
[15:32:37.546]                               next
[15:32:37.546]                             if (!grepl(pattern, name)) 
[15:32:37.546]                               next
[15:32:37.546]                             invokeRestart(restart)
[15:32:37.546]                             muffled <- TRUE
[15:32:37.546]                             break
[15:32:37.546]                           }
[15:32:37.546]                         }
[15:32:37.546]                       }
[15:32:37.546]                       invisible(muffled)
[15:32:37.546]                     }
[15:32:37.546]                     muffleCondition(cond, pattern = "^muffle")
[15:32:37.546]                   }
[15:32:37.546]                 }
[15:32:37.546]                 else {
[15:32:37.546]                   if (TRUE) {
[15:32:37.546]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:37.546]                     {
[15:32:37.546]                       inherits <- base::inherits
[15:32:37.546]                       invokeRestart <- base::invokeRestart
[15:32:37.546]                       is.null <- base::is.null
[15:32:37.546]                       muffled <- FALSE
[15:32:37.546]                       if (inherits(cond, "message")) {
[15:32:37.546]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:37.546]                         if (muffled) 
[15:32:37.546]                           invokeRestart("muffleMessage")
[15:32:37.546]                       }
[15:32:37.546]                       else if (inherits(cond, "warning")) {
[15:32:37.546]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:37.546]                         if (muffled) 
[15:32:37.546]                           invokeRestart("muffleWarning")
[15:32:37.546]                       }
[15:32:37.546]                       else if (inherits(cond, "condition")) {
[15:32:37.546]                         if (!is.null(pattern)) {
[15:32:37.546]                           computeRestarts <- base::computeRestarts
[15:32:37.546]                           grepl <- base::grepl
[15:32:37.546]                           restarts <- computeRestarts(cond)
[15:32:37.546]                           for (restart in restarts) {
[15:32:37.546]                             name <- restart$name
[15:32:37.546]                             if (is.null(name)) 
[15:32:37.546]                               next
[15:32:37.546]                             if (!grepl(pattern, name)) 
[15:32:37.546]                               next
[15:32:37.546]                             invokeRestart(restart)
[15:32:37.546]                             muffled <- TRUE
[15:32:37.546]                             break
[15:32:37.546]                           }
[15:32:37.546]                         }
[15:32:37.546]                       }
[15:32:37.546]                       invisible(muffled)
[15:32:37.546]                     }
[15:32:37.546]                     muffleCondition(cond, pattern = "^muffle")
[15:32:37.546]                   }
[15:32:37.546]                 }
[15:32:37.546]             }
[15:32:37.546]         }))
[15:32:37.546]     }, error = function(ex) {
[15:32:37.546]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:37.546]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:37.546]                 ...future.rng), started = ...future.startTime, 
[15:32:37.546]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:37.546]             version = "1.8"), class = "FutureResult")
[15:32:37.546]     }, finally = {
[15:32:37.546]         if (!identical(...future.workdir, getwd())) 
[15:32:37.546]             setwd(...future.workdir)
[15:32:37.546]         {
[15:32:37.546]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:37.546]                 ...future.oldOptions$nwarnings <- NULL
[15:32:37.546]             }
[15:32:37.546]             base::options(...future.oldOptions)
[15:32:37.546]             if (.Platform$OS.type == "windows") {
[15:32:37.546]                 old_names <- names(...future.oldEnvVars)
[15:32:37.546]                 envs <- base::Sys.getenv()
[15:32:37.546]                 names <- names(envs)
[15:32:37.546]                 common <- intersect(names, old_names)
[15:32:37.546]                 added <- setdiff(names, old_names)
[15:32:37.546]                 removed <- setdiff(old_names, names)
[15:32:37.546]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:37.546]                   envs[common]]
[15:32:37.546]                 NAMES <- toupper(changed)
[15:32:37.546]                 args <- list()
[15:32:37.546]                 for (kk in seq_along(NAMES)) {
[15:32:37.546]                   name <- changed[[kk]]
[15:32:37.546]                   NAME <- NAMES[[kk]]
[15:32:37.546]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:37.546]                     next
[15:32:37.546]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:37.546]                 }
[15:32:37.546]                 NAMES <- toupper(added)
[15:32:37.546]                 for (kk in seq_along(NAMES)) {
[15:32:37.546]                   name <- added[[kk]]
[15:32:37.546]                   NAME <- NAMES[[kk]]
[15:32:37.546]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:37.546]                     next
[15:32:37.546]                   args[[name]] <- ""
[15:32:37.546]                 }
[15:32:37.546]                 NAMES <- toupper(removed)
[15:32:37.546]                 for (kk in seq_along(NAMES)) {
[15:32:37.546]                   name <- removed[[kk]]
[15:32:37.546]                   NAME <- NAMES[[kk]]
[15:32:37.546]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:37.546]                     next
[15:32:37.546]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:37.546]                 }
[15:32:37.546]                 if (length(args) > 0) 
[15:32:37.546]                   base::do.call(base::Sys.setenv, args = args)
[15:32:37.546]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:37.546]             }
[15:32:37.546]             else {
[15:32:37.546]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:37.546]             }
[15:32:37.546]             {
[15:32:37.546]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:37.546]                   0L) {
[15:32:37.546]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:37.546]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:37.546]                   base::options(opts)
[15:32:37.546]                 }
[15:32:37.546]                 {
[15:32:37.546]                   {
[15:32:37.546]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:37.546]                     NULL
[15:32:37.546]                   }
[15:32:37.546]                   options(future.plan = NULL)
[15:32:37.546]                   if (is.na(NA_character_)) 
[15:32:37.546]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:37.546]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:37.546]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:37.546]                     .init = FALSE)
[15:32:37.546]                 }
[15:32:37.546]             }
[15:32:37.546]         }
[15:32:37.546]     })
[15:32:37.546]     if (TRUE) {
[15:32:37.546]         base::sink(type = "output", split = FALSE)
[15:32:37.546]         if (TRUE) {
[15:32:37.546]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:37.546]         }
[15:32:37.546]         else {
[15:32:37.546]             ...future.result["stdout"] <- base::list(NULL)
[15:32:37.546]         }
[15:32:37.546]         base::close(...future.stdout)
[15:32:37.546]         ...future.stdout <- NULL
[15:32:37.546]     }
[15:32:37.546]     ...future.result$conditions <- ...future.conditions
[15:32:37.546]     ...future.result$finished <- base::Sys.time()
[15:32:37.546]     ...future.result
[15:32:37.546] }
[15:32:37.555] Exporting 5 global objects (1.22 KiB) to cluster node #1 ...
[15:32:37.555] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ...
[15:32:37.556] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ... DONE
[15:32:37.556] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:37.557] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:37.557] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:37.558] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:37.558] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:37.559] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:37.559] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:37.560] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:37.560] Exporting 5 global objects (1.22 KiB) to cluster node #1 ... DONE
[15:32:37.561] MultisessionFuture started
[15:32:37.561] - Launch lazy future ... done
[15:32:37.561] run() for 'MultisessionFuture' ... done
[15:32:37.562] Created future:
[15:32:37.585] receiveMessageFromWorker() for ClusterFuture ...
[15:32:37.586] - Validating connection of MultisessionFuture
[15:32:37.586] - received message: FutureResult
[15:32:37.586] - Received FutureResult
[15:32:37.586] - Erased future from FutureRegistry
[15:32:37.587] result() for ClusterFuture ...
[15:32:37.587] - result already collected: FutureResult
[15:32:37.587] result() for ClusterFuture ... done
[15:32:37.587] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:37.562] MultisessionFuture:
[15:32:37.562] Label: 'future_sapply-1'
[15:32:37.562] Expression:
[15:32:37.562] {
[15:32:37.562]     do.call(function(...) {
[15:32:37.562]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:37.562]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:37.562]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:37.562]             on.exit(options(oopts), add = TRUE)
[15:32:37.562]         }
[15:32:37.562]         {
[15:32:37.562]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:37.562]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:37.562]                 ...future.FUN(...future.X_jj, ...)
[15:32:37.562]             })
[15:32:37.562]         }
[15:32:37.562]     }, args = future.call.arguments)
[15:32:37.562] }
[15:32:37.562] Lazy evaluation: FALSE
[15:32:37.562] Asynchronous evaluation: TRUE
[15:32:37.562] Local evaluation: TRUE
[15:32:37.562] Environment: R_GlobalEnv
[15:32:37.562] Capture standard output: TRUE
[15:32:37.562] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:37.562] Globals: 5 objects totaling 1.33 KiB (function '...future.FUN' of 1.22 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)
[15:32:37.562] Packages: <none>
[15:32:37.562] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:37.562] Resolved: TRUE
[15:32:37.562] Value: <not collected>
[15:32:37.562] Conditions captured: <none>
[15:32:37.562] Early signaling: FALSE
[15:32:37.562] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:37.562] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:37.588] Chunk #1 of 2 ... DONE
[15:32:37.588] Chunk #2 of 2 ...
[15:32:37.588]  - Finding globals in 'X' for chunk #2 ...
[15:32:37.588] getGlobalsAndPackages() ...
[15:32:37.588] Searching for globals...
[15:32:37.589] 
[15:32:37.589] Searching for globals ... DONE
[15:32:37.589] - globals: [0] <none>
[15:32:37.589] getGlobalsAndPackages() ... DONE
[15:32:37.589]    + additional globals found: [n=0] 
[15:32:37.589]    + additional namespaces needed: [n=0] 
[15:32:37.590]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:37.590]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:37.590]  - seeds: <none>
[15:32:37.590]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:37.590] getGlobalsAndPackages() ...
[15:32:37.590] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:37.591] Resolving globals: FALSE
[15:32:37.591] Tweak future expression to call with '...' arguments ...
[15:32:37.591] {
[15:32:37.591]     do.call(function(...) {
[15:32:37.591]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:37.591]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:37.591]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:37.591]             on.exit(options(oopts), add = TRUE)
[15:32:37.591]         }
[15:32:37.591]         {
[15:32:37.591]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:37.591]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:37.591]                 ...future.FUN(...future.X_jj, ...)
[15:32:37.591]             })
[15:32:37.591]         }
[15:32:37.591]     }, args = future.call.arguments)
[15:32:37.591] }
[15:32:37.592] Tweak future expression to call with '...' arguments ... DONE
[15:32:37.592] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:37.592] 
[15:32:37.592] getGlobalsAndPackages() ... DONE
[15:32:37.593] run() for 'Future' ...
[15:32:37.593] - state: 'created'
[15:32:37.593] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:37.609] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:37.609] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:37.609]   - Field: 'node'
[15:32:37.610]   - Field: 'label'
[15:32:37.610]   - Field: 'local'
[15:32:37.610]   - Field: 'owner'
[15:32:37.611]   - Field: 'envir'
[15:32:37.611]   - Field: 'workers'
[15:32:37.611]   - Field: 'packages'
[15:32:37.612]   - Field: 'gc'
[15:32:37.612]   - Field: 'conditions'
[15:32:37.612]   - Field: 'persistent'
[15:32:37.613]   - Field: 'expr'
[15:32:37.613]   - Field: 'uuid'
[15:32:37.613]   - Field: 'seed'
[15:32:37.613]   - Field: 'version'
[15:32:37.614]   - Field: 'result'
[15:32:37.614]   - Field: 'asynchronous'
[15:32:37.614]   - Field: 'calls'
[15:32:37.615]   - Field: 'globals'
[15:32:37.615]   - Field: 'stdout'
[15:32:37.615]   - Field: 'earlySignal'
[15:32:37.615]   - Field: 'lazy'
[15:32:37.616]   - Field: 'state'
[15:32:37.616] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:37.616] - Launch lazy future ...
[15:32:37.617] Packages needed by the future expression (n = 0): <none>
[15:32:37.617] Packages needed by future strategies (n = 0): <none>
[15:32:37.618] {
[15:32:37.618]     {
[15:32:37.618]         {
[15:32:37.618]             ...future.startTime <- base::Sys.time()
[15:32:37.618]             {
[15:32:37.618]                 {
[15:32:37.618]                   {
[15:32:37.618]                     {
[15:32:37.618]                       base::local({
[15:32:37.618]                         has_future <- base::requireNamespace("future", 
[15:32:37.618]                           quietly = TRUE)
[15:32:37.618]                         if (has_future) {
[15:32:37.618]                           ns <- base::getNamespace("future")
[15:32:37.618]                           version <- ns[[".package"]][["version"]]
[15:32:37.618]                           if (is.null(version)) 
[15:32:37.618]                             version <- utils::packageVersion("future")
[15:32:37.618]                         }
[15:32:37.618]                         else {
[15:32:37.618]                           version <- NULL
[15:32:37.618]                         }
[15:32:37.618]                         if (!has_future || version < "1.8.0") {
[15:32:37.618]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:37.618]                             "", base::R.version$version.string), 
[15:32:37.618]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:37.618]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:37.618]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:37.618]                               "release", "version")], collapse = " "), 
[15:32:37.618]                             hostname = base::Sys.info()[["nodename"]])
[15:32:37.618]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:37.618]                             info)
[15:32:37.618]                           info <- base::paste(info, collapse = "; ")
[15:32:37.618]                           if (!has_future) {
[15:32:37.618]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:37.618]                               info)
[15:32:37.618]                           }
[15:32:37.618]                           else {
[15:32:37.618]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:37.618]                               info, version)
[15:32:37.618]                           }
[15:32:37.618]                           base::stop(msg)
[15:32:37.618]                         }
[15:32:37.618]                       })
[15:32:37.618]                     }
[15:32:37.618]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:37.618]                     base::options(mc.cores = 1L)
[15:32:37.618]                   }
[15:32:37.618]                   ...future.strategy.old <- future::plan("list")
[15:32:37.618]                   options(future.plan = NULL)
[15:32:37.618]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:37.618]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:37.618]                 }
[15:32:37.618]                 ...future.workdir <- getwd()
[15:32:37.618]             }
[15:32:37.618]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:37.618]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:37.618]         }
[15:32:37.618]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:37.618]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:37.618]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:37.618]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:37.618]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:37.618]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:37.618]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:37.618]             base::names(...future.oldOptions))
[15:32:37.618]     }
[15:32:37.618]     if (FALSE) {
[15:32:37.618]     }
[15:32:37.618]     else {
[15:32:37.618]         if (TRUE) {
[15:32:37.618]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:37.618]                 open = "w")
[15:32:37.618]         }
[15:32:37.618]         else {
[15:32:37.618]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:37.618]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:37.618]         }
[15:32:37.618]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:37.618]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:37.618]             base::sink(type = "output", split = FALSE)
[15:32:37.618]             base::close(...future.stdout)
[15:32:37.618]         }, add = TRUE)
[15:32:37.618]     }
[15:32:37.618]     ...future.frame <- base::sys.nframe()
[15:32:37.618]     ...future.conditions <- base::list()
[15:32:37.618]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:37.618]     if (FALSE) {
[15:32:37.618]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:37.618]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:37.618]     }
[15:32:37.618]     ...future.result <- base::tryCatch({
[15:32:37.618]         base::withCallingHandlers({
[15:32:37.618]             ...future.value <- base::withVisible(base::local({
[15:32:37.618]                 ...future.makeSendCondition <- base::local({
[15:32:37.618]                   sendCondition <- NULL
[15:32:37.618]                   function(frame = 1L) {
[15:32:37.618]                     if (is.function(sendCondition)) 
[15:32:37.618]                       return(sendCondition)
[15:32:37.618]                     ns <- getNamespace("parallel")
[15:32:37.618]                     if (exists("sendData", mode = "function", 
[15:32:37.618]                       envir = ns)) {
[15:32:37.618]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:37.618]                         envir = ns)
[15:32:37.618]                       envir <- sys.frame(frame)
[15:32:37.618]                       master <- NULL
[15:32:37.618]                       while (!identical(envir, .GlobalEnv) && 
[15:32:37.618]                         !identical(envir, emptyenv())) {
[15:32:37.618]                         if (exists("master", mode = "list", envir = envir, 
[15:32:37.618]                           inherits = FALSE)) {
[15:32:37.618]                           master <- get("master", mode = "list", 
[15:32:37.618]                             envir = envir, inherits = FALSE)
[15:32:37.618]                           if (inherits(master, c("SOCKnode", 
[15:32:37.618]                             "SOCK0node"))) {
[15:32:37.618]                             sendCondition <<- function(cond) {
[15:32:37.618]                               data <- list(type = "VALUE", value = cond, 
[15:32:37.618]                                 success = TRUE)
[15:32:37.618]                               parallel_sendData(master, data)
[15:32:37.618]                             }
[15:32:37.618]                             return(sendCondition)
[15:32:37.618]                           }
[15:32:37.618]                         }
[15:32:37.618]                         frame <- frame + 1L
[15:32:37.618]                         envir <- sys.frame(frame)
[15:32:37.618]                       }
[15:32:37.618]                     }
[15:32:37.618]                     sendCondition <<- function(cond) NULL
[15:32:37.618]                   }
[15:32:37.618]                 })
[15:32:37.618]                 withCallingHandlers({
[15:32:37.618]                   {
[15:32:37.618]                     do.call(function(...) {
[15:32:37.618]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:37.618]                       if (!identical(...future.globals.maxSize.org, 
[15:32:37.618]                         ...future.globals.maxSize)) {
[15:32:37.618]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:37.618]                         on.exit(options(oopts), add = TRUE)
[15:32:37.618]                       }
[15:32:37.618]                       {
[15:32:37.618]                         lapply(seq_along(...future.elements_ii), 
[15:32:37.618]                           FUN = function(jj) {
[15:32:37.618]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:37.618]                             ...future.FUN(...future.X_jj, ...)
[15:32:37.618]                           })
[15:32:37.618]                       }
[15:32:37.618]                     }, args = future.call.arguments)
[15:32:37.618]                   }
[15:32:37.618]                 }, immediateCondition = function(cond) {
[15:32:37.618]                   sendCondition <- ...future.makeSendCondition()
[15:32:37.618]                   sendCondition(cond)
[15:32:37.618]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:37.618]                   {
[15:32:37.618]                     inherits <- base::inherits
[15:32:37.618]                     invokeRestart <- base::invokeRestart
[15:32:37.618]                     is.null <- base::is.null
[15:32:37.618]                     muffled <- FALSE
[15:32:37.618]                     if (inherits(cond, "message")) {
[15:32:37.618]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:37.618]                       if (muffled) 
[15:32:37.618]                         invokeRestart("muffleMessage")
[15:32:37.618]                     }
[15:32:37.618]                     else if (inherits(cond, "warning")) {
[15:32:37.618]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:37.618]                       if (muffled) 
[15:32:37.618]                         invokeRestart("muffleWarning")
[15:32:37.618]                     }
[15:32:37.618]                     else if (inherits(cond, "condition")) {
[15:32:37.618]                       if (!is.null(pattern)) {
[15:32:37.618]                         computeRestarts <- base::computeRestarts
[15:32:37.618]                         grepl <- base::grepl
[15:32:37.618]                         restarts <- computeRestarts(cond)
[15:32:37.618]                         for (restart in restarts) {
[15:32:37.618]                           name <- restart$name
[15:32:37.618]                           if (is.null(name)) 
[15:32:37.618]                             next
[15:32:37.618]                           if (!grepl(pattern, name)) 
[15:32:37.618]                             next
[15:32:37.618]                           invokeRestart(restart)
[15:32:37.618]                           muffled <- TRUE
[15:32:37.618]                           break
[15:32:37.618]                         }
[15:32:37.618]                       }
[15:32:37.618]                     }
[15:32:37.618]                     invisible(muffled)
[15:32:37.618]                   }
[15:32:37.618]                   muffleCondition(cond)
[15:32:37.618]                 })
[15:32:37.618]             }))
[15:32:37.618]             future::FutureResult(value = ...future.value$value, 
[15:32:37.618]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:37.618]                   ...future.rng), globalenv = if (FALSE) 
[15:32:37.618]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:37.618]                     ...future.globalenv.names))
[15:32:37.618]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:37.618]         }, condition = base::local({
[15:32:37.618]             c <- base::c
[15:32:37.618]             inherits <- base::inherits
[15:32:37.618]             invokeRestart <- base::invokeRestart
[15:32:37.618]             length <- base::length
[15:32:37.618]             list <- base::list
[15:32:37.618]             seq.int <- base::seq.int
[15:32:37.618]             signalCondition <- base::signalCondition
[15:32:37.618]             sys.calls <- base::sys.calls
[15:32:37.618]             `[[` <- base::`[[`
[15:32:37.618]             `+` <- base::`+`
[15:32:37.618]             `<<-` <- base::`<<-`
[15:32:37.618]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:37.618]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:37.618]                   3L)]
[15:32:37.618]             }
[15:32:37.618]             function(cond) {
[15:32:37.618]                 is_error <- inherits(cond, "error")
[15:32:37.618]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:37.618]                   NULL)
[15:32:37.618]                 if (is_error) {
[15:32:37.618]                   sessionInformation <- function() {
[15:32:37.618]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:37.618]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:37.618]                       search = base::search(), system = base::Sys.info())
[15:32:37.618]                   }
[15:32:37.618]                   ...future.conditions[[length(...future.conditions) + 
[15:32:37.618]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:37.618]                     cond$call), session = sessionInformation(), 
[15:32:37.618]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:37.618]                   signalCondition(cond)
[15:32:37.618]                 }
[15:32:37.618]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:37.618]                 "immediateCondition"))) {
[15:32:37.618]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:37.618]                   ...future.conditions[[length(...future.conditions) + 
[15:32:37.618]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:37.618]                   if (TRUE && !signal) {
[15:32:37.618]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:37.618]                     {
[15:32:37.618]                       inherits <- base::inherits
[15:32:37.618]                       invokeRestart <- base::invokeRestart
[15:32:37.618]                       is.null <- base::is.null
[15:32:37.618]                       muffled <- FALSE
[15:32:37.618]                       if (inherits(cond, "message")) {
[15:32:37.618]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:37.618]                         if (muffled) 
[15:32:37.618]                           invokeRestart("muffleMessage")
[15:32:37.618]                       }
[15:32:37.618]                       else if (inherits(cond, "warning")) {
[15:32:37.618]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:37.618]                         if (muffled) 
[15:32:37.618]                           invokeRestart("muffleWarning")
[15:32:37.618]                       }
[15:32:37.618]                       else if (inherits(cond, "condition")) {
[15:32:37.618]                         if (!is.null(pattern)) {
[15:32:37.618]                           computeRestarts <- base::computeRestarts
[15:32:37.618]                           grepl <- base::grepl
[15:32:37.618]                           restarts <- computeRestarts(cond)
[15:32:37.618]                           for (restart in restarts) {
[15:32:37.618]                             name <- restart$name
[15:32:37.618]                             if (is.null(name)) 
[15:32:37.618]                               next
[15:32:37.618]                             if (!grepl(pattern, name)) 
[15:32:37.618]                               next
[15:32:37.618]                             invokeRestart(restart)
[15:32:37.618]                             muffled <- TRUE
[15:32:37.618]                             break
[15:32:37.618]                           }
[15:32:37.618]                         }
[15:32:37.618]                       }
[15:32:37.618]                       invisible(muffled)
[15:32:37.618]                     }
[15:32:37.618]                     muffleCondition(cond, pattern = "^muffle")
[15:32:37.618]                   }
[15:32:37.618]                 }
[15:32:37.618]                 else {
[15:32:37.618]                   if (TRUE) {
[15:32:37.618]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:37.618]                     {
[15:32:37.618]                       inherits <- base::inherits
[15:32:37.618]                       invokeRestart <- base::invokeRestart
[15:32:37.618]                       is.null <- base::is.null
[15:32:37.618]                       muffled <- FALSE
[15:32:37.618]                       if (inherits(cond, "message")) {
[15:32:37.618]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:37.618]                         if (muffled) 
[15:32:37.618]                           invokeRestart("muffleMessage")
[15:32:37.618]                       }
[15:32:37.618]                       else if (inherits(cond, "warning")) {
[15:32:37.618]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:37.618]                         if (muffled) 
[15:32:37.618]                           invokeRestart("muffleWarning")
[15:32:37.618]                       }
[15:32:37.618]                       else if (inherits(cond, "condition")) {
[15:32:37.618]                         if (!is.null(pattern)) {
[15:32:37.618]                           computeRestarts <- base::computeRestarts
[15:32:37.618]                           grepl <- base::grepl
[15:32:37.618]                           restarts <- computeRestarts(cond)
[15:32:37.618]                           for (restart in restarts) {
[15:32:37.618]                             name <- restart$name
[15:32:37.618]                             if (is.null(name)) 
[15:32:37.618]                               next
[15:32:37.618]                             if (!grepl(pattern, name)) 
[15:32:37.618]                               next
[15:32:37.618]                             invokeRestart(restart)
[15:32:37.618]                             muffled <- TRUE
[15:32:37.618]                             break
[15:32:37.618]                           }
[15:32:37.618]                         }
[15:32:37.618]                       }
[15:32:37.618]                       invisible(muffled)
[15:32:37.618]                     }
[15:32:37.618]                     muffleCondition(cond, pattern = "^muffle")
[15:32:37.618]                   }
[15:32:37.618]                 }
[15:32:37.618]             }
[15:32:37.618]         }))
[15:32:37.618]     }, error = function(ex) {
[15:32:37.618]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:37.618]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:37.618]                 ...future.rng), started = ...future.startTime, 
[15:32:37.618]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:37.618]             version = "1.8"), class = "FutureResult")
[15:32:37.618]     }, finally = {
[15:32:37.618]         if (!identical(...future.workdir, getwd())) 
[15:32:37.618]             setwd(...future.workdir)
[15:32:37.618]         {
[15:32:37.618]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:37.618]                 ...future.oldOptions$nwarnings <- NULL
[15:32:37.618]             }
[15:32:37.618]             base::options(...future.oldOptions)
[15:32:37.618]             if (.Platform$OS.type == "windows") {
[15:32:37.618]                 old_names <- names(...future.oldEnvVars)
[15:32:37.618]                 envs <- base::Sys.getenv()
[15:32:37.618]                 names <- names(envs)
[15:32:37.618]                 common <- intersect(names, old_names)
[15:32:37.618]                 added <- setdiff(names, old_names)
[15:32:37.618]                 removed <- setdiff(old_names, names)
[15:32:37.618]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:37.618]                   envs[common]]
[15:32:37.618]                 NAMES <- toupper(changed)
[15:32:37.618]                 args <- list()
[15:32:37.618]                 for (kk in seq_along(NAMES)) {
[15:32:37.618]                   name <- changed[[kk]]
[15:32:37.618]                   NAME <- NAMES[[kk]]
[15:32:37.618]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:37.618]                     next
[15:32:37.618]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:37.618]                 }
[15:32:37.618]                 NAMES <- toupper(added)
[15:32:37.618]                 for (kk in seq_along(NAMES)) {
[15:32:37.618]                   name <- added[[kk]]
[15:32:37.618]                   NAME <- NAMES[[kk]]
[15:32:37.618]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:37.618]                     next
[15:32:37.618]                   args[[name]] <- ""
[15:32:37.618]                 }
[15:32:37.618]                 NAMES <- toupper(removed)
[15:32:37.618]                 for (kk in seq_along(NAMES)) {
[15:32:37.618]                   name <- removed[[kk]]
[15:32:37.618]                   NAME <- NAMES[[kk]]
[15:32:37.618]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:37.618]                     next
[15:32:37.618]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:37.618]                 }
[15:32:37.618]                 if (length(args) > 0) 
[15:32:37.618]                   base::do.call(base::Sys.setenv, args = args)
[15:32:37.618]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:37.618]             }
[15:32:37.618]             else {
[15:32:37.618]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:37.618]             }
[15:32:37.618]             {
[15:32:37.618]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:37.618]                   0L) {
[15:32:37.618]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:37.618]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:37.618]                   base::options(opts)
[15:32:37.618]                 }
[15:32:37.618]                 {
[15:32:37.618]                   {
[15:32:37.618]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:37.618]                     NULL
[15:32:37.618]                   }
[15:32:37.618]                   options(future.plan = NULL)
[15:32:37.618]                   if (is.na(NA_character_)) 
[15:32:37.618]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:37.618]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:37.618]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:37.618]                     .init = FALSE)
[15:32:37.618]                 }
[15:32:37.618]             }
[15:32:37.618]         }
[15:32:37.618]     })
[15:32:37.618]     if (TRUE) {
[15:32:37.618]         base::sink(type = "output", split = FALSE)
[15:32:37.618]         if (TRUE) {
[15:32:37.618]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:37.618]         }
[15:32:37.618]         else {
[15:32:37.618]             ...future.result["stdout"] <- base::list(NULL)
[15:32:37.618]         }
[15:32:37.618]         base::close(...future.stdout)
[15:32:37.618]         ...future.stdout <- NULL
[15:32:37.618]     }
[15:32:37.618]     ...future.result$conditions <- ...future.conditions
[15:32:37.618]     ...future.result$finished <- base::Sys.time()
[15:32:37.618]     ...future.result
[15:32:37.618] }
[15:32:37.623] Exporting 5 global objects (1.22 KiB) to cluster node #1 ...
[15:32:37.624] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ...
[15:32:37.624] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ... DONE
[15:32:37.624] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:37.625] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:37.625] Exporting '...future.elements_ii' (224 bytes) to cluster node #1 ...
[15:32:37.626] Exporting '...future.elements_ii' (224 bytes) to cluster node #1 ... DONE
[15:32:37.626] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:37.626] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:37.627] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:37.627] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:37.627] Exporting 5 global objects (1.22 KiB) to cluster node #1 ... DONE
[15:32:37.628] MultisessionFuture started
[15:32:37.628] - Launch lazy future ... done
[15:32:37.628] run() for 'MultisessionFuture' ... done
[15:32:37.629] Created future:
[15:32:37.649] receiveMessageFromWorker() for ClusterFuture ...
[15:32:37.649] - Validating connection of MultisessionFuture
[15:32:37.649] - received message: FutureResult
[15:32:37.650] - Received FutureResult
[15:32:37.650] - Erased future from FutureRegistry
[15:32:37.650] result() for ClusterFuture ...
[15:32:37.650] - result already collected: FutureResult
[15:32:37.650] result() for ClusterFuture ... done
[15:32:37.651] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:37.629] MultisessionFuture:
[15:32:37.629] Label: 'future_sapply-2'
[15:32:37.629] Expression:
[15:32:37.629] {
[15:32:37.629]     do.call(function(...) {
[15:32:37.629]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:37.629]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:37.629]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:37.629]             on.exit(options(oopts), add = TRUE)
[15:32:37.629]         }
[15:32:37.629]         {
[15:32:37.629]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:37.629]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:37.629]                 ...future.FUN(...future.X_jj, ...)
[15:32:37.629]             })
[15:32:37.629]         }
[15:32:37.629]     }, args = future.call.arguments)
[15:32:37.629] }
[15:32:37.629] Lazy evaluation: FALSE
[15:32:37.629] Asynchronous evaluation: TRUE
[15:32:37.629] Local evaluation: TRUE
[15:32:37.629] Environment: R_GlobalEnv
[15:32:37.629] Capture standard output: TRUE
[15:32:37.629] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:37.629] Globals: 5 objects totaling 1.44 KiB (function '...future.FUN' of 1.22 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 224 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:37.629] Packages: <none>
[15:32:37.629] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:37.629] Resolved: TRUE
[15:32:37.629] Value: <not collected>
[15:32:37.629] Conditions captured: <none>
[15:32:37.629] Early signaling: FALSE
[15:32:37.629] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:37.629] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:37.651] Chunk #2 of 2 ... DONE
[15:32:37.651] Launching 2 futures (chunks) ... DONE
[15:32:37.651] Resolving 2 futures (chunks) ...
[15:32:37.652] resolve() on list ...
[15:32:37.652]  recursive: 0
[15:32:37.652]  length: 2
[15:32:37.652] 
[15:32:37.652] Future #1
[15:32:37.652] result() for ClusterFuture ...
[15:32:37.653] - result already collected: FutureResult
[15:32:37.653] result() for ClusterFuture ... done
[15:32:37.653] result() for ClusterFuture ...
[15:32:37.653] - result already collected: FutureResult
[15:32:37.653] result() for ClusterFuture ... done
[15:32:37.653] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:37.653] - nx: 2
[15:32:37.654] - relay: TRUE
[15:32:37.654] - stdout: TRUE
[15:32:37.654] - signal: TRUE
[15:32:37.654] - resignal: FALSE
[15:32:37.654] - force: TRUE
[15:32:37.655] - relayed: [n=2] FALSE, FALSE
[15:32:37.655] - queued futures: [n=2] FALSE, FALSE
[15:32:37.655]  - until=1
[15:32:37.655]  - relaying element #1
[15:32:37.655] result() for ClusterFuture ...
[15:32:37.655] - result already collected: FutureResult
[15:32:37.655] result() for ClusterFuture ... done
[15:32:37.656] result() for ClusterFuture ...
[15:32:37.656] - result already collected: FutureResult
[15:32:37.656] result() for ClusterFuture ... done
[15:32:37.656] result() for ClusterFuture ...
[15:32:37.656] - result already collected: FutureResult
[15:32:37.657] result() for ClusterFuture ... done
[15:32:37.657] result() for ClusterFuture ...
[15:32:37.657] - result already collected: FutureResult
[15:32:37.657] result() for ClusterFuture ... done
[15:32:37.657] - relayed: [n=2] TRUE, FALSE
[15:32:37.657] - queued futures: [n=2] TRUE, FALSE
[15:32:37.657] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:37.658]  length: 1 (resolved future 1)
[15:32:37.658] Future #2
[15:32:37.658] result() for ClusterFuture ...
[15:32:37.658] - result already collected: FutureResult
[15:32:37.658] result() for ClusterFuture ... done
[15:32:37.658] result() for ClusterFuture ...
[15:32:37.659] - result already collected: FutureResult
[15:32:37.659] result() for ClusterFuture ... done
[15:32:37.659] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:37.659] - nx: 2
[15:32:37.659] - relay: TRUE
[15:32:37.659] - stdout: TRUE
[15:32:37.660] - signal: TRUE
[15:32:37.660] - resignal: FALSE
[15:32:37.660] - force: TRUE
[15:32:37.660] - relayed: [n=2] TRUE, FALSE
[15:32:37.660] - queued futures: [n=2] TRUE, FALSE
[15:32:37.660]  - until=2
[15:32:37.660]  - relaying element #2
[15:32:37.661] result() for ClusterFuture ...
[15:32:37.661] - result already collected: FutureResult
[15:32:37.661] result() for ClusterFuture ... done
[15:32:37.661] result() for ClusterFuture ...
[15:32:37.661] - result already collected: FutureResult
[15:32:37.661] result() for ClusterFuture ... done
[15:32:37.661] result() for ClusterFuture ...
[15:32:37.662] - result already collected: FutureResult
[15:32:37.662] result() for ClusterFuture ... done
[15:32:37.662] result() for ClusterFuture ...
[15:32:37.662] - result already collected: FutureResult
[15:32:37.662] result() for ClusterFuture ... done
[15:32:37.662] - relayed: [n=2] TRUE, TRUE
[15:32:37.662] - queued futures: [n=2] TRUE, TRUE
[15:32:37.663] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:37.663]  length: 0 (resolved future 2)
[15:32:37.663] Relaying remaining futures
[15:32:37.663] signalConditionsASAP(NULL, pos=0) ...
[15:32:37.663] - nx: 2
[15:32:37.663] - relay: TRUE
[15:32:37.664] - stdout: TRUE
[15:32:37.664] - signal: TRUE
[15:32:37.664] - resignal: FALSE
[15:32:37.664] - force: TRUE
[15:32:37.664] - relayed: [n=2] TRUE, TRUE
[15:32:37.664] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:37.664] - relayed: [n=2] TRUE, TRUE
[15:32:37.665] - queued futures: [n=2] TRUE, TRUE
[15:32:37.665] signalConditionsASAP(NULL, pos=0) ... done
[15:32:37.665] resolve() on list ... DONE
[15:32:37.665] result() for ClusterFuture ...
[15:32:37.665] - result already collected: FutureResult
[15:32:37.665] result() for ClusterFuture ... done
[15:32:37.666] result() for ClusterFuture ...
[15:32:37.670] - result already collected: FutureResult
[15:32:37.670] result() for ClusterFuture ... done
[15:32:37.670] result() for ClusterFuture ...
[15:32:37.670] - result already collected: FutureResult
[15:32:37.671] result() for ClusterFuture ... done
[15:32:37.671] result() for ClusterFuture ...
[15:32:37.671] - result already collected: FutureResult
[15:32:37.671] result() for ClusterFuture ... done
[15:32:37.671]  - Number of value chunks collected: 2
[15:32:37.672] Resolving 2 futures (chunks) ... DONE
[15:32:37.672] Reducing values from 2 chunks ...
[15:32:37.672]  - Number of values collected after concatenation: 3
[15:32:37.672]  - Number of values expected: 3
[15:32:37.672] Reducing values from 2 chunks ... DONE
[15:32:37.673] future_lapply() ... DONE
List of 2
 $ y0: Named chr [1:3] "a" "b" "c"
  ..- attr(*, "names")= chr [1:3] "a" "b" "c"
 $ y1: Named chr [1:3] "a" "b" "c"
  ..- attr(*, "names")= chr [1:3] "a" "b" "c"
[15:32:37.674] future_lapply() ...
[15:32:37.678] Number of chunks: 2
[15:32:37.678] getGlobalsAndPackagesXApply() ...
[15:32:37.678]  - future.globals: TRUE
[15:32:37.678] getGlobalsAndPackages() ...
[15:32:37.678] Searching for globals...
[15:32:37.680] - globals found: [1] 'FUN'
[15:32:37.680] Searching for globals ... DONE
[15:32:37.680] Resolving globals: FALSE
[15:32:37.680] The total size of the 1 globals is 848 bytes (848 bytes)
[15:32:37.681] The total size of the 1 globals exported for future expression ('FUN()') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:32:37.681] - globals: [1] 'FUN'
[15:32:37.681] 
[15:32:37.681] getGlobalsAndPackages() ... DONE
[15:32:37.681]  - globals found/used: [n=1] 'FUN'
[15:32:37.682]  - needed namespaces: [n=0] 
[15:32:37.682] Finding globals ... DONE
[15:32:37.682]  - use_args: TRUE
[15:32:37.682]  - Getting '...' globals ...
[15:32:37.683] resolve() on list ...
[15:32:37.683]  recursive: 0
[15:32:37.683]  length: 1
[15:32:37.683]  elements: '...'
[15:32:37.683]  length: 0 (resolved future 1)
[15:32:37.683] resolve() on list ... DONE
[15:32:37.684]    - '...' content: [n=0] 
[15:32:37.684] List of 1
[15:32:37.684]  $ ...: list()
[15:32:37.684]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:37.684]  - attr(*, "where")=List of 1
[15:32:37.684]   ..$ ...:<environment: 0x00000276e4393338> 
[15:32:37.684]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:37.684]  - attr(*, "resolved")= logi TRUE
[15:32:37.684]  - attr(*, "total_size")= num NA
[15:32:37.687]  - Getting '...' globals ... DONE
[15:32:37.687] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:37.687] List of 2
[15:32:37.687]  $ ...future.FUN:function (x)  
[15:32:37.687]  $ ...          : list()
[15:32:37.687]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:37.687]  - attr(*, "where")=List of 2
[15:32:37.687]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:37.687]   ..$ ...          :<environment: 0x00000276e4393338> 
[15:32:37.687]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:37.687]  - attr(*, "resolved")= logi FALSE
[15:32:37.687]  - attr(*, "total_size")= num 848
[15:32:37.692] Packages to be attached in all futures: [n=0] 
[15:32:37.692] getGlobalsAndPackagesXApply() ... DONE
[15:32:37.693] Number of futures (= number of chunks): 2
[15:32:37.693] Launching 2 futures (chunks) ...
[15:32:37.693] Chunk #1 of 2 ...
[15:32:37.694]  - Finding globals in 'X' for chunk #1 ...
[15:32:37.694] getGlobalsAndPackages() ...
[15:32:37.694] Searching for globals...
[15:32:37.695] 
[15:32:37.695] Searching for globals ... DONE
[15:32:37.695] - globals: [0] <none>
[15:32:37.696] getGlobalsAndPackages() ... DONE
[15:32:37.696]    + additional globals found: [n=0] 
[15:32:37.696]    + additional namespaces needed: [n=0] 
[15:32:37.696]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:37.696]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:37.697]  - seeds: <none>
[15:32:37.697]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:37.697] getGlobalsAndPackages() ...
[15:32:37.697] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:37.698] Resolving globals: FALSE
[15:32:37.698] Tweak future expression to call with '...' arguments ...
[15:32:37.698] {
[15:32:37.698]     do.call(function(...) {
[15:32:37.698]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:37.698]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:37.698]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:37.698]             on.exit(options(oopts), add = TRUE)
[15:32:37.698]         }
[15:32:37.698]         {
[15:32:37.698]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:37.698]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:37.698]                 ...future.FUN(...future.X_jj, ...)
[15:32:37.698]             })
[15:32:37.698]         }
[15:32:37.698]     }, args = future.call.arguments)
[15:32:37.698] }
[15:32:37.699] Tweak future expression to call with '...' arguments ... DONE
[15:32:37.700] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:37.700] 
[15:32:37.700] getGlobalsAndPackages() ... DONE
[15:32:37.701] run() for 'Future' ...
[15:32:37.701] - state: 'created'
[15:32:37.702] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:37.721] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:37.722] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:37.722]   - Field: 'node'
[15:32:37.722]   - Field: 'label'
[15:32:37.723]   - Field: 'local'
[15:32:37.723]   - Field: 'owner'
[15:32:37.723]   - Field: 'envir'
[15:32:37.723]   - Field: 'workers'
[15:32:37.724]   - Field: 'packages'
[15:32:37.724]   - Field: 'gc'
[15:32:37.724]   - Field: 'conditions'
[15:32:37.725]   - Field: 'persistent'
[15:32:37.725]   - Field: 'expr'
[15:32:37.725]   - Field: 'uuid'
[15:32:37.725]   - Field: 'seed'
[15:32:37.726]   - Field: 'version'
[15:32:37.726]   - Field: 'result'
[15:32:37.726]   - Field: 'asynchronous'
[15:32:37.726]   - Field: 'calls'
[15:32:37.727]   - Field: 'globals'
[15:32:37.727]   - Field: 'stdout'
[15:32:37.727]   - Field: 'earlySignal'
[15:32:37.727]   - Field: 'lazy'
[15:32:37.728]   - Field: 'state'
[15:32:37.728] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:37.728] - Launch lazy future ...
[15:32:37.729] Packages needed by the future expression (n = 0): <none>
[15:32:37.729] Packages needed by future strategies (n = 0): <none>
[15:32:37.730] {
[15:32:37.730]     {
[15:32:37.730]         {
[15:32:37.730]             ...future.startTime <- base::Sys.time()
[15:32:37.730]             {
[15:32:37.730]                 {
[15:32:37.730]                   {
[15:32:37.730]                     {
[15:32:37.730]                       base::local({
[15:32:37.730]                         has_future <- base::requireNamespace("future", 
[15:32:37.730]                           quietly = TRUE)
[15:32:37.730]                         if (has_future) {
[15:32:37.730]                           ns <- base::getNamespace("future")
[15:32:37.730]                           version <- ns[[".package"]][["version"]]
[15:32:37.730]                           if (is.null(version)) 
[15:32:37.730]                             version <- utils::packageVersion("future")
[15:32:37.730]                         }
[15:32:37.730]                         else {
[15:32:37.730]                           version <- NULL
[15:32:37.730]                         }
[15:32:37.730]                         if (!has_future || version < "1.8.0") {
[15:32:37.730]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:37.730]                             "", base::R.version$version.string), 
[15:32:37.730]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:37.730]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:37.730]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:37.730]                               "release", "version")], collapse = " "), 
[15:32:37.730]                             hostname = base::Sys.info()[["nodename"]])
[15:32:37.730]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:37.730]                             info)
[15:32:37.730]                           info <- base::paste(info, collapse = "; ")
[15:32:37.730]                           if (!has_future) {
[15:32:37.730]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:37.730]                               info)
[15:32:37.730]                           }
[15:32:37.730]                           else {
[15:32:37.730]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:37.730]                               info, version)
[15:32:37.730]                           }
[15:32:37.730]                           base::stop(msg)
[15:32:37.730]                         }
[15:32:37.730]                       })
[15:32:37.730]                     }
[15:32:37.730]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:37.730]                     base::options(mc.cores = 1L)
[15:32:37.730]                   }
[15:32:37.730]                   ...future.strategy.old <- future::plan("list")
[15:32:37.730]                   options(future.plan = NULL)
[15:32:37.730]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:37.730]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:37.730]                 }
[15:32:37.730]                 ...future.workdir <- getwd()
[15:32:37.730]             }
[15:32:37.730]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:37.730]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:37.730]         }
[15:32:37.730]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:37.730]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:37.730]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:37.730]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:37.730]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:37.730]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:37.730]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:37.730]             base::names(...future.oldOptions))
[15:32:37.730]     }
[15:32:37.730]     if (FALSE) {
[15:32:37.730]     }
[15:32:37.730]     else {
[15:32:37.730]         if (TRUE) {
[15:32:37.730]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:37.730]                 open = "w")
[15:32:37.730]         }
[15:32:37.730]         else {
[15:32:37.730]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:37.730]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:37.730]         }
[15:32:37.730]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:37.730]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:37.730]             base::sink(type = "output", split = FALSE)
[15:32:37.730]             base::close(...future.stdout)
[15:32:37.730]         }, add = TRUE)
[15:32:37.730]     }
[15:32:37.730]     ...future.frame <- base::sys.nframe()
[15:32:37.730]     ...future.conditions <- base::list()
[15:32:37.730]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:37.730]     if (FALSE) {
[15:32:37.730]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:37.730]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:37.730]     }
[15:32:37.730]     ...future.result <- base::tryCatch({
[15:32:37.730]         base::withCallingHandlers({
[15:32:37.730]             ...future.value <- base::withVisible(base::local({
[15:32:37.730]                 ...future.makeSendCondition <- base::local({
[15:32:37.730]                   sendCondition <- NULL
[15:32:37.730]                   function(frame = 1L) {
[15:32:37.730]                     if (is.function(sendCondition)) 
[15:32:37.730]                       return(sendCondition)
[15:32:37.730]                     ns <- getNamespace("parallel")
[15:32:37.730]                     if (exists("sendData", mode = "function", 
[15:32:37.730]                       envir = ns)) {
[15:32:37.730]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:37.730]                         envir = ns)
[15:32:37.730]                       envir <- sys.frame(frame)
[15:32:37.730]                       master <- NULL
[15:32:37.730]                       while (!identical(envir, .GlobalEnv) && 
[15:32:37.730]                         !identical(envir, emptyenv())) {
[15:32:37.730]                         if (exists("master", mode = "list", envir = envir, 
[15:32:37.730]                           inherits = FALSE)) {
[15:32:37.730]                           master <- get("master", mode = "list", 
[15:32:37.730]                             envir = envir, inherits = FALSE)
[15:32:37.730]                           if (inherits(master, c("SOCKnode", 
[15:32:37.730]                             "SOCK0node"))) {
[15:32:37.730]                             sendCondition <<- function(cond) {
[15:32:37.730]                               data <- list(type = "VALUE", value = cond, 
[15:32:37.730]                                 success = TRUE)
[15:32:37.730]                               parallel_sendData(master, data)
[15:32:37.730]                             }
[15:32:37.730]                             return(sendCondition)
[15:32:37.730]                           }
[15:32:37.730]                         }
[15:32:37.730]                         frame <- frame + 1L
[15:32:37.730]                         envir <- sys.frame(frame)
[15:32:37.730]                       }
[15:32:37.730]                     }
[15:32:37.730]                     sendCondition <<- function(cond) NULL
[15:32:37.730]                   }
[15:32:37.730]                 })
[15:32:37.730]                 withCallingHandlers({
[15:32:37.730]                   {
[15:32:37.730]                     do.call(function(...) {
[15:32:37.730]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:37.730]                       if (!identical(...future.globals.maxSize.org, 
[15:32:37.730]                         ...future.globals.maxSize)) {
[15:32:37.730]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:37.730]                         on.exit(options(oopts), add = TRUE)
[15:32:37.730]                       }
[15:32:37.730]                       {
[15:32:37.730]                         lapply(seq_along(...future.elements_ii), 
[15:32:37.730]                           FUN = function(jj) {
[15:32:37.730]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:37.730]                             ...future.FUN(...future.X_jj, ...)
[15:32:37.730]                           })
[15:32:37.730]                       }
[15:32:37.730]                     }, args = future.call.arguments)
[15:32:37.730]                   }
[15:32:37.730]                 }, immediateCondition = function(cond) {
[15:32:37.730]                   sendCondition <- ...future.makeSendCondition()
[15:32:37.730]                   sendCondition(cond)
[15:32:37.730]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:37.730]                   {
[15:32:37.730]                     inherits <- base::inherits
[15:32:37.730]                     invokeRestart <- base::invokeRestart
[15:32:37.730]                     is.null <- base::is.null
[15:32:37.730]                     muffled <- FALSE
[15:32:37.730]                     if (inherits(cond, "message")) {
[15:32:37.730]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:37.730]                       if (muffled) 
[15:32:37.730]                         invokeRestart("muffleMessage")
[15:32:37.730]                     }
[15:32:37.730]                     else if (inherits(cond, "warning")) {
[15:32:37.730]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:37.730]                       if (muffled) 
[15:32:37.730]                         invokeRestart("muffleWarning")
[15:32:37.730]                     }
[15:32:37.730]                     else if (inherits(cond, "condition")) {
[15:32:37.730]                       if (!is.null(pattern)) {
[15:32:37.730]                         computeRestarts <- base::computeRestarts
[15:32:37.730]                         grepl <- base::grepl
[15:32:37.730]                         restarts <- computeRestarts(cond)
[15:32:37.730]                         for (restart in restarts) {
[15:32:37.730]                           name <- restart$name
[15:32:37.730]                           if (is.null(name)) 
[15:32:37.730]                             next
[15:32:37.730]                           if (!grepl(pattern, name)) 
[15:32:37.730]                             next
[15:32:37.730]                           invokeRestart(restart)
[15:32:37.730]                           muffled <- TRUE
[15:32:37.730]                           break
[15:32:37.730]                         }
[15:32:37.730]                       }
[15:32:37.730]                     }
[15:32:37.730]                     invisible(muffled)
[15:32:37.730]                   }
[15:32:37.730]                   muffleCondition(cond)
[15:32:37.730]                 })
[15:32:37.730]             }))
[15:32:37.730]             future::FutureResult(value = ...future.value$value, 
[15:32:37.730]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:37.730]                   ...future.rng), globalenv = if (FALSE) 
[15:32:37.730]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:37.730]                     ...future.globalenv.names))
[15:32:37.730]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:37.730]         }, condition = base::local({
[15:32:37.730]             c <- base::c
[15:32:37.730]             inherits <- base::inherits
[15:32:37.730]             invokeRestart <- base::invokeRestart
[15:32:37.730]             length <- base::length
[15:32:37.730]             list <- base::list
[15:32:37.730]             seq.int <- base::seq.int
[15:32:37.730]             signalCondition <- base::signalCondition
[15:32:37.730]             sys.calls <- base::sys.calls
[15:32:37.730]             `[[` <- base::`[[`
[15:32:37.730]             `+` <- base::`+`
[15:32:37.730]             `<<-` <- base::`<<-`
[15:32:37.730]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:37.730]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:37.730]                   3L)]
[15:32:37.730]             }
[15:32:37.730]             function(cond) {
[15:32:37.730]                 is_error <- inherits(cond, "error")
[15:32:37.730]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:37.730]                   NULL)
[15:32:37.730]                 if (is_error) {
[15:32:37.730]                   sessionInformation <- function() {
[15:32:37.730]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:37.730]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:37.730]                       search = base::search(), system = base::Sys.info())
[15:32:37.730]                   }
[15:32:37.730]                   ...future.conditions[[length(...future.conditions) + 
[15:32:37.730]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:37.730]                     cond$call), session = sessionInformation(), 
[15:32:37.730]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:37.730]                   signalCondition(cond)
[15:32:37.730]                 }
[15:32:37.730]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:37.730]                 "immediateCondition"))) {
[15:32:37.730]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:37.730]                   ...future.conditions[[length(...future.conditions) + 
[15:32:37.730]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:37.730]                   if (TRUE && !signal) {
[15:32:37.730]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:37.730]                     {
[15:32:37.730]                       inherits <- base::inherits
[15:32:37.730]                       invokeRestart <- base::invokeRestart
[15:32:37.730]                       is.null <- base::is.null
[15:32:37.730]                       muffled <- FALSE
[15:32:37.730]                       if (inherits(cond, "message")) {
[15:32:37.730]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:37.730]                         if (muffled) 
[15:32:37.730]                           invokeRestart("muffleMessage")
[15:32:37.730]                       }
[15:32:37.730]                       else if (inherits(cond, "warning")) {
[15:32:37.730]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:37.730]                         if (muffled) 
[15:32:37.730]                           invokeRestart("muffleWarning")
[15:32:37.730]                       }
[15:32:37.730]                       else if (inherits(cond, "condition")) {
[15:32:37.730]                         if (!is.null(pattern)) {
[15:32:37.730]                           computeRestarts <- base::computeRestarts
[15:32:37.730]                           grepl <- base::grepl
[15:32:37.730]                           restarts <- computeRestarts(cond)
[15:32:37.730]                           for (restart in restarts) {
[15:32:37.730]                             name <- restart$name
[15:32:37.730]                             if (is.null(name)) 
[15:32:37.730]                               next
[15:32:37.730]                             if (!grepl(pattern, name)) 
[15:32:37.730]                               next
[15:32:37.730]                             invokeRestart(restart)
[15:32:37.730]                             muffled <- TRUE
[15:32:37.730]                             break
[15:32:37.730]                           }
[15:32:37.730]                         }
[15:32:37.730]                       }
[15:32:37.730]                       invisible(muffled)
[15:32:37.730]                     }
[15:32:37.730]                     muffleCondition(cond, pattern = "^muffle")
[15:32:37.730]                   }
[15:32:37.730]                 }
[15:32:37.730]                 else {
[15:32:37.730]                   if (TRUE) {
[15:32:37.730]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:37.730]                     {
[15:32:37.730]                       inherits <- base::inherits
[15:32:37.730]                       invokeRestart <- base::invokeRestart
[15:32:37.730]                       is.null <- base::is.null
[15:32:37.730]                       muffled <- FALSE
[15:32:37.730]                       if (inherits(cond, "message")) {
[15:32:37.730]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:37.730]                         if (muffled) 
[15:32:37.730]                           invokeRestart("muffleMessage")
[15:32:37.730]                       }
[15:32:37.730]                       else if (inherits(cond, "warning")) {
[15:32:37.730]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:37.730]                         if (muffled) 
[15:32:37.730]                           invokeRestart("muffleWarning")
[15:32:37.730]                       }
[15:32:37.730]                       else if (inherits(cond, "condition")) {
[15:32:37.730]                         if (!is.null(pattern)) {
[15:32:37.730]                           computeRestarts <- base::computeRestarts
[15:32:37.730]                           grepl <- base::grepl
[15:32:37.730]                           restarts <- computeRestarts(cond)
[15:32:37.730]                           for (restart in restarts) {
[15:32:37.730]                             name <- restart$name
[15:32:37.730]                             if (is.null(name)) 
[15:32:37.730]                               next
[15:32:37.730]                             if (!grepl(pattern, name)) 
[15:32:37.730]                               next
[15:32:37.730]                             invokeRestart(restart)
[15:32:37.730]                             muffled <- TRUE
[15:32:37.730]                             break
[15:32:37.730]                           }
[15:32:37.730]                         }
[15:32:37.730]                       }
[15:32:37.730]                       invisible(muffled)
[15:32:37.730]                     }
[15:32:37.730]                     muffleCondition(cond, pattern = "^muffle")
[15:32:37.730]                   }
[15:32:37.730]                 }
[15:32:37.730]             }
[15:32:37.730]         }))
[15:32:37.730]     }, error = function(ex) {
[15:32:37.730]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:37.730]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:37.730]                 ...future.rng), started = ...future.startTime, 
[15:32:37.730]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:37.730]             version = "1.8"), class = "FutureResult")
[15:32:37.730]     }, finally = {
[15:32:37.730]         if (!identical(...future.workdir, getwd())) 
[15:32:37.730]             setwd(...future.workdir)
[15:32:37.730]         {
[15:32:37.730]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:37.730]                 ...future.oldOptions$nwarnings <- NULL
[15:32:37.730]             }
[15:32:37.730]             base::options(...future.oldOptions)
[15:32:37.730]             if (.Platform$OS.type == "windows") {
[15:32:37.730]                 old_names <- names(...future.oldEnvVars)
[15:32:37.730]                 envs <- base::Sys.getenv()
[15:32:37.730]                 names <- names(envs)
[15:32:37.730]                 common <- intersect(names, old_names)
[15:32:37.730]                 added <- setdiff(names, old_names)
[15:32:37.730]                 removed <- setdiff(old_names, names)
[15:32:37.730]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:37.730]                   envs[common]]
[15:32:37.730]                 NAMES <- toupper(changed)
[15:32:37.730]                 args <- list()
[15:32:37.730]                 for (kk in seq_along(NAMES)) {
[15:32:37.730]                   name <- changed[[kk]]
[15:32:37.730]                   NAME <- NAMES[[kk]]
[15:32:37.730]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:37.730]                     next
[15:32:37.730]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:37.730]                 }
[15:32:37.730]                 NAMES <- toupper(added)
[15:32:37.730]                 for (kk in seq_along(NAMES)) {
[15:32:37.730]                   name <- added[[kk]]
[15:32:37.730]                   NAME <- NAMES[[kk]]
[15:32:37.730]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:37.730]                     next
[15:32:37.730]                   args[[name]] <- ""
[15:32:37.730]                 }
[15:32:37.730]                 NAMES <- toupper(removed)
[15:32:37.730]                 for (kk in seq_along(NAMES)) {
[15:32:37.730]                   name <- removed[[kk]]
[15:32:37.730]                   NAME <- NAMES[[kk]]
[15:32:37.730]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:37.730]                     next
[15:32:37.730]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:37.730]                 }
[15:32:37.730]                 if (length(args) > 0) 
[15:32:37.730]                   base::do.call(base::Sys.setenv, args = args)
[15:32:37.730]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:37.730]             }
[15:32:37.730]             else {
[15:32:37.730]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:37.730]             }
[15:32:37.730]             {
[15:32:37.730]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:37.730]                   0L) {
[15:32:37.730]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:37.730]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:37.730]                   base::options(opts)
[15:32:37.730]                 }
[15:32:37.730]                 {
[15:32:37.730]                   {
[15:32:37.730]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:37.730]                     NULL
[15:32:37.730]                   }
[15:32:37.730]                   options(future.plan = NULL)
[15:32:37.730]                   if (is.na(NA_character_)) 
[15:32:37.730]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:37.730]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:37.730]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:37.730]                     .init = FALSE)
[15:32:37.730]                 }
[15:32:37.730]             }
[15:32:37.730]         }
[15:32:37.730]     })
[15:32:37.730]     if (TRUE) {
[15:32:37.730]         base::sink(type = "output", split = FALSE)
[15:32:37.730]         if (TRUE) {
[15:32:37.730]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:37.730]         }
[15:32:37.730]         else {
[15:32:37.730]             ...future.result["stdout"] <- base::list(NULL)
[15:32:37.730]         }
[15:32:37.730]         base::close(...future.stdout)
[15:32:37.730]         ...future.stdout <- NULL
[15:32:37.730]     }
[15:32:37.730]     ...future.result$conditions <- ...future.conditions
[15:32:37.730]     ...future.result$finished <- base::Sys.time()
[15:32:37.730]     ...future.result
[15:32:37.730] }
[15:32:37.738] Exporting 5 global objects (848 bytes) to cluster node #1 ...
[15:32:37.739] Exporting '...future.FUN' (848 bytes) to cluster node #1 ...
[15:32:37.739] Exporting '...future.FUN' (848 bytes) to cluster node #1 ... DONE
[15:32:37.740] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:37.741] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:37.741] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:37.742] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:37.742] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:37.742] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:37.743] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:37.743] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:37.744] Exporting 5 global objects (848 bytes) to cluster node #1 ... DONE
[15:32:37.744] MultisessionFuture started
[15:32:37.745] - Launch lazy future ... done
[15:32:37.745] run() for 'MultisessionFuture' ... done
[15:32:37.745] Created future:
[15:32:37.772] receiveMessageFromWorker() for ClusterFuture ...
[15:32:37.772] - Validating connection of MultisessionFuture
[15:32:37.773] - received message: FutureResult
[15:32:37.773] - Received FutureResult
[15:32:37.773] - Erased future from FutureRegistry
[15:32:37.773] result() for ClusterFuture ...
[15:32:37.774] - result already collected: FutureResult
[15:32:37.774] result() for ClusterFuture ... done
[15:32:37.774] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:37.746] MultisessionFuture:
[15:32:37.746] Label: 'future_sapply-1'
[15:32:37.746] Expression:
[15:32:37.746] {
[15:32:37.746]     do.call(function(...) {
[15:32:37.746]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:37.746]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:37.746]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:37.746]             on.exit(options(oopts), add = TRUE)
[15:32:37.746]         }
[15:32:37.746]         {
[15:32:37.746]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:37.746]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:37.746]                 ...future.FUN(...future.X_jj, ...)
[15:32:37.746]             })
[15:32:37.746]         }
[15:32:37.746]     }, args = future.call.arguments)
[15:32:37.746] }
[15:32:37.746] Lazy evaluation: FALSE
[15:32:37.746] Asynchronous evaluation: TRUE
[15:32:37.746] Local evaluation: TRUE
[15:32:37.746] Environment: R_GlobalEnv
[15:32:37.746] Capture standard output: TRUE
[15:32:37.746] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:37.746] Globals: 5 objects totaling 960 bytes (function '...future.FUN' of 848 bytes, 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)
[15:32:37.746] Packages: <none>
[15:32:37.746] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:37.746] Resolved: TRUE
[15:32:37.746] Value: <not collected>
[15:32:37.746] Conditions captured: <none>
[15:32:37.746] Early signaling: FALSE
[15:32:37.746] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:37.746] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:37.775] Chunk #1 of 2 ... DONE
[15:32:37.775] Chunk #2 of 2 ...
[15:32:37.776]  - Finding globals in 'X' for chunk #2 ...
[15:32:37.776] getGlobalsAndPackages() ...
[15:32:37.776] Searching for globals...
[15:32:37.777] 
[15:32:37.777] Searching for globals ... DONE
[15:32:37.777] - globals: [0] <none>
[15:32:37.778] getGlobalsAndPackages() ... DONE
[15:32:37.778]    + additional globals found: [n=0] 
[15:32:37.778]    + additional namespaces needed: [n=0] 
[15:32:37.779]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:37.779]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:37.779]  - seeds: <none>
[15:32:37.779]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:37.780] getGlobalsAndPackages() ...
[15:32:37.780] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:37.780] Resolving globals: FALSE
[15:32:37.781] Tweak future expression to call with '...' arguments ...
[15:32:37.781] {
[15:32:37.781]     do.call(function(...) {
[15:32:37.781]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:37.781]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:37.781]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:37.781]             on.exit(options(oopts), add = TRUE)
[15:32:37.781]         }
[15:32:37.781]         {
[15:32:37.781]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:37.781]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:37.781]                 ...future.FUN(...future.X_jj, ...)
[15:32:37.781]             })
[15:32:37.781]         }
[15:32:37.781]     }, args = future.call.arguments)
[15:32:37.781] }
[15:32:37.782] Tweak future expression to call with '...' arguments ... DONE
[15:32:37.783] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:37.783] 
[15:32:37.783] getGlobalsAndPackages() ... DONE
[15:32:37.784] run() for 'Future' ...
[15:32:37.784] - state: 'created'
[15:32:37.785] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:37.804] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:37.804] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:37.804]   - Field: 'node'
[15:32:37.805]   - Field: 'label'
[15:32:37.805]   - Field: 'local'
[15:32:37.805]   - Field: 'owner'
[15:32:37.806]   - Field: 'envir'
[15:32:37.806]   - Field: 'workers'
[15:32:37.806]   - Field: 'packages'
[15:32:37.807]   - Field: 'gc'
[15:32:37.807]   - Field: 'conditions'
[15:32:37.807]   - Field: 'persistent'
[15:32:37.807]   - Field: 'expr'
[15:32:37.808]   - Field: 'uuid'
[15:32:37.808]   - Field: 'seed'
[15:32:37.808]   - Field: 'version'
[15:32:37.809]   - Field: 'result'
[15:32:37.809]   - Field: 'asynchronous'
[15:32:37.809]   - Field: 'calls'
[15:32:37.809]   - Field: 'globals'
[15:32:37.810]   - Field: 'stdout'
[15:32:37.810]   - Field: 'earlySignal'
[15:32:37.810]   - Field: 'lazy'
[15:32:37.811]   - Field: 'state'
[15:32:37.811] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:37.811] - Launch lazy future ...
[15:32:37.812] Packages needed by the future expression (n = 0): <none>
[15:32:37.812] Packages needed by future strategies (n = 0): <none>
[15:32:37.813] {
[15:32:37.813]     {
[15:32:37.813]         {
[15:32:37.813]             ...future.startTime <- base::Sys.time()
[15:32:37.813]             {
[15:32:37.813]                 {
[15:32:37.813]                   {
[15:32:37.813]                     {
[15:32:37.813]                       base::local({
[15:32:37.813]                         has_future <- base::requireNamespace("future", 
[15:32:37.813]                           quietly = TRUE)
[15:32:37.813]                         if (has_future) {
[15:32:37.813]                           ns <- base::getNamespace("future")
[15:32:37.813]                           version <- ns[[".package"]][["version"]]
[15:32:37.813]                           if (is.null(version)) 
[15:32:37.813]                             version <- utils::packageVersion("future")
[15:32:37.813]                         }
[15:32:37.813]                         else {
[15:32:37.813]                           version <- NULL
[15:32:37.813]                         }
[15:32:37.813]                         if (!has_future || version < "1.8.0") {
[15:32:37.813]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:37.813]                             "", base::R.version$version.string), 
[15:32:37.813]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:37.813]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:37.813]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:37.813]                               "release", "version")], collapse = " "), 
[15:32:37.813]                             hostname = base::Sys.info()[["nodename"]])
[15:32:37.813]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:37.813]                             info)
[15:32:37.813]                           info <- base::paste(info, collapse = "; ")
[15:32:37.813]                           if (!has_future) {
[15:32:37.813]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:37.813]                               info)
[15:32:37.813]                           }
[15:32:37.813]                           else {
[15:32:37.813]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:37.813]                               info, version)
[15:32:37.813]                           }
[15:32:37.813]                           base::stop(msg)
[15:32:37.813]                         }
[15:32:37.813]                       })
[15:32:37.813]                     }
[15:32:37.813]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:37.813]                     base::options(mc.cores = 1L)
[15:32:37.813]                   }
[15:32:37.813]                   ...future.strategy.old <- future::plan("list")
[15:32:37.813]                   options(future.plan = NULL)
[15:32:37.813]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:37.813]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:37.813]                 }
[15:32:37.813]                 ...future.workdir <- getwd()
[15:32:37.813]             }
[15:32:37.813]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:37.813]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:37.813]         }
[15:32:37.813]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:37.813]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:37.813]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:37.813]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:37.813]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:37.813]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:37.813]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:37.813]             base::names(...future.oldOptions))
[15:32:37.813]     }
[15:32:37.813]     if (FALSE) {
[15:32:37.813]     }
[15:32:37.813]     else {
[15:32:37.813]         if (TRUE) {
[15:32:37.813]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:37.813]                 open = "w")
[15:32:37.813]         }
[15:32:37.813]         else {
[15:32:37.813]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:37.813]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:37.813]         }
[15:32:37.813]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:37.813]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:37.813]             base::sink(type = "output", split = FALSE)
[15:32:37.813]             base::close(...future.stdout)
[15:32:37.813]         }, add = TRUE)
[15:32:37.813]     }
[15:32:37.813]     ...future.frame <- base::sys.nframe()
[15:32:37.813]     ...future.conditions <- base::list()
[15:32:37.813]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:37.813]     if (FALSE) {
[15:32:37.813]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:37.813]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:37.813]     }
[15:32:37.813]     ...future.result <- base::tryCatch({
[15:32:37.813]         base::withCallingHandlers({
[15:32:37.813]             ...future.value <- base::withVisible(base::local({
[15:32:37.813]                 ...future.makeSendCondition <- base::local({
[15:32:37.813]                   sendCondition <- NULL
[15:32:37.813]                   function(frame = 1L) {
[15:32:37.813]                     if (is.function(sendCondition)) 
[15:32:37.813]                       return(sendCondition)
[15:32:37.813]                     ns <- getNamespace("parallel")
[15:32:37.813]                     if (exists("sendData", mode = "function", 
[15:32:37.813]                       envir = ns)) {
[15:32:37.813]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:37.813]                         envir = ns)
[15:32:37.813]                       envir <- sys.frame(frame)
[15:32:37.813]                       master <- NULL
[15:32:37.813]                       while (!identical(envir, .GlobalEnv) && 
[15:32:37.813]                         !identical(envir, emptyenv())) {
[15:32:37.813]                         if (exists("master", mode = "list", envir = envir, 
[15:32:37.813]                           inherits = FALSE)) {
[15:32:37.813]                           master <- get("master", mode = "list", 
[15:32:37.813]                             envir = envir, inherits = FALSE)
[15:32:37.813]                           if (inherits(master, c("SOCKnode", 
[15:32:37.813]                             "SOCK0node"))) {
[15:32:37.813]                             sendCondition <<- function(cond) {
[15:32:37.813]                               data <- list(type = "VALUE", value = cond, 
[15:32:37.813]                                 success = TRUE)
[15:32:37.813]                               parallel_sendData(master, data)
[15:32:37.813]                             }
[15:32:37.813]                             return(sendCondition)
[15:32:37.813]                           }
[15:32:37.813]                         }
[15:32:37.813]                         frame <- frame + 1L
[15:32:37.813]                         envir <- sys.frame(frame)
[15:32:37.813]                       }
[15:32:37.813]                     }
[15:32:37.813]                     sendCondition <<- function(cond) NULL
[15:32:37.813]                   }
[15:32:37.813]                 })
[15:32:37.813]                 withCallingHandlers({
[15:32:37.813]                   {
[15:32:37.813]                     do.call(function(...) {
[15:32:37.813]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:37.813]                       if (!identical(...future.globals.maxSize.org, 
[15:32:37.813]                         ...future.globals.maxSize)) {
[15:32:37.813]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:37.813]                         on.exit(options(oopts), add = TRUE)
[15:32:37.813]                       }
[15:32:37.813]                       {
[15:32:37.813]                         lapply(seq_along(...future.elements_ii), 
[15:32:37.813]                           FUN = function(jj) {
[15:32:37.813]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:37.813]                             ...future.FUN(...future.X_jj, ...)
[15:32:37.813]                           })
[15:32:37.813]                       }
[15:32:37.813]                     }, args = future.call.arguments)
[15:32:37.813]                   }
[15:32:37.813]                 }, immediateCondition = function(cond) {
[15:32:37.813]                   sendCondition <- ...future.makeSendCondition()
[15:32:37.813]                   sendCondition(cond)
[15:32:37.813]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:37.813]                   {
[15:32:37.813]                     inherits <- base::inherits
[15:32:37.813]                     invokeRestart <- base::invokeRestart
[15:32:37.813]                     is.null <- base::is.null
[15:32:37.813]                     muffled <- FALSE
[15:32:37.813]                     if (inherits(cond, "message")) {
[15:32:37.813]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:37.813]                       if (muffled) 
[15:32:37.813]                         invokeRestart("muffleMessage")
[15:32:37.813]                     }
[15:32:37.813]                     else if (inherits(cond, "warning")) {
[15:32:37.813]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:37.813]                       if (muffled) 
[15:32:37.813]                         invokeRestart("muffleWarning")
[15:32:37.813]                     }
[15:32:37.813]                     else if (inherits(cond, "condition")) {
[15:32:37.813]                       if (!is.null(pattern)) {
[15:32:37.813]                         computeRestarts <- base::computeRestarts
[15:32:37.813]                         grepl <- base::grepl
[15:32:37.813]                         restarts <- computeRestarts(cond)
[15:32:37.813]                         for (restart in restarts) {
[15:32:37.813]                           name <- restart$name
[15:32:37.813]                           if (is.null(name)) 
[15:32:37.813]                             next
[15:32:37.813]                           if (!grepl(pattern, name)) 
[15:32:37.813]                             next
[15:32:37.813]                           invokeRestart(restart)
[15:32:37.813]                           muffled <- TRUE
[15:32:37.813]                           break
[15:32:37.813]                         }
[15:32:37.813]                       }
[15:32:37.813]                     }
[15:32:37.813]                     invisible(muffled)
[15:32:37.813]                   }
[15:32:37.813]                   muffleCondition(cond)
[15:32:37.813]                 })
[15:32:37.813]             }))
[15:32:37.813]             future::FutureResult(value = ...future.value$value, 
[15:32:37.813]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:37.813]                   ...future.rng), globalenv = if (FALSE) 
[15:32:37.813]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:37.813]                     ...future.globalenv.names))
[15:32:37.813]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:37.813]         }, condition = base::local({
[15:32:37.813]             c <- base::c
[15:32:37.813]             inherits <- base::inherits
[15:32:37.813]             invokeRestart <- base::invokeRestart
[15:32:37.813]             length <- base::length
[15:32:37.813]             list <- base::list
[15:32:37.813]             seq.int <- base::seq.int
[15:32:37.813]             signalCondition <- base::signalCondition
[15:32:37.813]             sys.calls <- base::sys.calls
[15:32:37.813]             `[[` <- base::`[[`
[15:32:37.813]             `+` <- base::`+`
[15:32:37.813]             `<<-` <- base::`<<-`
[15:32:37.813]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:37.813]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:37.813]                   3L)]
[15:32:37.813]             }
[15:32:37.813]             function(cond) {
[15:32:37.813]                 is_error <- inherits(cond, "error")
[15:32:37.813]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:37.813]                   NULL)
[15:32:37.813]                 if (is_error) {
[15:32:37.813]                   sessionInformation <- function() {
[15:32:37.813]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:37.813]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:37.813]                       search = base::search(), system = base::Sys.info())
[15:32:37.813]                   }
[15:32:37.813]                   ...future.conditions[[length(...future.conditions) + 
[15:32:37.813]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:37.813]                     cond$call), session = sessionInformation(), 
[15:32:37.813]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:37.813]                   signalCondition(cond)
[15:32:37.813]                 }
[15:32:37.813]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:37.813]                 "immediateCondition"))) {
[15:32:37.813]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:37.813]                   ...future.conditions[[length(...future.conditions) + 
[15:32:37.813]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:37.813]                   if (TRUE && !signal) {
[15:32:37.813]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:37.813]                     {
[15:32:37.813]                       inherits <- base::inherits
[15:32:37.813]                       invokeRestart <- base::invokeRestart
[15:32:37.813]                       is.null <- base::is.null
[15:32:37.813]                       muffled <- FALSE
[15:32:37.813]                       if (inherits(cond, "message")) {
[15:32:37.813]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:37.813]                         if (muffled) 
[15:32:37.813]                           invokeRestart("muffleMessage")
[15:32:37.813]                       }
[15:32:37.813]                       else if (inherits(cond, "warning")) {
[15:32:37.813]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:37.813]                         if (muffled) 
[15:32:37.813]                           invokeRestart("muffleWarning")
[15:32:37.813]                       }
[15:32:37.813]                       else if (inherits(cond, "condition")) {
[15:32:37.813]                         if (!is.null(pattern)) {
[15:32:37.813]                           computeRestarts <- base::computeRestarts
[15:32:37.813]                           grepl <- base::grepl
[15:32:37.813]                           restarts <- computeRestarts(cond)
[15:32:37.813]                           for (restart in restarts) {
[15:32:37.813]                             name <- restart$name
[15:32:37.813]                             if (is.null(name)) 
[15:32:37.813]                               next
[15:32:37.813]                             if (!grepl(pattern, name)) 
[15:32:37.813]                               next
[15:32:37.813]                             invokeRestart(restart)
[15:32:37.813]                             muffled <- TRUE
[15:32:37.813]                             break
[15:32:37.813]                           }
[15:32:37.813]                         }
[15:32:37.813]                       }
[15:32:37.813]                       invisible(muffled)
[15:32:37.813]                     }
[15:32:37.813]                     muffleCondition(cond, pattern = "^muffle")
[15:32:37.813]                   }
[15:32:37.813]                 }
[15:32:37.813]                 else {
[15:32:37.813]                   if (TRUE) {
[15:32:37.813]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:37.813]                     {
[15:32:37.813]                       inherits <- base::inherits
[15:32:37.813]                       invokeRestart <- base::invokeRestart
[15:32:37.813]                       is.null <- base::is.null
[15:32:37.813]                       muffled <- FALSE
[15:32:37.813]                       if (inherits(cond, "message")) {
[15:32:37.813]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:37.813]                         if (muffled) 
[15:32:37.813]                           invokeRestart("muffleMessage")
[15:32:37.813]                       }
[15:32:37.813]                       else if (inherits(cond, "warning")) {
[15:32:37.813]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:37.813]                         if (muffled) 
[15:32:37.813]                           invokeRestart("muffleWarning")
[15:32:37.813]                       }
[15:32:37.813]                       else if (inherits(cond, "condition")) {
[15:32:37.813]                         if (!is.null(pattern)) {
[15:32:37.813]                           computeRestarts <- base::computeRestarts
[15:32:37.813]                           grepl <- base::grepl
[15:32:37.813]                           restarts <- computeRestarts(cond)
[15:32:37.813]                           for (restart in restarts) {
[15:32:37.813]                             name <- restart$name
[15:32:37.813]                             if (is.null(name)) 
[15:32:37.813]                               next
[15:32:37.813]                             if (!grepl(pattern, name)) 
[15:32:37.813]                               next
[15:32:37.813]                             invokeRestart(restart)
[15:32:37.813]                             muffled <- TRUE
[15:32:37.813]                             break
[15:32:37.813]                           }
[15:32:37.813]                         }
[15:32:37.813]                       }
[15:32:37.813]                       invisible(muffled)
[15:32:37.813]                     }
[15:32:37.813]                     muffleCondition(cond, pattern = "^muffle")
[15:32:37.813]                   }
[15:32:37.813]                 }
[15:32:37.813]             }
[15:32:37.813]         }))
[15:32:37.813]     }, error = function(ex) {
[15:32:37.813]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:37.813]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:37.813]                 ...future.rng), started = ...future.startTime, 
[15:32:37.813]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:37.813]             version = "1.8"), class = "FutureResult")
[15:32:37.813]     }, finally = {
[15:32:37.813]         if (!identical(...future.workdir, getwd())) 
[15:32:37.813]             setwd(...future.workdir)
[15:32:37.813]         {
[15:32:37.813]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:37.813]                 ...future.oldOptions$nwarnings <- NULL
[15:32:37.813]             }
[15:32:37.813]             base::options(...future.oldOptions)
[15:32:37.813]             if (.Platform$OS.type == "windows") {
[15:32:37.813]                 old_names <- names(...future.oldEnvVars)
[15:32:37.813]                 envs <- base::Sys.getenv()
[15:32:37.813]                 names <- names(envs)
[15:32:37.813]                 common <- intersect(names, old_names)
[15:32:37.813]                 added <- setdiff(names, old_names)
[15:32:37.813]                 removed <- setdiff(old_names, names)
[15:32:37.813]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:37.813]                   envs[common]]
[15:32:37.813]                 NAMES <- toupper(changed)
[15:32:37.813]                 args <- list()
[15:32:37.813]                 for (kk in seq_along(NAMES)) {
[15:32:37.813]                   name <- changed[[kk]]
[15:32:37.813]                   NAME <- NAMES[[kk]]
[15:32:37.813]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:37.813]                     next
[15:32:37.813]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:37.813]                 }
[15:32:37.813]                 NAMES <- toupper(added)
[15:32:37.813]                 for (kk in seq_along(NAMES)) {
[15:32:37.813]                   name <- added[[kk]]
[15:32:37.813]                   NAME <- NAMES[[kk]]
[15:32:37.813]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:37.813]                     next
[15:32:37.813]                   args[[name]] <- ""
[15:32:37.813]                 }
[15:32:37.813]                 NAMES <- toupper(removed)
[15:32:37.813]                 for (kk in seq_along(NAMES)) {
[15:32:37.813]                   name <- removed[[kk]]
[15:32:37.813]                   NAME <- NAMES[[kk]]
[15:32:37.813]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:37.813]                     next
[15:32:37.813]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:37.813]                 }
[15:32:37.813]                 if (length(args) > 0) 
[15:32:37.813]                   base::do.call(base::Sys.setenv, args = args)
[15:32:37.813]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:37.813]             }
[15:32:37.813]             else {
[15:32:37.813]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:37.813]             }
[15:32:37.813]             {
[15:32:37.813]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:37.813]                   0L) {
[15:32:37.813]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:37.813]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:37.813]                   base::options(opts)
[15:32:37.813]                 }
[15:32:37.813]                 {
[15:32:37.813]                   {
[15:32:37.813]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:37.813]                     NULL
[15:32:37.813]                   }
[15:32:37.813]                   options(future.plan = NULL)
[15:32:37.813]                   if (is.na(NA_character_)) 
[15:32:37.813]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:37.813]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:37.813]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:37.813]                     .init = FALSE)
[15:32:37.813]                 }
[15:32:37.813]             }
[15:32:37.813]         }
[15:32:37.813]     })
[15:32:37.813]     if (TRUE) {
[15:32:37.813]         base::sink(type = "output", split = FALSE)
[15:32:37.813]         if (TRUE) {
[15:32:37.813]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:37.813]         }
[15:32:37.813]         else {
[15:32:37.813]             ...future.result["stdout"] <- base::list(NULL)
[15:32:37.813]         }
[15:32:37.813]         base::close(...future.stdout)
[15:32:37.813]         ...future.stdout <- NULL
[15:32:37.813]     }
[15:32:37.813]     ...future.result$conditions <- ...future.conditions
[15:32:37.813]     ...future.result$finished <- base::Sys.time()
[15:32:37.813]     ...future.result
[15:32:37.813] }
[15:32:37.822] Exporting 5 global objects (848 bytes) to cluster node #1 ...
[15:32:37.823] Exporting '...future.FUN' (848 bytes) to cluster node #1 ...
[15:32:37.823] Exporting '...future.FUN' (848 bytes) to cluster node #1 ... DONE
[15:32:37.824] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:37.825] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:37.825] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:37.826] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:37.826] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:37.827] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:37.827] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:37.828] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:37.828] Exporting 5 global objects (848 bytes) to cluster node #1 ... DONE
[15:32:37.829] MultisessionFuture started
[15:32:37.829] - Launch lazy future ... done
[15:32:37.829] run() for 'MultisessionFuture' ... done
[15:32:37.830] Created future:
[15:32:37.852] receiveMessageFromWorker() for ClusterFuture ...
[15:32:37.852] - Validating connection of MultisessionFuture
[15:32:37.852] - received message: FutureResult
[15:32:37.853] - Received FutureResult
[15:32:37.853] - Erased future from FutureRegistry
[15:32:37.853] result() for ClusterFuture ...
[15:32:37.853] - result already collected: FutureResult
[15:32:37.853] result() for ClusterFuture ... done
[15:32:37.854] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:37.830] MultisessionFuture:
[15:32:37.830] Label: 'future_sapply-2'
[15:32:37.830] Expression:
[15:32:37.830] {
[15:32:37.830]     do.call(function(...) {
[15:32:37.830]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:37.830]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:37.830]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:37.830]             on.exit(options(oopts), add = TRUE)
[15:32:37.830]         }
[15:32:37.830]         {
[15:32:37.830]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:37.830]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:37.830]                 ...future.FUN(...future.X_jj, ...)
[15:32:37.830]             })
[15:32:37.830]         }
[15:32:37.830]     }, args = future.call.arguments)
[15:32:37.830] }
[15:32:37.830] Lazy evaluation: FALSE
[15:32:37.830] Asynchronous evaluation: TRUE
[15:32:37.830] Local evaluation: TRUE
[15:32:37.830] Environment: R_GlobalEnv
[15:32:37.830] Capture standard output: TRUE
[15:32:37.830] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:37.830] Globals: 5 objects totaling 960 bytes (function '...future.FUN' of 848 bytes, 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)
[15:32:37.830] Packages: <none>
[15:32:37.830] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:37.830] Resolved: TRUE
[15:32:37.830] Value: <not collected>
[15:32:37.830] Conditions captured: <none>
[15:32:37.830] Early signaling: FALSE
[15:32:37.830] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:37.830] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:37.854] Chunk #2 of 2 ... DONE
[15:32:37.854] Launching 2 futures (chunks) ... DONE
[15:32:37.855] Resolving 2 futures (chunks) ...
[15:32:37.855] resolve() on list ...
[15:32:37.855]  recursive: 0
[15:32:37.855]  length: 2
[15:32:37.855] 
[15:32:37.855] Future #1
[15:32:37.856] result() for ClusterFuture ...
[15:32:37.856] - result already collected: FutureResult
[15:32:37.856] result() for ClusterFuture ... done
[15:32:37.856] result() for ClusterFuture ...
[15:32:37.856] - result already collected: FutureResult
[15:32:37.857] result() for ClusterFuture ... done
[15:32:37.857] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:37.857] - nx: 2
[15:32:37.857] - relay: TRUE
[15:32:37.857] - stdout: TRUE
[15:32:37.857] - signal: TRUE
[15:32:37.858] - resignal: FALSE
[15:32:37.858] - force: TRUE
[15:32:37.858] - relayed: [n=2] FALSE, FALSE
[15:32:37.858] - queued futures: [n=2] FALSE, FALSE
[15:32:37.858]  - until=1
[15:32:37.858]  - relaying element #1
[15:32:37.859] result() for ClusterFuture ...
[15:32:37.859] - result already collected: FutureResult
[15:32:37.859] result() for ClusterFuture ... done
[15:32:37.860] result() for ClusterFuture ...
[15:32:37.860] - result already collected: FutureResult
[15:32:37.860] result() for ClusterFuture ... done
[15:32:37.861] result() for ClusterFuture ...
[15:32:37.861] - result already collected: FutureResult
[15:32:37.861] result() for ClusterFuture ... done
[15:32:37.861] result() for ClusterFuture ...
[15:32:37.862] - result already collected: FutureResult
[15:32:37.862] result() for ClusterFuture ... done
[15:32:37.862] - relayed: [n=2] TRUE, FALSE
[15:32:37.862] - queued futures: [n=2] TRUE, FALSE
[15:32:37.863] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:37.863]  length: 1 (resolved future 1)
[15:32:37.863] Future #2
[15:32:37.863] result() for ClusterFuture ...
[15:32:37.864] - result already collected: FutureResult
[15:32:37.864] result() for ClusterFuture ... done
[15:32:37.864] result() for ClusterFuture ...
[15:32:37.864] - result already collected: FutureResult
[15:32:37.865] result() for ClusterFuture ... done
[15:32:37.865] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:37.865] - nx: 2
[15:32:37.865] - relay: TRUE
[15:32:37.866] - stdout: TRUE
[15:32:37.866] - signal: TRUE
[15:32:37.866] - resignal: FALSE
[15:32:37.866] - force: TRUE
[15:32:37.867] - relayed: [n=2] TRUE, FALSE
[15:32:37.867] - queued futures: [n=2] TRUE, FALSE
[15:32:37.867]  - until=2
[15:32:37.867]  - relaying element #2
[15:32:37.867] result() for ClusterFuture ...
[15:32:37.868] - result already collected: FutureResult
[15:32:37.868] result() for ClusterFuture ... done
[15:32:37.868] result() for ClusterFuture ...
[15:32:37.868] - result already collected: FutureResult
[15:32:37.869] result() for ClusterFuture ... done
[15:32:37.869] result() for ClusterFuture ...
[15:32:37.869] - result already collected: FutureResult
[15:32:37.870] result() for ClusterFuture ... done
[15:32:37.870] result() for ClusterFuture ...
[15:32:37.870] - result already collected: FutureResult
[15:32:37.870] result() for ClusterFuture ... done
[15:32:37.871] - relayed: [n=2] TRUE, TRUE
[15:32:37.871] - queued futures: [n=2] TRUE, TRUE
[15:32:37.871] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:37.871]  length: 0 (resolved future 2)
[15:32:37.872] Relaying remaining futures
[15:32:37.872] signalConditionsASAP(NULL, pos=0) ...
[15:32:37.872] - nx: 2
[15:32:37.872] - relay: TRUE
[15:32:37.873] - stdout: TRUE
[15:32:37.873] - signal: TRUE
[15:32:37.873] - resignal: FALSE
[15:32:37.873] - force: TRUE
[15:32:37.873] - relayed: [n=2] TRUE, TRUE
[15:32:37.874] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:37.874] - relayed: [n=2] TRUE, TRUE
[15:32:37.874] - queued futures: [n=2] TRUE, TRUE
[15:32:37.875] signalConditionsASAP(NULL, pos=0) ... done
[15:32:37.875] resolve() on list ... DONE
[15:32:37.875] result() for ClusterFuture ...
[15:32:37.875] - result already collected: FutureResult
[15:32:37.876] result() for ClusterFuture ... done
[15:32:37.876] result() for ClusterFuture ...
[15:32:37.876] - result already collected: FutureResult
[15:32:37.877] result() for ClusterFuture ... done
[15:32:37.877] result() for ClusterFuture ...
[15:32:37.877] - result already collected: FutureResult
[15:32:37.877] result() for ClusterFuture ... done
[15:32:37.878] result() for ClusterFuture ...
[15:32:37.878] - result already collected: FutureResult
[15:32:37.878] result() for ClusterFuture ... done
[15:32:37.879]  - Number of value chunks collected: 2
[15:32:37.879] Resolving 2 futures (chunks) ... DONE
[15:32:37.879] Reducing values from 2 chunks ...
[15:32:37.879]  - Number of values collected after concatenation: 4
[15:32:37.880]  - Number of values expected: 4
[15:32:37.880] Reducing values from 2 chunks ... DONE
[15:32:37.880] future_lapply() ... DONE
List of 2
 $ y0:List of 4
  ..$ A: num 50
  ..$ B: num 60
  ..$ C: num 70
  ..$ D: num 80
 $ y1:List of 4
  ..$ A: num 50
  ..$ B: num 60
  ..$ C: num 70
  ..$ D: num 80
List of 2
 $ y0:List of 4
  ..$ A: num 50
  ..$ B: num 60
  ..$ C: num 70
  ..$ D: num 80
 $ y2:List of 4
  ..$ A: num 50
  ..$ B: num 60
  ..$ C: num 70
  ..$ D: num 80
[15:32:37.898] future_lapply() ...
[15:32:37.903] Number of chunks: 2
[15:32:37.903] getGlobalsAndPackagesXApply() ...
[15:32:37.903]  - future.globals: TRUE
[15:32:37.904] getGlobalsAndPackages() ...
[15:32:37.904] Searching for globals...
[15:32:37.906] - globals found: [2] 'FUN', 'UseMethod'
[15:32:37.906] Searching for globals ... DONE
[15:32:37.907] Resolving globals: FALSE
[15:32:37.907] The total size of the 1 globals is 1.22 KiB (1248 bytes)
[15:32:37.908] The total size of the 1 globals exported for future expression ('FUN()') is 1.22 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.22 KiB of class 'function')
[15:32:37.908] - globals: [1] 'FUN'
[15:32:37.909] 
[15:32:37.909] getGlobalsAndPackages() ... DONE
[15:32:37.909]  - globals found/used: [n=1] 'FUN'
[15:32:37.909]  - needed namespaces: [n=0] 
[15:32:37.910] Finding globals ... DONE
[15:32:37.910]  - use_args: TRUE
[15:32:37.910]  - Getting '...' globals ...
[15:32:37.911] resolve() on list ...
[15:32:37.911]  recursive: 0
[15:32:37.911]  length: 1
[15:32:37.911]  elements: '...'
[15:32:37.912]  length: 0 (resolved future 1)
[15:32:37.912] resolve() on list ... DONE
[15:32:37.912]    - '...' content: [n=0] 
[15:32:37.913] List of 1
[15:32:37.913]  $ ...: list()
[15:32:37.913]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:37.913]  - attr(*, "where")=List of 1
[15:32:37.913]   ..$ ...:<environment: 0x00000276e1992a40> 
[15:32:37.913]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:37.913]  - attr(*, "resolved")= logi TRUE
[15:32:37.913]  - attr(*, "total_size")= num NA
[15:32:37.917]  - Getting '...' globals ... DONE
[15:32:37.917] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:37.918] List of 2
[15:32:37.918]  $ ...future.FUN:function (x, ...)  
[15:32:37.918]  $ ...          : list()
[15:32:37.918]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:37.918]  - attr(*, "where")=List of 2
[15:32:37.918]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:37.918]   ..$ ...          :<environment: 0x00000276e1992a40> 
[15:32:37.918]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:37.918]  - attr(*, "resolved")= logi FALSE
[15:32:37.918]  - attr(*, "total_size")= num 1248
[15:32:37.923] Packages to be attached in all futures: [n=0] 
[15:32:37.923] getGlobalsAndPackagesXApply() ... DONE
[15:32:37.924] Number of futures (= number of chunks): 2
[15:32:37.924] Launching 2 futures (chunks) ...
[15:32:37.924] Chunk #1 of 2 ...
[15:32:37.924]  - Finding globals in 'X' for chunk #1 ...
[15:32:37.925] getGlobalsAndPackages() ...
[15:32:37.925] Searching for globals...
[15:32:37.926] 
[15:32:37.926] Searching for globals ... DONE
[15:32:37.926] - globals: [0] <none>
[15:32:37.926] getGlobalsAndPackages() ... DONE
[15:32:37.927]    + additional globals found: [n=0] 
[15:32:37.927]    + additional namespaces needed: [n=0] 
[15:32:37.927]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:37.927]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:37.928]  - seeds: <none>
[15:32:37.928]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:37.928] getGlobalsAndPackages() ...
[15:32:37.928] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:37.929] Resolving globals: FALSE
[15:32:37.929] Tweak future expression to call with '...' arguments ...
[15:32:37.929] {
[15:32:37.929]     do.call(function(...) {
[15:32:37.929]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:37.929]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:37.929]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:37.929]             on.exit(options(oopts), add = TRUE)
[15:32:37.929]         }
[15:32:37.929]         {
[15:32:37.929]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:37.929]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:37.929]                 ...future.FUN(...future.X_jj, ...)
[15:32:37.929]             })
[15:32:37.929]         }
[15:32:37.929]     }, args = future.call.arguments)
[15:32:37.929] }
[15:32:37.930] Tweak future expression to call with '...' arguments ... DONE
[15:32:37.931] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:37.931] 
[15:32:37.931] getGlobalsAndPackages() ... DONE
[15:32:37.932] run() for 'Future' ...
[15:32:37.932] - state: 'created'
[15:32:37.933] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:37.951] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:37.951] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:37.952]   - Field: 'node'
[15:32:37.952]   - Field: 'label'
[15:32:37.952]   - Field: 'local'
[15:32:37.952]   - Field: 'owner'
[15:32:37.953]   - Field: 'envir'
[15:32:37.953]   - Field: 'workers'
[15:32:37.953]   - Field: 'packages'
[15:32:37.954]   - Field: 'gc'
[15:32:37.954]   - Field: 'conditions'
[15:32:37.954]   - Field: 'persistent'
[15:32:37.954]   - Field: 'expr'
[15:32:37.955]   - Field: 'uuid'
[15:32:37.955]   - Field: 'seed'
[15:32:37.955]   - Field: 'version'
[15:32:37.956]   - Field: 'result'
[15:32:37.956]   - Field: 'asynchronous'
[15:32:37.956]   - Field: 'calls'
[15:32:37.957]   - Field: 'globals'
[15:32:37.957]   - Field: 'stdout'
[15:32:37.957]   - Field: 'earlySignal'
[15:32:37.957]   - Field: 'lazy'
[15:32:37.958]   - Field: 'state'
[15:32:37.958] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:37.958] - Launch lazy future ...
[15:32:37.959] Packages needed by the future expression (n = 0): <none>
[15:32:37.959] Packages needed by future strategies (n = 0): <none>
[15:32:37.960] {
[15:32:37.960]     {
[15:32:37.960]         {
[15:32:37.960]             ...future.startTime <- base::Sys.time()
[15:32:37.960]             {
[15:32:37.960]                 {
[15:32:37.960]                   {
[15:32:37.960]                     {
[15:32:37.960]                       base::local({
[15:32:37.960]                         has_future <- base::requireNamespace("future", 
[15:32:37.960]                           quietly = TRUE)
[15:32:37.960]                         if (has_future) {
[15:32:37.960]                           ns <- base::getNamespace("future")
[15:32:37.960]                           version <- ns[[".package"]][["version"]]
[15:32:37.960]                           if (is.null(version)) 
[15:32:37.960]                             version <- utils::packageVersion("future")
[15:32:37.960]                         }
[15:32:37.960]                         else {
[15:32:37.960]                           version <- NULL
[15:32:37.960]                         }
[15:32:37.960]                         if (!has_future || version < "1.8.0") {
[15:32:37.960]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:37.960]                             "", base::R.version$version.string), 
[15:32:37.960]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:37.960]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:37.960]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:37.960]                               "release", "version")], collapse = " "), 
[15:32:37.960]                             hostname = base::Sys.info()[["nodename"]])
[15:32:37.960]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:37.960]                             info)
[15:32:37.960]                           info <- base::paste(info, collapse = "; ")
[15:32:37.960]                           if (!has_future) {
[15:32:37.960]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:37.960]                               info)
[15:32:37.960]                           }
[15:32:37.960]                           else {
[15:32:37.960]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:37.960]                               info, version)
[15:32:37.960]                           }
[15:32:37.960]                           base::stop(msg)
[15:32:37.960]                         }
[15:32:37.960]                       })
[15:32:37.960]                     }
[15:32:37.960]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:37.960]                     base::options(mc.cores = 1L)
[15:32:37.960]                   }
[15:32:37.960]                   ...future.strategy.old <- future::plan("list")
[15:32:37.960]                   options(future.plan = NULL)
[15:32:37.960]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:37.960]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:37.960]                 }
[15:32:37.960]                 ...future.workdir <- getwd()
[15:32:37.960]             }
[15:32:37.960]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:37.960]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:37.960]         }
[15:32:37.960]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:37.960]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:37.960]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:37.960]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:37.960]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:37.960]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:37.960]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:37.960]             base::names(...future.oldOptions))
[15:32:37.960]     }
[15:32:37.960]     if (FALSE) {
[15:32:37.960]     }
[15:32:37.960]     else {
[15:32:37.960]         if (TRUE) {
[15:32:37.960]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:37.960]                 open = "w")
[15:32:37.960]         }
[15:32:37.960]         else {
[15:32:37.960]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:37.960]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:37.960]         }
[15:32:37.960]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:37.960]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:37.960]             base::sink(type = "output", split = FALSE)
[15:32:37.960]             base::close(...future.stdout)
[15:32:37.960]         }, add = TRUE)
[15:32:37.960]     }
[15:32:37.960]     ...future.frame <- base::sys.nframe()
[15:32:37.960]     ...future.conditions <- base::list()
[15:32:37.960]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:37.960]     if (FALSE) {
[15:32:37.960]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:37.960]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:37.960]     }
[15:32:37.960]     ...future.result <- base::tryCatch({
[15:32:37.960]         base::withCallingHandlers({
[15:32:37.960]             ...future.value <- base::withVisible(base::local({
[15:32:37.960]                 ...future.makeSendCondition <- base::local({
[15:32:37.960]                   sendCondition <- NULL
[15:32:37.960]                   function(frame = 1L) {
[15:32:37.960]                     if (is.function(sendCondition)) 
[15:32:37.960]                       return(sendCondition)
[15:32:37.960]                     ns <- getNamespace("parallel")
[15:32:37.960]                     if (exists("sendData", mode = "function", 
[15:32:37.960]                       envir = ns)) {
[15:32:37.960]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:37.960]                         envir = ns)
[15:32:37.960]                       envir <- sys.frame(frame)
[15:32:37.960]                       master <- NULL
[15:32:37.960]                       while (!identical(envir, .GlobalEnv) && 
[15:32:37.960]                         !identical(envir, emptyenv())) {
[15:32:37.960]                         if (exists("master", mode = "list", envir = envir, 
[15:32:37.960]                           inherits = FALSE)) {
[15:32:37.960]                           master <- get("master", mode = "list", 
[15:32:37.960]                             envir = envir, inherits = FALSE)
[15:32:37.960]                           if (inherits(master, c("SOCKnode", 
[15:32:37.960]                             "SOCK0node"))) {
[15:32:37.960]                             sendCondition <<- function(cond) {
[15:32:37.960]                               data <- list(type = "VALUE", value = cond, 
[15:32:37.960]                                 success = TRUE)
[15:32:37.960]                               parallel_sendData(master, data)
[15:32:37.960]                             }
[15:32:37.960]                             return(sendCondition)
[15:32:37.960]                           }
[15:32:37.960]                         }
[15:32:37.960]                         frame <- frame + 1L
[15:32:37.960]                         envir <- sys.frame(frame)
[15:32:37.960]                       }
[15:32:37.960]                     }
[15:32:37.960]                     sendCondition <<- function(cond) NULL
[15:32:37.960]                   }
[15:32:37.960]                 })
[15:32:37.960]                 withCallingHandlers({
[15:32:37.960]                   {
[15:32:37.960]                     do.call(function(...) {
[15:32:37.960]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:37.960]                       if (!identical(...future.globals.maxSize.org, 
[15:32:37.960]                         ...future.globals.maxSize)) {
[15:32:37.960]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:37.960]                         on.exit(options(oopts), add = TRUE)
[15:32:37.960]                       }
[15:32:37.960]                       {
[15:32:37.960]                         lapply(seq_along(...future.elements_ii), 
[15:32:37.960]                           FUN = function(jj) {
[15:32:37.960]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:37.960]                             ...future.FUN(...future.X_jj, ...)
[15:32:37.960]                           })
[15:32:37.960]                       }
[15:32:37.960]                     }, args = future.call.arguments)
[15:32:37.960]                   }
[15:32:37.960]                 }, immediateCondition = function(cond) {
[15:32:37.960]                   sendCondition <- ...future.makeSendCondition()
[15:32:37.960]                   sendCondition(cond)
[15:32:37.960]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:37.960]                   {
[15:32:37.960]                     inherits <- base::inherits
[15:32:37.960]                     invokeRestart <- base::invokeRestart
[15:32:37.960]                     is.null <- base::is.null
[15:32:37.960]                     muffled <- FALSE
[15:32:37.960]                     if (inherits(cond, "message")) {
[15:32:37.960]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:37.960]                       if (muffled) 
[15:32:37.960]                         invokeRestart("muffleMessage")
[15:32:37.960]                     }
[15:32:37.960]                     else if (inherits(cond, "warning")) {
[15:32:37.960]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:37.960]                       if (muffled) 
[15:32:37.960]                         invokeRestart("muffleWarning")
[15:32:37.960]                     }
[15:32:37.960]                     else if (inherits(cond, "condition")) {
[15:32:37.960]                       if (!is.null(pattern)) {
[15:32:37.960]                         computeRestarts <- base::computeRestarts
[15:32:37.960]                         grepl <- base::grepl
[15:32:37.960]                         restarts <- computeRestarts(cond)
[15:32:37.960]                         for (restart in restarts) {
[15:32:37.960]                           name <- restart$name
[15:32:37.960]                           if (is.null(name)) 
[15:32:37.960]                             next
[15:32:37.960]                           if (!grepl(pattern, name)) 
[15:32:37.960]                             next
[15:32:37.960]                           invokeRestart(restart)
[15:32:37.960]                           muffled <- TRUE
[15:32:37.960]                           break
[15:32:37.960]                         }
[15:32:37.960]                       }
[15:32:37.960]                     }
[15:32:37.960]                     invisible(muffled)
[15:32:37.960]                   }
[15:32:37.960]                   muffleCondition(cond)
[15:32:37.960]                 })
[15:32:37.960]             }))
[15:32:37.960]             future::FutureResult(value = ...future.value$value, 
[15:32:37.960]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:37.960]                   ...future.rng), globalenv = if (FALSE) 
[15:32:37.960]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:37.960]                     ...future.globalenv.names))
[15:32:37.960]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:37.960]         }, condition = base::local({
[15:32:37.960]             c <- base::c
[15:32:37.960]             inherits <- base::inherits
[15:32:37.960]             invokeRestart <- base::invokeRestart
[15:32:37.960]             length <- base::length
[15:32:37.960]             list <- base::list
[15:32:37.960]             seq.int <- base::seq.int
[15:32:37.960]             signalCondition <- base::signalCondition
[15:32:37.960]             sys.calls <- base::sys.calls
[15:32:37.960]             `[[` <- base::`[[`
[15:32:37.960]             `+` <- base::`+`
[15:32:37.960]             `<<-` <- base::`<<-`
[15:32:37.960]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:37.960]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:37.960]                   3L)]
[15:32:37.960]             }
[15:32:37.960]             function(cond) {
[15:32:37.960]                 is_error <- inherits(cond, "error")
[15:32:37.960]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:37.960]                   NULL)
[15:32:37.960]                 if (is_error) {
[15:32:37.960]                   sessionInformation <- function() {
[15:32:37.960]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:37.960]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:37.960]                       search = base::search(), system = base::Sys.info())
[15:32:37.960]                   }
[15:32:37.960]                   ...future.conditions[[length(...future.conditions) + 
[15:32:37.960]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:37.960]                     cond$call), session = sessionInformation(), 
[15:32:37.960]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:37.960]                   signalCondition(cond)
[15:32:37.960]                 }
[15:32:37.960]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:37.960]                 "immediateCondition"))) {
[15:32:37.960]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:37.960]                   ...future.conditions[[length(...future.conditions) + 
[15:32:37.960]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:37.960]                   if (TRUE && !signal) {
[15:32:37.960]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:37.960]                     {
[15:32:37.960]                       inherits <- base::inherits
[15:32:37.960]                       invokeRestart <- base::invokeRestart
[15:32:37.960]                       is.null <- base::is.null
[15:32:37.960]                       muffled <- FALSE
[15:32:37.960]                       if (inherits(cond, "message")) {
[15:32:37.960]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:37.960]                         if (muffled) 
[15:32:37.960]                           invokeRestart("muffleMessage")
[15:32:37.960]                       }
[15:32:37.960]                       else if (inherits(cond, "warning")) {
[15:32:37.960]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:37.960]                         if (muffled) 
[15:32:37.960]                           invokeRestart("muffleWarning")
[15:32:37.960]                       }
[15:32:37.960]                       else if (inherits(cond, "condition")) {
[15:32:37.960]                         if (!is.null(pattern)) {
[15:32:37.960]                           computeRestarts <- base::computeRestarts
[15:32:37.960]                           grepl <- base::grepl
[15:32:37.960]                           restarts <- computeRestarts(cond)
[15:32:37.960]                           for (restart in restarts) {
[15:32:37.960]                             name <- restart$name
[15:32:37.960]                             if (is.null(name)) 
[15:32:37.960]                               next
[15:32:37.960]                             if (!grepl(pattern, name)) 
[15:32:37.960]                               next
[15:32:37.960]                             invokeRestart(restart)
[15:32:37.960]                             muffled <- TRUE
[15:32:37.960]                             break
[15:32:37.960]                           }
[15:32:37.960]                         }
[15:32:37.960]                       }
[15:32:37.960]                       invisible(muffled)
[15:32:37.960]                     }
[15:32:37.960]                     muffleCondition(cond, pattern = "^muffle")
[15:32:37.960]                   }
[15:32:37.960]                 }
[15:32:37.960]                 else {
[15:32:37.960]                   if (TRUE) {
[15:32:37.960]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:37.960]                     {
[15:32:37.960]                       inherits <- base::inherits
[15:32:37.960]                       invokeRestart <- base::invokeRestart
[15:32:37.960]                       is.null <- base::is.null
[15:32:37.960]                       muffled <- FALSE
[15:32:37.960]                       if (inherits(cond, "message")) {
[15:32:37.960]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:37.960]                         if (muffled) 
[15:32:37.960]                           invokeRestart("muffleMessage")
[15:32:37.960]                       }
[15:32:37.960]                       else if (inherits(cond, "warning")) {
[15:32:37.960]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:37.960]                         if (muffled) 
[15:32:37.960]                           invokeRestart("muffleWarning")
[15:32:37.960]                       }
[15:32:37.960]                       else if (inherits(cond, "condition")) {
[15:32:37.960]                         if (!is.null(pattern)) {
[15:32:37.960]                           computeRestarts <- base::computeRestarts
[15:32:37.960]                           grepl <- base::grepl
[15:32:37.960]                           restarts <- computeRestarts(cond)
[15:32:37.960]                           for (restart in restarts) {
[15:32:37.960]                             name <- restart$name
[15:32:37.960]                             if (is.null(name)) 
[15:32:37.960]                               next
[15:32:37.960]                             if (!grepl(pattern, name)) 
[15:32:37.960]                               next
[15:32:37.960]                             invokeRestart(restart)
[15:32:37.960]                             muffled <- TRUE
[15:32:37.960]                             break
[15:32:37.960]                           }
[15:32:37.960]                         }
[15:32:37.960]                       }
[15:32:37.960]                       invisible(muffled)
[15:32:37.960]                     }
[15:32:37.960]                     muffleCondition(cond, pattern = "^muffle")
[15:32:37.960]                   }
[15:32:37.960]                 }
[15:32:37.960]             }
[15:32:37.960]         }))
[15:32:37.960]     }, error = function(ex) {
[15:32:37.960]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:37.960]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:37.960]                 ...future.rng), started = ...future.startTime, 
[15:32:37.960]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:37.960]             version = "1.8"), class = "FutureResult")
[15:32:37.960]     }, finally = {
[15:32:37.960]         if (!identical(...future.workdir, getwd())) 
[15:32:37.960]             setwd(...future.workdir)
[15:32:37.960]         {
[15:32:37.960]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:37.960]                 ...future.oldOptions$nwarnings <- NULL
[15:32:37.960]             }
[15:32:37.960]             base::options(...future.oldOptions)
[15:32:37.960]             if (.Platform$OS.type == "windows") {
[15:32:37.960]                 old_names <- names(...future.oldEnvVars)
[15:32:37.960]                 envs <- base::Sys.getenv()
[15:32:37.960]                 names <- names(envs)
[15:32:37.960]                 common <- intersect(names, old_names)
[15:32:37.960]                 added <- setdiff(names, old_names)
[15:32:37.960]                 removed <- setdiff(old_names, names)
[15:32:37.960]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:37.960]                   envs[common]]
[15:32:37.960]                 NAMES <- toupper(changed)
[15:32:37.960]                 args <- list()
[15:32:37.960]                 for (kk in seq_along(NAMES)) {
[15:32:37.960]                   name <- changed[[kk]]
[15:32:37.960]                   NAME <- NAMES[[kk]]
[15:32:37.960]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:37.960]                     next
[15:32:37.960]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:37.960]                 }
[15:32:37.960]                 NAMES <- toupper(added)
[15:32:37.960]                 for (kk in seq_along(NAMES)) {
[15:32:37.960]                   name <- added[[kk]]
[15:32:37.960]                   NAME <- NAMES[[kk]]
[15:32:37.960]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:37.960]                     next
[15:32:37.960]                   args[[name]] <- ""
[15:32:37.960]                 }
[15:32:37.960]                 NAMES <- toupper(removed)
[15:32:37.960]                 for (kk in seq_along(NAMES)) {
[15:32:37.960]                   name <- removed[[kk]]
[15:32:37.960]                   NAME <- NAMES[[kk]]
[15:32:37.960]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:37.960]                     next
[15:32:37.960]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:37.960]                 }
[15:32:37.960]                 if (length(args) > 0) 
[15:32:37.960]                   base::do.call(base::Sys.setenv, args = args)
[15:32:37.960]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:37.960]             }
[15:32:37.960]             else {
[15:32:37.960]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:37.960]             }
[15:32:37.960]             {
[15:32:37.960]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:37.960]                   0L) {
[15:32:37.960]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:37.960]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:37.960]                   base::options(opts)
[15:32:37.960]                 }
[15:32:37.960]                 {
[15:32:37.960]                   {
[15:32:37.960]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:37.960]                     NULL
[15:32:37.960]                   }
[15:32:37.960]                   options(future.plan = NULL)
[15:32:37.960]                   if (is.na(NA_character_)) 
[15:32:37.960]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:37.960]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:37.960]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:37.960]                     .init = FALSE)
[15:32:37.960]                 }
[15:32:37.960]             }
[15:32:37.960]         }
[15:32:37.960]     })
[15:32:37.960]     if (TRUE) {
[15:32:37.960]         base::sink(type = "output", split = FALSE)
[15:32:37.960]         if (TRUE) {
[15:32:37.960]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:37.960]         }
[15:32:37.960]         else {
[15:32:37.960]             ...future.result["stdout"] <- base::list(NULL)
[15:32:37.960]         }
[15:32:37.960]         base::close(...future.stdout)
[15:32:37.960]         ...future.stdout <- NULL
[15:32:37.960]     }
[15:32:37.960]     ...future.result$conditions <- ...future.conditions
[15:32:37.960]     ...future.result$finished <- base::Sys.time()
[15:32:37.960]     ...future.result
[15:32:37.960] }
[15:32:37.970] Exporting 5 global objects (1.22 KiB) to cluster node #1 ...
[15:32:37.971] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ...
[15:32:37.971] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ... DONE
[15:32:37.972] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:37.973] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:37.973] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:37.974] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:37.974] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:37.975] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:37.975] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:37.976] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:37.976] Exporting 5 global objects (1.22 KiB) to cluster node #1 ... DONE
[15:32:37.977] MultisessionFuture started
[15:32:37.978] - Launch lazy future ... done
[15:32:37.978] run() for 'MultisessionFuture' ... done
[15:32:37.978] Created future:
[15:32:38.009] receiveMessageFromWorker() for ClusterFuture ...
[15:32:38.010] - Validating connection of MultisessionFuture
[15:32:38.010] - received message: FutureResult
[15:32:38.011] - Received FutureResult
[15:32:38.011] - Erased future from FutureRegistry
[15:32:38.011] result() for ClusterFuture ...
[15:32:38.011] - result already collected: FutureResult
[15:32:38.012] result() for ClusterFuture ... done
[15:32:38.012] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:37.979] MultisessionFuture:
[15:32:37.979] Label: 'future_sapply-1'
[15:32:37.979] Expression:
[15:32:37.979] {
[15:32:37.979]     do.call(function(...) {
[15:32:37.979]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:37.979]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:37.979]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:37.979]             on.exit(options(oopts), add = TRUE)
[15:32:37.979]         }
[15:32:37.979]         {
[15:32:37.979]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:37.979]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:37.979]                 ...future.FUN(...future.X_jj, ...)
[15:32:37.979]             })
[15:32:37.979]         }
[15:32:37.979]     }, args = future.call.arguments)
[15:32:37.979] }
[15:32:37.979] Lazy evaluation: FALSE
[15:32:37.979] Asynchronous evaluation: TRUE
[15:32:37.979] Local evaluation: TRUE
[15:32:37.979] Environment: R_GlobalEnv
[15:32:37.979] Capture standard output: TRUE
[15:32:37.979] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:37.979] Globals: 5 objects totaling 1.33 KiB (function '...future.FUN' of 1.22 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)
[15:32:37.979] Packages: <none>
[15:32:37.979] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:37.979] Resolved: TRUE
[15:32:37.979] Value: <not collected>
[15:32:37.979] Conditions captured: <none>
[15:32:37.979] Early signaling: FALSE
[15:32:37.979] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:37.979] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:38.013] Chunk #1 of 2 ... DONE
[15:32:38.013] Chunk #2 of 2 ...
[15:32:38.013]  - Finding globals in 'X' for chunk #2 ...
[15:32:38.014] getGlobalsAndPackages() ...
[15:32:38.014] Searching for globals...
[15:32:38.014] 
[15:32:38.015] Searching for globals ... DONE
[15:32:38.015] - globals: [0] <none>
[15:32:38.015] getGlobalsAndPackages() ... DONE
[15:32:38.015]    + additional globals found: [n=0] 
[15:32:38.016]    + additional namespaces needed: [n=0] 
[15:32:38.016]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:38.016]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:38.016]  - seeds: <none>
[15:32:38.017]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:38.017] getGlobalsAndPackages() ...
[15:32:38.017] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:38.018] Resolving globals: FALSE
[15:32:38.018] Tweak future expression to call with '...' arguments ...
[15:32:38.018] {
[15:32:38.018]     do.call(function(...) {
[15:32:38.018]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:38.018]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:38.018]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:38.018]             on.exit(options(oopts), add = TRUE)
[15:32:38.018]         }
[15:32:38.018]         {
[15:32:38.018]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:38.018]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:38.018]                 ...future.FUN(...future.X_jj, ...)
[15:32:38.018]             })
[15:32:38.018]         }
[15:32:38.018]     }, args = future.call.arguments)
[15:32:38.018] }
[15:32:38.019] Tweak future expression to call with '...' arguments ... DONE
[15:32:38.020] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:38.020] 
[15:32:38.020] getGlobalsAndPackages() ... DONE
[15:32:38.021] run() for 'Future' ...
[15:32:38.021] - state: 'created'
[15:32:38.022] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:38.040] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:38.040] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:38.040]   - Field: 'node'
[15:32:38.041]   - Field: 'label'
[15:32:38.041]   - Field: 'local'
[15:32:38.041]   - Field: 'owner'
[15:32:38.042]   - Field: 'envir'
[15:32:38.042]   - Field: 'workers'
[15:32:38.042]   - Field: 'packages'
[15:32:38.042]   - Field: 'gc'
[15:32:38.043]   - Field: 'conditions'
[15:32:38.043]   - Field: 'persistent'
[15:32:38.043]   - Field: 'expr'
[15:32:38.044]   - Field: 'uuid'
[15:32:38.044]   - Field: 'seed'
[15:32:38.044]   - Field: 'version'
[15:32:38.044]   - Field: 'result'
[15:32:38.045]   - Field: 'asynchronous'
[15:32:38.045]   - Field: 'calls'
[15:32:38.045]   - Field: 'globals'
[15:32:38.046]   - Field: 'stdout'
[15:32:38.046]   - Field: 'earlySignal'
[15:32:38.046]   - Field: 'lazy'
[15:32:38.046]   - Field: 'state'
[15:32:38.047] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:38.047] - Launch lazy future ...
[15:32:38.048] Packages needed by the future expression (n = 0): <none>
[15:32:38.048] Packages needed by future strategies (n = 0): <none>
[15:32:38.049] {
[15:32:38.049]     {
[15:32:38.049]         {
[15:32:38.049]             ...future.startTime <- base::Sys.time()
[15:32:38.049]             {
[15:32:38.049]                 {
[15:32:38.049]                   {
[15:32:38.049]                     {
[15:32:38.049]                       base::local({
[15:32:38.049]                         has_future <- base::requireNamespace("future", 
[15:32:38.049]                           quietly = TRUE)
[15:32:38.049]                         if (has_future) {
[15:32:38.049]                           ns <- base::getNamespace("future")
[15:32:38.049]                           version <- ns[[".package"]][["version"]]
[15:32:38.049]                           if (is.null(version)) 
[15:32:38.049]                             version <- utils::packageVersion("future")
[15:32:38.049]                         }
[15:32:38.049]                         else {
[15:32:38.049]                           version <- NULL
[15:32:38.049]                         }
[15:32:38.049]                         if (!has_future || version < "1.8.0") {
[15:32:38.049]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:38.049]                             "", base::R.version$version.string), 
[15:32:38.049]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:38.049]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:38.049]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:38.049]                               "release", "version")], collapse = " "), 
[15:32:38.049]                             hostname = base::Sys.info()[["nodename"]])
[15:32:38.049]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:38.049]                             info)
[15:32:38.049]                           info <- base::paste(info, collapse = "; ")
[15:32:38.049]                           if (!has_future) {
[15:32:38.049]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:38.049]                               info)
[15:32:38.049]                           }
[15:32:38.049]                           else {
[15:32:38.049]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:38.049]                               info, version)
[15:32:38.049]                           }
[15:32:38.049]                           base::stop(msg)
[15:32:38.049]                         }
[15:32:38.049]                       })
[15:32:38.049]                     }
[15:32:38.049]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:38.049]                     base::options(mc.cores = 1L)
[15:32:38.049]                   }
[15:32:38.049]                   ...future.strategy.old <- future::plan("list")
[15:32:38.049]                   options(future.plan = NULL)
[15:32:38.049]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:38.049]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:38.049]                 }
[15:32:38.049]                 ...future.workdir <- getwd()
[15:32:38.049]             }
[15:32:38.049]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:38.049]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:38.049]         }
[15:32:38.049]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:38.049]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:38.049]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:38.049]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:38.049]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:38.049]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:38.049]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:38.049]             base::names(...future.oldOptions))
[15:32:38.049]     }
[15:32:38.049]     if (FALSE) {
[15:32:38.049]     }
[15:32:38.049]     else {
[15:32:38.049]         if (TRUE) {
[15:32:38.049]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:38.049]                 open = "w")
[15:32:38.049]         }
[15:32:38.049]         else {
[15:32:38.049]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:38.049]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:38.049]         }
[15:32:38.049]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:38.049]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:38.049]             base::sink(type = "output", split = FALSE)
[15:32:38.049]             base::close(...future.stdout)
[15:32:38.049]         }, add = TRUE)
[15:32:38.049]     }
[15:32:38.049]     ...future.frame <- base::sys.nframe()
[15:32:38.049]     ...future.conditions <- base::list()
[15:32:38.049]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:38.049]     if (FALSE) {
[15:32:38.049]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:38.049]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:38.049]     }
[15:32:38.049]     ...future.result <- base::tryCatch({
[15:32:38.049]         base::withCallingHandlers({
[15:32:38.049]             ...future.value <- base::withVisible(base::local({
[15:32:38.049]                 ...future.makeSendCondition <- base::local({
[15:32:38.049]                   sendCondition <- NULL
[15:32:38.049]                   function(frame = 1L) {
[15:32:38.049]                     if (is.function(sendCondition)) 
[15:32:38.049]                       return(sendCondition)
[15:32:38.049]                     ns <- getNamespace("parallel")
[15:32:38.049]                     if (exists("sendData", mode = "function", 
[15:32:38.049]                       envir = ns)) {
[15:32:38.049]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:38.049]                         envir = ns)
[15:32:38.049]                       envir <- sys.frame(frame)
[15:32:38.049]                       master <- NULL
[15:32:38.049]                       while (!identical(envir, .GlobalEnv) && 
[15:32:38.049]                         !identical(envir, emptyenv())) {
[15:32:38.049]                         if (exists("master", mode = "list", envir = envir, 
[15:32:38.049]                           inherits = FALSE)) {
[15:32:38.049]                           master <- get("master", mode = "list", 
[15:32:38.049]                             envir = envir, inherits = FALSE)
[15:32:38.049]                           if (inherits(master, c("SOCKnode", 
[15:32:38.049]                             "SOCK0node"))) {
[15:32:38.049]                             sendCondition <<- function(cond) {
[15:32:38.049]                               data <- list(type = "VALUE", value = cond, 
[15:32:38.049]                                 success = TRUE)
[15:32:38.049]                               parallel_sendData(master, data)
[15:32:38.049]                             }
[15:32:38.049]                             return(sendCondition)
[15:32:38.049]                           }
[15:32:38.049]                         }
[15:32:38.049]                         frame <- frame + 1L
[15:32:38.049]                         envir <- sys.frame(frame)
[15:32:38.049]                       }
[15:32:38.049]                     }
[15:32:38.049]                     sendCondition <<- function(cond) NULL
[15:32:38.049]                   }
[15:32:38.049]                 })
[15:32:38.049]                 withCallingHandlers({
[15:32:38.049]                   {
[15:32:38.049]                     do.call(function(...) {
[15:32:38.049]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:38.049]                       if (!identical(...future.globals.maxSize.org, 
[15:32:38.049]                         ...future.globals.maxSize)) {
[15:32:38.049]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:38.049]                         on.exit(options(oopts), add = TRUE)
[15:32:38.049]                       }
[15:32:38.049]                       {
[15:32:38.049]                         lapply(seq_along(...future.elements_ii), 
[15:32:38.049]                           FUN = function(jj) {
[15:32:38.049]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:38.049]                             ...future.FUN(...future.X_jj, ...)
[15:32:38.049]                           })
[15:32:38.049]                       }
[15:32:38.049]                     }, args = future.call.arguments)
[15:32:38.049]                   }
[15:32:38.049]                 }, immediateCondition = function(cond) {
[15:32:38.049]                   sendCondition <- ...future.makeSendCondition()
[15:32:38.049]                   sendCondition(cond)
[15:32:38.049]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:38.049]                   {
[15:32:38.049]                     inherits <- base::inherits
[15:32:38.049]                     invokeRestart <- base::invokeRestart
[15:32:38.049]                     is.null <- base::is.null
[15:32:38.049]                     muffled <- FALSE
[15:32:38.049]                     if (inherits(cond, "message")) {
[15:32:38.049]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:38.049]                       if (muffled) 
[15:32:38.049]                         invokeRestart("muffleMessage")
[15:32:38.049]                     }
[15:32:38.049]                     else if (inherits(cond, "warning")) {
[15:32:38.049]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:38.049]                       if (muffled) 
[15:32:38.049]                         invokeRestart("muffleWarning")
[15:32:38.049]                     }
[15:32:38.049]                     else if (inherits(cond, "condition")) {
[15:32:38.049]                       if (!is.null(pattern)) {
[15:32:38.049]                         computeRestarts <- base::computeRestarts
[15:32:38.049]                         grepl <- base::grepl
[15:32:38.049]                         restarts <- computeRestarts(cond)
[15:32:38.049]                         for (restart in restarts) {
[15:32:38.049]                           name <- restart$name
[15:32:38.049]                           if (is.null(name)) 
[15:32:38.049]                             next
[15:32:38.049]                           if (!grepl(pattern, name)) 
[15:32:38.049]                             next
[15:32:38.049]                           invokeRestart(restart)
[15:32:38.049]                           muffled <- TRUE
[15:32:38.049]                           break
[15:32:38.049]                         }
[15:32:38.049]                       }
[15:32:38.049]                     }
[15:32:38.049]                     invisible(muffled)
[15:32:38.049]                   }
[15:32:38.049]                   muffleCondition(cond)
[15:32:38.049]                 })
[15:32:38.049]             }))
[15:32:38.049]             future::FutureResult(value = ...future.value$value, 
[15:32:38.049]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:38.049]                   ...future.rng), globalenv = if (FALSE) 
[15:32:38.049]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:38.049]                     ...future.globalenv.names))
[15:32:38.049]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:38.049]         }, condition = base::local({
[15:32:38.049]             c <- base::c
[15:32:38.049]             inherits <- base::inherits
[15:32:38.049]             invokeRestart <- base::invokeRestart
[15:32:38.049]             length <- base::length
[15:32:38.049]             list <- base::list
[15:32:38.049]             seq.int <- base::seq.int
[15:32:38.049]             signalCondition <- base::signalCondition
[15:32:38.049]             sys.calls <- base::sys.calls
[15:32:38.049]             `[[` <- base::`[[`
[15:32:38.049]             `+` <- base::`+`
[15:32:38.049]             `<<-` <- base::`<<-`
[15:32:38.049]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:38.049]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:38.049]                   3L)]
[15:32:38.049]             }
[15:32:38.049]             function(cond) {
[15:32:38.049]                 is_error <- inherits(cond, "error")
[15:32:38.049]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:38.049]                   NULL)
[15:32:38.049]                 if (is_error) {
[15:32:38.049]                   sessionInformation <- function() {
[15:32:38.049]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:38.049]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:38.049]                       search = base::search(), system = base::Sys.info())
[15:32:38.049]                   }
[15:32:38.049]                   ...future.conditions[[length(...future.conditions) + 
[15:32:38.049]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:38.049]                     cond$call), session = sessionInformation(), 
[15:32:38.049]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:38.049]                   signalCondition(cond)
[15:32:38.049]                 }
[15:32:38.049]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:38.049]                 "immediateCondition"))) {
[15:32:38.049]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:38.049]                   ...future.conditions[[length(...future.conditions) + 
[15:32:38.049]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:38.049]                   if (TRUE && !signal) {
[15:32:38.049]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:38.049]                     {
[15:32:38.049]                       inherits <- base::inherits
[15:32:38.049]                       invokeRestart <- base::invokeRestart
[15:32:38.049]                       is.null <- base::is.null
[15:32:38.049]                       muffled <- FALSE
[15:32:38.049]                       if (inherits(cond, "message")) {
[15:32:38.049]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:38.049]                         if (muffled) 
[15:32:38.049]                           invokeRestart("muffleMessage")
[15:32:38.049]                       }
[15:32:38.049]                       else if (inherits(cond, "warning")) {
[15:32:38.049]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:38.049]                         if (muffled) 
[15:32:38.049]                           invokeRestart("muffleWarning")
[15:32:38.049]                       }
[15:32:38.049]                       else if (inherits(cond, "condition")) {
[15:32:38.049]                         if (!is.null(pattern)) {
[15:32:38.049]                           computeRestarts <- base::computeRestarts
[15:32:38.049]                           grepl <- base::grepl
[15:32:38.049]                           restarts <- computeRestarts(cond)
[15:32:38.049]                           for (restart in restarts) {
[15:32:38.049]                             name <- restart$name
[15:32:38.049]                             if (is.null(name)) 
[15:32:38.049]                               next
[15:32:38.049]                             if (!grepl(pattern, name)) 
[15:32:38.049]                               next
[15:32:38.049]                             invokeRestart(restart)
[15:32:38.049]                             muffled <- TRUE
[15:32:38.049]                             break
[15:32:38.049]                           }
[15:32:38.049]                         }
[15:32:38.049]                       }
[15:32:38.049]                       invisible(muffled)
[15:32:38.049]                     }
[15:32:38.049]                     muffleCondition(cond, pattern = "^muffle")
[15:32:38.049]                   }
[15:32:38.049]                 }
[15:32:38.049]                 else {
[15:32:38.049]                   if (TRUE) {
[15:32:38.049]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:38.049]                     {
[15:32:38.049]                       inherits <- base::inherits
[15:32:38.049]                       invokeRestart <- base::invokeRestart
[15:32:38.049]                       is.null <- base::is.null
[15:32:38.049]                       muffled <- FALSE
[15:32:38.049]                       if (inherits(cond, "message")) {
[15:32:38.049]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:38.049]                         if (muffled) 
[15:32:38.049]                           invokeRestart("muffleMessage")
[15:32:38.049]                       }
[15:32:38.049]                       else if (inherits(cond, "warning")) {
[15:32:38.049]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:38.049]                         if (muffled) 
[15:32:38.049]                           invokeRestart("muffleWarning")
[15:32:38.049]                       }
[15:32:38.049]                       else if (inherits(cond, "condition")) {
[15:32:38.049]                         if (!is.null(pattern)) {
[15:32:38.049]                           computeRestarts <- base::computeRestarts
[15:32:38.049]                           grepl <- base::grepl
[15:32:38.049]                           restarts <- computeRestarts(cond)
[15:32:38.049]                           for (restart in restarts) {
[15:32:38.049]                             name <- restart$name
[15:32:38.049]                             if (is.null(name)) 
[15:32:38.049]                               next
[15:32:38.049]                             if (!grepl(pattern, name)) 
[15:32:38.049]                               next
[15:32:38.049]                             invokeRestart(restart)
[15:32:38.049]                             muffled <- TRUE
[15:32:38.049]                             break
[15:32:38.049]                           }
[15:32:38.049]                         }
[15:32:38.049]                       }
[15:32:38.049]                       invisible(muffled)
[15:32:38.049]                     }
[15:32:38.049]                     muffleCondition(cond, pattern = "^muffle")
[15:32:38.049]                   }
[15:32:38.049]                 }
[15:32:38.049]             }
[15:32:38.049]         }))
[15:32:38.049]     }, error = function(ex) {
[15:32:38.049]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:38.049]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:38.049]                 ...future.rng), started = ...future.startTime, 
[15:32:38.049]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:38.049]             version = "1.8"), class = "FutureResult")
[15:32:38.049]     }, finally = {
[15:32:38.049]         if (!identical(...future.workdir, getwd())) 
[15:32:38.049]             setwd(...future.workdir)
[15:32:38.049]         {
[15:32:38.049]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:38.049]                 ...future.oldOptions$nwarnings <- NULL
[15:32:38.049]             }
[15:32:38.049]             base::options(...future.oldOptions)
[15:32:38.049]             if (.Platform$OS.type == "windows") {
[15:32:38.049]                 old_names <- names(...future.oldEnvVars)
[15:32:38.049]                 envs <- base::Sys.getenv()
[15:32:38.049]                 names <- names(envs)
[15:32:38.049]                 common <- intersect(names, old_names)
[15:32:38.049]                 added <- setdiff(names, old_names)
[15:32:38.049]                 removed <- setdiff(old_names, names)
[15:32:38.049]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:38.049]                   envs[common]]
[15:32:38.049]                 NAMES <- toupper(changed)
[15:32:38.049]                 args <- list()
[15:32:38.049]                 for (kk in seq_along(NAMES)) {
[15:32:38.049]                   name <- changed[[kk]]
[15:32:38.049]                   NAME <- NAMES[[kk]]
[15:32:38.049]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:38.049]                     next
[15:32:38.049]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:38.049]                 }
[15:32:38.049]                 NAMES <- toupper(added)
[15:32:38.049]                 for (kk in seq_along(NAMES)) {
[15:32:38.049]                   name <- added[[kk]]
[15:32:38.049]                   NAME <- NAMES[[kk]]
[15:32:38.049]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:38.049]                     next
[15:32:38.049]                   args[[name]] <- ""
[15:32:38.049]                 }
[15:32:38.049]                 NAMES <- toupper(removed)
[15:32:38.049]                 for (kk in seq_along(NAMES)) {
[15:32:38.049]                   name <- removed[[kk]]
[15:32:38.049]                   NAME <- NAMES[[kk]]
[15:32:38.049]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:38.049]                     next
[15:32:38.049]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:38.049]                 }
[15:32:38.049]                 if (length(args) > 0) 
[15:32:38.049]                   base::do.call(base::Sys.setenv, args = args)
[15:32:38.049]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:38.049]             }
[15:32:38.049]             else {
[15:32:38.049]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:38.049]             }
[15:32:38.049]             {
[15:32:38.049]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:38.049]                   0L) {
[15:32:38.049]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:38.049]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:38.049]                   base::options(opts)
[15:32:38.049]                 }
[15:32:38.049]                 {
[15:32:38.049]                   {
[15:32:38.049]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:38.049]                     NULL
[15:32:38.049]                   }
[15:32:38.049]                   options(future.plan = NULL)
[15:32:38.049]                   if (is.na(NA_character_)) 
[15:32:38.049]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:38.049]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:38.049]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:38.049]                     .init = FALSE)
[15:32:38.049]                 }
[15:32:38.049]             }
[15:32:38.049]         }
[15:32:38.049]     })
[15:32:38.049]     if (TRUE) {
[15:32:38.049]         base::sink(type = "output", split = FALSE)
[15:32:38.049]         if (TRUE) {
[15:32:38.049]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:38.049]         }
[15:32:38.049]         else {
[15:32:38.049]             ...future.result["stdout"] <- base::list(NULL)
[15:32:38.049]         }
[15:32:38.049]         base::close(...future.stdout)
[15:32:38.049]         ...future.stdout <- NULL
[15:32:38.049]     }
[15:32:38.049]     ...future.result$conditions <- ...future.conditions
[15:32:38.049]     ...future.result$finished <- base::Sys.time()
[15:32:38.049]     ...future.result
[15:32:38.049] }
[15:32:38.059] Exporting 5 global objects (1.22 KiB) to cluster node #1 ...
[15:32:38.059] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ...
[15:32:38.060] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ... DONE
[15:32:38.060] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:38.061] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:38.061] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:38.062] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:38.062] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:38.063] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:38.063] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:38.064] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:38.064] Exporting 5 global objects (1.22 KiB) to cluster node #1 ... DONE
[15:32:38.065] MultisessionFuture started
[15:32:38.065] - Launch lazy future ... done
[15:32:38.066] run() for 'MultisessionFuture' ... done
[15:32:38.066] Created future:
[15:32:38.093] receiveMessageFromWorker() for ClusterFuture ...
[15:32:38.094] - Validating connection of MultisessionFuture
[15:32:38.094] - received message: FutureResult
[15:32:38.095] - Received FutureResult
[15:32:38.095] - Erased future from FutureRegistry
[15:32:38.095] result() for ClusterFuture ...
[15:32:38.095] - result already collected: FutureResult
[15:32:38.096] result() for ClusterFuture ... done
[15:32:38.096] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:38.066] MultisessionFuture:
[15:32:38.066] Label: 'future_sapply-2'
[15:32:38.066] Expression:
[15:32:38.066] {
[15:32:38.066]     do.call(function(...) {
[15:32:38.066]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:38.066]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:38.066]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:38.066]             on.exit(options(oopts), add = TRUE)
[15:32:38.066]         }
[15:32:38.066]         {
[15:32:38.066]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:38.066]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:38.066]                 ...future.FUN(...future.X_jj, ...)
[15:32:38.066]             })
[15:32:38.066]         }
[15:32:38.066]     }, args = future.call.arguments)
[15:32:38.066] }
[15:32:38.066] Lazy evaluation: FALSE
[15:32:38.066] Asynchronous evaluation: TRUE
[15:32:38.066] Local evaluation: TRUE
[15:32:38.066] Environment: R_GlobalEnv
[15:32:38.066] Capture standard output: TRUE
[15:32:38.066] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:38.066] Globals: 5 objects totaling 1.33 KiB (function '...future.FUN' of 1.22 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)
[15:32:38.066] Packages: <none>
[15:32:38.066] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:38.066] Resolved: TRUE
[15:32:38.066] Value: <not collected>
[15:32:38.066] Conditions captured: <none>
[15:32:38.066] Early signaling: FALSE
[15:32:38.066] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:38.066] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:38.097] Chunk #2 of 2 ... DONE
[15:32:38.097] Launching 2 futures (chunks) ... DONE
[15:32:38.097] Resolving 2 futures (chunks) ...
[15:32:38.098] resolve() on list ...
[15:32:38.098]  recursive: 0
[15:32:38.098]  length: 2
[15:32:38.098] 
[15:32:38.099] Future #1
[15:32:38.099] result() for ClusterFuture ...
[15:32:38.099] - result already collected: FutureResult
[15:32:38.100] result() for ClusterFuture ... done
[15:32:38.100] result() for ClusterFuture ...
[15:32:38.100] - result already collected: FutureResult
[15:32:38.100] result() for ClusterFuture ... done
[15:32:38.101] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:38.101] - nx: 2
[15:32:38.101] - relay: TRUE
[15:32:38.101] - stdout: TRUE
[15:32:38.102] - signal: TRUE
[15:32:38.102] - resignal: FALSE
[15:32:38.102] - force: TRUE
[15:32:38.102] - relayed: [n=2] FALSE, FALSE
[15:32:38.103] - queued futures: [n=2] FALSE, FALSE
[15:32:38.103]  - until=1
[15:32:38.103]  - relaying element #1
[15:32:38.104] result() for ClusterFuture ...
[15:32:38.104] - result already collected: FutureResult
[15:32:38.104] result() for ClusterFuture ... done
[15:32:38.104] result() for ClusterFuture ...
[15:32:38.105] - result already collected: FutureResult
[15:32:38.105] result() for ClusterFuture ... done
[15:32:38.105] result() for ClusterFuture ...
[15:32:38.105] - result already collected: FutureResult
[15:32:38.106] result() for ClusterFuture ... done
[15:32:38.106] result() for ClusterFuture ...
[15:32:38.106] - result already collected: FutureResult
[15:32:38.107] result() for ClusterFuture ... done
[15:32:38.107] - relayed: [n=2] TRUE, FALSE
[15:32:38.107] - queued futures: [n=2] TRUE, FALSE
[15:32:38.107] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:38.108]  length: 1 (resolved future 1)
[15:32:38.108] Future #2
[15:32:38.108] result() for ClusterFuture ...
[15:32:38.108] - result already collected: FutureResult
[15:32:38.109] result() for ClusterFuture ... done
[15:32:38.109] result() for ClusterFuture ...
[15:32:38.109] - result already collected: FutureResult
[15:32:38.110] result() for ClusterFuture ... done
[15:32:38.110] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:38.110] - nx: 2
[15:32:38.110] - relay: TRUE
[15:32:38.111] - stdout: TRUE
[15:32:38.111] - signal: TRUE
[15:32:38.111] - resignal: FALSE
[15:32:38.111] - force: TRUE
[15:32:38.112] - relayed: [n=2] TRUE, FALSE
[15:32:38.112] - queued futures: [n=2] TRUE, FALSE
[15:32:38.112]  - until=2
[15:32:38.112]  - relaying element #2
[15:32:38.113] result() for ClusterFuture ...
[15:32:38.113] - result already collected: FutureResult
[15:32:38.113] result() for ClusterFuture ... done
[15:32:38.113] result() for ClusterFuture ...
[15:32:38.114] - result already collected: FutureResult
[15:32:38.114] result() for ClusterFuture ... done
[15:32:38.114] result() for ClusterFuture ...
[15:32:38.114] - result already collected: FutureResult
[15:32:38.115] result() for ClusterFuture ... done
[15:32:38.115] result() for ClusterFuture ...
[15:32:38.115] - result already collected: FutureResult
[15:32:38.115] result() for ClusterFuture ... done
[15:32:38.116] - relayed: [n=2] TRUE, TRUE
[15:32:38.116] - queued futures: [n=2] TRUE, TRUE
[15:32:38.116] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:38.116]  length: 0 (resolved future 2)
[15:32:38.117] Relaying remaining futures
[15:32:38.117] signalConditionsASAP(NULL, pos=0) ...
[15:32:38.117] - nx: 2
[15:32:38.117] - relay: TRUE
[15:32:38.118] - stdout: TRUE
[15:32:38.118] - signal: TRUE
[15:32:38.118] - resignal: FALSE
[15:32:38.118] - force: TRUE
[15:32:38.119] - relayed: [n=2] TRUE, TRUE
[15:32:38.119] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:38.119] - relayed: [n=2] TRUE, TRUE
[15:32:38.120] - queued futures: [n=2] TRUE, TRUE
[15:32:38.120] signalConditionsASAP(NULL, pos=0) ... done
[15:32:38.120] resolve() on list ... DONE
[15:32:38.120] result() for ClusterFuture ...
[15:32:38.120] - result already collected: FutureResult
[15:32:38.121] result() for ClusterFuture ... done
[15:32:38.121] result() for ClusterFuture ...
[15:32:38.121] - result already collected: FutureResult
[15:32:38.121] result() for ClusterFuture ... done
[15:32:38.122] result() for ClusterFuture ...
[15:32:38.122] - result already collected: FutureResult
[15:32:38.122] result() for ClusterFuture ... done
[15:32:38.123] result() for ClusterFuture ...
[15:32:38.123] - result already collected: FutureResult
[15:32:38.123] result() for ClusterFuture ... done
[15:32:38.123]  - Number of value chunks collected: 2
[15:32:38.124] Resolving 2 futures (chunks) ... DONE
[15:32:38.124] Reducing values from 2 chunks ...
[15:32:38.124]  - Number of values collected after concatenation: 4
[15:32:38.124]  - Number of values expected: 4
[15:32:38.125] Reducing values from 2 chunks ... DONE
[15:32:38.125] future_lapply() ... DONE
List of 2
 $ y0:List of 4
  ..$ A: num [1, 1] 50
  ..$ B: num [1, 1] 60
  ..$ C: num [1, 1] 70
  ..$ D: num [1, 1] 80
 $ y1:List of 4
  ..$ A: num [1, 1] 50
  ..$ B: num [1, 1] 60
  ..$ C: num [1, 1] 70
  ..$ D: num [1, 1] 80
List of 2
 $ y0:List of 4
  ..$ A: num [1, 1] 50
  ..$ B: num [1, 1] 60
  ..$ C: num [1, 1] 70
  ..$ D: num [1, 1] 80
 $ y2:List of 4
  ..$ A: num [1, 1] 50
  ..$ B: num [1, 1] 60
  ..$ C: num [1, 1] 70
  ..$ D: num [1, 1] 80
[15:32:38.138] future_lapply() ...
[15:32:38.149] Number of chunks: 2
[15:32:38.149] getGlobalsAndPackagesXApply() ...
[15:32:38.149]  - future.globals: TRUE
[15:32:38.150] getGlobalsAndPackages() ...
[15:32:38.150] Searching for globals...
[15:32:38.153] - globals found: [5] 'FUN', '*', ':', 'outer', 'rep'
[15:32:38.154] Searching for globals ... DONE
[15:32:38.154] Resolving globals: FALSE
[15:32:38.155] The total size of the 1 globals is 4.62 KiB (4728 bytes)
[15:32:38.156] The total size of the 1 globals exported for future expression ('FUN()') is 4.62 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.62 KiB of class 'function')
[15:32:38.156] - globals: [1] 'FUN'
[15:32:38.156] 
[15:32:38.156] getGlobalsAndPackages() ... DONE
[15:32:38.157]  - globals found/used: [n=1] 'FUN'
[15:32:38.157]  - needed namespaces: [n=0] 
[15:32:38.157] Finding globals ... DONE
[15:32:38.158]  - use_args: TRUE
[15:32:38.158]  - Getting '...' globals ...
[15:32:38.158] resolve() on list ...
[15:32:38.159]  recursive: 0
[15:32:38.159]  length: 1
[15:32:38.159]  elements: '...'
[15:32:38.160]  length: 0 (resolved future 1)
[15:32:38.160] resolve() on list ... DONE
[15:32:38.160]    - '...' content: [n=0] 
[15:32:38.160] List of 1
[15:32:38.160]  $ ...: list()
[15:32:38.160]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:38.160]  - attr(*, "where")=List of 1
[15:32:38.160]   ..$ ...:<environment: 0x00000276e5648078> 
[15:32:38.160]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:38.160]  - attr(*, "resolved")= logi TRUE
[15:32:38.160]  - attr(*, "total_size")= num NA
[15:32:38.165]  - Getting '...' globals ... DONE
[15:32:38.166] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:38.166] List of 2
[15:32:38.166]  $ ...future.FUN:function (x, y = 2 * 1:5)  
[15:32:38.166]  $ ...          : list()
[15:32:38.166]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:38.166]  - attr(*, "where")=List of 2
[15:32:38.166]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:38.166]   ..$ ...          :<environment: 0x00000276e5648078> 
[15:32:38.166]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:38.166]  - attr(*, "resolved")= logi FALSE
[15:32:38.166]  - attr(*, "total_size")= num 4728
[15:32:38.171] Packages to be attached in all futures: [n=0] 
[15:32:38.172] getGlobalsAndPackagesXApply() ... DONE
[15:32:38.172] Number of futures (= number of chunks): 2
[15:32:38.172] Launching 2 futures (chunks) ...
[15:32:38.173] Chunk #1 of 2 ...
[15:32:38.173]  - Finding globals in 'X' for chunk #1 ...
[15:32:38.173] getGlobalsAndPackages() ...
[15:32:38.174] Searching for globals...
[15:32:38.174] 
[15:32:38.175] Searching for globals ... DONE
[15:32:38.175] - globals: [0] <none>
[15:32:38.175] getGlobalsAndPackages() ... DONE
[15:32:38.175]    + additional globals found: [n=0] 
[15:32:38.176]    + additional namespaces needed: [n=0] 
[15:32:38.176]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:38.176]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:38.176]  - seeds: <none>
[15:32:38.177]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:38.177] getGlobalsAndPackages() ...
[15:32:38.177] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:38.178] Resolving globals: FALSE
[15:32:38.178] Tweak future expression to call with '...' arguments ...
[15:32:38.178] {
[15:32:38.178]     do.call(function(...) {
[15:32:38.178]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:38.178]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:38.178]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:38.178]             on.exit(options(oopts), add = TRUE)
[15:32:38.178]         }
[15:32:38.178]         {
[15:32:38.178]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:38.178]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:38.178]                 ...future.FUN(...future.X_jj, ...)
[15:32:38.178]             })
[15:32:38.178]         }
[15:32:38.178]     }, args = future.call.arguments)
[15:32:38.178] }
[15:32:38.179] Tweak future expression to call with '...' arguments ... DONE
[15:32:38.180] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:38.180] 
[15:32:38.180] getGlobalsAndPackages() ... DONE
[15:32:38.181] run() for 'Future' ...
[15:32:38.181] - state: 'created'
[15:32:38.182] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:38.199] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:38.200] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:38.200]   - Field: 'node'
[15:32:38.200]   - Field: 'label'
[15:32:38.201]   - Field: 'local'
[15:32:38.201]   - Field: 'owner'
[15:32:38.201]   - Field: 'envir'
[15:32:38.201]   - Field: 'workers'
[15:32:38.202]   - Field: 'packages'
[15:32:38.202]   - Field: 'gc'
[15:32:38.202]   - Field: 'conditions'
[15:32:38.203]   - Field: 'persistent'
[15:32:38.203]   - Field: 'expr'
[15:32:38.203]   - Field: 'uuid'
[15:32:38.203]   - Field: 'seed'
[15:32:38.203]   - Field: 'version'
[15:32:38.204]   - Field: 'result'
[15:32:38.204]   - Field: 'asynchronous'
[15:32:38.204]   - Field: 'calls'
[15:32:38.204]   - Field: 'globals'
[15:32:38.204]   - Field: 'stdout'
[15:32:38.204]   - Field: 'earlySignal'
[15:32:38.205]   - Field: 'lazy'
[15:32:38.205]   - Field: 'state'
[15:32:38.205] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:38.205] - Launch lazy future ...
[15:32:38.206] Packages needed by the future expression (n = 0): <none>
[15:32:38.206] Packages needed by future strategies (n = 0): <none>
[15:32:38.206] {
[15:32:38.206]     {
[15:32:38.206]         {
[15:32:38.206]             ...future.startTime <- base::Sys.time()
[15:32:38.206]             {
[15:32:38.206]                 {
[15:32:38.206]                   {
[15:32:38.206]                     {
[15:32:38.206]                       base::local({
[15:32:38.206]                         has_future <- base::requireNamespace("future", 
[15:32:38.206]                           quietly = TRUE)
[15:32:38.206]                         if (has_future) {
[15:32:38.206]                           ns <- base::getNamespace("future")
[15:32:38.206]                           version <- ns[[".package"]][["version"]]
[15:32:38.206]                           if (is.null(version)) 
[15:32:38.206]                             version <- utils::packageVersion("future")
[15:32:38.206]                         }
[15:32:38.206]                         else {
[15:32:38.206]                           version <- NULL
[15:32:38.206]                         }
[15:32:38.206]                         if (!has_future || version < "1.8.0") {
[15:32:38.206]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:38.206]                             "", base::R.version$version.string), 
[15:32:38.206]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:38.206]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:38.206]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:38.206]                               "release", "version")], collapse = " "), 
[15:32:38.206]                             hostname = base::Sys.info()[["nodename"]])
[15:32:38.206]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:38.206]                             info)
[15:32:38.206]                           info <- base::paste(info, collapse = "; ")
[15:32:38.206]                           if (!has_future) {
[15:32:38.206]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:38.206]                               info)
[15:32:38.206]                           }
[15:32:38.206]                           else {
[15:32:38.206]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:38.206]                               info, version)
[15:32:38.206]                           }
[15:32:38.206]                           base::stop(msg)
[15:32:38.206]                         }
[15:32:38.206]                       })
[15:32:38.206]                     }
[15:32:38.206]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:38.206]                     base::options(mc.cores = 1L)
[15:32:38.206]                   }
[15:32:38.206]                   ...future.strategy.old <- future::plan("list")
[15:32:38.206]                   options(future.plan = NULL)
[15:32:38.206]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:38.206]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:38.206]                 }
[15:32:38.206]                 ...future.workdir <- getwd()
[15:32:38.206]             }
[15:32:38.206]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:38.206]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:38.206]         }
[15:32:38.206]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:38.206]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:38.206]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:38.206]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:38.206]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:38.206]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:38.206]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:38.206]             base::names(...future.oldOptions))
[15:32:38.206]     }
[15:32:38.206]     if (FALSE) {
[15:32:38.206]     }
[15:32:38.206]     else {
[15:32:38.206]         if (TRUE) {
[15:32:38.206]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:38.206]                 open = "w")
[15:32:38.206]         }
[15:32:38.206]         else {
[15:32:38.206]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:38.206]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:38.206]         }
[15:32:38.206]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:38.206]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:38.206]             base::sink(type = "output", split = FALSE)
[15:32:38.206]             base::close(...future.stdout)
[15:32:38.206]         }, add = TRUE)
[15:32:38.206]     }
[15:32:38.206]     ...future.frame <- base::sys.nframe()
[15:32:38.206]     ...future.conditions <- base::list()
[15:32:38.206]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:38.206]     if (FALSE) {
[15:32:38.206]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:38.206]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:38.206]     }
[15:32:38.206]     ...future.result <- base::tryCatch({
[15:32:38.206]         base::withCallingHandlers({
[15:32:38.206]             ...future.value <- base::withVisible(base::local({
[15:32:38.206]                 ...future.makeSendCondition <- base::local({
[15:32:38.206]                   sendCondition <- NULL
[15:32:38.206]                   function(frame = 1L) {
[15:32:38.206]                     if (is.function(sendCondition)) 
[15:32:38.206]                       return(sendCondition)
[15:32:38.206]                     ns <- getNamespace("parallel")
[15:32:38.206]                     if (exists("sendData", mode = "function", 
[15:32:38.206]                       envir = ns)) {
[15:32:38.206]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:38.206]                         envir = ns)
[15:32:38.206]                       envir <- sys.frame(frame)
[15:32:38.206]                       master <- NULL
[15:32:38.206]                       while (!identical(envir, .GlobalEnv) && 
[15:32:38.206]                         !identical(envir, emptyenv())) {
[15:32:38.206]                         if (exists("master", mode = "list", envir = envir, 
[15:32:38.206]                           inherits = FALSE)) {
[15:32:38.206]                           master <- get("master", mode = "list", 
[15:32:38.206]                             envir = envir, inherits = FALSE)
[15:32:38.206]                           if (inherits(master, c("SOCKnode", 
[15:32:38.206]                             "SOCK0node"))) {
[15:32:38.206]                             sendCondition <<- function(cond) {
[15:32:38.206]                               data <- list(type = "VALUE", value = cond, 
[15:32:38.206]                                 success = TRUE)
[15:32:38.206]                               parallel_sendData(master, data)
[15:32:38.206]                             }
[15:32:38.206]                             return(sendCondition)
[15:32:38.206]                           }
[15:32:38.206]                         }
[15:32:38.206]                         frame <- frame + 1L
[15:32:38.206]                         envir <- sys.frame(frame)
[15:32:38.206]                       }
[15:32:38.206]                     }
[15:32:38.206]                     sendCondition <<- function(cond) NULL
[15:32:38.206]                   }
[15:32:38.206]                 })
[15:32:38.206]                 withCallingHandlers({
[15:32:38.206]                   {
[15:32:38.206]                     do.call(function(...) {
[15:32:38.206]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:38.206]                       if (!identical(...future.globals.maxSize.org, 
[15:32:38.206]                         ...future.globals.maxSize)) {
[15:32:38.206]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:38.206]                         on.exit(options(oopts), add = TRUE)
[15:32:38.206]                       }
[15:32:38.206]                       {
[15:32:38.206]                         lapply(seq_along(...future.elements_ii), 
[15:32:38.206]                           FUN = function(jj) {
[15:32:38.206]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:38.206]                             ...future.FUN(...future.X_jj, ...)
[15:32:38.206]                           })
[15:32:38.206]                       }
[15:32:38.206]                     }, args = future.call.arguments)
[15:32:38.206]                   }
[15:32:38.206]                 }, immediateCondition = function(cond) {
[15:32:38.206]                   sendCondition <- ...future.makeSendCondition()
[15:32:38.206]                   sendCondition(cond)
[15:32:38.206]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:38.206]                   {
[15:32:38.206]                     inherits <- base::inherits
[15:32:38.206]                     invokeRestart <- base::invokeRestart
[15:32:38.206]                     is.null <- base::is.null
[15:32:38.206]                     muffled <- FALSE
[15:32:38.206]                     if (inherits(cond, "message")) {
[15:32:38.206]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:38.206]                       if (muffled) 
[15:32:38.206]                         invokeRestart("muffleMessage")
[15:32:38.206]                     }
[15:32:38.206]                     else if (inherits(cond, "warning")) {
[15:32:38.206]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:38.206]                       if (muffled) 
[15:32:38.206]                         invokeRestart("muffleWarning")
[15:32:38.206]                     }
[15:32:38.206]                     else if (inherits(cond, "condition")) {
[15:32:38.206]                       if (!is.null(pattern)) {
[15:32:38.206]                         computeRestarts <- base::computeRestarts
[15:32:38.206]                         grepl <- base::grepl
[15:32:38.206]                         restarts <- computeRestarts(cond)
[15:32:38.206]                         for (restart in restarts) {
[15:32:38.206]                           name <- restart$name
[15:32:38.206]                           if (is.null(name)) 
[15:32:38.206]                             next
[15:32:38.206]                           if (!grepl(pattern, name)) 
[15:32:38.206]                             next
[15:32:38.206]                           invokeRestart(restart)
[15:32:38.206]                           muffled <- TRUE
[15:32:38.206]                           break
[15:32:38.206]                         }
[15:32:38.206]                       }
[15:32:38.206]                     }
[15:32:38.206]                     invisible(muffled)
[15:32:38.206]                   }
[15:32:38.206]                   muffleCondition(cond)
[15:32:38.206]                 })
[15:32:38.206]             }))
[15:32:38.206]             future::FutureResult(value = ...future.value$value, 
[15:32:38.206]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:38.206]                   ...future.rng), globalenv = if (FALSE) 
[15:32:38.206]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:38.206]                     ...future.globalenv.names))
[15:32:38.206]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:38.206]         }, condition = base::local({
[15:32:38.206]             c <- base::c
[15:32:38.206]             inherits <- base::inherits
[15:32:38.206]             invokeRestart <- base::invokeRestart
[15:32:38.206]             length <- base::length
[15:32:38.206]             list <- base::list
[15:32:38.206]             seq.int <- base::seq.int
[15:32:38.206]             signalCondition <- base::signalCondition
[15:32:38.206]             sys.calls <- base::sys.calls
[15:32:38.206]             `[[` <- base::`[[`
[15:32:38.206]             `+` <- base::`+`
[15:32:38.206]             `<<-` <- base::`<<-`
[15:32:38.206]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:38.206]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:38.206]                   3L)]
[15:32:38.206]             }
[15:32:38.206]             function(cond) {
[15:32:38.206]                 is_error <- inherits(cond, "error")
[15:32:38.206]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:38.206]                   NULL)
[15:32:38.206]                 if (is_error) {
[15:32:38.206]                   sessionInformation <- function() {
[15:32:38.206]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:38.206]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:38.206]                       search = base::search(), system = base::Sys.info())
[15:32:38.206]                   }
[15:32:38.206]                   ...future.conditions[[length(...future.conditions) + 
[15:32:38.206]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:38.206]                     cond$call), session = sessionInformation(), 
[15:32:38.206]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:38.206]                   signalCondition(cond)
[15:32:38.206]                 }
[15:32:38.206]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:38.206]                 "immediateCondition"))) {
[15:32:38.206]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:38.206]                   ...future.conditions[[length(...future.conditions) + 
[15:32:38.206]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:38.206]                   if (TRUE && !signal) {
[15:32:38.206]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:38.206]                     {
[15:32:38.206]                       inherits <- base::inherits
[15:32:38.206]                       invokeRestart <- base::invokeRestart
[15:32:38.206]                       is.null <- base::is.null
[15:32:38.206]                       muffled <- FALSE
[15:32:38.206]                       if (inherits(cond, "message")) {
[15:32:38.206]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:38.206]                         if (muffled) 
[15:32:38.206]                           invokeRestart("muffleMessage")
[15:32:38.206]                       }
[15:32:38.206]                       else if (inherits(cond, "warning")) {
[15:32:38.206]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:38.206]                         if (muffled) 
[15:32:38.206]                           invokeRestart("muffleWarning")
[15:32:38.206]                       }
[15:32:38.206]                       else if (inherits(cond, "condition")) {
[15:32:38.206]                         if (!is.null(pattern)) {
[15:32:38.206]                           computeRestarts <- base::computeRestarts
[15:32:38.206]                           grepl <- base::grepl
[15:32:38.206]                           restarts <- computeRestarts(cond)
[15:32:38.206]                           for (restart in restarts) {
[15:32:38.206]                             name <- restart$name
[15:32:38.206]                             if (is.null(name)) 
[15:32:38.206]                               next
[15:32:38.206]                             if (!grepl(pattern, name)) 
[15:32:38.206]                               next
[15:32:38.206]                             invokeRestart(restart)
[15:32:38.206]                             muffled <- TRUE
[15:32:38.206]                             break
[15:32:38.206]                           }
[15:32:38.206]                         }
[15:32:38.206]                       }
[15:32:38.206]                       invisible(muffled)
[15:32:38.206]                     }
[15:32:38.206]                     muffleCondition(cond, pattern = "^muffle")
[15:32:38.206]                   }
[15:32:38.206]                 }
[15:32:38.206]                 else {
[15:32:38.206]                   if (TRUE) {
[15:32:38.206]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:38.206]                     {
[15:32:38.206]                       inherits <- base::inherits
[15:32:38.206]                       invokeRestart <- base::invokeRestart
[15:32:38.206]                       is.null <- base::is.null
[15:32:38.206]                       muffled <- FALSE
[15:32:38.206]                       if (inherits(cond, "message")) {
[15:32:38.206]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:38.206]                         if (muffled) 
[15:32:38.206]                           invokeRestart("muffleMessage")
[15:32:38.206]                       }
[15:32:38.206]                       else if (inherits(cond, "warning")) {
[15:32:38.206]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:38.206]                         if (muffled) 
[15:32:38.206]                           invokeRestart("muffleWarning")
[15:32:38.206]                       }
[15:32:38.206]                       else if (inherits(cond, "condition")) {
[15:32:38.206]                         if (!is.null(pattern)) {
[15:32:38.206]                           computeRestarts <- base::computeRestarts
[15:32:38.206]                           grepl <- base::grepl
[15:32:38.206]                           restarts <- computeRestarts(cond)
[15:32:38.206]                           for (restart in restarts) {
[15:32:38.206]                             name <- restart$name
[15:32:38.206]                             if (is.null(name)) 
[15:32:38.206]                               next
[15:32:38.206]                             if (!grepl(pattern, name)) 
[15:32:38.206]                               next
[15:32:38.206]                             invokeRestart(restart)
[15:32:38.206]                             muffled <- TRUE
[15:32:38.206]                             break
[15:32:38.206]                           }
[15:32:38.206]                         }
[15:32:38.206]                       }
[15:32:38.206]                       invisible(muffled)
[15:32:38.206]                     }
[15:32:38.206]                     muffleCondition(cond, pattern = "^muffle")
[15:32:38.206]                   }
[15:32:38.206]                 }
[15:32:38.206]             }
[15:32:38.206]         }))
[15:32:38.206]     }, error = function(ex) {
[15:32:38.206]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:38.206]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:38.206]                 ...future.rng), started = ...future.startTime, 
[15:32:38.206]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:38.206]             version = "1.8"), class = "FutureResult")
[15:32:38.206]     }, finally = {
[15:32:38.206]         if (!identical(...future.workdir, getwd())) 
[15:32:38.206]             setwd(...future.workdir)
[15:32:38.206]         {
[15:32:38.206]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:38.206]                 ...future.oldOptions$nwarnings <- NULL
[15:32:38.206]             }
[15:32:38.206]             base::options(...future.oldOptions)
[15:32:38.206]             if (.Platform$OS.type == "windows") {
[15:32:38.206]                 old_names <- names(...future.oldEnvVars)
[15:32:38.206]                 envs <- base::Sys.getenv()
[15:32:38.206]                 names <- names(envs)
[15:32:38.206]                 common <- intersect(names, old_names)
[15:32:38.206]                 added <- setdiff(names, old_names)
[15:32:38.206]                 removed <- setdiff(old_names, names)
[15:32:38.206]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:38.206]                   envs[common]]
[15:32:38.206]                 NAMES <- toupper(changed)
[15:32:38.206]                 args <- list()
[15:32:38.206]                 for (kk in seq_along(NAMES)) {
[15:32:38.206]                   name <- changed[[kk]]
[15:32:38.206]                   NAME <- NAMES[[kk]]
[15:32:38.206]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:38.206]                     next
[15:32:38.206]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:38.206]                 }
[15:32:38.206]                 NAMES <- toupper(added)
[15:32:38.206]                 for (kk in seq_along(NAMES)) {
[15:32:38.206]                   name <- added[[kk]]
[15:32:38.206]                   NAME <- NAMES[[kk]]
[15:32:38.206]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:38.206]                     next
[15:32:38.206]                   args[[name]] <- ""
[15:32:38.206]                 }
[15:32:38.206]                 NAMES <- toupper(removed)
[15:32:38.206]                 for (kk in seq_along(NAMES)) {
[15:32:38.206]                   name <- removed[[kk]]
[15:32:38.206]                   NAME <- NAMES[[kk]]
[15:32:38.206]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:38.206]                     next
[15:32:38.206]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:38.206]                 }
[15:32:38.206]                 if (length(args) > 0) 
[15:32:38.206]                   base::do.call(base::Sys.setenv, args = args)
[15:32:38.206]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:38.206]             }
[15:32:38.206]             else {
[15:32:38.206]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:38.206]             }
[15:32:38.206]             {
[15:32:38.206]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:38.206]                   0L) {
[15:32:38.206]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:38.206]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:38.206]                   base::options(opts)
[15:32:38.206]                 }
[15:32:38.206]                 {
[15:32:38.206]                   {
[15:32:38.206]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:38.206]                     NULL
[15:32:38.206]                   }
[15:32:38.206]                   options(future.plan = NULL)
[15:32:38.206]                   if (is.na(NA_character_)) 
[15:32:38.206]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:38.206]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:38.206]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:38.206]                     .init = FALSE)
[15:32:38.206]                 }
[15:32:38.206]             }
[15:32:38.206]         }
[15:32:38.206]     })
[15:32:38.206]     if (TRUE) {
[15:32:38.206]         base::sink(type = "output", split = FALSE)
[15:32:38.206]         if (TRUE) {
[15:32:38.206]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:38.206]         }
[15:32:38.206]         else {
[15:32:38.206]             ...future.result["stdout"] <- base::list(NULL)
[15:32:38.206]         }
[15:32:38.206]         base::close(...future.stdout)
[15:32:38.206]         ...future.stdout <- NULL
[15:32:38.206]     }
[15:32:38.206]     ...future.result$conditions <- ...future.conditions
[15:32:38.206]     ...future.result$finished <- base::Sys.time()
[15:32:38.206]     ...future.result
[15:32:38.206] }
[15:32:38.212] Exporting 5 global objects (4.62 KiB) to cluster node #1 ...
[15:32:38.212] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ...
[15:32:38.213] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ... DONE
[15:32:38.213] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:38.214] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:38.214] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:38.215] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:38.215] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:38.216] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:38.216] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:38.217] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:38.217] Exporting 5 global objects (4.62 KiB) to cluster node #1 ... DONE
[15:32:38.218] MultisessionFuture started
[15:32:38.218] - Launch lazy future ... done
[15:32:38.218] run() for 'MultisessionFuture' ... done
[15:32:38.219] Created future:
[15:32:38.246] receiveMessageFromWorker() for ClusterFuture ...
[15:32:38.246] - Validating connection of MultisessionFuture
[15:32:38.247] - received message: FutureResult
[15:32:38.247] - Received FutureResult
[15:32:38.247] - Erased future from FutureRegistry
[15:32:38.248] result() for ClusterFuture ...
[15:32:38.248] - result already collected: FutureResult
[15:32:38.248] result() for ClusterFuture ... done
[15:32:38.248] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:38.219] MultisessionFuture:
[15:32:38.219] Label: 'future_sapply-1'
[15:32:38.219] Expression:
[15:32:38.219] {
[15:32:38.219]     do.call(function(...) {
[15:32:38.219]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:38.219]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:38.219]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:38.219]             on.exit(options(oopts), add = TRUE)
[15:32:38.219]         }
[15:32:38.219]         {
[15:32:38.219]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:38.219]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:38.219]                 ...future.FUN(...future.X_jj, ...)
[15:32:38.219]             })
[15:32:38.219]         }
[15:32:38.219]     }, args = future.call.arguments)
[15:32:38.219] }
[15:32:38.219] Lazy evaluation: FALSE
[15:32:38.219] Asynchronous evaluation: TRUE
[15:32:38.219] Local evaluation: TRUE
[15:32:38.219] Environment: R_GlobalEnv
[15:32:38.219] Capture standard output: TRUE
[15:32:38.219] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:38.219] Globals: 5 objects totaling 4.73 KiB (function '...future.FUN' of 4.62 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)
[15:32:38.219] Packages: <none>
[15:32:38.219] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:38.219] Resolved: TRUE
[15:32:38.219] Value: <not collected>
[15:32:38.219] Conditions captured: <none>
[15:32:38.219] Early signaling: FALSE
[15:32:38.219] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:38.219] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:38.249] Chunk #1 of 2 ... DONE
[15:32:38.249] Chunk #2 of 2 ...
[15:32:38.250]  - Finding globals in 'X' for chunk #2 ...
[15:32:38.250] getGlobalsAndPackages() ...
[15:32:38.250] Searching for globals...
[15:32:38.251] 
[15:32:38.251] Searching for globals ... DONE
[15:32:38.251] - globals: [0] <none>
[15:32:38.252] getGlobalsAndPackages() ... DONE
[15:32:38.252]    + additional globals found: [n=0] 
[15:32:38.252]    + additional namespaces needed: [n=0] 
[15:32:38.252]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:38.253]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:38.253]  - seeds: <none>
[15:32:38.253]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:38.254] getGlobalsAndPackages() ...
[15:32:38.254] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:38.254] Resolving globals: FALSE
[15:32:38.255] Tweak future expression to call with '...' arguments ...
[15:32:38.255] {
[15:32:38.255]     do.call(function(...) {
[15:32:38.255]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:38.255]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:38.255]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:38.255]             on.exit(options(oopts), add = TRUE)
[15:32:38.255]         }
[15:32:38.255]         {
[15:32:38.255]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:38.255]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:38.255]                 ...future.FUN(...future.X_jj, ...)
[15:32:38.255]             })
[15:32:38.255]         }
[15:32:38.255]     }, args = future.call.arguments)
[15:32:38.255] }
[15:32:38.256] Tweak future expression to call with '...' arguments ... DONE
[15:32:38.257] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:38.257] 
[15:32:38.257] getGlobalsAndPackages() ... DONE
[15:32:38.258] run() for 'Future' ...
[15:32:38.258] - state: 'created'
[15:32:38.259] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:38.280] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:38.280] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:38.280]   - Field: 'node'
[15:32:38.281]   - Field: 'label'
[15:32:38.281]   - Field: 'local'
[15:32:38.281]   - Field: 'owner'
[15:32:38.282]   - Field: 'envir'
[15:32:38.282]   - Field: 'workers'
[15:32:38.282]   - Field: 'packages'
[15:32:38.283]   - Field: 'gc'
[15:32:38.283]   - Field: 'conditions'
[15:32:38.283]   - Field: 'persistent'
[15:32:38.284]   - Field: 'expr'
[15:32:38.284]   - Field: 'uuid'
[15:32:38.284]   - Field: 'seed'
[15:32:38.285]   - Field: 'version'
[15:32:38.285]   - Field: 'result'
[15:32:38.285]   - Field: 'asynchronous'
[15:32:38.285]   - Field: 'calls'
[15:32:38.286]   - Field: 'globals'
[15:32:38.286]   - Field: 'stdout'
[15:32:38.286]   - Field: 'earlySignal'
[15:32:38.287]   - Field: 'lazy'
[15:32:38.287]   - Field: 'state'
[15:32:38.287] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:38.288] - Launch lazy future ...
[15:32:38.288] Packages needed by the future expression (n = 0): <none>
[15:32:38.289] Packages needed by future strategies (n = 0): <none>
[15:32:38.290] {
[15:32:38.290]     {
[15:32:38.290]         {
[15:32:38.290]             ...future.startTime <- base::Sys.time()
[15:32:38.290]             {
[15:32:38.290]                 {
[15:32:38.290]                   {
[15:32:38.290]                     {
[15:32:38.290]                       base::local({
[15:32:38.290]                         has_future <- base::requireNamespace("future", 
[15:32:38.290]                           quietly = TRUE)
[15:32:38.290]                         if (has_future) {
[15:32:38.290]                           ns <- base::getNamespace("future")
[15:32:38.290]                           version <- ns[[".package"]][["version"]]
[15:32:38.290]                           if (is.null(version)) 
[15:32:38.290]                             version <- utils::packageVersion("future")
[15:32:38.290]                         }
[15:32:38.290]                         else {
[15:32:38.290]                           version <- NULL
[15:32:38.290]                         }
[15:32:38.290]                         if (!has_future || version < "1.8.0") {
[15:32:38.290]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:38.290]                             "", base::R.version$version.string), 
[15:32:38.290]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:38.290]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:38.290]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:38.290]                               "release", "version")], collapse = " "), 
[15:32:38.290]                             hostname = base::Sys.info()[["nodename"]])
[15:32:38.290]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:38.290]                             info)
[15:32:38.290]                           info <- base::paste(info, collapse = "; ")
[15:32:38.290]                           if (!has_future) {
[15:32:38.290]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:38.290]                               info)
[15:32:38.290]                           }
[15:32:38.290]                           else {
[15:32:38.290]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:38.290]                               info, version)
[15:32:38.290]                           }
[15:32:38.290]                           base::stop(msg)
[15:32:38.290]                         }
[15:32:38.290]                       })
[15:32:38.290]                     }
[15:32:38.290]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:38.290]                     base::options(mc.cores = 1L)
[15:32:38.290]                   }
[15:32:38.290]                   ...future.strategy.old <- future::plan("list")
[15:32:38.290]                   options(future.plan = NULL)
[15:32:38.290]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:38.290]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:38.290]                 }
[15:32:38.290]                 ...future.workdir <- getwd()
[15:32:38.290]             }
[15:32:38.290]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:38.290]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:38.290]         }
[15:32:38.290]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:38.290]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:38.290]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:38.290]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:38.290]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:38.290]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:38.290]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:38.290]             base::names(...future.oldOptions))
[15:32:38.290]     }
[15:32:38.290]     if (FALSE) {
[15:32:38.290]     }
[15:32:38.290]     else {
[15:32:38.290]         if (TRUE) {
[15:32:38.290]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:38.290]                 open = "w")
[15:32:38.290]         }
[15:32:38.290]         else {
[15:32:38.290]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:38.290]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:38.290]         }
[15:32:38.290]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:38.290]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:38.290]             base::sink(type = "output", split = FALSE)
[15:32:38.290]             base::close(...future.stdout)
[15:32:38.290]         }, add = TRUE)
[15:32:38.290]     }
[15:32:38.290]     ...future.frame <- base::sys.nframe()
[15:32:38.290]     ...future.conditions <- base::list()
[15:32:38.290]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:38.290]     if (FALSE) {
[15:32:38.290]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:38.290]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:38.290]     }
[15:32:38.290]     ...future.result <- base::tryCatch({
[15:32:38.290]         base::withCallingHandlers({
[15:32:38.290]             ...future.value <- base::withVisible(base::local({
[15:32:38.290]                 ...future.makeSendCondition <- base::local({
[15:32:38.290]                   sendCondition <- NULL
[15:32:38.290]                   function(frame = 1L) {
[15:32:38.290]                     if (is.function(sendCondition)) 
[15:32:38.290]                       return(sendCondition)
[15:32:38.290]                     ns <- getNamespace("parallel")
[15:32:38.290]                     if (exists("sendData", mode = "function", 
[15:32:38.290]                       envir = ns)) {
[15:32:38.290]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:38.290]                         envir = ns)
[15:32:38.290]                       envir <- sys.frame(frame)
[15:32:38.290]                       master <- NULL
[15:32:38.290]                       while (!identical(envir, .GlobalEnv) && 
[15:32:38.290]                         !identical(envir, emptyenv())) {
[15:32:38.290]                         if (exists("master", mode = "list", envir = envir, 
[15:32:38.290]                           inherits = FALSE)) {
[15:32:38.290]                           master <- get("master", mode = "list", 
[15:32:38.290]                             envir = envir, inherits = FALSE)
[15:32:38.290]                           if (inherits(master, c("SOCKnode", 
[15:32:38.290]                             "SOCK0node"))) {
[15:32:38.290]                             sendCondition <<- function(cond) {
[15:32:38.290]                               data <- list(type = "VALUE", value = cond, 
[15:32:38.290]                                 success = TRUE)
[15:32:38.290]                               parallel_sendData(master, data)
[15:32:38.290]                             }
[15:32:38.290]                             return(sendCondition)
[15:32:38.290]                           }
[15:32:38.290]                         }
[15:32:38.290]                         frame <- frame + 1L
[15:32:38.290]                         envir <- sys.frame(frame)
[15:32:38.290]                       }
[15:32:38.290]                     }
[15:32:38.290]                     sendCondition <<- function(cond) NULL
[15:32:38.290]                   }
[15:32:38.290]                 })
[15:32:38.290]                 withCallingHandlers({
[15:32:38.290]                   {
[15:32:38.290]                     do.call(function(...) {
[15:32:38.290]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:38.290]                       if (!identical(...future.globals.maxSize.org, 
[15:32:38.290]                         ...future.globals.maxSize)) {
[15:32:38.290]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:38.290]                         on.exit(options(oopts), add = TRUE)
[15:32:38.290]                       }
[15:32:38.290]                       {
[15:32:38.290]                         lapply(seq_along(...future.elements_ii), 
[15:32:38.290]                           FUN = function(jj) {
[15:32:38.290]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:38.290]                             ...future.FUN(...future.X_jj, ...)
[15:32:38.290]                           })
[15:32:38.290]                       }
[15:32:38.290]                     }, args = future.call.arguments)
[15:32:38.290]                   }
[15:32:38.290]                 }, immediateCondition = function(cond) {
[15:32:38.290]                   sendCondition <- ...future.makeSendCondition()
[15:32:38.290]                   sendCondition(cond)
[15:32:38.290]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:38.290]                   {
[15:32:38.290]                     inherits <- base::inherits
[15:32:38.290]                     invokeRestart <- base::invokeRestart
[15:32:38.290]                     is.null <- base::is.null
[15:32:38.290]                     muffled <- FALSE
[15:32:38.290]                     if (inherits(cond, "message")) {
[15:32:38.290]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:38.290]                       if (muffled) 
[15:32:38.290]                         invokeRestart("muffleMessage")
[15:32:38.290]                     }
[15:32:38.290]                     else if (inherits(cond, "warning")) {
[15:32:38.290]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:38.290]                       if (muffled) 
[15:32:38.290]                         invokeRestart("muffleWarning")
[15:32:38.290]                     }
[15:32:38.290]                     else if (inherits(cond, "condition")) {
[15:32:38.290]                       if (!is.null(pattern)) {
[15:32:38.290]                         computeRestarts <- base::computeRestarts
[15:32:38.290]                         grepl <- base::grepl
[15:32:38.290]                         restarts <- computeRestarts(cond)
[15:32:38.290]                         for (restart in restarts) {
[15:32:38.290]                           name <- restart$name
[15:32:38.290]                           if (is.null(name)) 
[15:32:38.290]                             next
[15:32:38.290]                           if (!grepl(pattern, name)) 
[15:32:38.290]                             next
[15:32:38.290]                           invokeRestart(restart)
[15:32:38.290]                           muffled <- TRUE
[15:32:38.290]                           break
[15:32:38.290]                         }
[15:32:38.290]                       }
[15:32:38.290]                     }
[15:32:38.290]                     invisible(muffled)
[15:32:38.290]                   }
[15:32:38.290]                   muffleCondition(cond)
[15:32:38.290]                 })
[15:32:38.290]             }))
[15:32:38.290]             future::FutureResult(value = ...future.value$value, 
[15:32:38.290]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:38.290]                   ...future.rng), globalenv = if (FALSE) 
[15:32:38.290]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:38.290]                     ...future.globalenv.names))
[15:32:38.290]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:38.290]         }, condition = base::local({
[15:32:38.290]             c <- base::c
[15:32:38.290]             inherits <- base::inherits
[15:32:38.290]             invokeRestart <- base::invokeRestart
[15:32:38.290]             length <- base::length
[15:32:38.290]             list <- base::list
[15:32:38.290]             seq.int <- base::seq.int
[15:32:38.290]             signalCondition <- base::signalCondition
[15:32:38.290]             sys.calls <- base::sys.calls
[15:32:38.290]             `[[` <- base::`[[`
[15:32:38.290]             `+` <- base::`+`
[15:32:38.290]             `<<-` <- base::`<<-`
[15:32:38.290]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:38.290]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:38.290]                   3L)]
[15:32:38.290]             }
[15:32:38.290]             function(cond) {
[15:32:38.290]                 is_error <- inherits(cond, "error")
[15:32:38.290]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:38.290]                   NULL)
[15:32:38.290]                 if (is_error) {
[15:32:38.290]                   sessionInformation <- function() {
[15:32:38.290]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:38.290]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:38.290]                       search = base::search(), system = base::Sys.info())
[15:32:38.290]                   }
[15:32:38.290]                   ...future.conditions[[length(...future.conditions) + 
[15:32:38.290]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:38.290]                     cond$call), session = sessionInformation(), 
[15:32:38.290]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:38.290]                   signalCondition(cond)
[15:32:38.290]                 }
[15:32:38.290]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:38.290]                 "immediateCondition"))) {
[15:32:38.290]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:38.290]                   ...future.conditions[[length(...future.conditions) + 
[15:32:38.290]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:38.290]                   if (TRUE && !signal) {
[15:32:38.290]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:38.290]                     {
[15:32:38.290]                       inherits <- base::inherits
[15:32:38.290]                       invokeRestart <- base::invokeRestart
[15:32:38.290]                       is.null <- base::is.null
[15:32:38.290]                       muffled <- FALSE
[15:32:38.290]                       if (inherits(cond, "message")) {
[15:32:38.290]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:38.290]                         if (muffled) 
[15:32:38.290]                           invokeRestart("muffleMessage")
[15:32:38.290]                       }
[15:32:38.290]                       else if (inherits(cond, "warning")) {
[15:32:38.290]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:38.290]                         if (muffled) 
[15:32:38.290]                           invokeRestart("muffleWarning")
[15:32:38.290]                       }
[15:32:38.290]                       else if (inherits(cond, "condition")) {
[15:32:38.290]                         if (!is.null(pattern)) {
[15:32:38.290]                           computeRestarts <- base::computeRestarts
[15:32:38.290]                           grepl <- base::grepl
[15:32:38.290]                           restarts <- computeRestarts(cond)
[15:32:38.290]                           for (restart in restarts) {
[15:32:38.290]                             name <- restart$name
[15:32:38.290]                             if (is.null(name)) 
[15:32:38.290]                               next
[15:32:38.290]                             if (!grepl(pattern, name)) 
[15:32:38.290]                               next
[15:32:38.290]                             invokeRestart(restart)
[15:32:38.290]                             muffled <- TRUE
[15:32:38.290]                             break
[15:32:38.290]                           }
[15:32:38.290]                         }
[15:32:38.290]                       }
[15:32:38.290]                       invisible(muffled)
[15:32:38.290]                     }
[15:32:38.290]                     muffleCondition(cond, pattern = "^muffle")
[15:32:38.290]                   }
[15:32:38.290]                 }
[15:32:38.290]                 else {
[15:32:38.290]                   if (TRUE) {
[15:32:38.290]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:38.290]                     {
[15:32:38.290]                       inherits <- base::inherits
[15:32:38.290]                       invokeRestart <- base::invokeRestart
[15:32:38.290]                       is.null <- base::is.null
[15:32:38.290]                       muffled <- FALSE
[15:32:38.290]                       if (inherits(cond, "message")) {
[15:32:38.290]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:38.290]                         if (muffled) 
[15:32:38.290]                           invokeRestart("muffleMessage")
[15:32:38.290]                       }
[15:32:38.290]                       else if (inherits(cond, "warning")) {
[15:32:38.290]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:38.290]                         if (muffled) 
[15:32:38.290]                           invokeRestart("muffleWarning")
[15:32:38.290]                       }
[15:32:38.290]                       else if (inherits(cond, "condition")) {
[15:32:38.290]                         if (!is.null(pattern)) {
[15:32:38.290]                           computeRestarts <- base::computeRestarts
[15:32:38.290]                           grepl <- base::grepl
[15:32:38.290]                           restarts <- computeRestarts(cond)
[15:32:38.290]                           for (restart in restarts) {
[15:32:38.290]                             name <- restart$name
[15:32:38.290]                             if (is.null(name)) 
[15:32:38.290]                               next
[15:32:38.290]                             if (!grepl(pattern, name)) 
[15:32:38.290]                               next
[15:32:38.290]                             invokeRestart(restart)
[15:32:38.290]                             muffled <- TRUE
[15:32:38.290]                             break
[15:32:38.290]                           }
[15:32:38.290]                         }
[15:32:38.290]                       }
[15:32:38.290]                       invisible(muffled)
[15:32:38.290]                     }
[15:32:38.290]                     muffleCondition(cond, pattern = "^muffle")
[15:32:38.290]                   }
[15:32:38.290]                 }
[15:32:38.290]             }
[15:32:38.290]         }))
[15:32:38.290]     }, error = function(ex) {
[15:32:38.290]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:38.290]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:38.290]                 ...future.rng), started = ...future.startTime, 
[15:32:38.290]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:38.290]             version = "1.8"), class = "FutureResult")
[15:32:38.290]     }, finally = {
[15:32:38.290]         if (!identical(...future.workdir, getwd())) 
[15:32:38.290]             setwd(...future.workdir)
[15:32:38.290]         {
[15:32:38.290]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:38.290]                 ...future.oldOptions$nwarnings <- NULL
[15:32:38.290]             }
[15:32:38.290]             base::options(...future.oldOptions)
[15:32:38.290]             if (.Platform$OS.type == "windows") {
[15:32:38.290]                 old_names <- names(...future.oldEnvVars)
[15:32:38.290]                 envs <- base::Sys.getenv()
[15:32:38.290]                 names <- names(envs)
[15:32:38.290]                 common <- intersect(names, old_names)
[15:32:38.290]                 added <- setdiff(names, old_names)
[15:32:38.290]                 removed <- setdiff(old_names, names)
[15:32:38.290]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:38.290]                   envs[common]]
[15:32:38.290]                 NAMES <- toupper(changed)
[15:32:38.290]                 args <- list()
[15:32:38.290]                 for (kk in seq_along(NAMES)) {
[15:32:38.290]                   name <- changed[[kk]]
[15:32:38.290]                   NAME <- NAMES[[kk]]
[15:32:38.290]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:38.290]                     next
[15:32:38.290]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:38.290]                 }
[15:32:38.290]                 NAMES <- toupper(added)
[15:32:38.290]                 for (kk in seq_along(NAMES)) {
[15:32:38.290]                   name <- added[[kk]]
[15:32:38.290]                   NAME <- NAMES[[kk]]
[15:32:38.290]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:38.290]                     next
[15:32:38.290]                   args[[name]] <- ""
[15:32:38.290]                 }
[15:32:38.290]                 NAMES <- toupper(removed)
[15:32:38.290]                 for (kk in seq_along(NAMES)) {
[15:32:38.290]                   name <- removed[[kk]]
[15:32:38.290]                   NAME <- NAMES[[kk]]
[15:32:38.290]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:38.290]                     next
[15:32:38.290]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:38.290]                 }
[15:32:38.290]                 if (length(args) > 0) 
[15:32:38.290]                   base::do.call(base::Sys.setenv, args = args)
[15:32:38.290]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:38.290]             }
[15:32:38.290]             else {
[15:32:38.290]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:38.290]             }
[15:32:38.290]             {
[15:32:38.290]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:38.290]                   0L) {
[15:32:38.290]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:38.290]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:38.290]                   base::options(opts)
[15:32:38.290]                 }
[15:32:38.290]                 {
[15:32:38.290]                   {
[15:32:38.290]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:38.290]                     NULL
[15:32:38.290]                   }
[15:32:38.290]                   options(future.plan = NULL)
[15:32:38.290]                   if (is.na(NA_character_)) 
[15:32:38.290]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:38.290]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:38.290]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:38.290]                     .init = FALSE)
[15:32:38.290]                 }
[15:32:38.290]             }
[15:32:38.290]         }
[15:32:38.290]     })
[15:32:38.290]     if (TRUE) {
[15:32:38.290]         base::sink(type = "output", split = FALSE)
[15:32:38.290]         if (TRUE) {
[15:32:38.290]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:38.290]         }
[15:32:38.290]         else {
[15:32:38.290]             ...future.result["stdout"] <- base::list(NULL)
[15:32:38.290]         }
[15:32:38.290]         base::close(...future.stdout)
[15:32:38.290]         ...future.stdout <- NULL
[15:32:38.290]     }
[15:32:38.290]     ...future.result$conditions <- ...future.conditions
[15:32:38.290]     ...future.result$finished <- base::Sys.time()
[15:32:38.290]     ...future.result
[15:32:38.290] }
[15:32:38.300] Exporting 5 global objects (4.62 KiB) to cluster node #1 ...
[15:32:38.300] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ...
[15:32:38.301] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ... DONE
[15:32:38.302] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:38.303] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:38.303] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:38.304] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:38.305] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:38.306] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:38.306] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:38.307] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:38.308] Exporting 5 global objects (4.62 KiB) to cluster node #1 ... DONE
[15:32:38.309] MultisessionFuture started
[15:32:38.309] - Launch lazy future ... done
[15:32:38.310] run() for 'MultisessionFuture' ... done
[15:32:38.310] Created future:
[15:32:38.342] receiveMessageFromWorker() for ClusterFuture ...
[15:32:38.343] - Validating connection of MultisessionFuture
[15:32:38.344] - received message: FutureResult
[15:32:38.344] - Received FutureResult
[15:32:38.344] - Erased future from FutureRegistry
[15:32:38.345] result() for ClusterFuture ...
[15:32:38.345] - result already collected: FutureResult
[15:32:38.345] result() for ClusterFuture ... done
[15:32:38.345] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:38.310] MultisessionFuture:
[15:32:38.310] Label: 'future_sapply-2'
[15:32:38.310] Expression:
[15:32:38.310] {
[15:32:38.310]     do.call(function(...) {
[15:32:38.310]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:38.310]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:38.310]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:38.310]             on.exit(options(oopts), add = TRUE)
[15:32:38.310]         }
[15:32:38.310]         {
[15:32:38.310]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:38.310]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:38.310]                 ...future.FUN(...future.X_jj, ...)
[15:32:38.310]             })
[15:32:38.310]         }
[15:32:38.310]     }, args = future.call.arguments)
[15:32:38.310] }
[15:32:38.310] Lazy evaluation: FALSE
[15:32:38.310] Asynchronous evaluation: TRUE
[15:32:38.310] Local evaluation: TRUE
[15:32:38.310] Environment: R_GlobalEnv
[15:32:38.310] Capture standard output: TRUE
[15:32:38.310] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:38.310] Globals: 5 objects totaling 4.73 KiB (function '...future.FUN' of 4.62 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)
[15:32:38.310] Packages: <none>
[15:32:38.310] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:38.310] Resolved: TRUE
[15:32:38.310] Value: <not collected>
[15:32:38.310] Conditions captured: <none>
[15:32:38.310] Early signaling: FALSE
[15:32:38.310] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:38.310] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:38.346] Chunk #2 of 2 ... DONE
[15:32:38.346] Launching 2 futures (chunks) ... DONE
[15:32:38.347] Resolving 2 futures (chunks) ...
[15:32:38.347] resolve() on list ...
[15:32:38.347]  recursive: 0
[15:32:38.348]  length: 2
[15:32:38.348] 
[15:32:38.348] Future #1
[15:32:38.348] result() for ClusterFuture ...
[15:32:38.349] - result already collected: FutureResult
[15:32:38.349] result() for ClusterFuture ... done
[15:32:38.349] result() for ClusterFuture ...
[15:32:38.350] - result already collected: FutureResult
[15:32:38.350] result() for ClusterFuture ... done
[15:32:38.350] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:38.350] - nx: 2
[15:32:38.351] - relay: TRUE
[15:32:38.351] - stdout: TRUE
[15:32:38.351] - signal: TRUE
[15:32:38.351] - resignal: FALSE
[15:32:38.352] - force: TRUE
[15:32:38.352] - relayed: [n=2] FALSE, FALSE
[15:32:38.352] - queued futures: [n=2] FALSE, FALSE
[15:32:38.352]  - until=1
[15:32:38.353]  - relaying element #1
[15:32:38.353] result() for ClusterFuture ...
[15:32:38.353] - result already collected: FutureResult
[15:32:38.353] result() for ClusterFuture ... done
[15:32:38.354] result() for ClusterFuture ...
[15:32:38.354] - result already collected: FutureResult
[15:32:38.354] result() for ClusterFuture ... done
[15:32:38.355] result() for ClusterFuture ...
[15:32:38.355] - result already collected: FutureResult
[15:32:38.355] result() for ClusterFuture ... done
[15:32:38.355] result() for ClusterFuture ...
[15:32:38.355] - result already collected: FutureResult
[15:32:38.356] result() for ClusterFuture ... done
[15:32:38.356] - relayed: [n=2] TRUE, FALSE
[15:32:38.356] - queued futures: [n=2] TRUE, FALSE
[15:32:38.356] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:38.357]  length: 1 (resolved future 1)
[15:32:38.357] Future #2
[15:32:38.357] result() for ClusterFuture ...
[15:32:38.358] - result already collected: FutureResult
[15:32:38.358] result() for ClusterFuture ... done
[15:32:38.358] result() for ClusterFuture ...
[15:32:38.358] - result already collected: FutureResult
[15:32:38.359] result() for ClusterFuture ... done
[15:32:38.359] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:38.359] - nx: 2
[15:32:38.359] - relay: TRUE
[15:32:38.360] - stdout: TRUE
[15:32:38.360] - signal: TRUE
[15:32:38.360] - resignal: FALSE
[15:32:38.360] - force: TRUE
[15:32:38.361] - relayed: [n=2] TRUE, FALSE
[15:32:38.361] - queued futures: [n=2] TRUE, FALSE
[15:32:38.361]  - until=2
[15:32:38.361]  - relaying element #2
[15:32:38.361] result() for ClusterFuture ...
[15:32:38.361] - result already collected: FutureResult
[15:32:38.361] result() for ClusterFuture ... done
[15:32:38.362] result() for ClusterFuture ...
[15:32:38.362] - result already collected: FutureResult
[15:32:38.362] result() for ClusterFuture ... done
[15:32:38.362] result() for ClusterFuture ...
[15:32:38.362] - result already collected: FutureResult
[15:32:38.362] result() for ClusterFuture ... done
[15:32:38.363] result() for ClusterFuture ...
[15:32:38.363] - result already collected: FutureResult
[15:32:38.363] result() for ClusterFuture ... done
[15:32:38.363] - relayed: [n=2] TRUE, TRUE
[15:32:38.363] - queued futures: [n=2] TRUE, TRUE
[15:32:38.363] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:38.363]  length: 0 (resolved future 2)
[15:32:38.364] Relaying remaining futures
[15:32:38.364] signalConditionsASAP(NULL, pos=0) ...
[15:32:38.364] - nx: 2
[15:32:38.364] - relay: TRUE
[15:32:38.364] - stdout: TRUE
[15:32:38.364] - signal: TRUE
[15:32:38.364] - resignal: FALSE
[15:32:38.365] - force: TRUE
[15:32:38.365] - relayed: [n=2] TRUE, TRUE
[15:32:38.365] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:38.365] - relayed: [n=2] TRUE, TRUE
[15:32:38.365] - queued futures: [n=2] TRUE, TRUE
[15:32:38.365] signalConditionsASAP(NULL, pos=0) ... done
[15:32:38.366] resolve() on list ... DONE
[15:32:38.366] result() for ClusterFuture ...
[15:32:38.366] - result already collected: FutureResult
[15:32:38.366] result() for ClusterFuture ... done
[15:32:38.367] result() for ClusterFuture ...
[15:32:38.367] - result already collected: FutureResult
[15:32:38.367] result() for ClusterFuture ... done
[15:32:38.367] result() for ClusterFuture ...
[15:32:38.367] - result already collected: FutureResult
[15:32:38.367] result() for ClusterFuture ... done
[15:32:38.367] result() for ClusterFuture ...
[15:32:38.368] - result already collected: FutureResult
[15:32:38.368] result() for ClusterFuture ... done
[15:32:38.368]  - Number of value chunks collected: 2
[15:32:38.368] Resolving 2 futures (chunks) ... DONE
[15:32:38.368] Reducing values from 2 chunks ...
[15:32:38.369]  - Number of values collected after concatenation: 4
[15:32:38.369]  - Number of values expected: 4
[15:32:38.369] Reducing values from 2 chunks ... DONE
[15:32:38.369] future_lapply() ... DONE
List of 2
 $ y0:List of 4
  ..$ A: num [1:3, 1:5] 100 100 100 200 200 200 300 300 300 400 ...
  ..$ B: num [1:3, 1:5] 120 120 120 240 240 240 360 360 360 480 ...
  ..$ C: num [1:3, 1:5] 140 140 140 280 280 280 420 420 420 560 ...
  ..$ D: num [1:3, 1:5] 160 160 160 320 320 320 480 480 480 640 ...
 $ y1:List of 4
  ..$ A: num [1:3, 1:5] 100 100 100 200 200 200 300 300 300 400 ...
  ..$ B: num [1:3, 1:5] 120 120 120 240 240 240 360 360 360 480 ...
  ..$ C: num [1:3, 1:5] 140 140 140 280 280 280 420 420 420 560 ...
  ..$ D: num [1:3, 1:5] 160 160 160 320 320 320 480 480 480 640 ...
List of 2
 $ y0:List of 4
  ..$ A: num [1:3, 1:5] 100 100 100 200 200 200 300 300 300 400 ...
  ..$ B: num [1:3, 1:5] 120 120 120 240 240 240 360 360 360 480 ...
  ..$ C: num [1:3, 1:5] 140 140 140 280 280 280 420 420 420 560 ...
  ..$ D: num [1:3, 1:5] 160 160 160 320 320 320 480 480 480 640 ...
 $ y2:List of 4
  ..$ A: num [1:3, 1:5] 100 100 100 200 200 200 300 300 300 400 ...
  ..$ B: num [1:3, 1:5] 120 120 120 240 240 240 360 360 360 480 ...
  ..$ C: num [1:3, 1:5] 140 140 140 280 280 280 420 420 420 560 ...
  ..$ D: num [1:3, 1:5] 160 160 160 320 320 320 480 480 480 640 ...
[15:32:38.380] future_lapply() ...
[15:32:38.383] Number of chunks: 2
[15:32:38.386] getGlobalsAndPackagesXApply() ...
[15:32:38.386]  - future.globals: TRUE
[15:32:38.386] getGlobalsAndPackages() ...
[15:32:38.387] Searching for globals...
[15:32:38.388] - globals found: [1] 'FUN'
[15:32:38.388] Searching for globals ... DONE
[15:32:38.388] Resolving globals: FALSE
[15:32:38.389] The total size of the 1 globals is 848 bytes (848 bytes)
[15:32:38.389] The total size of the 1 globals exported for future expression ('FUN()') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:32:38.389] - globals: [1] 'FUN'
[15:32:38.390] 
[15:32:38.390] getGlobalsAndPackages() ... DONE
[15:32:38.390]  - globals found/used: [n=1] 'FUN'
[15:32:38.390]  - needed namespaces: [n=0] 
[15:32:38.390] Finding globals ... DONE
[15:32:38.390]  - use_args: TRUE
[15:32:38.391]  - Getting '...' globals ...
[15:32:38.391] resolve() on list ...
[15:32:38.391]  recursive: 0
[15:32:38.391]  length: 1
[15:32:38.392]  elements: '...'
[15:32:38.392]  length: 0 (resolved future 1)
[15:32:38.392] resolve() on list ... DONE
[15:32:38.392]    - '...' content: [n=0] 
[15:32:38.392] List of 1
[15:32:38.392]  $ ...: list()
[15:32:38.392]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:38.392]  - attr(*, "where")=List of 1
[15:32:38.392]   ..$ ...:<environment: 0x00000276e561f5b8> 
[15:32:38.392]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:38.392]  - attr(*, "resolved")= logi TRUE
[15:32:38.392]  - attr(*, "total_size")= num NA
[15:32:38.396]  - Getting '...' globals ... DONE
[15:32:38.397] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:38.397] List of 2
[15:32:38.397]  $ ...future.FUN:function (x)  
[15:32:38.397]  $ ...          : list()
[15:32:38.397]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:38.397]  - attr(*, "where")=List of 2
[15:32:38.397]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:38.397]   ..$ ...          :<environment: 0x00000276e561f5b8> 
[15:32:38.397]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:38.397]  - attr(*, "resolved")= logi FALSE
[15:32:38.397]  - attr(*, "total_size")= num 848
[15:32:38.400] Packages to be attached in all futures: [n=0] 
[15:32:38.400] getGlobalsAndPackagesXApply() ... DONE
[15:32:38.400] Number of futures (= number of chunks): 2
[15:32:38.401] Launching 2 futures (chunks) ...
[15:32:38.401] Chunk #1 of 2 ...
[15:32:38.401]  - Finding globals in 'X' for chunk #1 ...
[15:32:38.401] getGlobalsAndPackages() ...
[15:32:38.401] Searching for globals...
[15:32:38.402] 
[15:32:38.402] Searching for globals ... DONE
[15:32:38.402] - globals: [0] <none>
[15:32:38.402] getGlobalsAndPackages() ... DONE
[15:32:38.402]    + additional globals found: [n=0] 
[15:32:38.402]    + additional namespaces needed: [n=0] 
[15:32:38.403]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:38.403]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:38.403]  - seeds: <none>
[15:32:38.403]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:38.403] getGlobalsAndPackages() ...
[15:32:38.403] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:38.404] Resolving globals: FALSE
[15:32:38.404] Tweak future expression to call with '...' arguments ...
[15:32:38.404] {
[15:32:38.404]     do.call(function(...) {
[15:32:38.404]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:38.404]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:38.404]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:38.404]             on.exit(options(oopts), add = TRUE)
[15:32:38.404]         }
[15:32:38.404]         {
[15:32:38.404]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:38.404]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:38.404]                 ...future.FUN(...future.X_jj, ...)
[15:32:38.404]             })
[15:32:38.404]         }
[15:32:38.404]     }, args = future.call.arguments)
[15:32:38.404] }
[15:32:38.404] Tweak future expression to call with '...' arguments ... DONE
[15:32:38.405] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:38.405] 
[15:32:38.405] getGlobalsAndPackages() ... DONE
[15:32:38.406] run() for 'Future' ...
[15:32:38.406] - state: 'created'
[15:32:38.406] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:38.424] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:38.425] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:38.425]   - Field: 'node'
[15:32:38.425]   - Field: 'label'
[15:32:38.426]   - Field: 'local'
[15:32:38.426]   - Field: 'owner'
[15:32:38.426]   - Field: 'envir'
[15:32:38.427]   - Field: 'workers'
[15:32:38.427]   - Field: 'packages'
[15:32:38.427]   - Field: 'gc'
[15:32:38.427]   - Field: 'conditions'
[15:32:38.428]   - Field: 'persistent'
[15:32:38.428]   - Field: 'expr'
[15:32:38.428]   - Field: 'uuid'
[15:32:38.429]   - Field: 'seed'
[15:32:38.429]   - Field: 'version'
[15:32:38.429]   - Field: 'result'
[15:32:38.429]   - Field: 'asynchronous'
[15:32:38.430]   - Field: 'calls'
[15:32:38.430]   - Field: 'globals'
[15:32:38.430]   - Field: 'stdout'
[15:32:38.431]   - Field: 'earlySignal'
[15:32:38.431]   - Field: 'lazy'
[15:32:38.431]   - Field: 'state'
[15:32:38.431] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:38.432] - Launch lazy future ...
[15:32:38.432] Packages needed by the future expression (n = 0): <none>
[15:32:38.433] Packages needed by future strategies (n = 0): <none>
[15:32:38.434] {
[15:32:38.434]     {
[15:32:38.434]         {
[15:32:38.434]             ...future.startTime <- base::Sys.time()
[15:32:38.434]             {
[15:32:38.434]                 {
[15:32:38.434]                   {
[15:32:38.434]                     {
[15:32:38.434]                       base::local({
[15:32:38.434]                         has_future <- base::requireNamespace("future", 
[15:32:38.434]                           quietly = TRUE)
[15:32:38.434]                         if (has_future) {
[15:32:38.434]                           ns <- base::getNamespace("future")
[15:32:38.434]                           version <- ns[[".package"]][["version"]]
[15:32:38.434]                           if (is.null(version)) 
[15:32:38.434]                             version <- utils::packageVersion("future")
[15:32:38.434]                         }
[15:32:38.434]                         else {
[15:32:38.434]                           version <- NULL
[15:32:38.434]                         }
[15:32:38.434]                         if (!has_future || version < "1.8.0") {
[15:32:38.434]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:38.434]                             "", base::R.version$version.string), 
[15:32:38.434]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:38.434]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:38.434]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:38.434]                               "release", "version")], collapse = " "), 
[15:32:38.434]                             hostname = base::Sys.info()[["nodename"]])
[15:32:38.434]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:38.434]                             info)
[15:32:38.434]                           info <- base::paste(info, collapse = "; ")
[15:32:38.434]                           if (!has_future) {
[15:32:38.434]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:38.434]                               info)
[15:32:38.434]                           }
[15:32:38.434]                           else {
[15:32:38.434]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:38.434]                               info, version)
[15:32:38.434]                           }
[15:32:38.434]                           base::stop(msg)
[15:32:38.434]                         }
[15:32:38.434]                       })
[15:32:38.434]                     }
[15:32:38.434]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:38.434]                     base::options(mc.cores = 1L)
[15:32:38.434]                   }
[15:32:38.434]                   ...future.strategy.old <- future::plan("list")
[15:32:38.434]                   options(future.plan = NULL)
[15:32:38.434]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:38.434]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:38.434]                 }
[15:32:38.434]                 ...future.workdir <- getwd()
[15:32:38.434]             }
[15:32:38.434]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:38.434]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:38.434]         }
[15:32:38.434]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:38.434]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:38.434]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:38.434]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:38.434]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:38.434]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:38.434]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:38.434]             base::names(...future.oldOptions))
[15:32:38.434]     }
[15:32:38.434]     if (FALSE) {
[15:32:38.434]     }
[15:32:38.434]     else {
[15:32:38.434]         if (TRUE) {
[15:32:38.434]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:38.434]                 open = "w")
[15:32:38.434]         }
[15:32:38.434]         else {
[15:32:38.434]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:38.434]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:38.434]         }
[15:32:38.434]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:38.434]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:38.434]             base::sink(type = "output", split = FALSE)
[15:32:38.434]             base::close(...future.stdout)
[15:32:38.434]         }, add = TRUE)
[15:32:38.434]     }
[15:32:38.434]     ...future.frame <- base::sys.nframe()
[15:32:38.434]     ...future.conditions <- base::list()
[15:32:38.434]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:38.434]     if (FALSE) {
[15:32:38.434]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:38.434]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:38.434]     }
[15:32:38.434]     ...future.result <- base::tryCatch({
[15:32:38.434]         base::withCallingHandlers({
[15:32:38.434]             ...future.value <- base::withVisible(base::local({
[15:32:38.434]                 ...future.makeSendCondition <- base::local({
[15:32:38.434]                   sendCondition <- NULL
[15:32:38.434]                   function(frame = 1L) {
[15:32:38.434]                     if (is.function(sendCondition)) 
[15:32:38.434]                       return(sendCondition)
[15:32:38.434]                     ns <- getNamespace("parallel")
[15:32:38.434]                     if (exists("sendData", mode = "function", 
[15:32:38.434]                       envir = ns)) {
[15:32:38.434]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:38.434]                         envir = ns)
[15:32:38.434]                       envir <- sys.frame(frame)
[15:32:38.434]                       master <- NULL
[15:32:38.434]                       while (!identical(envir, .GlobalEnv) && 
[15:32:38.434]                         !identical(envir, emptyenv())) {
[15:32:38.434]                         if (exists("master", mode = "list", envir = envir, 
[15:32:38.434]                           inherits = FALSE)) {
[15:32:38.434]                           master <- get("master", mode = "list", 
[15:32:38.434]                             envir = envir, inherits = FALSE)
[15:32:38.434]                           if (inherits(master, c("SOCKnode", 
[15:32:38.434]                             "SOCK0node"))) {
[15:32:38.434]                             sendCondition <<- function(cond) {
[15:32:38.434]                               data <- list(type = "VALUE", value = cond, 
[15:32:38.434]                                 success = TRUE)
[15:32:38.434]                               parallel_sendData(master, data)
[15:32:38.434]                             }
[15:32:38.434]                             return(sendCondition)
[15:32:38.434]                           }
[15:32:38.434]                         }
[15:32:38.434]                         frame <- frame + 1L
[15:32:38.434]                         envir <- sys.frame(frame)
[15:32:38.434]                       }
[15:32:38.434]                     }
[15:32:38.434]                     sendCondition <<- function(cond) NULL
[15:32:38.434]                   }
[15:32:38.434]                 })
[15:32:38.434]                 withCallingHandlers({
[15:32:38.434]                   {
[15:32:38.434]                     do.call(function(...) {
[15:32:38.434]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:38.434]                       if (!identical(...future.globals.maxSize.org, 
[15:32:38.434]                         ...future.globals.maxSize)) {
[15:32:38.434]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:38.434]                         on.exit(options(oopts), add = TRUE)
[15:32:38.434]                       }
[15:32:38.434]                       {
[15:32:38.434]                         lapply(seq_along(...future.elements_ii), 
[15:32:38.434]                           FUN = function(jj) {
[15:32:38.434]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:38.434]                             ...future.FUN(...future.X_jj, ...)
[15:32:38.434]                           })
[15:32:38.434]                       }
[15:32:38.434]                     }, args = future.call.arguments)
[15:32:38.434]                   }
[15:32:38.434]                 }, immediateCondition = function(cond) {
[15:32:38.434]                   sendCondition <- ...future.makeSendCondition()
[15:32:38.434]                   sendCondition(cond)
[15:32:38.434]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:38.434]                   {
[15:32:38.434]                     inherits <- base::inherits
[15:32:38.434]                     invokeRestart <- base::invokeRestart
[15:32:38.434]                     is.null <- base::is.null
[15:32:38.434]                     muffled <- FALSE
[15:32:38.434]                     if (inherits(cond, "message")) {
[15:32:38.434]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:38.434]                       if (muffled) 
[15:32:38.434]                         invokeRestart("muffleMessage")
[15:32:38.434]                     }
[15:32:38.434]                     else if (inherits(cond, "warning")) {
[15:32:38.434]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:38.434]                       if (muffled) 
[15:32:38.434]                         invokeRestart("muffleWarning")
[15:32:38.434]                     }
[15:32:38.434]                     else if (inherits(cond, "condition")) {
[15:32:38.434]                       if (!is.null(pattern)) {
[15:32:38.434]                         computeRestarts <- base::computeRestarts
[15:32:38.434]                         grepl <- base::grepl
[15:32:38.434]                         restarts <- computeRestarts(cond)
[15:32:38.434]                         for (restart in restarts) {
[15:32:38.434]                           name <- restart$name
[15:32:38.434]                           if (is.null(name)) 
[15:32:38.434]                             next
[15:32:38.434]                           if (!grepl(pattern, name)) 
[15:32:38.434]                             next
[15:32:38.434]                           invokeRestart(restart)
[15:32:38.434]                           muffled <- TRUE
[15:32:38.434]                           break
[15:32:38.434]                         }
[15:32:38.434]                       }
[15:32:38.434]                     }
[15:32:38.434]                     invisible(muffled)
[15:32:38.434]                   }
[15:32:38.434]                   muffleCondition(cond)
[15:32:38.434]                 })
[15:32:38.434]             }))
[15:32:38.434]             future::FutureResult(value = ...future.value$value, 
[15:32:38.434]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:38.434]                   ...future.rng), globalenv = if (FALSE) 
[15:32:38.434]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:38.434]                     ...future.globalenv.names))
[15:32:38.434]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:38.434]         }, condition = base::local({
[15:32:38.434]             c <- base::c
[15:32:38.434]             inherits <- base::inherits
[15:32:38.434]             invokeRestart <- base::invokeRestart
[15:32:38.434]             length <- base::length
[15:32:38.434]             list <- base::list
[15:32:38.434]             seq.int <- base::seq.int
[15:32:38.434]             signalCondition <- base::signalCondition
[15:32:38.434]             sys.calls <- base::sys.calls
[15:32:38.434]             `[[` <- base::`[[`
[15:32:38.434]             `+` <- base::`+`
[15:32:38.434]             `<<-` <- base::`<<-`
[15:32:38.434]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:38.434]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:38.434]                   3L)]
[15:32:38.434]             }
[15:32:38.434]             function(cond) {
[15:32:38.434]                 is_error <- inherits(cond, "error")
[15:32:38.434]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:38.434]                   NULL)
[15:32:38.434]                 if (is_error) {
[15:32:38.434]                   sessionInformation <- function() {
[15:32:38.434]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:38.434]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:38.434]                       search = base::search(), system = base::Sys.info())
[15:32:38.434]                   }
[15:32:38.434]                   ...future.conditions[[length(...future.conditions) + 
[15:32:38.434]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:38.434]                     cond$call), session = sessionInformation(), 
[15:32:38.434]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:38.434]                   signalCondition(cond)
[15:32:38.434]                 }
[15:32:38.434]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:38.434]                 "immediateCondition"))) {
[15:32:38.434]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:38.434]                   ...future.conditions[[length(...future.conditions) + 
[15:32:38.434]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:38.434]                   if (TRUE && !signal) {
[15:32:38.434]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:38.434]                     {
[15:32:38.434]                       inherits <- base::inherits
[15:32:38.434]                       invokeRestart <- base::invokeRestart
[15:32:38.434]                       is.null <- base::is.null
[15:32:38.434]                       muffled <- FALSE
[15:32:38.434]                       if (inherits(cond, "message")) {
[15:32:38.434]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:38.434]                         if (muffled) 
[15:32:38.434]                           invokeRestart("muffleMessage")
[15:32:38.434]                       }
[15:32:38.434]                       else if (inherits(cond, "warning")) {
[15:32:38.434]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:38.434]                         if (muffled) 
[15:32:38.434]                           invokeRestart("muffleWarning")
[15:32:38.434]                       }
[15:32:38.434]                       else if (inherits(cond, "condition")) {
[15:32:38.434]                         if (!is.null(pattern)) {
[15:32:38.434]                           computeRestarts <- base::computeRestarts
[15:32:38.434]                           grepl <- base::grepl
[15:32:38.434]                           restarts <- computeRestarts(cond)
[15:32:38.434]                           for (restart in restarts) {
[15:32:38.434]                             name <- restart$name
[15:32:38.434]                             if (is.null(name)) 
[15:32:38.434]                               next
[15:32:38.434]                             if (!grepl(pattern, name)) 
[15:32:38.434]                               next
[15:32:38.434]                             invokeRestart(restart)
[15:32:38.434]                             muffled <- TRUE
[15:32:38.434]                             break
[15:32:38.434]                           }
[15:32:38.434]                         }
[15:32:38.434]                       }
[15:32:38.434]                       invisible(muffled)
[15:32:38.434]                     }
[15:32:38.434]                     muffleCondition(cond, pattern = "^muffle")
[15:32:38.434]                   }
[15:32:38.434]                 }
[15:32:38.434]                 else {
[15:32:38.434]                   if (TRUE) {
[15:32:38.434]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:38.434]                     {
[15:32:38.434]                       inherits <- base::inherits
[15:32:38.434]                       invokeRestart <- base::invokeRestart
[15:32:38.434]                       is.null <- base::is.null
[15:32:38.434]                       muffled <- FALSE
[15:32:38.434]                       if (inherits(cond, "message")) {
[15:32:38.434]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:38.434]                         if (muffled) 
[15:32:38.434]                           invokeRestart("muffleMessage")
[15:32:38.434]                       }
[15:32:38.434]                       else if (inherits(cond, "warning")) {
[15:32:38.434]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:38.434]                         if (muffled) 
[15:32:38.434]                           invokeRestart("muffleWarning")
[15:32:38.434]                       }
[15:32:38.434]                       else if (inherits(cond, "condition")) {
[15:32:38.434]                         if (!is.null(pattern)) {
[15:32:38.434]                           computeRestarts <- base::computeRestarts
[15:32:38.434]                           grepl <- base::grepl
[15:32:38.434]                           restarts <- computeRestarts(cond)
[15:32:38.434]                           for (restart in restarts) {
[15:32:38.434]                             name <- restart$name
[15:32:38.434]                             if (is.null(name)) 
[15:32:38.434]                               next
[15:32:38.434]                             if (!grepl(pattern, name)) 
[15:32:38.434]                               next
[15:32:38.434]                             invokeRestart(restart)
[15:32:38.434]                             muffled <- TRUE
[15:32:38.434]                             break
[15:32:38.434]                           }
[15:32:38.434]                         }
[15:32:38.434]                       }
[15:32:38.434]                       invisible(muffled)
[15:32:38.434]                     }
[15:32:38.434]                     muffleCondition(cond, pattern = "^muffle")
[15:32:38.434]                   }
[15:32:38.434]                 }
[15:32:38.434]             }
[15:32:38.434]         }))
[15:32:38.434]     }, error = function(ex) {
[15:32:38.434]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:38.434]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:38.434]                 ...future.rng), started = ...future.startTime, 
[15:32:38.434]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:38.434]             version = "1.8"), class = "FutureResult")
[15:32:38.434]     }, finally = {
[15:32:38.434]         if (!identical(...future.workdir, getwd())) 
[15:32:38.434]             setwd(...future.workdir)
[15:32:38.434]         {
[15:32:38.434]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:38.434]                 ...future.oldOptions$nwarnings <- NULL
[15:32:38.434]             }
[15:32:38.434]             base::options(...future.oldOptions)
[15:32:38.434]             if (.Platform$OS.type == "windows") {
[15:32:38.434]                 old_names <- names(...future.oldEnvVars)
[15:32:38.434]                 envs <- base::Sys.getenv()
[15:32:38.434]                 names <- names(envs)
[15:32:38.434]                 common <- intersect(names, old_names)
[15:32:38.434]                 added <- setdiff(names, old_names)
[15:32:38.434]                 removed <- setdiff(old_names, names)
[15:32:38.434]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:38.434]                   envs[common]]
[15:32:38.434]                 NAMES <- toupper(changed)
[15:32:38.434]                 args <- list()
[15:32:38.434]                 for (kk in seq_along(NAMES)) {
[15:32:38.434]                   name <- changed[[kk]]
[15:32:38.434]                   NAME <- NAMES[[kk]]
[15:32:38.434]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:38.434]                     next
[15:32:38.434]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:38.434]                 }
[15:32:38.434]                 NAMES <- toupper(added)
[15:32:38.434]                 for (kk in seq_along(NAMES)) {
[15:32:38.434]                   name <- added[[kk]]
[15:32:38.434]                   NAME <- NAMES[[kk]]
[15:32:38.434]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:38.434]                     next
[15:32:38.434]                   args[[name]] <- ""
[15:32:38.434]                 }
[15:32:38.434]                 NAMES <- toupper(removed)
[15:32:38.434]                 for (kk in seq_along(NAMES)) {
[15:32:38.434]                   name <- removed[[kk]]
[15:32:38.434]                   NAME <- NAMES[[kk]]
[15:32:38.434]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:38.434]                     next
[15:32:38.434]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:38.434]                 }
[15:32:38.434]                 if (length(args) > 0) 
[15:32:38.434]                   base::do.call(base::Sys.setenv, args = args)
[15:32:38.434]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:38.434]             }
[15:32:38.434]             else {
[15:32:38.434]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:38.434]             }
[15:32:38.434]             {
[15:32:38.434]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:38.434]                   0L) {
[15:32:38.434]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:38.434]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:38.434]                   base::options(opts)
[15:32:38.434]                 }
[15:32:38.434]                 {
[15:32:38.434]                   {
[15:32:38.434]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:38.434]                     NULL
[15:32:38.434]                   }
[15:32:38.434]                   options(future.plan = NULL)
[15:32:38.434]                   if (is.na(NA_character_)) 
[15:32:38.434]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:38.434]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:38.434]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:38.434]                     .init = FALSE)
[15:32:38.434]                 }
[15:32:38.434]             }
[15:32:38.434]         }
[15:32:38.434]     })
[15:32:38.434]     if (TRUE) {
[15:32:38.434]         base::sink(type = "output", split = FALSE)
[15:32:38.434]         if (TRUE) {
[15:32:38.434]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:38.434]         }
[15:32:38.434]         else {
[15:32:38.434]             ...future.result["stdout"] <- base::list(NULL)
[15:32:38.434]         }
[15:32:38.434]         base::close(...future.stdout)
[15:32:38.434]         ...future.stdout <- NULL
[15:32:38.434]     }
[15:32:38.434]     ...future.result$conditions <- ...future.conditions
[15:32:38.434]     ...future.result$finished <- base::Sys.time()
[15:32:38.434]     ...future.result
[15:32:38.434] }
[15:32:38.442] Exporting 5 global objects (848 bytes) to cluster node #1 ...
[15:32:38.443] Exporting '...future.FUN' (848 bytes) to cluster node #1 ...
[15:32:38.443] Exporting '...future.FUN' (848 bytes) to cluster node #1 ... DONE
[15:32:38.444] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:38.444] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:38.445] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:38.445] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:38.446] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:38.447] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:38.447] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:38.448] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:38.448] Exporting 5 global objects (848 bytes) to cluster node #1 ... DONE
[15:32:38.449] MultisessionFuture started
[15:32:38.449] - Launch lazy future ... done
[15:32:38.450] run() for 'MultisessionFuture' ... done
[15:32:38.450] Created future:
[15:32:38.480] receiveMessageFromWorker() for ClusterFuture ...
[15:32:38.481] - Validating connection of MultisessionFuture
[15:32:38.481] - received message: FutureResult
[15:32:38.482] - Received FutureResult
[15:32:38.482] - Erased future from FutureRegistry
[15:32:38.482] result() for ClusterFuture ...
[15:32:38.482] - result already collected: FutureResult
[15:32:38.483] result() for ClusterFuture ... done
[15:32:38.483] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:38.450] MultisessionFuture:
[15:32:38.450] Label: 'future_sapply-1'
[15:32:38.450] Expression:
[15:32:38.450] {
[15:32:38.450]     do.call(function(...) {
[15:32:38.450]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:38.450]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:38.450]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:38.450]             on.exit(options(oopts), add = TRUE)
[15:32:38.450]         }
[15:32:38.450]         {
[15:32:38.450]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:38.450]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:38.450]                 ...future.FUN(...future.X_jj, ...)
[15:32:38.450]             })
[15:32:38.450]         }
[15:32:38.450]     }, args = future.call.arguments)
[15:32:38.450] }
[15:32:38.450] Lazy evaluation: FALSE
[15:32:38.450] Asynchronous evaluation: TRUE
[15:32:38.450] Local evaluation: TRUE
[15:32:38.450] Environment: R_GlobalEnv
[15:32:38.450] Capture standard output: TRUE
[15:32:38.450] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:38.450] Globals: 5 objects totaling 960 bytes (function '...future.FUN' of 848 bytes, 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)
[15:32:38.450] Packages: <none>
[15:32:38.450] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:38.450] Resolved: TRUE
[15:32:38.450] Value: <not collected>
[15:32:38.450] Conditions captured: <none>
[15:32:38.450] Early signaling: FALSE
[15:32:38.450] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:38.450] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:38.484] Chunk #1 of 2 ... DONE
[15:32:38.484] Chunk #2 of 2 ...
[15:32:38.484]  - Finding globals in 'X' for chunk #2 ...
[15:32:38.484] getGlobalsAndPackages() ...
[15:32:38.485] Searching for globals...
[15:32:38.485] 
[15:32:38.485] Searching for globals ... DONE
[15:32:38.486] - globals: [0] <none>
[15:32:38.486] getGlobalsAndPackages() ... DONE
[15:32:38.486]    + additional globals found: [n=0] 
[15:32:38.486]    + additional namespaces needed: [n=0] 
[15:32:38.487]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:38.487]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:38.487]  - seeds: <none>
[15:32:38.487]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:38.488] getGlobalsAndPackages() ...
[15:32:38.488] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:38.488] Resolving globals: FALSE
[15:32:38.488] Tweak future expression to call with '...' arguments ...
[15:32:38.489] {
[15:32:38.489]     do.call(function(...) {
[15:32:38.489]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:38.489]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:38.489]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:38.489]             on.exit(options(oopts), add = TRUE)
[15:32:38.489]         }
[15:32:38.489]         {
[15:32:38.489]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:38.489]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:38.489]                 ...future.FUN(...future.X_jj, ...)
[15:32:38.489]             })
[15:32:38.489]         }
[15:32:38.489]     }, args = future.call.arguments)
[15:32:38.489] }
[15:32:38.489] Tweak future expression to call with '...' arguments ... DONE
[15:32:38.490] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:38.490] 
[15:32:38.491] getGlobalsAndPackages() ... DONE
[15:32:38.491] run() for 'Future' ...
[15:32:38.492] - state: 'created'
[15:32:38.492] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:38.509] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:38.509] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:38.509]   - Field: 'node'
[15:32:38.510]   - Field: 'label'
[15:32:38.510]   - Field: 'local'
[15:32:38.510]   - Field: 'owner'
[15:32:38.511]   - Field: 'envir'
[15:32:38.511]   - Field: 'workers'
[15:32:38.511]   - Field: 'packages'
[15:32:38.511]   - Field: 'gc'
[15:32:38.512]   - Field: 'conditions'
[15:32:38.512]   - Field: 'persistent'
[15:32:38.512]   - Field: 'expr'
[15:32:38.512]   - Field: 'uuid'
[15:32:38.513]   - Field: 'seed'
[15:32:38.513]   - Field: 'version'
[15:32:38.513]   - Field: 'result'
[15:32:38.513]   - Field: 'asynchronous'
[15:32:38.514]   - Field: 'calls'
[15:32:38.514]   - Field: 'globals'
[15:32:38.514]   - Field: 'stdout'
[15:32:38.515]   - Field: 'earlySignal'
[15:32:38.515]   - Field: 'lazy'
[15:32:38.515]   - Field: 'state'
[15:32:38.515] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:38.516] - Launch lazy future ...
[15:32:38.516] Packages needed by the future expression (n = 0): <none>
[15:32:38.517] Packages needed by future strategies (n = 0): <none>
[15:32:38.518] {
[15:32:38.518]     {
[15:32:38.518]         {
[15:32:38.518]             ...future.startTime <- base::Sys.time()
[15:32:38.518]             {
[15:32:38.518]                 {
[15:32:38.518]                   {
[15:32:38.518]                     {
[15:32:38.518]                       base::local({
[15:32:38.518]                         has_future <- base::requireNamespace("future", 
[15:32:38.518]                           quietly = TRUE)
[15:32:38.518]                         if (has_future) {
[15:32:38.518]                           ns <- base::getNamespace("future")
[15:32:38.518]                           version <- ns[[".package"]][["version"]]
[15:32:38.518]                           if (is.null(version)) 
[15:32:38.518]                             version <- utils::packageVersion("future")
[15:32:38.518]                         }
[15:32:38.518]                         else {
[15:32:38.518]                           version <- NULL
[15:32:38.518]                         }
[15:32:38.518]                         if (!has_future || version < "1.8.0") {
[15:32:38.518]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:38.518]                             "", base::R.version$version.string), 
[15:32:38.518]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:38.518]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:38.518]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:38.518]                               "release", "version")], collapse = " "), 
[15:32:38.518]                             hostname = base::Sys.info()[["nodename"]])
[15:32:38.518]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:38.518]                             info)
[15:32:38.518]                           info <- base::paste(info, collapse = "; ")
[15:32:38.518]                           if (!has_future) {
[15:32:38.518]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:38.518]                               info)
[15:32:38.518]                           }
[15:32:38.518]                           else {
[15:32:38.518]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:38.518]                               info, version)
[15:32:38.518]                           }
[15:32:38.518]                           base::stop(msg)
[15:32:38.518]                         }
[15:32:38.518]                       })
[15:32:38.518]                     }
[15:32:38.518]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:38.518]                     base::options(mc.cores = 1L)
[15:32:38.518]                   }
[15:32:38.518]                   ...future.strategy.old <- future::plan("list")
[15:32:38.518]                   options(future.plan = NULL)
[15:32:38.518]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:38.518]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:38.518]                 }
[15:32:38.518]                 ...future.workdir <- getwd()
[15:32:38.518]             }
[15:32:38.518]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:38.518]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:38.518]         }
[15:32:38.518]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:38.518]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:38.518]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:38.518]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:38.518]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:38.518]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:38.518]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:38.518]             base::names(...future.oldOptions))
[15:32:38.518]     }
[15:32:38.518]     if (FALSE) {
[15:32:38.518]     }
[15:32:38.518]     else {
[15:32:38.518]         if (TRUE) {
[15:32:38.518]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:38.518]                 open = "w")
[15:32:38.518]         }
[15:32:38.518]         else {
[15:32:38.518]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:38.518]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:38.518]         }
[15:32:38.518]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:38.518]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:38.518]             base::sink(type = "output", split = FALSE)
[15:32:38.518]             base::close(...future.stdout)
[15:32:38.518]         }, add = TRUE)
[15:32:38.518]     }
[15:32:38.518]     ...future.frame <- base::sys.nframe()
[15:32:38.518]     ...future.conditions <- base::list()
[15:32:38.518]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:38.518]     if (FALSE) {
[15:32:38.518]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:38.518]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:38.518]     }
[15:32:38.518]     ...future.result <- base::tryCatch({
[15:32:38.518]         base::withCallingHandlers({
[15:32:38.518]             ...future.value <- base::withVisible(base::local({
[15:32:38.518]                 ...future.makeSendCondition <- base::local({
[15:32:38.518]                   sendCondition <- NULL
[15:32:38.518]                   function(frame = 1L) {
[15:32:38.518]                     if (is.function(sendCondition)) 
[15:32:38.518]                       return(sendCondition)
[15:32:38.518]                     ns <- getNamespace("parallel")
[15:32:38.518]                     if (exists("sendData", mode = "function", 
[15:32:38.518]                       envir = ns)) {
[15:32:38.518]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:38.518]                         envir = ns)
[15:32:38.518]                       envir <- sys.frame(frame)
[15:32:38.518]                       master <- NULL
[15:32:38.518]                       while (!identical(envir, .GlobalEnv) && 
[15:32:38.518]                         !identical(envir, emptyenv())) {
[15:32:38.518]                         if (exists("master", mode = "list", envir = envir, 
[15:32:38.518]                           inherits = FALSE)) {
[15:32:38.518]                           master <- get("master", mode = "list", 
[15:32:38.518]                             envir = envir, inherits = FALSE)
[15:32:38.518]                           if (inherits(master, c("SOCKnode", 
[15:32:38.518]                             "SOCK0node"))) {
[15:32:38.518]                             sendCondition <<- function(cond) {
[15:32:38.518]                               data <- list(type = "VALUE", value = cond, 
[15:32:38.518]                                 success = TRUE)
[15:32:38.518]                               parallel_sendData(master, data)
[15:32:38.518]                             }
[15:32:38.518]                             return(sendCondition)
[15:32:38.518]                           }
[15:32:38.518]                         }
[15:32:38.518]                         frame <- frame + 1L
[15:32:38.518]                         envir <- sys.frame(frame)
[15:32:38.518]                       }
[15:32:38.518]                     }
[15:32:38.518]                     sendCondition <<- function(cond) NULL
[15:32:38.518]                   }
[15:32:38.518]                 })
[15:32:38.518]                 withCallingHandlers({
[15:32:38.518]                   {
[15:32:38.518]                     do.call(function(...) {
[15:32:38.518]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:38.518]                       if (!identical(...future.globals.maxSize.org, 
[15:32:38.518]                         ...future.globals.maxSize)) {
[15:32:38.518]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:38.518]                         on.exit(options(oopts), add = TRUE)
[15:32:38.518]                       }
[15:32:38.518]                       {
[15:32:38.518]                         lapply(seq_along(...future.elements_ii), 
[15:32:38.518]                           FUN = function(jj) {
[15:32:38.518]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:38.518]                             ...future.FUN(...future.X_jj, ...)
[15:32:38.518]                           })
[15:32:38.518]                       }
[15:32:38.518]                     }, args = future.call.arguments)
[15:32:38.518]                   }
[15:32:38.518]                 }, immediateCondition = function(cond) {
[15:32:38.518]                   sendCondition <- ...future.makeSendCondition()
[15:32:38.518]                   sendCondition(cond)
[15:32:38.518]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:38.518]                   {
[15:32:38.518]                     inherits <- base::inherits
[15:32:38.518]                     invokeRestart <- base::invokeRestart
[15:32:38.518]                     is.null <- base::is.null
[15:32:38.518]                     muffled <- FALSE
[15:32:38.518]                     if (inherits(cond, "message")) {
[15:32:38.518]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:38.518]                       if (muffled) 
[15:32:38.518]                         invokeRestart("muffleMessage")
[15:32:38.518]                     }
[15:32:38.518]                     else if (inherits(cond, "warning")) {
[15:32:38.518]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:38.518]                       if (muffled) 
[15:32:38.518]                         invokeRestart("muffleWarning")
[15:32:38.518]                     }
[15:32:38.518]                     else if (inherits(cond, "condition")) {
[15:32:38.518]                       if (!is.null(pattern)) {
[15:32:38.518]                         computeRestarts <- base::computeRestarts
[15:32:38.518]                         grepl <- base::grepl
[15:32:38.518]                         restarts <- computeRestarts(cond)
[15:32:38.518]                         for (restart in restarts) {
[15:32:38.518]                           name <- restart$name
[15:32:38.518]                           if (is.null(name)) 
[15:32:38.518]                             next
[15:32:38.518]                           if (!grepl(pattern, name)) 
[15:32:38.518]                             next
[15:32:38.518]                           invokeRestart(restart)
[15:32:38.518]                           muffled <- TRUE
[15:32:38.518]                           break
[15:32:38.518]                         }
[15:32:38.518]                       }
[15:32:38.518]                     }
[15:32:38.518]                     invisible(muffled)
[15:32:38.518]                   }
[15:32:38.518]                   muffleCondition(cond)
[15:32:38.518]                 })
[15:32:38.518]             }))
[15:32:38.518]             future::FutureResult(value = ...future.value$value, 
[15:32:38.518]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:38.518]                   ...future.rng), globalenv = if (FALSE) 
[15:32:38.518]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:38.518]                     ...future.globalenv.names))
[15:32:38.518]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:38.518]         }, condition = base::local({
[15:32:38.518]             c <- base::c
[15:32:38.518]             inherits <- base::inherits
[15:32:38.518]             invokeRestart <- base::invokeRestart
[15:32:38.518]             length <- base::length
[15:32:38.518]             list <- base::list
[15:32:38.518]             seq.int <- base::seq.int
[15:32:38.518]             signalCondition <- base::signalCondition
[15:32:38.518]             sys.calls <- base::sys.calls
[15:32:38.518]             `[[` <- base::`[[`
[15:32:38.518]             `+` <- base::`+`
[15:32:38.518]             `<<-` <- base::`<<-`
[15:32:38.518]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:38.518]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:38.518]                   3L)]
[15:32:38.518]             }
[15:32:38.518]             function(cond) {
[15:32:38.518]                 is_error <- inherits(cond, "error")
[15:32:38.518]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:38.518]                   NULL)
[15:32:38.518]                 if (is_error) {
[15:32:38.518]                   sessionInformation <- function() {
[15:32:38.518]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:38.518]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:38.518]                       search = base::search(), system = base::Sys.info())
[15:32:38.518]                   }
[15:32:38.518]                   ...future.conditions[[length(...future.conditions) + 
[15:32:38.518]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:38.518]                     cond$call), session = sessionInformation(), 
[15:32:38.518]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:38.518]                   signalCondition(cond)
[15:32:38.518]                 }
[15:32:38.518]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:38.518]                 "immediateCondition"))) {
[15:32:38.518]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:38.518]                   ...future.conditions[[length(...future.conditions) + 
[15:32:38.518]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:38.518]                   if (TRUE && !signal) {
[15:32:38.518]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:38.518]                     {
[15:32:38.518]                       inherits <- base::inherits
[15:32:38.518]                       invokeRestart <- base::invokeRestart
[15:32:38.518]                       is.null <- base::is.null
[15:32:38.518]                       muffled <- FALSE
[15:32:38.518]                       if (inherits(cond, "message")) {
[15:32:38.518]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:38.518]                         if (muffled) 
[15:32:38.518]                           invokeRestart("muffleMessage")
[15:32:38.518]                       }
[15:32:38.518]                       else if (inherits(cond, "warning")) {
[15:32:38.518]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:38.518]                         if (muffled) 
[15:32:38.518]                           invokeRestart("muffleWarning")
[15:32:38.518]                       }
[15:32:38.518]                       else if (inherits(cond, "condition")) {
[15:32:38.518]                         if (!is.null(pattern)) {
[15:32:38.518]                           computeRestarts <- base::computeRestarts
[15:32:38.518]                           grepl <- base::grepl
[15:32:38.518]                           restarts <- computeRestarts(cond)
[15:32:38.518]                           for (restart in restarts) {
[15:32:38.518]                             name <- restart$name
[15:32:38.518]                             if (is.null(name)) 
[15:32:38.518]                               next
[15:32:38.518]                             if (!grepl(pattern, name)) 
[15:32:38.518]                               next
[15:32:38.518]                             invokeRestart(restart)
[15:32:38.518]                             muffled <- TRUE
[15:32:38.518]                             break
[15:32:38.518]                           }
[15:32:38.518]                         }
[15:32:38.518]                       }
[15:32:38.518]                       invisible(muffled)
[15:32:38.518]                     }
[15:32:38.518]                     muffleCondition(cond, pattern = "^muffle")
[15:32:38.518]                   }
[15:32:38.518]                 }
[15:32:38.518]                 else {
[15:32:38.518]                   if (TRUE) {
[15:32:38.518]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:38.518]                     {
[15:32:38.518]                       inherits <- base::inherits
[15:32:38.518]                       invokeRestart <- base::invokeRestart
[15:32:38.518]                       is.null <- base::is.null
[15:32:38.518]                       muffled <- FALSE
[15:32:38.518]                       if (inherits(cond, "message")) {
[15:32:38.518]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:38.518]                         if (muffled) 
[15:32:38.518]                           invokeRestart("muffleMessage")
[15:32:38.518]                       }
[15:32:38.518]                       else if (inherits(cond, "warning")) {
[15:32:38.518]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:38.518]                         if (muffled) 
[15:32:38.518]                           invokeRestart("muffleWarning")
[15:32:38.518]                       }
[15:32:38.518]                       else if (inherits(cond, "condition")) {
[15:32:38.518]                         if (!is.null(pattern)) {
[15:32:38.518]                           computeRestarts <- base::computeRestarts
[15:32:38.518]                           grepl <- base::grepl
[15:32:38.518]                           restarts <- computeRestarts(cond)
[15:32:38.518]                           for (restart in restarts) {
[15:32:38.518]                             name <- restart$name
[15:32:38.518]                             if (is.null(name)) 
[15:32:38.518]                               next
[15:32:38.518]                             if (!grepl(pattern, name)) 
[15:32:38.518]                               next
[15:32:38.518]                             invokeRestart(restart)
[15:32:38.518]                             muffled <- TRUE
[15:32:38.518]                             break
[15:32:38.518]                           }
[15:32:38.518]                         }
[15:32:38.518]                       }
[15:32:38.518]                       invisible(muffled)
[15:32:38.518]                     }
[15:32:38.518]                     muffleCondition(cond, pattern = "^muffle")
[15:32:38.518]                   }
[15:32:38.518]                 }
[15:32:38.518]             }
[15:32:38.518]         }))
[15:32:38.518]     }, error = function(ex) {
[15:32:38.518]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:38.518]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:38.518]                 ...future.rng), started = ...future.startTime, 
[15:32:38.518]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:38.518]             version = "1.8"), class = "FutureResult")
[15:32:38.518]     }, finally = {
[15:32:38.518]         if (!identical(...future.workdir, getwd())) 
[15:32:38.518]             setwd(...future.workdir)
[15:32:38.518]         {
[15:32:38.518]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:38.518]                 ...future.oldOptions$nwarnings <- NULL
[15:32:38.518]             }
[15:32:38.518]             base::options(...future.oldOptions)
[15:32:38.518]             if (.Platform$OS.type == "windows") {
[15:32:38.518]                 old_names <- names(...future.oldEnvVars)
[15:32:38.518]                 envs <- base::Sys.getenv()
[15:32:38.518]                 names <- names(envs)
[15:32:38.518]                 common <- intersect(names, old_names)
[15:32:38.518]                 added <- setdiff(names, old_names)
[15:32:38.518]                 removed <- setdiff(old_names, names)
[15:32:38.518]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:38.518]                   envs[common]]
[15:32:38.518]                 NAMES <- toupper(changed)
[15:32:38.518]                 args <- list()
[15:32:38.518]                 for (kk in seq_along(NAMES)) {
[15:32:38.518]                   name <- changed[[kk]]
[15:32:38.518]                   NAME <- NAMES[[kk]]
[15:32:38.518]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:38.518]                     next
[15:32:38.518]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:38.518]                 }
[15:32:38.518]                 NAMES <- toupper(added)
[15:32:38.518]                 for (kk in seq_along(NAMES)) {
[15:32:38.518]                   name <- added[[kk]]
[15:32:38.518]                   NAME <- NAMES[[kk]]
[15:32:38.518]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:38.518]                     next
[15:32:38.518]                   args[[name]] <- ""
[15:32:38.518]                 }
[15:32:38.518]                 NAMES <- toupper(removed)
[15:32:38.518]                 for (kk in seq_along(NAMES)) {
[15:32:38.518]                   name <- removed[[kk]]
[15:32:38.518]                   NAME <- NAMES[[kk]]
[15:32:38.518]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:38.518]                     next
[15:32:38.518]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:38.518]                 }
[15:32:38.518]                 if (length(args) > 0) 
[15:32:38.518]                   base::do.call(base::Sys.setenv, args = args)
[15:32:38.518]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:38.518]             }
[15:32:38.518]             else {
[15:32:38.518]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:38.518]             }
[15:32:38.518]             {
[15:32:38.518]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:38.518]                   0L) {
[15:32:38.518]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:38.518]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:38.518]                   base::options(opts)
[15:32:38.518]                 }
[15:32:38.518]                 {
[15:32:38.518]                   {
[15:32:38.518]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:38.518]                     NULL
[15:32:38.518]                   }
[15:32:38.518]                   options(future.plan = NULL)
[15:32:38.518]                   if (is.na(NA_character_)) 
[15:32:38.518]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:38.518]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:38.518]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:38.518]                     .init = FALSE)
[15:32:38.518]                 }
[15:32:38.518]             }
[15:32:38.518]         }
[15:32:38.518]     })
[15:32:38.518]     if (TRUE) {
[15:32:38.518]         base::sink(type = "output", split = FALSE)
[15:32:38.518]         if (TRUE) {
[15:32:38.518]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:38.518]         }
[15:32:38.518]         else {
[15:32:38.518]             ...future.result["stdout"] <- base::list(NULL)
[15:32:38.518]         }
[15:32:38.518]         base::close(...future.stdout)
[15:32:38.518]         ...future.stdout <- NULL
[15:32:38.518]     }
[15:32:38.518]     ...future.result$conditions <- ...future.conditions
[15:32:38.518]     ...future.result$finished <- base::Sys.time()
[15:32:38.518]     ...future.result
[15:32:38.518] }
[15:32:38.526] Exporting 5 global objects (848 bytes) to cluster node #1 ...
[15:32:38.527] Exporting '...future.FUN' (848 bytes) to cluster node #1 ...
[15:32:38.527] Exporting '...future.FUN' (848 bytes) to cluster node #1 ... DONE
[15:32:38.528] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:38.529] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:38.529] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:38.530] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:38.530] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:38.531] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:38.531] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:38.532] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:38.532] Exporting 5 global objects (848 bytes) to cluster node #1 ... DONE
[15:32:38.533] MultisessionFuture started
[15:32:38.534] - Launch lazy future ... done
[15:32:38.534] run() for 'MultisessionFuture' ... done
[15:32:38.534] Created future:
[15:32:38.562] receiveMessageFromWorker() for ClusterFuture ...
[15:32:38.562] - Validating connection of MultisessionFuture
[15:32:38.563] - received message: FutureResult
[15:32:38.563] - Received FutureResult
[15:32:38.563] - Erased future from FutureRegistry
[15:32:38.563] result() for ClusterFuture ...
[15:32:38.563] - result already collected: FutureResult
[15:32:38.564] result() for ClusterFuture ... done
[15:32:38.564] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:38.535] MultisessionFuture:
[15:32:38.535] Label: 'future_sapply-2'
[15:32:38.535] Expression:
[15:32:38.535] {
[15:32:38.535]     do.call(function(...) {
[15:32:38.535]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:38.535]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:38.535]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:38.535]             on.exit(options(oopts), add = TRUE)
[15:32:38.535]         }
[15:32:38.535]         {
[15:32:38.535]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:38.535]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:38.535]                 ...future.FUN(...future.X_jj, ...)
[15:32:38.535]             })
[15:32:38.535]         }
[15:32:38.535]     }, args = future.call.arguments)
[15:32:38.535] }
[15:32:38.535] Lazy evaluation: FALSE
[15:32:38.535] Asynchronous evaluation: TRUE
[15:32:38.535] Local evaluation: TRUE
[15:32:38.535] Environment: R_GlobalEnv
[15:32:38.535] Capture standard output: TRUE
[15:32:38.535] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:38.535] Globals: 5 objects totaling 960 bytes (function '...future.FUN' of 848 bytes, 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)
[15:32:38.535] Packages: <none>
[15:32:38.535] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:38.535] Resolved: TRUE
[15:32:38.535] Value: <not collected>
[15:32:38.535] Conditions captured: <none>
[15:32:38.535] Early signaling: FALSE
[15:32:38.535] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:38.535] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:38.565] Chunk #2 of 2 ... DONE
[15:32:38.565] Launching 2 futures (chunks) ... DONE
[15:32:38.565] Resolving 2 futures (chunks) ...
[15:32:38.565] resolve() on list ...
[15:32:38.565]  recursive: 0
[15:32:38.566]  length: 2
[15:32:38.566] 
[15:32:38.566] Future #1
[15:32:38.567] result() for ClusterFuture ...
[15:32:38.567] - result already collected: FutureResult
[15:32:38.567] result() for ClusterFuture ... done
[15:32:38.567] result() for ClusterFuture ...
[15:32:38.568] - result already collected: FutureResult
[15:32:38.568] result() for ClusterFuture ... done
[15:32:38.568] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:38.569] - nx: 2
[15:32:38.569] - relay: TRUE
[15:32:38.569] - stdout: TRUE
[15:32:38.569] - signal: TRUE
[15:32:38.570] - resignal: FALSE
[15:32:38.570] - force: TRUE
[15:32:38.570] - relayed: [n=2] FALSE, FALSE
[15:32:38.570] - queued futures: [n=2] FALSE, FALSE
[15:32:38.571]  - until=1
[15:32:38.571]  - relaying element #1
[15:32:38.571] result() for ClusterFuture ...
[15:32:38.572] - result already collected: FutureResult
[15:32:38.572] result() for ClusterFuture ... done
[15:32:38.572] result() for ClusterFuture ...
[15:32:38.572] - result already collected: FutureResult
[15:32:38.573] result() for ClusterFuture ... done
[15:32:38.573] result() for ClusterFuture ...
[15:32:38.573] - result already collected: FutureResult
[15:32:38.574] result() for ClusterFuture ... done
[15:32:38.574] result() for ClusterFuture ...
[15:32:38.574] - result already collected: FutureResult
[15:32:38.574] result() for ClusterFuture ... done
[15:32:38.575] - relayed: [n=2] TRUE, FALSE
[15:32:38.575] - queued futures: [n=2] TRUE, FALSE
[15:32:38.575] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:38.576]  length: 1 (resolved future 1)
[15:32:38.576] Future #2
[15:32:38.576] result() for ClusterFuture ...
[15:32:38.577] - result already collected: FutureResult
[15:32:38.577] result() for ClusterFuture ... done
[15:32:38.577] result() for ClusterFuture ...
[15:32:38.577] - result already collected: FutureResult
[15:32:38.578] result() for ClusterFuture ... done
[15:32:38.578] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:38.578] - nx: 2
[15:32:38.579] - relay: TRUE
[15:32:38.579] - stdout: TRUE
[15:32:38.579] - signal: TRUE
[15:32:38.579] - resignal: FALSE
[15:32:38.580] - force: TRUE
[15:32:38.580] - relayed: [n=2] TRUE, FALSE
[15:32:38.580] - queued futures: [n=2] TRUE, FALSE
[15:32:38.580]  - until=2
[15:32:38.581]  - relaying element #2
[15:32:38.581] result() for ClusterFuture ...
[15:32:38.581] - result already collected: FutureResult
[15:32:38.581] result() for ClusterFuture ... done
[15:32:38.582] result() for ClusterFuture ...
[15:32:38.582] - result already collected: FutureResult
[15:32:38.582] result() for ClusterFuture ... done
[15:32:38.583] result() for ClusterFuture ...
[15:32:38.583] - result already collected: FutureResult
[15:32:38.583] result() for ClusterFuture ... done
[15:32:38.584] result() for ClusterFuture ...
[15:32:38.584] - result already collected: FutureResult
[15:32:38.584] result() for ClusterFuture ... done
[15:32:38.584] - relayed: [n=2] TRUE, TRUE
[15:32:38.585] - queued futures: [n=2] TRUE, TRUE
[15:32:38.585] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:38.585]  length: 0 (resolved future 2)
[15:32:38.586] Relaying remaining futures
[15:32:38.586] signalConditionsASAP(NULL, pos=0) ...
[15:32:38.586] - nx: 2
[15:32:38.586] - relay: TRUE
[15:32:38.587] - stdout: TRUE
[15:32:38.587] - signal: TRUE
[15:32:38.587] - resignal: FALSE
[15:32:38.587] - force: TRUE
[15:32:38.588] - relayed: [n=2] TRUE, TRUE
[15:32:38.588] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:38.588] - relayed: [n=2] TRUE, TRUE
[15:32:38.589] - queued futures: [n=2] TRUE, TRUE
[15:32:38.589] signalConditionsASAP(NULL, pos=0) ... done
[15:32:38.589] resolve() on list ... DONE
[15:32:38.590] result() for ClusterFuture ...
[15:32:38.590] - result already collected: FutureResult
[15:32:38.590] result() for ClusterFuture ... done
[15:32:38.590] result() for ClusterFuture ...
[15:32:38.591] - result already collected: FutureResult
[15:32:38.591] result() for ClusterFuture ... done
[15:32:38.591] result() for ClusterFuture ...
[15:32:38.592] - result already collected: FutureResult
[15:32:38.592] result() for ClusterFuture ... done
[15:32:38.592] result() for ClusterFuture ...
[15:32:38.592] - result already collected: FutureResult
[15:32:38.593] result() for ClusterFuture ... done
[15:32:38.593]  - Number of value chunks collected: 2
[15:32:38.593] Resolving 2 futures (chunks) ... DONE
[15:32:38.593] Reducing values from 2 chunks ...
[15:32:38.594]  - Number of values collected after concatenation: 4
[15:32:38.594]  - Number of values expected: 4
[15:32:38.594] Reducing values from 2 chunks ... DONE
[15:32:38.594] future_lapply() ... DONE
List of 2
 $ y0: Named num [1:4] 50 60 70 80
  ..- attr(*, "names")= chr [1:4] "A" "B" "C" "D"
 $ y1: Named num [1:4] 50 60 70 80
  ..- attr(*, "names")= chr [1:4] "A" "B" "C" "D"
[15:32:38.597] future_lapply() ...
[15:32:38.601] Number of chunks: 2
[15:32:38.602] getGlobalsAndPackagesXApply() ...
[15:32:38.602]  - future.globals: TRUE
[15:32:38.602] getGlobalsAndPackages() ...
[15:32:38.602] Searching for globals...
[15:32:38.604] - globals found: [2] 'FUN', 'UseMethod'
[15:32:38.604] Searching for globals ... DONE
[15:32:38.605] Resolving globals: FALSE
[15:32:38.605] The total size of the 1 globals is 1.22 KiB (1248 bytes)
[15:32:38.606] The total size of the 1 globals exported for future expression ('FUN()') is 1.22 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.22 KiB of class 'function')
[15:32:38.606] - globals: [1] 'FUN'
[15:32:38.606] 
[15:32:38.607] getGlobalsAndPackages() ... DONE
[15:32:38.607]  - globals found/used: [n=1] 'FUN'
[15:32:38.607]  - needed namespaces: [n=0] 
[15:32:38.607] Finding globals ... DONE
[15:32:38.607]  - use_args: TRUE
[15:32:38.607]  - Getting '...' globals ...
[15:32:38.608] resolve() on list ...
[15:32:38.608]  recursive: 0
[15:32:38.608]  length: 1
[15:32:38.608]  elements: '...'
[15:32:38.609]  length: 0 (resolved future 1)
[15:32:38.609] resolve() on list ... DONE
[15:32:38.609]    - '...' content: [n=0] 
[15:32:38.609] List of 1
[15:32:38.609]  $ ...: list()
[15:32:38.609]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:38.609]  - attr(*, "where")=List of 1
[15:32:38.609]   ..$ ...:<environment: 0x00000276e4e18298> 
[15:32:38.609]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:38.609]  - attr(*, "resolved")= logi TRUE
[15:32:38.609]  - attr(*, "total_size")= num NA
[15:32:38.614]  - Getting '...' globals ... DONE
[15:32:38.614] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:38.614] List of 2
[15:32:38.614]  $ ...future.FUN:function (x, ...)  
[15:32:38.614]  $ ...          : list()
[15:32:38.614]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:38.614]  - attr(*, "where")=List of 2
[15:32:38.614]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:38.614]   ..$ ...          :<environment: 0x00000276e4e18298> 
[15:32:38.614]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:38.614]  - attr(*, "resolved")= logi FALSE
[15:32:38.614]  - attr(*, "total_size")= num 1248
[15:32:38.625] Packages to be attached in all futures: [n=0] 
[15:32:38.625] getGlobalsAndPackagesXApply() ... DONE
[15:32:38.626] Number of futures (= number of chunks): 2
[15:32:38.626] Launching 2 futures (chunks) ...
[15:32:38.626] Chunk #1 of 2 ...
[15:32:38.626]  - Finding globals in 'X' for chunk #1 ...
[15:32:38.627] getGlobalsAndPackages() ...
[15:32:38.627] Searching for globals...
[15:32:38.627] 
[15:32:38.628] Searching for globals ... DONE
[15:32:38.628] - globals: [0] <none>
[15:32:38.628] getGlobalsAndPackages() ... DONE
[15:32:38.628]    + additional globals found: [n=0] 
[15:32:38.629]    + additional namespaces needed: [n=0] 
[15:32:38.629]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:38.629]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:38.629]  - seeds: <none>
[15:32:38.630]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:38.630] getGlobalsAndPackages() ...
[15:32:38.630] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:38.630] Resolving globals: FALSE
[15:32:38.631] Tweak future expression to call with '...' arguments ...
[15:32:38.631] {
[15:32:38.631]     do.call(function(...) {
[15:32:38.631]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:38.631]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:38.631]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:38.631]             on.exit(options(oopts), add = TRUE)
[15:32:38.631]         }
[15:32:38.631]         {
[15:32:38.631]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:38.631]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:38.631]                 ...future.FUN(...future.X_jj, ...)
[15:32:38.631]             })
[15:32:38.631]         }
[15:32:38.631]     }, args = future.call.arguments)
[15:32:38.631] }
[15:32:38.632] Tweak future expression to call with '...' arguments ... DONE
[15:32:38.632] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:38.633] 
[15:32:38.633] getGlobalsAndPackages() ... DONE
[15:32:38.634] run() for 'Future' ...
[15:32:38.634] - state: 'created'
[15:32:38.634] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:38.651] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:38.652] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:38.652]   - Field: 'node'
[15:32:38.652]   - Field: 'label'
[15:32:38.653]   - Field: 'local'
[15:32:38.653]   - Field: 'owner'
[15:32:38.653]   - Field: 'envir'
[15:32:38.653]   - Field: 'workers'
[15:32:38.654]   - Field: 'packages'
[15:32:38.654]   - Field: 'gc'
[15:32:38.654]   - Field: 'conditions'
[15:32:38.655]   - Field: 'persistent'
[15:32:38.655]   - Field: 'expr'
[15:32:38.655]   - Field: 'uuid'
[15:32:38.655]   - Field: 'seed'
[15:32:38.656]   - Field: 'version'
[15:32:38.656]   - Field: 'result'
[15:32:38.656]   - Field: 'asynchronous'
[15:32:38.656]   - Field: 'calls'
[15:32:38.657]   - Field: 'globals'
[15:32:38.657]   - Field: 'stdout'
[15:32:38.657]   - Field: 'earlySignal'
[15:32:38.658]   - Field: 'lazy'
[15:32:38.658]   - Field: 'state'
[15:32:38.658] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:38.659] - Launch lazy future ...
[15:32:38.659] Packages needed by the future expression (n = 0): <none>
[15:32:38.660] Packages needed by future strategies (n = 0): <none>
[15:32:38.661] {
[15:32:38.661]     {
[15:32:38.661]         {
[15:32:38.661]             ...future.startTime <- base::Sys.time()
[15:32:38.661]             {
[15:32:38.661]                 {
[15:32:38.661]                   {
[15:32:38.661]                     {
[15:32:38.661]                       base::local({
[15:32:38.661]                         has_future <- base::requireNamespace("future", 
[15:32:38.661]                           quietly = TRUE)
[15:32:38.661]                         if (has_future) {
[15:32:38.661]                           ns <- base::getNamespace("future")
[15:32:38.661]                           version <- ns[[".package"]][["version"]]
[15:32:38.661]                           if (is.null(version)) 
[15:32:38.661]                             version <- utils::packageVersion("future")
[15:32:38.661]                         }
[15:32:38.661]                         else {
[15:32:38.661]                           version <- NULL
[15:32:38.661]                         }
[15:32:38.661]                         if (!has_future || version < "1.8.0") {
[15:32:38.661]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:38.661]                             "", base::R.version$version.string), 
[15:32:38.661]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:38.661]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:38.661]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:38.661]                               "release", "version")], collapse = " "), 
[15:32:38.661]                             hostname = base::Sys.info()[["nodename"]])
[15:32:38.661]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:38.661]                             info)
[15:32:38.661]                           info <- base::paste(info, collapse = "; ")
[15:32:38.661]                           if (!has_future) {
[15:32:38.661]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:38.661]                               info)
[15:32:38.661]                           }
[15:32:38.661]                           else {
[15:32:38.661]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:38.661]                               info, version)
[15:32:38.661]                           }
[15:32:38.661]                           base::stop(msg)
[15:32:38.661]                         }
[15:32:38.661]                       })
[15:32:38.661]                     }
[15:32:38.661]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:38.661]                     base::options(mc.cores = 1L)
[15:32:38.661]                   }
[15:32:38.661]                   ...future.strategy.old <- future::plan("list")
[15:32:38.661]                   options(future.plan = NULL)
[15:32:38.661]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:38.661]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:38.661]                 }
[15:32:38.661]                 ...future.workdir <- getwd()
[15:32:38.661]             }
[15:32:38.661]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:38.661]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:38.661]         }
[15:32:38.661]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:38.661]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:38.661]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:38.661]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:38.661]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:38.661]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:38.661]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:38.661]             base::names(...future.oldOptions))
[15:32:38.661]     }
[15:32:38.661]     if (FALSE) {
[15:32:38.661]     }
[15:32:38.661]     else {
[15:32:38.661]         if (TRUE) {
[15:32:38.661]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:38.661]                 open = "w")
[15:32:38.661]         }
[15:32:38.661]         else {
[15:32:38.661]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:38.661]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:38.661]         }
[15:32:38.661]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:38.661]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:38.661]             base::sink(type = "output", split = FALSE)
[15:32:38.661]             base::close(...future.stdout)
[15:32:38.661]         }, add = TRUE)
[15:32:38.661]     }
[15:32:38.661]     ...future.frame <- base::sys.nframe()
[15:32:38.661]     ...future.conditions <- base::list()
[15:32:38.661]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:38.661]     if (FALSE) {
[15:32:38.661]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:38.661]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:38.661]     }
[15:32:38.661]     ...future.result <- base::tryCatch({
[15:32:38.661]         base::withCallingHandlers({
[15:32:38.661]             ...future.value <- base::withVisible(base::local({
[15:32:38.661]                 ...future.makeSendCondition <- base::local({
[15:32:38.661]                   sendCondition <- NULL
[15:32:38.661]                   function(frame = 1L) {
[15:32:38.661]                     if (is.function(sendCondition)) 
[15:32:38.661]                       return(sendCondition)
[15:32:38.661]                     ns <- getNamespace("parallel")
[15:32:38.661]                     if (exists("sendData", mode = "function", 
[15:32:38.661]                       envir = ns)) {
[15:32:38.661]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:38.661]                         envir = ns)
[15:32:38.661]                       envir <- sys.frame(frame)
[15:32:38.661]                       master <- NULL
[15:32:38.661]                       while (!identical(envir, .GlobalEnv) && 
[15:32:38.661]                         !identical(envir, emptyenv())) {
[15:32:38.661]                         if (exists("master", mode = "list", envir = envir, 
[15:32:38.661]                           inherits = FALSE)) {
[15:32:38.661]                           master <- get("master", mode = "list", 
[15:32:38.661]                             envir = envir, inherits = FALSE)
[15:32:38.661]                           if (inherits(master, c("SOCKnode", 
[15:32:38.661]                             "SOCK0node"))) {
[15:32:38.661]                             sendCondition <<- function(cond) {
[15:32:38.661]                               data <- list(type = "VALUE", value = cond, 
[15:32:38.661]                                 success = TRUE)
[15:32:38.661]                               parallel_sendData(master, data)
[15:32:38.661]                             }
[15:32:38.661]                             return(sendCondition)
[15:32:38.661]                           }
[15:32:38.661]                         }
[15:32:38.661]                         frame <- frame + 1L
[15:32:38.661]                         envir <- sys.frame(frame)
[15:32:38.661]                       }
[15:32:38.661]                     }
[15:32:38.661]                     sendCondition <<- function(cond) NULL
[15:32:38.661]                   }
[15:32:38.661]                 })
[15:32:38.661]                 withCallingHandlers({
[15:32:38.661]                   {
[15:32:38.661]                     do.call(function(...) {
[15:32:38.661]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:38.661]                       if (!identical(...future.globals.maxSize.org, 
[15:32:38.661]                         ...future.globals.maxSize)) {
[15:32:38.661]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:38.661]                         on.exit(options(oopts), add = TRUE)
[15:32:38.661]                       }
[15:32:38.661]                       {
[15:32:38.661]                         lapply(seq_along(...future.elements_ii), 
[15:32:38.661]                           FUN = function(jj) {
[15:32:38.661]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:38.661]                             ...future.FUN(...future.X_jj, ...)
[15:32:38.661]                           })
[15:32:38.661]                       }
[15:32:38.661]                     }, args = future.call.arguments)
[15:32:38.661]                   }
[15:32:38.661]                 }, immediateCondition = function(cond) {
[15:32:38.661]                   sendCondition <- ...future.makeSendCondition()
[15:32:38.661]                   sendCondition(cond)
[15:32:38.661]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:38.661]                   {
[15:32:38.661]                     inherits <- base::inherits
[15:32:38.661]                     invokeRestart <- base::invokeRestart
[15:32:38.661]                     is.null <- base::is.null
[15:32:38.661]                     muffled <- FALSE
[15:32:38.661]                     if (inherits(cond, "message")) {
[15:32:38.661]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:38.661]                       if (muffled) 
[15:32:38.661]                         invokeRestart("muffleMessage")
[15:32:38.661]                     }
[15:32:38.661]                     else if (inherits(cond, "warning")) {
[15:32:38.661]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:38.661]                       if (muffled) 
[15:32:38.661]                         invokeRestart("muffleWarning")
[15:32:38.661]                     }
[15:32:38.661]                     else if (inherits(cond, "condition")) {
[15:32:38.661]                       if (!is.null(pattern)) {
[15:32:38.661]                         computeRestarts <- base::computeRestarts
[15:32:38.661]                         grepl <- base::grepl
[15:32:38.661]                         restarts <- computeRestarts(cond)
[15:32:38.661]                         for (restart in restarts) {
[15:32:38.661]                           name <- restart$name
[15:32:38.661]                           if (is.null(name)) 
[15:32:38.661]                             next
[15:32:38.661]                           if (!grepl(pattern, name)) 
[15:32:38.661]                             next
[15:32:38.661]                           invokeRestart(restart)
[15:32:38.661]                           muffled <- TRUE
[15:32:38.661]                           break
[15:32:38.661]                         }
[15:32:38.661]                       }
[15:32:38.661]                     }
[15:32:38.661]                     invisible(muffled)
[15:32:38.661]                   }
[15:32:38.661]                   muffleCondition(cond)
[15:32:38.661]                 })
[15:32:38.661]             }))
[15:32:38.661]             future::FutureResult(value = ...future.value$value, 
[15:32:38.661]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:38.661]                   ...future.rng), globalenv = if (FALSE) 
[15:32:38.661]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:38.661]                     ...future.globalenv.names))
[15:32:38.661]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:38.661]         }, condition = base::local({
[15:32:38.661]             c <- base::c
[15:32:38.661]             inherits <- base::inherits
[15:32:38.661]             invokeRestart <- base::invokeRestart
[15:32:38.661]             length <- base::length
[15:32:38.661]             list <- base::list
[15:32:38.661]             seq.int <- base::seq.int
[15:32:38.661]             signalCondition <- base::signalCondition
[15:32:38.661]             sys.calls <- base::sys.calls
[15:32:38.661]             `[[` <- base::`[[`
[15:32:38.661]             `+` <- base::`+`
[15:32:38.661]             `<<-` <- base::`<<-`
[15:32:38.661]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:38.661]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:38.661]                   3L)]
[15:32:38.661]             }
[15:32:38.661]             function(cond) {
[15:32:38.661]                 is_error <- inherits(cond, "error")
[15:32:38.661]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:38.661]                   NULL)
[15:32:38.661]                 if (is_error) {
[15:32:38.661]                   sessionInformation <- function() {
[15:32:38.661]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:38.661]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:38.661]                       search = base::search(), system = base::Sys.info())
[15:32:38.661]                   }
[15:32:38.661]                   ...future.conditions[[length(...future.conditions) + 
[15:32:38.661]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:38.661]                     cond$call), session = sessionInformation(), 
[15:32:38.661]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:38.661]                   signalCondition(cond)
[15:32:38.661]                 }
[15:32:38.661]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:38.661]                 "immediateCondition"))) {
[15:32:38.661]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:38.661]                   ...future.conditions[[length(...future.conditions) + 
[15:32:38.661]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:38.661]                   if (TRUE && !signal) {
[15:32:38.661]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:38.661]                     {
[15:32:38.661]                       inherits <- base::inherits
[15:32:38.661]                       invokeRestart <- base::invokeRestart
[15:32:38.661]                       is.null <- base::is.null
[15:32:38.661]                       muffled <- FALSE
[15:32:38.661]                       if (inherits(cond, "message")) {
[15:32:38.661]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:38.661]                         if (muffled) 
[15:32:38.661]                           invokeRestart("muffleMessage")
[15:32:38.661]                       }
[15:32:38.661]                       else if (inherits(cond, "warning")) {
[15:32:38.661]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:38.661]                         if (muffled) 
[15:32:38.661]                           invokeRestart("muffleWarning")
[15:32:38.661]                       }
[15:32:38.661]                       else if (inherits(cond, "condition")) {
[15:32:38.661]                         if (!is.null(pattern)) {
[15:32:38.661]                           computeRestarts <- base::computeRestarts
[15:32:38.661]                           grepl <- base::grepl
[15:32:38.661]                           restarts <- computeRestarts(cond)
[15:32:38.661]                           for (restart in restarts) {
[15:32:38.661]                             name <- restart$name
[15:32:38.661]                             if (is.null(name)) 
[15:32:38.661]                               next
[15:32:38.661]                             if (!grepl(pattern, name)) 
[15:32:38.661]                               next
[15:32:38.661]                             invokeRestart(restart)
[15:32:38.661]                             muffled <- TRUE
[15:32:38.661]                             break
[15:32:38.661]                           }
[15:32:38.661]                         }
[15:32:38.661]                       }
[15:32:38.661]                       invisible(muffled)
[15:32:38.661]                     }
[15:32:38.661]                     muffleCondition(cond, pattern = "^muffle")
[15:32:38.661]                   }
[15:32:38.661]                 }
[15:32:38.661]                 else {
[15:32:38.661]                   if (TRUE) {
[15:32:38.661]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:38.661]                     {
[15:32:38.661]                       inherits <- base::inherits
[15:32:38.661]                       invokeRestart <- base::invokeRestart
[15:32:38.661]                       is.null <- base::is.null
[15:32:38.661]                       muffled <- FALSE
[15:32:38.661]                       if (inherits(cond, "message")) {
[15:32:38.661]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:38.661]                         if (muffled) 
[15:32:38.661]                           invokeRestart("muffleMessage")
[15:32:38.661]                       }
[15:32:38.661]                       else if (inherits(cond, "warning")) {
[15:32:38.661]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:38.661]                         if (muffled) 
[15:32:38.661]                           invokeRestart("muffleWarning")
[15:32:38.661]                       }
[15:32:38.661]                       else if (inherits(cond, "condition")) {
[15:32:38.661]                         if (!is.null(pattern)) {
[15:32:38.661]                           computeRestarts <- base::computeRestarts
[15:32:38.661]                           grepl <- base::grepl
[15:32:38.661]                           restarts <- computeRestarts(cond)
[15:32:38.661]                           for (restart in restarts) {
[15:32:38.661]                             name <- restart$name
[15:32:38.661]                             if (is.null(name)) 
[15:32:38.661]                               next
[15:32:38.661]                             if (!grepl(pattern, name)) 
[15:32:38.661]                               next
[15:32:38.661]                             invokeRestart(restart)
[15:32:38.661]                             muffled <- TRUE
[15:32:38.661]                             break
[15:32:38.661]                           }
[15:32:38.661]                         }
[15:32:38.661]                       }
[15:32:38.661]                       invisible(muffled)
[15:32:38.661]                     }
[15:32:38.661]                     muffleCondition(cond, pattern = "^muffle")
[15:32:38.661]                   }
[15:32:38.661]                 }
[15:32:38.661]             }
[15:32:38.661]         }))
[15:32:38.661]     }, error = function(ex) {
[15:32:38.661]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:38.661]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:38.661]                 ...future.rng), started = ...future.startTime, 
[15:32:38.661]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:38.661]             version = "1.8"), class = "FutureResult")
[15:32:38.661]     }, finally = {
[15:32:38.661]         if (!identical(...future.workdir, getwd())) 
[15:32:38.661]             setwd(...future.workdir)
[15:32:38.661]         {
[15:32:38.661]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:38.661]                 ...future.oldOptions$nwarnings <- NULL
[15:32:38.661]             }
[15:32:38.661]             base::options(...future.oldOptions)
[15:32:38.661]             if (.Platform$OS.type == "windows") {
[15:32:38.661]                 old_names <- names(...future.oldEnvVars)
[15:32:38.661]                 envs <- base::Sys.getenv()
[15:32:38.661]                 names <- names(envs)
[15:32:38.661]                 common <- intersect(names, old_names)
[15:32:38.661]                 added <- setdiff(names, old_names)
[15:32:38.661]                 removed <- setdiff(old_names, names)
[15:32:38.661]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:38.661]                   envs[common]]
[15:32:38.661]                 NAMES <- toupper(changed)
[15:32:38.661]                 args <- list()
[15:32:38.661]                 for (kk in seq_along(NAMES)) {
[15:32:38.661]                   name <- changed[[kk]]
[15:32:38.661]                   NAME <- NAMES[[kk]]
[15:32:38.661]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:38.661]                     next
[15:32:38.661]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:38.661]                 }
[15:32:38.661]                 NAMES <- toupper(added)
[15:32:38.661]                 for (kk in seq_along(NAMES)) {
[15:32:38.661]                   name <- added[[kk]]
[15:32:38.661]                   NAME <- NAMES[[kk]]
[15:32:38.661]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:38.661]                     next
[15:32:38.661]                   args[[name]] <- ""
[15:32:38.661]                 }
[15:32:38.661]                 NAMES <- toupper(removed)
[15:32:38.661]                 for (kk in seq_along(NAMES)) {
[15:32:38.661]                   name <- removed[[kk]]
[15:32:38.661]                   NAME <- NAMES[[kk]]
[15:32:38.661]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:38.661]                     next
[15:32:38.661]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:38.661]                 }
[15:32:38.661]                 if (length(args) > 0) 
[15:32:38.661]                   base::do.call(base::Sys.setenv, args = args)
[15:32:38.661]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:38.661]             }
[15:32:38.661]             else {
[15:32:38.661]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:38.661]             }
[15:32:38.661]             {
[15:32:38.661]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:38.661]                   0L) {
[15:32:38.661]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:38.661]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:38.661]                   base::options(opts)
[15:32:38.661]                 }
[15:32:38.661]                 {
[15:32:38.661]                   {
[15:32:38.661]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:38.661]                     NULL
[15:32:38.661]                   }
[15:32:38.661]                   options(future.plan = NULL)
[15:32:38.661]                   if (is.na(NA_character_)) 
[15:32:38.661]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:38.661]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:38.661]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:38.661]                     .init = FALSE)
[15:32:38.661]                 }
[15:32:38.661]             }
[15:32:38.661]         }
[15:32:38.661]     })
[15:32:38.661]     if (TRUE) {
[15:32:38.661]         base::sink(type = "output", split = FALSE)
[15:32:38.661]         if (TRUE) {
[15:32:38.661]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:38.661]         }
[15:32:38.661]         else {
[15:32:38.661]             ...future.result["stdout"] <- base::list(NULL)
[15:32:38.661]         }
[15:32:38.661]         base::close(...future.stdout)
[15:32:38.661]         ...future.stdout <- NULL
[15:32:38.661]     }
[15:32:38.661]     ...future.result$conditions <- ...future.conditions
[15:32:38.661]     ...future.result$finished <- base::Sys.time()
[15:32:38.661]     ...future.result
[15:32:38.661] }
[15:32:38.671] Exporting 5 global objects (1.22 KiB) to cluster node #1 ...
[15:32:38.671] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ...
[15:32:38.672] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ... DONE
[15:32:38.673] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:38.674] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:38.674] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:38.675] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:38.676] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:38.676] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:38.677] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:38.677] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:38.678] Exporting 5 global objects (1.22 KiB) to cluster node #1 ... DONE
[15:32:38.679] MultisessionFuture started
[15:32:38.679] - Launch lazy future ... done
[15:32:38.680] run() for 'MultisessionFuture' ... done
[15:32:38.680] Created future:
[15:32:38.707] receiveMessageFromWorker() for ClusterFuture ...
[15:32:38.707] - Validating connection of MultisessionFuture
[15:32:38.707] - received message: FutureResult
[15:32:38.708] - Received FutureResult
[15:32:38.708] - Erased future from FutureRegistry
[15:32:38.708] result() for ClusterFuture ...
[15:32:38.708] - result already collected: FutureResult
[15:32:38.708] result() for ClusterFuture ... done
[15:32:38.709] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:38.680] MultisessionFuture:
[15:32:38.680] Label: 'future_sapply-1'
[15:32:38.680] Expression:
[15:32:38.680] {
[15:32:38.680]     do.call(function(...) {
[15:32:38.680]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:38.680]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:38.680]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:38.680]             on.exit(options(oopts), add = TRUE)
[15:32:38.680]         }
[15:32:38.680]         {
[15:32:38.680]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:38.680]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:38.680]                 ...future.FUN(...future.X_jj, ...)
[15:32:38.680]             })
[15:32:38.680]         }
[15:32:38.680]     }, args = future.call.arguments)
[15:32:38.680] }
[15:32:38.680] Lazy evaluation: FALSE
[15:32:38.680] Asynchronous evaluation: TRUE
[15:32:38.680] Local evaluation: TRUE
[15:32:38.680] Environment: R_GlobalEnv
[15:32:38.680] Capture standard output: TRUE
[15:32:38.680] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:38.680] Globals: 5 objects totaling 1.33 KiB (function '...future.FUN' of 1.22 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)
[15:32:38.680] Packages: <none>
[15:32:38.680] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:38.680] Resolved: TRUE
[15:32:38.680] Value: <not collected>
[15:32:38.680] Conditions captured: <none>
[15:32:38.680] Early signaling: FALSE
[15:32:38.680] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:38.680] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:38.709] Chunk #1 of 2 ... DONE
[15:32:38.709] Chunk #2 of 2 ...
[15:32:38.709]  - Finding globals in 'X' for chunk #2 ...
[15:32:38.710] getGlobalsAndPackages() ...
[15:32:38.710] Searching for globals...
[15:32:38.710] 
[15:32:38.710] Searching for globals ... DONE
[15:32:38.711] - globals: [0] <none>
[15:32:38.711] getGlobalsAndPackages() ... DONE
[15:32:38.711]    + additional globals found: [n=0] 
[15:32:38.711]    + additional namespaces needed: [n=0] 
[15:32:38.711]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:38.711]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:38.712]  - seeds: <none>
[15:32:38.712]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:38.712] getGlobalsAndPackages() ...
[15:32:38.712] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:38.712] Resolving globals: FALSE
[15:32:38.713] Tweak future expression to call with '...' arguments ...
[15:32:38.713] {
[15:32:38.713]     do.call(function(...) {
[15:32:38.713]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:38.713]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:38.713]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:38.713]             on.exit(options(oopts), add = TRUE)
[15:32:38.713]         }
[15:32:38.713]         {
[15:32:38.713]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:38.713]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:38.713]                 ...future.FUN(...future.X_jj, ...)
[15:32:38.713]             })
[15:32:38.713]         }
[15:32:38.713]     }, args = future.call.arguments)
[15:32:38.713] }
[15:32:38.713] Tweak future expression to call with '...' arguments ... DONE
[15:32:38.714] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:38.714] 
[15:32:38.715] getGlobalsAndPackages() ... DONE
[15:32:38.715] run() for 'Future' ...
[15:32:38.716] - state: 'created'
[15:32:38.716] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:38.736] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:38.736] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:38.736]   - Field: 'node'
[15:32:38.737]   - Field: 'label'
[15:32:38.737]   - Field: 'local'
[15:32:38.737]   - Field: 'owner'
[15:32:38.738]   - Field: 'envir'
[15:32:38.738]   - Field: 'workers'
[15:32:38.738]   - Field: 'packages'
[15:32:38.738]   - Field: 'gc'
[15:32:38.739]   - Field: 'conditions'
[15:32:38.739]   - Field: 'persistent'
[15:32:38.739]   - Field: 'expr'
[15:32:38.740]   - Field: 'uuid'
[15:32:38.740]   - Field: 'seed'
[15:32:38.740]   - Field: 'version'
[15:32:38.740]   - Field: 'result'
[15:32:38.741]   - Field: 'asynchronous'
[15:32:38.741]   - Field: 'calls'
[15:32:38.741]   - Field: 'globals'
[15:32:38.741]   - Field: 'stdout'
[15:32:38.742]   - Field: 'earlySignal'
[15:32:38.742]   - Field: 'lazy'
[15:32:38.742]   - Field: 'state'
[15:32:38.742] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:38.743] - Launch lazy future ...
[15:32:38.743] Packages needed by the future expression (n = 0): <none>
[15:32:38.744] Packages needed by future strategies (n = 0): <none>
[15:32:38.744] {
[15:32:38.744]     {
[15:32:38.744]         {
[15:32:38.744]             ...future.startTime <- base::Sys.time()
[15:32:38.744]             {
[15:32:38.744]                 {
[15:32:38.744]                   {
[15:32:38.744]                     {
[15:32:38.744]                       base::local({
[15:32:38.744]                         has_future <- base::requireNamespace("future", 
[15:32:38.744]                           quietly = TRUE)
[15:32:38.744]                         if (has_future) {
[15:32:38.744]                           ns <- base::getNamespace("future")
[15:32:38.744]                           version <- ns[[".package"]][["version"]]
[15:32:38.744]                           if (is.null(version)) 
[15:32:38.744]                             version <- utils::packageVersion("future")
[15:32:38.744]                         }
[15:32:38.744]                         else {
[15:32:38.744]                           version <- NULL
[15:32:38.744]                         }
[15:32:38.744]                         if (!has_future || version < "1.8.0") {
[15:32:38.744]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:38.744]                             "", base::R.version$version.string), 
[15:32:38.744]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:38.744]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:38.744]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:38.744]                               "release", "version")], collapse = " "), 
[15:32:38.744]                             hostname = base::Sys.info()[["nodename"]])
[15:32:38.744]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:38.744]                             info)
[15:32:38.744]                           info <- base::paste(info, collapse = "; ")
[15:32:38.744]                           if (!has_future) {
[15:32:38.744]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:38.744]                               info)
[15:32:38.744]                           }
[15:32:38.744]                           else {
[15:32:38.744]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:38.744]                               info, version)
[15:32:38.744]                           }
[15:32:38.744]                           base::stop(msg)
[15:32:38.744]                         }
[15:32:38.744]                       })
[15:32:38.744]                     }
[15:32:38.744]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:38.744]                     base::options(mc.cores = 1L)
[15:32:38.744]                   }
[15:32:38.744]                   ...future.strategy.old <- future::plan("list")
[15:32:38.744]                   options(future.plan = NULL)
[15:32:38.744]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:38.744]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:38.744]                 }
[15:32:38.744]                 ...future.workdir <- getwd()
[15:32:38.744]             }
[15:32:38.744]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:38.744]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:38.744]         }
[15:32:38.744]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:38.744]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:38.744]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:38.744]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:38.744]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:38.744]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:38.744]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:38.744]             base::names(...future.oldOptions))
[15:32:38.744]     }
[15:32:38.744]     if (FALSE) {
[15:32:38.744]     }
[15:32:38.744]     else {
[15:32:38.744]         if (TRUE) {
[15:32:38.744]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:38.744]                 open = "w")
[15:32:38.744]         }
[15:32:38.744]         else {
[15:32:38.744]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:38.744]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:38.744]         }
[15:32:38.744]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:38.744]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:38.744]             base::sink(type = "output", split = FALSE)
[15:32:38.744]             base::close(...future.stdout)
[15:32:38.744]         }, add = TRUE)
[15:32:38.744]     }
[15:32:38.744]     ...future.frame <- base::sys.nframe()
[15:32:38.744]     ...future.conditions <- base::list()
[15:32:38.744]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:38.744]     if (FALSE) {
[15:32:38.744]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:38.744]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:38.744]     }
[15:32:38.744]     ...future.result <- base::tryCatch({
[15:32:38.744]         base::withCallingHandlers({
[15:32:38.744]             ...future.value <- base::withVisible(base::local({
[15:32:38.744]                 ...future.makeSendCondition <- base::local({
[15:32:38.744]                   sendCondition <- NULL
[15:32:38.744]                   function(frame = 1L) {
[15:32:38.744]                     if (is.function(sendCondition)) 
[15:32:38.744]                       return(sendCondition)
[15:32:38.744]                     ns <- getNamespace("parallel")
[15:32:38.744]                     if (exists("sendData", mode = "function", 
[15:32:38.744]                       envir = ns)) {
[15:32:38.744]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:38.744]                         envir = ns)
[15:32:38.744]                       envir <- sys.frame(frame)
[15:32:38.744]                       master <- NULL
[15:32:38.744]                       while (!identical(envir, .GlobalEnv) && 
[15:32:38.744]                         !identical(envir, emptyenv())) {
[15:32:38.744]                         if (exists("master", mode = "list", envir = envir, 
[15:32:38.744]                           inherits = FALSE)) {
[15:32:38.744]                           master <- get("master", mode = "list", 
[15:32:38.744]                             envir = envir, inherits = FALSE)
[15:32:38.744]                           if (inherits(master, c("SOCKnode", 
[15:32:38.744]                             "SOCK0node"))) {
[15:32:38.744]                             sendCondition <<- function(cond) {
[15:32:38.744]                               data <- list(type = "VALUE", value = cond, 
[15:32:38.744]                                 success = TRUE)
[15:32:38.744]                               parallel_sendData(master, data)
[15:32:38.744]                             }
[15:32:38.744]                             return(sendCondition)
[15:32:38.744]                           }
[15:32:38.744]                         }
[15:32:38.744]                         frame <- frame + 1L
[15:32:38.744]                         envir <- sys.frame(frame)
[15:32:38.744]                       }
[15:32:38.744]                     }
[15:32:38.744]                     sendCondition <<- function(cond) NULL
[15:32:38.744]                   }
[15:32:38.744]                 })
[15:32:38.744]                 withCallingHandlers({
[15:32:38.744]                   {
[15:32:38.744]                     do.call(function(...) {
[15:32:38.744]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:38.744]                       if (!identical(...future.globals.maxSize.org, 
[15:32:38.744]                         ...future.globals.maxSize)) {
[15:32:38.744]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:38.744]                         on.exit(options(oopts), add = TRUE)
[15:32:38.744]                       }
[15:32:38.744]                       {
[15:32:38.744]                         lapply(seq_along(...future.elements_ii), 
[15:32:38.744]                           FUN = function(jj) {
[15:32:38.744]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:38.744]                             ...future.FUN(...future.X_jj, ...)
[15:32:38.744]                           })
[15:32:38.744]                       }
[15:32:38.744]                     }, args = future.call.arguments)
[15:32:38.744]                   }
[15:32:38.744]                 }, immediateCondition = function(cond) {
[15:32:38.744]                   sendCondition <- ...future.makeSendCondition()
[15:32:38.744]                   sendCondition(cond)
[15:32:38.744]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:38.744]                   {
[15:32:38.744]                     inherits <- base::inherits
[15:32:38.744]                     invokeRestart <- base::invokeRestart
[15:32:38.744]                     is.null <- base::is.null
[15:32:38.744]                     muffled <- FALSE
[15:32:38.744]                     if (inherits(cond, "message")) {
[15:32:38.744]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:38.744]                       if (muffled) 
[15:32:38.744]                         invokeRestart("muffleMessage")
[15:32:38.744]                     }
[15:32:38.744]                     else if (inherits(cond, "warning")) {
[15:32:38.744]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:38.744]                       if (muffled) 
[15:32:38.744]                         invokeRestart("muffleWarning")
[15:32:38.744]                     }
[15:32:38.744]                     else if (inherits(cond, "condition")) {
[15:32:38.744]                       if (!is.null(pattern)) {
[15:32:38.744]                         computeRestarts <- base::computeRestarts
[15:32:38.744]                         grepl <- base::grepl
[15:32:38.744]                         restarts <- computeRestarts(cond)
[15:32:38.744]                         for (restart in restarts) {
[15:32:38.744]                           name <- restart$name
[15:32:38.744]                           if (is.null(name)) 
[15:32:38.744]                             next
[15:32:38.744]                           if (!grepl(pattern, name)) 
[15:32:38.744]                             next
[15:32:38.744]                           invokeRestart(restart)
[15:32:38.744]                           muffled <- TRUE
[15:32:38.744]                           break
[15:32:38.744]                         }
[15:32:38.744]                       }
[15:32:38.744]                     }
[15:32:38.744]                     invisible(muffled)
[15:32:38.744]                   }
[15:32:38.744]                   muffleCondition(cond)
[15:32:38.744]                 })
[15:32:38.744]             }))
[15:32:38.744]             future::FutureResult(value = ...future.value$value, 
[15:32:38.744]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:38.744]                   ...future.rng), globalenv = if (FALSE) 
[15:32:38.744]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:38.744]                     ...future.globalenv.names))
[15:32:38.744]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:38.744]         }, condition = base::local({
[15:32:38.744]             c <- base::c
[15:32:38.744]             inherits <- base::inherits
[15:32:38.744]             invokeRestart <- base::invokeRestart
[15:32:38.744]             length <- base::length
[15:32:38.744]             list <- base::list
[15:32:38.744]             seq.int <- base::seq.int
[15:32:38.744]             signalCondition <- base::signalCondition
[15:32:38.744]             sys.calls <- base::sys.calls
[15:32:38.744]             `[[` <- base::`[[`
[15:32:38.744]             `+` <- base::`+`
[15:32:38.744]             `<<-` <- base::`<<-`
[15:32:38.744]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:38.744]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:38.744]                   3L)]
[15:32:38.744]             }
[15:32:38.744]             function(cond) {
[15:32:38.744]                 is_error <- inherits(cond, "error")
[15:32:38.744]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:38.744]                   NULL)
[15:32:38.744]                 if (is_error) {
[15:32:38.744]                   sessionInformation <- function() {
[15:32:38.744]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:38.744]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:38.744]                       search = base::search(), system = base::Sys.info())
[15:32:38.744]                   }
[15:32:38.744]                   ...future.conditions[[length(...future.conditions) + 
[15:32:38.744]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:38.744]                     cond$call), session = sessionInformation(), 
[15:32:38.744]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:38.744]                   signalCondition(cond)
[15:32:38.744]                 }
[15:32:38.744]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:38.744]                 "immediateCondition"))) {
[15:32:38.744]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:38.744]                   ...future.conditions[[length(...future.conditions) + 
[15:32:38.744]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:38.744]                   if (TRUE && !signal) {
[15:32:38.744]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:38.744]                     {
[15:32:38.744]                       inherits <- base::inherits
[15:32:38.744]                       invokeRestart <- base::invokeRestart
[15:32:38.744]                       is.null <- base::is.null
[15:32:38.744]                       muffled <- FALSE
[15:32:38.744]                       if (inherits(cond, "message")) {
[15:32:38.744]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:38.744]                         if (muffled) 
[15:32:38.744]                           invokeRestart("muffleMessage")
[15:32:38.744]                       }
[15:32:38.744]                       else if (inherits(cond, "warning")) {
[15:32:38.744]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:38.744]                         if (muffled) 
[15:32:38.744]                           invokeRestart("muffleWarning")
[15:32:38.744]                       }
[15:32:38.744]                       else if (inherits(cond, "condition")) {
[15:32:38.744]                         if (!is.null(pattern)) {
[15:32:38.744]                           computeRestarts <- base::computeRestarts
[15:32:38.744]                           grepl <- base::grepl
[15:32:38.744]                           restarts <- computeRestarts(cond)
[15:32:38.744]                           for (restart in restarts) {
[15:32:38.744]                             name <- restart$name
[15:32:38.744]                             if (is.null(name)) 
[15:32:38.744]                               next
[15:32:38.744]                             if (!grepl(pattern, name)) 
[15:32:38.744]                               next
[15:32:38.744]                             invokeRestart(restart)
[15:32:38.744]                             muffled <- TRUE
[15:32:38.744]                             break
[15:32:38.744]                           }
[15:32:38.744]                         }
[15:32:38.744]                       }
[15:32:38.744]                       invisible(muffled)
[15:32:38.744]                     }
[15:32:38.744]                     muffleCondition(cond, pattern = "^muffle")
[15:32:38.744]                   }
[15:32:38.744]                 }
[15:32:38.744]                 else {
[15:32:38.744]                   if (TRUE) {
[15:32:38.744]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:38.744]                     {
[15:32:38.744]                       inherits <- base::inherits
[15:32:38.744]                       invokeRestart <- base::invokeRestart
[15:32:38.744]                       is.null <- base::is.null
[15:32:38.744]                       muffled <- FALSE
[15:32:38.744]                       if (inherits(cond, "message")) {
[15:32:38.744]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:38.744]                         if (muffled) 
[15:32:38.744]                           invokeRestart("muffleMessage")
[15:32:38.744]                       }
[15:32:38.744]                       else if (inherits(cond, "warning")) {
[15:32:38.744]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:38.744]                         if (muffled) 
[15:32:38.744]                           invokeRestart("muffleWarning")
[15:32:38.744]                       }
[15:32:38.744]                       else if (inherits(cond, "condition")) {
[15:32:38.744]                         if (!is.null(pattern)) {
[15:32:38.744]                           computeRestarts <- base::computeRestarts
[15:32:38.744]                           grepl <- base::grepl
[15:32:38.744]                           restarts <- computeRestarts(cond)
[15:32:38.744]                           for (restart in restarts) {
[15:32:38.744]                             name <- restart$name
[15:32:38.744]                             if (is.null(name)) 
[15:32:38.744]                               next
[15:32:38.744]                             if (!grepl(pattern, name)) 
[15:32:38.744]                               next
[15:32:38.744]                             invokeRestart(restart)
[15:32:38.744]                             muffled <- TRUE
[15:32:38.744]                             break
[15:32:38.744]                           }
[15:32:38.744]                         }
[15:32:38.744]                       }
[15:32:38.744]                       invisible(muffled)
[15:32:38.744]                     }
[15:32:38.744]                     muffleCondition(cond, pattern = "^muffle")
[15:32:38.744]                   }
[15:32:38.744]                 }
[15:32:38.744]             }
[15:32:38.744]         }))
[15:32:38.744]     }, error = function(ex) {
[15:32:38.744]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:38.744]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:38.744]                 ...future.rng), started = ...future.startTime, 
[15:32:38.744]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:38.744]             version = "1.8"), class = "FutureResult")
[15:32:38.744]     }, finally = {
[15:32:38.744]         if (!identical(...future.workdir, getwd())) 
[15:32:38.744]             setwd(...future.workdir)
[15:32:38.744]         {
[15:32:38.744]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:38.744]                 ...future.oldOptions$nwarnings <- NULL
[15:32:38.744]             }
[15:32:38.744]             base::options(...future.oldOptions)
[15:32:38.744]             if (.Platform$OS.type == "windows") {
[15:32:38.744]                 old_names <- names(...future.oldEnvVars)
[15:32:38.744]                 envs <- base::Sys.getenv()
[15:32:38.744]                 names <- names(envs)
[15:32:38.744]                 common <- intersect(names, old_names)
[15:32:38.744]                 added <- setdiff(names, old_names)
[15:32:38.744]                 removed <- setdiff(old_names, names)
[15:32:38.744]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:38.744]                   envs[common]]
[15:32:38.744]                 NAMES <- toupper(changed)
[15:32:38.744]                 args <- list()
[15:32:38.744]                 for (kk in seq_along(NAMES)) {
[15:32:38.744]                   name <- changed[[kk]]
[15:32:38.744]                   NAME <- NAMES[[kk]]
[15:32:38.744]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:38.744]                     next
[15:32:38.744]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:38.744]                 }
[15:32:38.744]                 NAMES <- toupper(added)
[15:32:38.744]                 for (kk in seq_along(NAMES)) {
[15:32:38.744]                   name <- added[[kk]]
[15:32:38.744]                   NAME <- NAMES[[kk]]
[15:32:38.744]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:38.744]                     next
[15:32:38.744]                   args[[name]] <- ""
[15:32:38.744]                 }
[15:32:38.744]                 NAMES <- toupper(removed)
[15:32:38.744]                 for (kk in seq_along(NAMES)) {
[15:32:38.744]                   name <- removed[[kk]]
[15:32:38.744]                   NAME <- NAMES[[kk]]
[15:32:38.744]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:38.744]                     next
[15:32:38.744]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:38.744]                 }
[15:32:38.744]                 if (length(args) > 0) 
[15:32:38.744]                   base::do.call(base::Sys.setenv, args = args)
[15:32:38.744]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:38.744]             }
[15:32:38.744]             else {
[15:32:38.744]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:38.744]             }
[15:32:38.744]             {
[15:32:38.744]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:38.744]                   0L) {
[15:32:38.744]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:38.744]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:38.744]                   base::options(opts)
[15:32:38.744]                 }
[15:32:38.744]                 {
[15:32:38.744]                   {
[15:32:38.744]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:38.744]                     NULL
[15:32:38.744]                   }
[15:32:38.744]                   options(future.plan = NULL)
[15:32:38.744]                   if (is.na(NA_character_)) 
[15:32:38.744]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:38.744]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:38.744]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:38.744]                     .init = FALSE)
[15:32:38.744]                 }
[15:32:38.744]             }
[15:32:38.744]         }
[15:32:38.744]     })
[15:32:38.744]     if (TRUE) {
[15:32:38.744]         base::sink(type = "output", split = FALSE)
[15:32:38.744]         if (TRUE) {
[15:32:38.744]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:38.744]         }
[15:32:38.744]         else {
[15:32:38.744]             ...future.result["stdout"] <- base::list(NULL)
[15:32:38.744]         }
[15:32:38.744]         base::close(...future.stdout)
[15:32:38.744]         ...future.stdout <- NULL
[15:32:38.744]     }
[15:32:38.744]     ...future.result$conditions <- ...future.conditions
[15:32:38.744]     ...future.result$finished <- base::Sys.time()
[15:32:38.744]     ...future.result
[15:32:38.744] }
[15:32:38.753] Exporting 5 global objects (1.22 KiB) to cluster node #1 ...
[15:32:38.754] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ...
[15:32:38.754] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ... DONE
[15:32:38.755] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:38.756] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:38.756] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:38.756] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:38.757] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:38.757] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:38.757] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:38.758] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:38.758] Exporting 5 global objects (1.22 KiB) to cluster node #1 ... DONE
[15:32:38.758] MultisessionFuture started
[15:32:38.759] - Launch lazy future ... done
[15:32:38.759] run() for 'MultisessionFuture' ... done
[15:32:38.759] Created future:
[15:32:38.781] receiveMessageFromWorker() for ClusterFuture ...
[15:32:38.781] - Validating connection of MultisessionFuture
[15:32:38.782] - received message: FutureResult
[15:32:38.782] - Received FutureResult
[15:32:38.783] - Erased future from FutureRegistry
[15:32:38.783] result() for ClusterFuture ...
[15:32:38.783] - result already collected: FutureResult
[15:32:38.784] result() for ClusterFuture ... done
[15:32:38.784] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:38.759] MultisessionFuture:
[15:32:38.759] Label: 'future_sapply-2'
[15:32:38.759] Expression:
[15:32:38.759] {
[15:32:38.759]     do.call(function(...) {
[15:32:38.759]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:38.759]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:38.759]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:38.759]             on.exit(options(oopts), add = TRUE)
[15:32:38.759]         }
[15:32:38.759]         {
[15:32:38.759]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:38.759]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:38.759]                 ...future.FUN(...future.X_jj, ...)
[15:32:38.759]             })
[15:32:38.759]         }
[15:32:38.759]     }, args = future.call.arguments)
[15:32:38.759] }
[15:32:38.759] Lazy evaluation: FALSE
[15:32:38.759] Asynchronous evaluation: TRUE
[15:32:38.759] Local evaluation: TRUE
[15:32:38.759] Environment: R_GlobalEnv
[15:32:38.759] Capture standard output: TRUE
[15:32:38.759] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:38.759] Globals: 5 objects totaling 1.33 KiB (function '...future.FUN' of 1.22 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)
[15:32:38.759] Packages: <none>
[15:32:38.759] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:38.759] Resolved: TRUE
[15:32:38.759] Value: <not collected>
[15:32:38.759] Conditions captured: <none>
[15:32:38.759] Early signaling: FALSE
[15:32:38.759] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:38.759] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:38.785] Chunk #2 of 2 ... DONE
[15:32:38.785] Launching 2 futures (chunks) ... DONE
[15:32:38.785] Resolving 2 futures (chunks) ...
[15:32:38.786] resolve() on list ...
[15:32:38.786]  recursive: 0
[15:32:38.786]  length: 2
[15:32:38.787] 
[15:32:38.787] Future #1
[15:32:38.787] result() for ClusterFuture ...
[15:32:38.788] - result already collected: FutureResult
[15:32:38.788] result() for ClusterFuture ... done
[15:32:38.788] result() for ClusterFuture ...
[15:32:38.788] - result already collected: FutureResult
[15:32:38.789] result() for ClusterFuture ... done
[15:32:38.789] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:38.789] - nx: 2
[15:32:38.790] - relay: TRUE
[15:32:38.790] - stdout: TRUE
[15:32:38.790] - signal: TRUE
[15:32:38.791] - resignal: FALSE
[15:32:38.791] - force: TRUE
[15:32:38.791] - relayed: [n=2] FALSE, FALSE
[15:32:38.791] - queued futures: [n=2] FALSE, FALSE
[15:32:38.792]  - until=1
[15:32:38.792]  - relaying element #1
[15:32:38.792] result() for ClusterFuture ...
[15:32:38.793] - result already collected: FutureResult
[15:32:38.793] result() for ClusterFuture ... done
[15:32:38.793] result() for ClusterFuture ...
[15:32:38.794] - result already collected: FutureResult
[15:32:38.794] result() for ClusterFuture ... done
[15:32:38.794] result() for ClusterFuture ...
[15:32:38.795] - result already collected: FutureResult
[15:32:38.795] result() for ClusterFuture ... done
[15:32:38.795] result() for ClusterFuture ...
[15:32:38.795] - result already collected: FutureResult
[15:32:38.796] result() for ClusterFuture ... done
[15:32:38.796] - relayed: [n=2] TRUE, FALSE
[15:32:38.796] - queued futures: [n=2] TRUE, FALSE
[15:32:38.797] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:38.797]  length: 1 (resolved future 1)
[15:32:38.797] Future #2
[15:32:38.798] result() for ClusterFuture ...
[15:32:38.798] - result already collected: FutureResult
[15:32:38.798] result() for ClusterFuture ... done
[15:32:38.799] result() for ClusterFuture ...
[15:32:38.799] - result already collected: FutureResult
[15:32:38.799] result() for ClusterFuture ... done
[15:32:38.800] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:38.800] - nx: 2
[15:32:38.800] - relay: TRUE
[15:32:38.800] - stdout: TRUE
[15:32:38.801] - signal: TRUE
[15:32:38.801] - resignal: FALSE
[15:32:38.801] - force: TRUE
[15:32:38.802] - relayed: [n=2] TRUE, FALSE
[15:32:38.802] - queued futures: [n=2] TRUE, FALSE
[15:32:38.802]  - until=2
[15:32:38.802]  - relaying element #2
[15:32:38.803] result() for ClusterFuture ...
[15:32:38.803] - result already collected: FutureResult
[15:32:38.803] result() for ClusterFuture ... done
[15:32:38.804] result() for ClusterFuture ...
[15:32:38.804] - result already collected: FutureResult
[15:32:38.804] result() for ClusterFuture ... done
[15:32:38.805] result() for ClusterFuture ...
[15:32:38.805] - result already collected: FutureResult
[15:32:38.805] result() for ClusterFuture ... done
[15:32:38.806] result() for ClusterFuture ...
[15:32:38.806] - result already collected: FutureResult
[15:32:38.806] result() for ClusterFuture ... done
[15:32:38.806] - relayed: [n=2] TRUE, TRUE
[15:32:38.807] - queued futures: [n=2] TRUE, TRUE
[15:32:38.807] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:38.807]  length: 0 (resolved future 2)
[15:32:38.808] Relaying remaining futures
[15:32:38.808] signalConditionsASAP(NULL, pos=0) ...
[15:32:38.808] - nx: 2
[15:32:38.809] - relay: TRUE
[15:32:38.809] - stdout: TRUE
[15:32:38.809] - signal: TRUE
[15:32:38.809] - resignal: FALSE
[15:32:38.810] - force: TRUE
[15:32:38.810] - relayed: [n=2] TRUE, TRUE
[15:32:38.810] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:38.811] - relayed: [n=2] TRUE, TRUE
[15:32:38.811] - queued futures: [n=2] TRUE, TRUE
[15:32:38.811] signalConditionsASAP(NULL, pos=0) ... done
[15:32:38.812] resolve() on list ... DONE
[15:32:38.812] result() for ClusterFuture ...
[15:32:38.812] - result already collected: FutureResult
[15:32:38.813] result() for ClusterFuture ... done
[15:32:38.813] result() for ClusterFuture ...
[15:32:38.813] - result already collected: FutureResult
[15:32:38.814] result() for ClusterFuture ... done
[15:32:38.814] result() for ClusterFuture ...
[15:32:38.814] - result already collected: FutureResult
[15:32:38.814] result() for ClusterFuture ... done
[15:32:38.815] result() for ClusterFuture ...
[15:32:38.815] - result already collected: FutureResult
[15:32:38.815] result() for ClusterFuture ... done
[15:32:38.816]  - Number of value chunks collected: 2
[15:32:38.816] Resolving 2 futures (chunks) ... DONE
[15:32:38.816] Reducing values from 2 chunks ...
[15:32:38.817]  - Number of values collected after concatenation: 4
[15:32:38.817]  - Number of values expected: 4
[15:32:38.817] Reducing values from 2 chunks ... DONE
[15:32:38.818] future_lapply() ... DONE
List of 2
 $ y0: Named num [1:4] 50 60 70 80
  ..- attr(*, "names")= chr [1:4] "A" "B" "C" "D"
 $ y1: Named num [1:4] 50 60 70 80
  ..- attr(*, "names")= chr [1:4] "A" "B" "C" "D"
[15:32:38.821] future_lapply() ...
[15:32:38.827] Number of chunks: 2
[15:32:38.828] getGlobalsAndPackagesXApply() ...
[15:32:38.828]  - future.globals: TRUE
[15:32:38.828] getGlobalsAndPackages() ...
[15:32:38.829] Searching for globals...
[15:32:38.832] - globals found: [5] 'FUN', '*', ':', 'outer', 'rep'
[15:32:38.833] Searching for globals ... DONE
[15:32:38.833] Resolving globals: FALSE
[15:32:38.834] The total size of the 1 globals is 4.62 KiB (4728 bytes)
[15:32:38.835] The total size of the 1 globals exported for future expression ('FUN()') is 4.62 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.62 KiB of class 'function')
[15:32:38.835] - globals: [1] 'FUN'
[15:32:38.835] 
[15:32:38.836] getGlobalsAndPackages() ... DONE
[15:32:38.836]  - globals found/used: [n=1] 'FUN'
[15:32:38.836]  - needed namespaces: [n=0] 
[15:32:38.837] Finding globals ... DONE
[15:32:38.837]  - use_args: TRUE
[15:32:38.837]  - Getting '...' globals ...
[15:32:38.838] resolve() on list ...
[15:32:38.838]  recursive: 0
[15:32:38.839]  length: 1
[15:32:38.839]  elements: '...'
[15:32:38.839]  length: 0 (resolved future 1)
[15:32:38.840] resolve() on list ... DONE
[15:32:38.840]    - '...' content: [n=0] 
[15:32:38.840] List of 1
[15:32:38.840]  $ ...: list()
[15:32:38.840]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:38.840]  - attr(*, "where")=List of 1
[15:32:38.840]   ..$ ...:<environment: 0x00000276e491e378> 
[15:32:38.840]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:38.840]  - attr(*, "resolved")= logi TRUE
[15:32:38.840]  - attr(*, "total_size")= num NA
[15:32:38.844]  - Getting '...' globals ... DONE
[15:32:38.844] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:38.844] List of 2
[15:32:38.844]  $ ...future.FUN:function (x, y = 2 * 1:5)  
[15:32:38.844]  $ ...          : list()
[15:32:38.844]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:38.844]  - attr(*, "where")=List of 2
[15:32:38.844]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:38.844]   ..$ ...          :<environment: 0x00000276e491e378> 
[15:32:38.844]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:38.844]  - attr(*, "resolved")= logi FALSE
[15:32:38.844]  - attr(*, "total_size")= num 4728
[15:32:38.848] Packages to be attached in all futures: [n=0] 
[15:32:38.848] getGlobalsAndPackagesXApply() ... DONE
[15:32:38.848] Number of futures (= number of chunks): 2
[15:32:38.849] Launching 2 futures (chunks) ...
[15:32:38.849] Chunk #1 of 2 ...
[15:32:38.849]  - Finding globals in 'X' for chunk #1 ...
[15:32:38.849] getGlobalsAndPackages() ...
[15:32:38.849] Searching for globals...
[15:32:38.850] 
[15:32:38.850] Searching for globals ... DONE
[15:32:38.850] - globals: [0] <none>
[15:32:38.850] getGlobalsAndPackages() ... DONE
[15:32:38.850]    + additional globals found: [n=0] 
[15:32:38.851]    + additional namespaces needed: [n=0] 
[15:32:38.851]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:38.851]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:38.851]  - seeds: <none>
[15:32:38.851]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:38.851] getGlobalsAndPackages() ...
[15:32:38.852] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:38.852] Resolving globals: FALSE
[15:32:38.852] Tweak future expression to call with '...' arguments ...
[15:32:38.852] {
[15:32:38.852]     do.call(function(...) {
[15:32:38.852]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:38.852]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:38.852]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:38.852]             on.exit(options(oopts), add = TRUE)
[15:32:38.852]         }
[15:32:38.852]         {
[15:32:38.852]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:38.852]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:38.852]                 ...future.FUN(...future.X_jj, ...)
[15:32:38.852]             })
[15:32:38.852]         }
[15:32:38.852]     }, args = future.call.arguments)
[15:32:38.852] }
[15:32:38.853] Tweak future expression to call with '...' arguments ... DONE
[15:32:38.853] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:38.853] 
[15:32:38.854] getGlobalsAndPackages() ... DONE
[15:32:38.857] run() for 'Future' ...
[15:32:38.857] - state: 'created'
[15:32:38.858] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:38.873] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:38.873] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:38.873]   - Field: 'node'
[15:32:38.874]   - Field: 'label'
[15:32:38.874]   - Field: 'local'
[15:32:38.874]   - Field: 'owner'
[15:32:38.874]   - Field: 'envir'
[15:32:38.874]   - Field: 'workers'
[15:32:38.875]   - Field: 'packages'
[15:32:38.875]   - Field: 'gc'
[15:32:38.875]   - Field: 'conditions'
[15:32:38.875]   - Field: 'persistent'
[15:32:38.875]   - Field: 'expr'
[15:32:38.876]   - Field: 'uuid'
[15:32:38.876]   - Field: 'seed'
[15:32:38.876]   - Field: 'version'
[15:32:38.876]   - Field: 'result'
[15:32:38.876]   - Field: 'asynchronous'
[15:32:38.876]   - Field: 'calls'
[15:32:38.877]   - Field: 'globals'
[15:32:38.877]   - Field: 'stdout'
[15:32:38.877]   - Field: 'earlySignal'
[15:32:38.877]   - Field: 'lazy'
[15:32:38.877]   - Field: 'state'
[15:32:38.878] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:38.878] - Launch lazy future ...
[15:32:38.878] Packages needed by the future expression (n = 0): <none>
[15:32:38.878] Packages needed by future strategies (n = 0): <none>
[15:32:38.879] {
[15:32:38.879]     {
[15:32:38.879]         {
[15:32:38.879]             ...future.startTime <- base::Sys.time()
[15:32:38.879]             {
[15:32:38.879]                 {
[15:32:38.879]                   {
[15:32:38.879]                     {
[15:32:38.879]                       base::local({
[15:32:38.879]                         has_future <- base::requireNamespace("future", 
[15:32:38.879]                           quietly = TRUE)
[15:32:38.879]                         if (has_future) {
[15:32:38.879]                           ns <- base::getNamespace("future")
[15:32:38.879]                           version <- ns[[".package"]][["version"]]
[15:32:38.879]                           if (is.null(version)) 
[15:32:38.879]                             version <- utils::packageVersion("future")
[15:32:38.879]                         }
[15:32:38.879]                         else {
[15:32:38.879]                           version <- NULL
[15:32:38.879]                         }
[15:32:38.879]                         if (!has_future || version < "1.8.0") {
[15:32:38.879]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:38.879]                             "", base::R.version$version.string), 
[15:32:38.879]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:38.879]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:38.879]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:38.879]                               "release", "version")], collapse = " "), 
[15:32:38.879]                             hostname = base::Sys.info()[["nodename"]])
[15:32:38.879]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:38.879]                             info)
[15:32:38.879]                           info <- base::paste(info, collapse = "; ")
[15:32:38.879]                           if (!has_future) {
[15:32:38.879]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:38.879]                               info)
[15:32:38.879]                           }
[15:32:38.879]                           else {
[15:32:38.879]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:38.879]                               info, version)
[15:32:38.879]                           }
[15:32:38.879]                           base::stop(msg)
[15:32:38.879]                         }
[15:32:38.879]                       })
[15:32:38.879]                     }
[15:32:38.879]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:38.879]                     base::options(mc.cores = 1L)
[15:32:38.879]                   }
[15:32:38.879]                   ...future.strategy.old <- future::plan("list")
[15:32:38.879]                   options(future.plan = NULL)
[15:32:38.879]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:38.879]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:38.879]                 }
[15:32:38.879]                 ...future.workdir <- getwd()
[15:32:38.879]             }
[15:32:38.879]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:38.879]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:38.879]         }
[15:32:38.879]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:38.879]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:38.879]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:38.879]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:38.879]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:38.879]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:38.879]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:38.879]             base::names(...future.oldOptions))
[15:32:38.879]     }
[15:32:38.879]     if (FALSE) {
[15:32:38.879]     }
[15:32:38.879]     else {
[15:32:38.879]         if (TRUE) {
[15:32:38.879]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:38.879]                 open = "w")
[15:32:38.879]         }
[15:32:38.879]         else {
[15:32:38.879]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:38.879]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:38.879]         }
[15:32:38.879]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:38.879]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:38.879]             base::sink(type = "output", split = FALSE)
[15:32:38.879]             base::close(...future.stdout)
[15:32:38.879]         }, add = TRUE)
[15:32:38.879]     }
[15:32:38.879]     ...future.frame <- base::sys.nframe()
[15:32:38.879]     ...future.conditions <- base::list()
[15:32:38.879]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:38.879]     if (FALSE) {
[15:32:38.879]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:38.879]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:38.879]     }
[15:32:38.879]     ...future.result <- base::tryCatch({
[15:32:38.879]         base::withCallingHandlers({
[15:32:38.879]             ...future.value <- base::withVisible(base::local({
[15:32:38.879]                 ...future.makeSendCondition <- base::local({
[15:32:38.879]                   sendCondition <- NULL
[15:32:38.879]                   function(frame = 1L) {
[15:32:38.879]                     if (is.function(sendCondition)) 
[15:32:38.879]                       return(sendCondition)
[15:32:38.879]                     ns <- getNamespace("parallel")
[15:32:38.879]                     if (exists("sendData", mode = "function", 
[15:32:38.879]                       envir = ns)) {
[15:32:38.879]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:38.879]                         envir = ns)
[15:32:38.879]                       envir <- sys.frame(frame)
[15:32:38.879]                       master <- NULL
[15:32:38.879]                       while (!identical(envir, .GlobalEnv) && 
[15:32:38.879]                         !identical(envir, emptyenv())) {
[15:32:38.879]                         if (exists("master", mode = "list", envir = envir, 
[15:32:38.879]                           inherits = FALSE)) {
[15:32:38.879]                           master <- get("master", mode = "list", 
[15:32:38.879]                             envir = envir, inherits = FALSE)
[15:32:38.879]                           if (inherits(master, c("SOCKnode", 
[15:32:38.879]                             "SOCK0node"))) {
[15:32:38.879]                             sendCondition <<- function(cond) {
[15:32:38.879]                               data <- list(type = "VALUE", value = cond, 
[15:32:38.879]                                 success = TRUE)
[15:32:38.879]                               parallel_sendData(master, data)
[15:32:38.879]                             }
[15:32:38.879]                             return(sendCondition)
[15:32:38.879]                           }
[15:32:38.879]                         }
[15:32:38.879]                         frame <- frame + 1L
[15:32:38.879]                         envir <- sys.frame(frame)
[15:32:38.879]                       }
[15:32:38.879]                     }
[15:32:38.879]                     sendCondition <<- function(cond) NULL
[15:32:38.879]                   }
[15:32:38.879]                 })
[15:32:38.879]                 withCallingHandlers({
[15:32:38.879]                   {
[15:32:38.879]                     do.call(function(...) {
[15:32:38.879]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:38.879]                       if (!identical(...future.globals.maxSize.org, 
[15:32:38.879]                         ...future.globals.maxSize)) {
[15:32:38.879]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:38.879]                         on.exit(options(oopts), add = TRUE)
[15:32:38.879]                       }
[15:32:38.879]                       {
[15:32:38.879]                         lapply(seq_along(...future.elements_ii), 
[15:32:38.879]                           FUN = function(jj) {
[15:32:38.879]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:38.879]                             ...future.FUN(...future.X_jj, ...)
[15:32:38.879]                           })
[15:32:38.879]                       }
[15:32:38.879]                     }, args = future.call.arguments)
[15:32:38.879]                   }
[15:32:38.879]                 }, immediateCondition = function(cond) {
[15:32:38.879]                   sendCondition <- ...future.makeSendCondition()
[15:32:38.879]                   sendCondition(cond)
[15:32:38.879]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:38.879]                   {
[15:32:38.879]                     inherits <- base::inherits
[15:32:38.879]                     invokeRestart <- base::invokeRestart
[15:32:38.879]                     is.null <- base::is.null
[15:32:38.879]                     muffled <- FALSE
[15:32:38.879]                     if (inherits(cond, "message")) {
[15:32:38.879]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:38.879]                       if (muffled) 
[15:32:38.879]                         invokeRestart("muffleMessage")
[15:32:38.879]                     }
[15:32:38.879]                     else if (inherits(cond, "warning")) {
[15:32:38.879]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:38.879]                       if (muffled) 
[15:32:38.879]                         invokeRestart("muffleWarning")
[15:32:38.879]                     }
[15:32:38.879]                     else if (inherits(cond, "condition")) {
[15:32:38.879]                       if (!is.null(pattern)) {
[15:32:38.879]                         computeRestarts <- base::computeRestarts
[15:32:38.879]                         grepl <- base::grepl
[15:32:38.879]                         restarts <- computeRestarts(cond)
[15:32:38.879]                         for (restart in restarts) {
[15:32:38.879]                           name <- restart$name
[15:32:38.879]                           if (is.null(name)) 
[15:32:38.879]                             next
[15:32:38.879]                           if (!grepl(pattern, name)) 
[15:32:38.879]                             next
[15:32:38.879]                           invokeRestart(restart)
[15:32:38.879]                           muffled <- TRUE
[15:32:38.879]                           break
[15:32:38.879]                         }
[15:32:38.879]                       }
[15:32:38.879]                     }
[15:32:38.879]                     invisible(muffled)
[15:32:38.879]                   }
[15:32:38.879]                   muffleCondition(cond)
[15:32:38.879]                 })
[15:32:38.879]             }))
[15:32:38.879]             future::FutureResult(value = ...future.value$value, 
[15:32:38.879]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:38.879]                   ...future.rng), globalenv = if (FALSE) 
[15:32:38.879]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:38.879]                     ...future.globalenv.names))
[15:32:38.879]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:38.879]         }, condition = base::local({
[15:32:38.879]             c <- base::c
[15:32:38.879]             inherits <- base::inherits
[15:32:38.879]             invokeRestart <- base::invokeRestart
[15:32:38.879]             length <- base::length
[15:32:38.879]             list <- base::list
[15:32:38.879]             seq.int <- base::seq.int
[15:32:38.879]             signalCondition <- base::signalCondition
[15:32:38.879]             sys.calls <- base::sys.calls
[15:32:38.879]             `[[` <- base::`[[`
[15:32:38.879]             `+` <- base::`+`
[15:32:38.879]             `<<-` <- base::`<<-`
[15:32:38.879]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:38.879]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:38.879]                   3L)]
[15:32:38.879]             }
[15:32:38.879]             function(cond) {
[15:32:38.879]                 is_error <- inherits(cond, "error")
[15:32:38.879]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:38.879]                   NULL)
[15:32:38.879]                 if (is_error) {
[15:32:38.879]                   sessionInformation <- function() {
[15:32:38.879]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:38.879]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:38.879]                       search = base::search(), system = base::Sys.info())
[15:32:38.879]                   }
[15:32:38.879]                   ...future.conditions[[length(...future.conditions) + 
[15:32:38.879]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:38.879]                     cond$call), session = sessionInformation(), 
[15:32:38.879]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:38.879]                   signalCondition(cond)
[15:32:38.879]                 }
[15:32:38.879]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:38.879]                 "immediateCondition"))) {
[15:32:38.879]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:38.879]                   ...future.conditions[[length(...future.conditions) + 
[15:32:38.879]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:38.879]                   if (TRUE && !signal) {
[15:32:38.879]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:38.879]                     {
[15:32:38.879]                       inherits <- base::inherits
[15:32:38.879]                       invokeRestart <- base::invokeRestart
[15:32:38.879]                       is.null <- base::is.null
[15:32:38.879]                       muffled <- FALSE
[15:32:38.879]                       if (inherits(cond, "message")) {
[15:32:38.879]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:38.879]                         if (muffled) 
[15:32:38.879]                           invokeRestart("muffleMessage")
[15:32:38.879]                       }
[15:32:38.879]                       else if (inherits(cond, "warning")) {
[15:32:38.879]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:38.879]                         if (muffled) 
[15:32:38.879]                           invokeRestart("muffleWarning")
[15:32:38.879]                       }
[15:32:38.879]                       else if (inherits(cond, "condition")) {
[15:32:38.879]                         if (!is.null(pattern)) {
[15:32:38.879]                           computeRestarts <- base::computeRestarts
[15:32:38.879]                           grepl <- base::grepl
[15:32:38.879]                           restarts <- computeRestarts(cond)
[15:32:38.879]                           for (restart in restarts) {
[15:32:38.879]                             name <- restart$name
[15:32:38.879]                             if (is.null(name)) 
[15:32:38.879]                               next
[15:32:38.879]                             if (!grepl(pattern, name)) 
[15:32:38.879]                               next
[15:32:38.879]                             invokeRestart(restart)
[15:32:38.879]                             muffled <- TRUE
[15:32:38.879]                             break
[15:32:38.879]                           }
[15:32:38.879]                         }
[15:32:38.879]                       }
[15:32:38.879]                       invisible(muffled)
[15:32:38.879]                     }
[15:32:38.879]                     muffleCondition(cond, pattern = "^muffle")
[15:32:38.879]                   }
[15:32:38.879]                 }
[15:32:38.879]                 else {
[15:32:38.879]                   if (TRUE) {
[15:32:38.879]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:38.879]                     {
[15:32:38.879]                       inherits <- base::inherits
[15:32:38.879]                       invokeRestart <- base::invokeRestart
[15:32:38.879]                       is.null <- base::is.null
[15:32:38.879]                       muffled <- FALSE
[15:32:38.879]                       if (inherits(cond, "message")) {
[15:32:38.879]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:38.879]                         if (muffled) 
[15:32:38.879]                           invokeRestart("muffleMessage")
[15:32:38.879]                       }
[15:32:38.879]                       else if (inherits(cond, "warning")) {
[15:32:38.879]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:38.879]                         if (muffled) 
[15:32:38.879]                           invokeRestart("muffleWarning")
[15:32:38.879]                       }
[15:32:38.879]                       else if (inherits(cond, "condition")) {
[15:32:38.879]                         if (!is.null(pattern)) {
[15:32:38.879]                           computeRestarts <- base::computeRestarts
[15:32:38.879]                           grepl <- base::grepl
[15:32:38.879]                           restarts <- computeRestarts(cond)
[15:32:38.879]                           for (restart in restarts) {
[15:32:38.879]                             name <- restart$name
[15:32:38.879]                             if (is.null(name)) 
[15:32:38.879]                               next
[15:32:38.879]                             if (!grepl(pattern, name)) 
[15:32:38.879]                               next
[15:32:38.879]                             invokeRestart(restart)
[15:32:38.879]                             muffled <- TRUE
[15:32:38.879]                             break
[15:32:38.879]                           }
[15:32:38.879]                         }
[15:32:38.879]                       }
[15:32:38.879]                       invisible(muffled)
[15:32:38.879]                     }
[15:32:38.879]                     muffleCondition(cond, pattern = "^muffle")
[15:32:38.879]                   }
[15:32:38.879]                 }
[15:32:38.879]             }
[15:32:38.879]         }))
[15:32:38.879]     }, error = function(ex) {
[15:32:38.879]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:38.879]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:38.879]                 ...future.rng), started = ...future.startTime, 
[15:32:38.879]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:38.879]             version = "1.8"), class = "FutureResult")
[15:32:38.879]     }, finally = {
[15:32:38.879]         if (!identical(...future.workdir, getwd())) 
[15:32:38.879]             setwd(...future.workdir)
[15:32:38.879]         {
[15:32:38.879]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:38.879]                 ...future.oldOptions$nwarnings <- NULL
[15:32:38.879]             }
[15:32:38.879]             base::options(...future.oldOptions)
[15:32:38.879]             if (.Platform$OS.type == "windows") {
[15:32:38.879]                 old_names <- names(...future.oldEnvVars)
[15:32:38.879]                 envs <- base::Sys.getenv()
[15:32:38.879]                 names <- names(envs)
[15:32:38.879]                 common <- intersect(names, old_names)
[15:32:38.879]                 added <- setdiff(names, old_names)
[15:32:38.879]                 removed <- setdiff(old_names, names)
[15:32:38.879]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:38.879]                   envs[common]]
[15:32:38.879]                 NAMES <- toupper(changed)
[15:32:38.879]                 args <- list()
[15:32:38.879]                 for (kk in seq_along(NAMES)) {
[15:32:38.879]                   name <- changed[[kk]]
[15:32:38.879]                   NAME <- NAMES[[kk]]
[15:32:38.879]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:38.879]                     next
[15:32:38.879]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:38.879]                 }
[15:32:38.879]                 NAMES <- toupper(added)
[15:32:38.879]                 for (kk in seq_along(NAMES)) {
[15:32:38.879]                   name <- added[[kk]]
[15:32:38.879]                   NAME <- NAMES[[kk]]
[15:32:38.879]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:38.879]                     next
[15:32:38.879]                   args[[name]] <- ""
[15:32:38.879]                 }
[15:32:38.879]                 NAMES <- toupper(removed)
[15:32:38.879]                 for (kk in seq_along(NAMES)) {
[15:32:38.879]                   name <- removed[[kk]]
[15:32:38.879]                   NAME <- NAMES[[kk]]
[15:32:38.879]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:38.879]                     next
[15:32:38.879]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:38.879]                 }
[15:32:38.879]                 if (length(args) > 0) 
[15:32:38.879]                   base::do.call(base::Sys.setenv, args = args)
[15:32:38.879]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:38.879]             }
[15:32:38.879]             else {
[15:32:38.879]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:38.879]             }
[15:32:38.879]             {
[15:32:38.879]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:38.879]                   0L) {
[15:32:38.879]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:38.879]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:38.879]                   base::options(opts)
[15:32:38.879]                 }
[15:32:38.879]                 {
[15:32:38.879]                   {
[15:32:38.879]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:38.879]                     NULL
[15:32:38.879]                   }
[15:32:38.879]                   options(future.plan = NULL)
[15:32:38.879]                   if (is.na(NA_character_)) 
[15:32:38.879]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:38.879]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:38.879]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:38.879]                     .init = FALSE)
[15:32:38.879]                 }
[15:32:38.879]             }
[15:32:38.879]         }
[15:32:38.879]     })
[15:32:38.879]     if (TRUE) {
[15:32:38.879]         base::sink(type = "output", split = FALSE)
[15:32:38.879]         if (TRUE) {
[15:32:38.879]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:38.879]         }
[15:32:38.879]         else {
[15:32:38.879]             ...future.result["stdout"] <- base::list(NULL)
[15:32:38.879]         }
[15:32:38.879]         base::close(...future.stdout)
[15:32:38.879]         ...future.stdout <- NULL
[15:32:38.879]     }
[15:32:38.879]     ...future.result$conditions <- ...future.conditions
[15:32:38.879]     ...future.result$finished <- base::Sys.time()
[15:32:38.879]     ...future.result
[15:32:38.879] }
[15:32:38.885] Exporting 5 global objects (4.62 KiB) to cluster node #1 ...
[15:32:38.885] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ...
[15:32:38.886] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ... DONE
[15:32:38.886] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:38.886] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:38.887] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:38.887] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:38.887] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:38.888] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:38.888] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:38.888] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:38.888] Exporting 5 global objects (4.62 KiB) to cluster node #1 ... DONE
[15:32:38.889] MultisessionFuture started
[15:32:38.889] - Launch lazy future ... done
[15:32:38.889] run() for 'MultisessionFuture' ... done
[15:32:38.890] Created future:
[15:32:38.910] receiveMessageFromWorker() for ClusterFuture ...
[15:32:38.911] - Validating connection of MultisessionFuture
[15:32:38.911] - received message: FutureResult
[15:32:38.912] - Received FutureResult
[15:32:38.912] - Erased future from FutureRegistry
[15:32:38.912] result() for ClusterFuture ...
[15:32:38.912] - result already collected: FutureResult
[15:32:38.913] result() for ClusterFuture ... done
[15:32:38.913] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:38.890] MultisessionFuture:
[15:32:38.890] Label: 'future_sapply-1'
[15:32:38.890] Expression:
[15:32:38.890] {
[15:32:38.890]     do.call(function(...) {
[15:32:38.890]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:38.890]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:38.890]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:38.890]             on.exit(options(oopts), add = TRUE)
[15:32:38.890]         }
[15:32:38.890]         {
[15:32:38.890]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:38.890]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:38.890]                 ...future.FUN(...future.X_jj, ...)
[15:32:38.890]             })
[15:32:38.890]         }
[15:32:38.890]     }, args = future.call.arguments)
[15:32:38.890] }
[15:32:38.890] Lazy evaluation: FALSE
[15:32:38.890] Asynchronous evaluation: TRUE
[15:32:38.890] Local evaluation: TRUE
[15:32:38.890] Environment: R_GlobalEnv
[15:32:38.890] Capture standard output: TRUE
[15:32:38.890] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:38.890] Globals: 5 objects totaling 4.73 KiB (function '...future.FUN' of 4.62 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)
[15:32:38.890] Packages: <none>
[15:32:38.890] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:38.890] Resolved: TRUE
[15:32:38.890] Value: <not collected>
[15:32:38.890] Conditions captured: <none>
[15:32:38.890] Early signaling: FALSE
[15:32:38.890] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:38.890] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:38.914] Chunk #1 of 2 ... DONE
[15:32:38.914] Chunk #2 of 2 ...
[15:32:38.914]  - Finding globals in 'X' for chunk #2 ...
[15:32:38.914] getGlobalsAndPackages() ...
[15:32:38.915] Searching for globals...
[15:32:38.915] 
[15:32:38.915] Searching for globals ... DONE
[15:32:38.915] - globals: [0] <none>
[15:32:38.916] getGlobalsAndPackages() ... DONE
[15:32:38.916]    + additional globals found: [n=0] 
[15:32:38.916]    + additional namespaces needed: [n=0] 
[15:32:38.916]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:38.916]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:38.916]  - seeds: <none>
[15:32:38.917]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:38.917] getGlobalsAndPackages() ...
[15:32:38.917] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:38.917] Resolving globals: FALSE
[15:32:38.917] Tweak future expression to call with '...' arguments ...
[15:32:38.918] {
[15:32:38.918]     do.call(function(...) {
[15:32:38.918]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:38.918]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:38.918]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:38.918]             on.exit(options(oopts), add = TRUE)
[15:32:38.918]         }
[15:32:38.918]         {
[15:32:38.918]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:38.918]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:38.918]                 ...future.FUN(...future.X_jj, ...)
[15:32:38.918]             })
[15:32:38.918]         }
[15:32:38.918]     }, args = future.call.arguments)
[15:32:38.918] }
[15:32:38.918] Tweak future expression to call with '...' arguments ... DONE
[15:32:38.919] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:38.919] 
[15:32:38.919] getGlobalsAndPackages() ... DONE
[15:32:38.919] run() for 'Future' ...
[15:32:38.920] - state: 'created'
[15:32:38.920] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:38.935] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:38.936] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:38.936]   - Field: 'node'
[15:32:38.936]   - Field: 'label'
[15:32:38.936]   - Field: 'local'
[15:32:38.936]   - Field: 'owner'
[15:32:38.936]   - Field: 'envir'
[15:32:38.937]   - Field: 'workers'
[15:32:38.937]   - Field: 'packages'
[15:32:38.937]   - Field: 'gc'
[15:32:38.937]   - Field: 'conditions'
[15:32:38.937]   - Field: 'persistent'
[15:32:38.938]   - Field: 'expr'
[15:32:38.938]   - Field: 'uuid'
[15:32:38.938]   - Field: 'seed'
[15:32:38.938]   - Field: 'version'
[15:32:38.938]   - Field: 'result'
[15:32:38.939]   - Field: 'asynchronous'
[15:32:38.939]   - Field: 'calls'
[15:32:38.939]   - Field: 'globals'
[15:32:38.939]   - Field: 'stdout'
[15:32:38.939]   - Field: 'earlySignal'
[15:32:38.940]   - Field: 'lazy'
[15:32:38.940]   - Field: 'state'
[15:32:38.940] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:38.940] - Launch lazy future ...
[15:32:38.941] Packages needed by the future expression (n = 0): <none>
[15:32:38.941] Packages needed by future strategies (n = 0): <none>
[15:32:38.941] {
[15:32:38.941]     {
[15:32:38.941]         {
[15:32:38.941]             ...future.startTime <- base::Sys.time()
[15:32:38.941]             {
[15:32:38.941]                 {
[15:32:38.941]                   {
[15:32:38.941]                     {
[15:32:38.941]                       base::local({
[15:32:38.941]                         has_future <- base::requireNamespace("future", 
[15:32:38.941]                           quietly = TRUE)
[15:32:38.941]                         if (has_future) {
[15:32:38.941]                           ns <- base::getNamespace("future")
[15:32:38.941]                           version <- ns[[".package"]][["version"]]
[15:32:38.941]                           if (is.null(version)) 
[15:32:38.941]                             version <- utils::packageVersion("future")
[15:32:38.941]                         }
[15:32:38.941]                         else {
[15:32:38.941]                           version <- NULL
[15:32:38.941]                         }
[15:32:38.941]                         if (!has_future || version < "1.8.0") {
[15:32:38.941]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:38.941]                             "", base::R.version$version.string), 
[15:32:38.941]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:38.941]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:38.941]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:38.941]                               "release", "version")], collapse = " "), 
[15:32:38.941]                             hostname = base::Sys.info()[["nodename"]])
[15:32:38.941]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:38.941]                             info)
[15:32:38.941]                           info <- base::paste(info, collapse = "; ")
[15:32:38.941]                           if (!has_future) {
[15:32:38.941]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:38.941]                               info)
[15:32:38.941]                           }
[15:32:38.941]                           else {
[15:32:38.941]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:38.941]                               info, version)
[15:32:38.941]                           }
[15:32:38.941]                           base::stop(msg)
[15:32:38.941]                         }
[15:32:38.941]                       })
[15:32:38.941]                     }
[15:32:38.941]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:38.941]                     base::options(mc.cores = 1L)
[15:32:38.941]                   }
[15:32:38.941]                   ...future.strategy.old <- future::plan("list")
[15:32:38.941]                   options(future.plan = NULL)
[15:32:38.941]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:38.941]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:38.941]                 }
[15:32:38.941]                 ...future.workdir <- getwd()
[15:32:38.941]             }
[15:32:38.941]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:38.941]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:38.941]         }
[15:32:38.941]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:38.941]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:38.941]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:38.941]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:38.941]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:38.941]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:38.941]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:38.941]             base::names(...future.oldOptions))
[15:32:38.941]     }
[15:32:38.941]     if (FALSE) {
[15:32:38.941]     }
[15:32:38.941]     else {
[15:32:38.941]         if (TRUE) {
[15:32:38.941]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:38.941]                 open = "w")
[15:32:38.941]         }
[15:32:38.941]         else {
[15:32:38.941]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:38.941]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:38.941]         }
[15:32:38.941]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:38.941]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:38.941]             base::sink(type = "output", split = FALSE)
[15:32:38.941]             base::close(...future.stdout)
[15:32:38.941]         }, add = TRUE)
[15:32:38.941]     }
[15:32:38.941]     ...future.frame <- base::sys.nframe()
[15:32:38.941]     ...future.conditions <- base::list()
[15:32:38.941]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:38.941]     if (FALSE) {
[15:32:38.941]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:38.941]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:38.941]     }
[15:32:38.941]     ...future.result <- base::tryCatch({
[15:32:38.941]         base::withCallingHandlers({
[15:32:38.941]             ...future.value <- base::withVisible(base::local({
[15:32:38.941]                 ...future.makeSendCondition <- base::local({
[15:32:38.941]                   sendCondition <- NULL
[15:32:38.941]                   function(frame = 1L) {
[15:32:38.941]                     if (is.function(sendCondition)) 
[15:32:38.941]                       return(sendCondition)
[15:32:38.941]                     ns <- getNamespace("parallel")
[15:32:38.941]                     if (exists("sendData", mode = "function", 
[15:32:38.941]                       envir = ns)) {
[15:32:38.941]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:38.941]                         envir = ns)
[15:32:38.941]                       envir <- sys.frame(frame)
[15:32:38.941]                       master <- NULL
[15:32:38.941]                       while (!identical(envir, .GlobalEnv) && 
[15:32:38.941]                         !identical(envir, emptyenv())) {
[15:32:38.941]                         if (exists("master", mode = "list", envir = envir, 
[15:32:38.941]                           inherits = FALSE)) {
[15:32:38.941]                           master <- get("master", mode = "list", 
[15:32:38.941]                             envir = envir, inherits = FALSE)
[15:32:38.941]                           if (inherits(master, c("SOCKnode", 
[15:32:38.941]                             "SOCK0node"))) {
[15:32:38.941]                             sendCondition <<- function(cond) {
[15:32:38.941]                               data <- list(type = "VALUE", value = cond, 
[15:32:38.941]                                 success = TRUE)
[15:32:38.941]                               parallel_sendData(master, data)
[15:32:38.941]                             }
[15:32:38.941]                             return(sendCondition)
[15:32:38.941]                           }
[15:32:38.941]                         }
[15:32:38.941]                         frame <- frame + 1L
[15:32:38.941]                         envir <- sys.frame(frame)
[15:32:38.941]                       }
[15:32:38.941]                     }
[15:32:38.941]                     sendCondition <<- function(cond) NULL
[15:32:38.941]                   }
[15:32:38.941]                 })
[15:32:38.941]                 withCallingHandlers({
[15:32:38.941]                   {
[15:32:38.941]                     do.call(function(...) {
[15:32:38.941]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:38.941]                       if (!identical(...future.globals.maxSize.org, 
[15:32:38.941]                         ...future.globals.maxSize)) {
[15:32:38.941]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:38.941]                         on.exit(options(oopts), add = TRUE)
[15:32:38.941]                       }
[15:32:38.941]                       {
[15:32:38.941]                         lapply(seq_along(...future.elements_ii), 
[15:32:38.941]                           FUN = function(jj) {
[15:32:38.941]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:38.941]                             ...future.FUN(...future.X_jj, ...)
[15:32:38.941]                           })
[15:32:38.941]                       }
[15:32:38.941]                     }, args = future.call.arguments)
[15:32:38.941]                   }
[15:32:38.941]                 }, immediateCondition = function(cond) {
[15:32:38.941]                   sendCondition <- ...future.makeSendCondition()
[15:32:38.941]                   sendCondition(cond)
[15:32:38.941]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:38.941]                   {
[15:32:38.941]                     inherits <- base::inherits
[15:32:38.941]                     invokeRestart <- base::invokeRestart
[15:32:38.941]                     is.null <- base::is.null
[15:32:38.941]                     muffled <- FALSE
[15:32:38.941]                     if (inherits(cond, "message")) {
[15:32:38.941]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:38.941]                       if (muffled) 
[15:32:38.941]                         invokeRestart("muffleMessage")
[15:32:38.941]                     }
[15:32:38.941]                     else if (inherits(cond, "warning")) {
[15:32:38.941]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:38.941]                       if (muffled) 
[15:32:38.941]                         invokeRestart("muffleWarning")
[15:32:38.941]                     }
[15:32:38.941]                     else if (inherits(cond, "condition")) {
[15:32:38.941]                       if (!is.null(pattern)) {
[15:32:38.941]                         computeRestarts <- base::computeRestarts
[15:32:38.941]                         grepl <- base::grepl
[15:32:38.941]                         restarts <- computeRestarts(cond)
[15:32:38.941]                         for (restart in restarts) {
[15:32:38.941]                           name <- restart$name
[15:32:38.941]                           if (is.null(name)) 
[15:32:38.941]                             next
[15:32:38.941]                           if (!grepl(pattern, name)) 
[15:32:38.941]                             next
[15:32:38.941]                           invokeRestart(restart)
[15:32:38.941]                           muffled <- TRUE
[15:32:38.941]                           break
[15:32:38.941]                         }
[15:32:38.941]                       }
[15:32:38.941]                     }
[15:32:38.941]                     invisible(muffled)
[15:32:38.941]                   }
[15:32:38.941]                   muffleCondition(cond)
[15:32:38.941]                 })
[15:32:38.941]             }))
[15:32:38.941]             future::FutureResult(value = ...future.value$value, 
[15:32:38.941]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:38.941]                   ...future.rng), globalenv = if (FALSE) 
[15:32:38.941]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:38.941]                     ...future.globalenv.names))
[15:32:38.941]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:38.941]         }, condition = base::local({
[15:32:38.941]             c <- base::c
[15:32:38.941]             inherits <- base::inherits
[15:32:38.941]             invokeRestart <- base::invokeRestart
[15:32:38.941]             length <- base::length
[15:32:38.941]             list <- base::list
[15:32:38.941]             seq.int <- base::seq.int
[15:32:38.941]             signalCondition <- base::signalCondition
[15:32:38.941]             sys.calls <- base::sys.calls
[15:32:38.941]             `[[` <- base::`[[`
[15:32:38.941]             `+` <- base::`+`
[15:32:38.941]             `<<-` <- base::`<<-`
[15:32:38.941]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:38.941]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:38.941]                   3L)]
[15:32:38.941]             }
[15:32:38.941]             function(cond) {
[15:32:38.941]                 is_error <- inherits(cond, "error")
[15:32:38.941]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:38.941]                   NULL)
[15:32:38.941]                 if (is_error) {
[15:32:38.941]                   sessionInformation <- function() {
[15:32:38.941]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:38.941]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:38.941]                       search = base::search(), system = base::Sys.info())
[15:32:38.941]                   }
[15:32:38.941]                   ...future.conditions[[length(...future.conditions) + 
[15:32:38.941]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:38.941]                     cond$call), session = sessionInformation(), 
[15:32:38.941]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:38.941]                   signalCondition(cond)
[15:32:38.941]                 }
[15:32:38.941]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:38.941]                 "immediateCondition"))) {
[15:32:38.941]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:38.941]                   ...future.conditions[[length(...future.conditions) + 
[15:32:38.941]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:38.941]                   if (TRUE && !signal) {
[15:32:38.941]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:38.941]                     {
[15:32:38.941]                       inherits <- base::inherits
[15:32:38.941]                       invokeRestart <- base::invokeRestart
[15:32:38.941]                       is.null <- base::is.null
[15:32:38.941]                       muffled <- FALSE
[15:32:38.941]                       if (inherits(cond, "message")) {
[15:32:38.941]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:38.941]                         if (muffled) 
[15:32:38.941]                           invokeRestart("muffleMessage")
[15:32:38.941]                       }
[15:32:38.941]                       else if (inherits(cond, "warning")) {
[15:32:38.941]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:38.941]                         if (muffled) 
[15:32:38.941]                           invokeRestart("muffleWarning")
[15:32:38.941]                       }
[15:32:38.941]                       else if (inherits(cond, "condition")) {
[15:32:38.941]                         if (!is.null(pattern)) {
[15:32:38.941]                           computeRestarts <- base::computeRestarts
[15:32:38.941]                           grepl <- base::grepl
[15:32:38.941]                           restarts <- computeRestarts(cond)
[15:32:38.941]                           for (restart in restarts) {
[15:32:38.941]                             name <- restart$name
[15:32:38.941]                             if (is.null(name)) 
[15:32:38.941]                               next
[15:32:38.941]                             if (!grepl(pattern, name)) 
[15:32:38.941]                               next
[15:32:38.941]                             invokeRestart(restart)
[15:32:38.941]                             muffled <- TRUE
[15:32:38.941]                             break
[15:32:38.941]                           }
[15:32:38.941]                         }
[15:32:38.941]                       }
[15:32:38.941]                       invisible(muffled)
[15:32:38.941]                     }
[15:32:38.941]                     muffleCondition(cond, pattern = "^muffle")
[15:32:38.941]                   }
[15:32:38.941]                 }
[15:32:38.941]                 else {
[15:32:38.941]                   if (TRUE) {
[15:32:38.941]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:38.941]                     {
[15:32:38.941]                       inherits <- base::inherits
[15:32:38.941]                       invokeRestart <- base::invokeRestart
[15:32:38.941]                       is.null <- base::is.null
[15:32:38.941]                       muffled <- FALSE
[15:32:38.941]                       if (inherits(cond, "message")) {
[15:32:38.941]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:38.941]                         if (muffled) 
[15:32:38.941]                           invokeRestart("muffleMessage")
[15:32:38.941]                       }
[15:32:38.941]                       else if (inherits(cond, "warning")) {
[15:32:38.941]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:38.941]                         if (muffled) 
[15:32:38.941]                           invokeRestart("muffleWarning")
[15:32:38.941]                       }
[15:32:38.941]                       else if (inherits(cond, "condition")) {
[15:32:38.941]                         if (!is.null(pattern)) {
[15:32:38.941]                           computeRestarts <- base::computeRestarts
[15:32:38.941]                           grepl <- base::grepl
[15:32:38.941]                           restarts <- computeRestarts(cond)
[15:32:38.941]                           for (restart in restarts) {
[15:32:38.941]                             name <- restart$name
[15:32:38.941]                             if (is.null(name)) 
[15:32:38.941]                               next
[15:32:38.941]                             if (!grepl(pattern, name)) 
[15:32:38.941]                               next
[15:32:38.941]                             invokeRestart(restart)
[15:32:38.941]                             muffled <- TRUE
[15:32:38.941]                             break
[15:32:38.941]                           }
[15:32:38.941]                         }
[15:32:38.941]                       }
[15:32:38.941]                       invisible(muffled)
[15:32:38.941]                     }
[15:32:38.941]                     muffleCondition(cond, pattern = "^muffle")
[15:32:38.941]                   }
[15:32:38.941]                 }
[15:32:38.941]             }
[15:32:38.941]         }))
[15:32:38.941]     }, error = function(ex) {
[15:32:38.941]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:38.941]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:38.941]                 ...future.rng), started = ...future.startTime, 
[15:32:38.941]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:38.941]             version = "1.8"), class = "FutureResult")
[15:32:38.941]     }, finally = {
[15:32:38.941]         if (!identical(...future.workdir, getwd())) 
[15:32:38.941]             setwd(...future.workdir)
[15:32:38.941]         {
[15:32:38.941]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:38.941]                 ...future.oldOptions$nwarnings <- NULL
[15:32:38.941]             }
[15:32:38.941]             base::options(...future.oldOptions)
[15:32:38.941]             if (.Platform$OS.type == "windows") {
[15:32:38.941]                 old_names <- names(...future.oldEnvVars)
[15:32:38.941]                 envs <- base::Sys.getenv()
[15:32:38.941]                 names <- names(envs)
[15:32:38.941]                 common <- intersect(names, old_names)
[15:32:38.941]                 added <- setdiff(names, old_names)
[15:32:38.941]                 removed <- setdiff(old_names, names)
[15:32:38.941]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:38.941]                   envs[common]]
[15:32:38.941]                 NAMES <- toupper(changed)
[15:32:38.941]                 args <- list()
[15:32:38.941]                 for (kk in seq_along(NAMES)) {
[15:32:38.941]                   name <- changed[[kk]]
[15:32:38.941]                   NAME <- NAMES[[kk]]
[15:32:38.941]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:38.941]                     next
[15:32:38.941]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:38.941]                 }
[15:32:38.941]                 NAMES <- toupper(added)
[15:32:38.941]                 for (kk in seq_along(NAMES)) {
[15:32:38.941]                   name <- added[[kk]]
[15:32:38.941]                   NAME <- NAMES[[kk]]
[15:32:38.941]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:38.941]                     next
[15:32:38.941]                   args[[name]] <- ""
[15:32:38.941]                 }
[15:32:38.941]                 NAMES <- toupper(removed)
[15:32:38.941]                 for (kk in seq_along(NAMES)) {
[15:32:38.941]                   name <- removed[[kk]]
[15:32:38.941]                   NAME <- NAMES[[kk]]
[15:32:38.941]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:38.941]                     next
[15:32:38.941]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:38.941]                 }
[15:32:38.941]                 if (length(args) > 0) 
[15:32:38.941]                   base::do.call(base::Sys.setenv, args = args)
[15:32:38.941]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:38.941]             }
[15:32:38.941]             else {
[15:32:38.941]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:38.941]             }
[15:32:38.941]             {
[15:32:38.941]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:38.941]                   0L) {
[15:32:38.941]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:38.941]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:38.941]                   base::options(opts)
[15:32:38.941]                 }
[15:32:38.941]                 {
[15:32:38.941]                   {
[15:32:38.941]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:38.941]                     NULL
[15:32:38.941]                   }
[15:32:38.941]                   options(future.plan = NULL)
[15:32:38.941]                   if (is.na(NA_character_)) 
[15:32:38.941]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:38.941]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:38.941]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:38.941]                     .init = FALSE)
[15:32:38.941]                 }
[15:32:38.941]             }
[15:32:38.941]         }
[15:32:38.941]     })
[15:32:38.941]     if (TRUE) {
[15:32:38.941]         base::sink(type = "output", split = FALSE)
[15:32:38.941]         if (TRUE) {
[15:32:38.941]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:38.941]         }
[15:32:38.941]         else {
[15:32:38.941]             ...future.result["stdout"] <- base::list(NULL)
[15:32:38.941]         }
[15:32:38.941]         base::close(...future.stdout)
[15:32:38.941]         ...future.stdout <- NULL
[15:32:38.941]     }
[15:32:38.941]     ...future.result$conditions <- ...future.conditions
[15:32:38.941]     ...future.result$finished <- base::Sys.time()
[15:32:38.941]     ...future.result
[15:32:38.941] }
[15:32:38.947] Exporting 5 global objects (4.62 KiB) to cluster node #1 ...
[15:32:38.948] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ...
[15:32:38.948] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ... DONE
[15:32:38.949] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:38.949] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:38.949] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:38.950] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:38.950] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:38.950] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:38.951] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:38.951] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:38.951] Exporting 5 global objects (4.62 KiB) to cluster node #1 ... DONE
[15:32:38.952] MultisessionFuture started
[15:32:38.952] - Launch lazy future ... done
[15:32:38.953] run() for 'MultisessionFuture' ... done
[15:32:38.953] Created future:
[15:32:38.977] receiveMessageFromWorker() for ClusterFuture ...
[15:32:38.978] - Validating connection of MultisessionFuture
[15:32:38.978] - received message: FutureResult
[15:32:38.979] - Received FutureResult
[15:32:38.979] - Erased future from FutureRegistry
[15:32:38.979] result() for ClusterFuture ...
[15:32:38.980] - result already collected: FutureResult
[15:32:38.980] result() for ClusterFuture ... done
[15:32:38.980] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:38.953] MultisessionFuture:
[15:32:38.953] Label: 'future_sapply-2'
[15:32:38.953] Expression:
[15:32:38.953] {
[15:32:38.953]     do.call(function(...) {
[15:32:38.953]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:38.953]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:38.953]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:38.953]             on.exit(options(oopts), add = TRUE)
[15:32:38.953]         }
[15:32:38.953]         {
[15:32:38.953]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:38.953]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:38.953]                 ...future.FUN(...future.X_jj, ...)
[15:32:38.953]             })
[15:32:38.953]         }
[15:32:38.953]     }, args = future.call.arguments)
[15:32:38.953] }
[15:32:38.953] Lazy evaluation: FALSE
[15:32:38.953] Asynchronous evaluation: TRUE
[15:32:38.953] Local evaluation: TRUE
[15:32:38.953] Environment: R_GlobalEnv
[15:32:38.953] Capture standard output: TRUE
[15:32:38.953] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:38.953] Globals: 5 objects totaling 4.73 KiB (function '...future.FUN' of 4.62 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)
[15:32:38.953] Packages: <none>
[15:32:38.953] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:38.953] Resolved: TRUE
[15:32:38.953] Value: <not collected>
[15:32:38.953] Conditions captured: <none>
[15:32:38.953] Early signaling: FALSE
[15:32:38.953] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:38.953] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:38.981] Chunk #2 of 2 ... DONE
[15:32:38.981] Launching 2 futures (chunks) ... DONE
[15:32:38.982] Resolving 2 futures (chunks) ...
[15:32:38.982] resolve() on list ...
[15:32:38.982]  recursive: 0
[15:32:38.982]  length: 2
[15:32:38.983] 
[15:32:38.983] Future #1
[15:32:38.983] result() for ClusterFuture ...
[15:32:38.984] - result already collected: FutureResult
[15:32:38.984] result() for ClusterFuture ... done
[15:32:38.984] result() for ClusterFuture ...
[15:32:38.984] - result already collected: FutureResult
[15:32:38.985] result() for ClusterFuture ... done
[15:32:38.985] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:38.985] - nx: 2
[15:32:38.986] - relay: TRUE
[15:32:38.986] - stdout: TRUE
[15:32:38.986] - signal: TRUE
[15:32:38.986] - resignal: FALSE
[15:32:38.987] - force: TRUE
[15:32:38.987] - relayed: [n=2] FALSE, FALSE
[15:32:38.987] - queued futures: [n=2] FALSE, FALSE
[15:32:38.987]  - until=1
[15:32:38.988]  - relaying element #1
[15:32:38.988] result() for ClusterFuture ...
[15:32:38.988] - result already collected: FutureResult
[15:32:38.989] result() for ClusterFuture ... done
[15:32:38.989] result() for ClusterFuture ...
[15:32:38.989] - result already collected: FutureResult
[15:32:38.989] result() for ClusterFuture ... done
[15:32:38.990] result() for ClusterFuture ...
[15:32:38.990] - result already collected: FutureResult
[15:32:38.990] result() for ClusterFuture ... done
[15:32:38.991] result() for ClusterFuture ...
[15:32:38.991] - result already collected: FutureResult
[15:32:38.991] result() for ClusterFuture ... done
[15:32:38.991] - relayed: [n=2] TRUE, FALSE
[15:32:38.992] - queued futures: [n=2] TRUE, FALSE
[15:32:38.992] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:38.992]  length: 1 (resolved future 1)
[15:32:38.993] Future #2
[15:32:38.993] result() for ClusterFuture ...
[15:32:38.993] - result already collected: FutureResult
[15:32:38.994] result() for ClusterFuture ... done
[15:32:38.994] result() for ClusterFuture ...
[15:32:38.994] - result already collected: FutureResult
[15:32:38.994] result() for ClusterFuture ... done
[15:32:38.995] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:38.995] - nx: 2
[15:32:38.995] - relay: TRUE
[15:32:38.996] - stdout: TRUE
[15:32:38.996] - signal: TRUE
[15:32:38.996] - resignal: FALSE
[15:32:38.996] - force: TRUE
[15:32:38.997] - relayed: [n=2] TRUE, FALSE
[15:32:38.997] - queued futures: [n=2] TRUE, FALSE
[15:32:38.997]  - until=2
[15:32:38.998]  - relaying element #2
[15:32:38.998] result() for ClusterFuture ...
[15:32:38.998] - result already collected: FutureResult
[15:32:38.998] result() for ClusterFuture ... done
[15:32:38.999] result() for ClusterFuture ...
[15:32:38.999] - result already collected: FutureResult
[15:32:38.999] result() for ClusterFuture ... done
[15:32:39.000] result() for ClusterFuture ...
[15:32:39.000] - result already collected: FutureResult
[15:32:39.000] result() for ClusterFuture ... done
[15:32:39.001] result() for ClusterFuture ...
[15:32:39.001] - result already collected: FutureResult
[15:32:39.001] result() for ClusterFuture ... done
[15:32:39.001] - relayed: [n=2] TRUE, TRUE
[15:32:39.002] - queued futures: [n=2] TRUE, TRUE
[15:32:39.002] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:39.002]  length: 0 (resolved future 2)
[15:32:39.003] Relaying remaining futures
[15:32:39.003] signalConditionsASAP(NULL, pos=0) ...
[15:32:39.003] - nx: 2
[15:32:39.004] - relay: TRUE
[15:32:39.004] - stdout: TRUE
[15:32:39.004] - signal: TRUE
[15:32:39.004] - resignal: FALSE
[15:32:39.005] - force: TRUE
[15:32:39.005] - relayed: [n=2] TRUE, TRUE
[15:32:39.005] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:39.006] - relayed: [n=2] TRUE, TRUE
[15:32:39.006] - queued futures: [n=2] TRUE, TRUE
[15:32:39.006] signalConditionsASAP(NULL, pos=0) ... done
[15:32:39.007] resolve() on list ... DONE
[15:32:39.007] result() for ClusterFuture ...
[15:32:39.007] - result already collected: FutureResult
[15:32:39.007] result() for ClusterFuture ... done
[15:32:39.008] result() for ClusterFuture ...
[15:32:39.008] - result already collected: FutureResult
[15:32:39.008] result() for ClusterFuture ... done
[15:32:39.008] result() for ClusterFuture ...
[15:32:39.009] - result already collected: FutureResult
[15:32:39.009] result() for ClusterFuture ... done
[15:32:39.009] result() for ClusterFuture ...
[15:32:39.009] - result already collected: FutureResult
[15:32:39.010] result() for ClusterFuture ... done
[15:32:39.010]  - Number of value chunks collected: 2
[15:32:39.010] Resolving 2 futures (chunks) ... DONE
[15:32:39.011] Reducing values from 2 chunks ...
[15:32:39.011]  - Number of values collected after concatenation: 4
[15:32:39.011]  - Number of values expected: 4
[15:32:39.011] Reducing values from 2 chunks ... DONE
[15:32:39.011] future_lapply() ... DONE
List of 2
 $ y0: num [1:15, 1:4] 100 100 100 200 200 200 300 300 300 400 ...
  ..- attr(*, "dimnames")=List of 2
  .. ..$ : NULL
  .. ..$ : chr [1:4] "A" "B" "C" "D"
 $ y1: num [1:15, 1:4] 100 100 100 200 200 200 300 300 300 400 ...
  ..- attr(*, "dimnames")=List of 2
  .. ..$ : NULL
  .. ..$ : chr [1:4] "A" "B" "C" "D"
[15:32:39.017] future_lapply() ...
[15:32:39.021] Number of chunks: 2
[15:32:39.021] getGlobalsAndPackagesXApply() ...
[15:32:39.021]  - future.globals: TRUE
[15:32:39.021] getGlobalsAndPackages() ...
[15:32:39.022] Searching for globals...
[15:32:39.023] - globals found: [1] 'FUN'
[15:32:39.024] Searching for globals ... DONE
[15:32:39.024] Resolving globals: FALSE
[15:32:39.024] The total size of the 1 globals is 848 bytes (848 bytes)
[15:32:39.025] The total size of the 1 globals exported for future expression ('FUN()') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:32:39.025] - globals: [1] 'FUN'
[15:32:39.026] 
[15:32:39.026] getGlobalsAndPackages() ... DONE
[15:32:39.026]  - globals found/used: [n=1] 'FUN'
[15:32:39.026]  - needed namespaces: [n=0] 
[15:32:39.027] Finding globals ... DONE
[15:32:39.027]  - use_args: TRUE
[15:32:39.027]  - Getting '...' globals ...
[15:32:39.028] resolve() on list ...
[15:32:39.028]  recursive: 0
[15:32:39.028]  length: 1
[15:32:39.029]  elements: '...'
[15:32:39.029]  length: 0 (resolved future 1)
[15:32:39.029] resolve() on list ... DONE
[15:32:39.029]    - '...' content: [n=0] 
[15:32:39.030] List of 1
[15:32:39.030]  $ ...: list()
[15:32:39.030]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:39.030]  - attr(*, "where")=List of 1
[15:32:39.030]   ..$ ...:<environment: 0x00000276e44bab58> 
[15:32:39.030]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:39.030]  - attr(*, "resolved")= logi TRUE
[15:32:39.030]  - attr(*, "total_size")= num NA
[15:32:39.035]  - Getting '...' globals ... DONE
[15:32:39.035] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:39.035] List of 2
[15:32:39.035]  $ ...future.FUN:function (x)  
[15:32:39.035]  $ ...          : list()
[15:32:39.035]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:39.035]  - attr(*, "where")=List of 2
[15:32:39.035]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:39.035]   ..$ ...          :<environment: 0x00000276e44bab58> 
[15:32:39.035]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:39.035]  - attr(*, "resolved")= logi FALSE
[15:32:39.035]  - attr(*, "total_size")= num 848
[15:32:39.041] Packages to be attached in all futures: [n=0] 
[15:32:39.041] getGlobalsAndPackagesXApply() ... DONE
[15:32:39.042] Number of futures (= number of chunks): 2
[15:32:39.042] Launching 2 futures (chunks) ...
[15:32:39.043] Chunk #1 of 2 ...
[15:32:39.043]  - Finding globals in 'X' for chunk #1 ...
[15:32:39.043] getGlobalsAndPackages() ...
[15:32:39.043] Searching for globals...
[15:32:39.044] 
[15:32:39.044] Searching for globals ... DONE
[15:32:39.044] - globals: [0] <none>
[15:32:39.045] getGlobalsAndPackages() ... DONE
[15:32:39.045]    + additional globals found: [n=0] 
[15:32:39.045]    + additional namespaces needed: [n=0] 
[15:32:39.045]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:39.045]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:39.046]  - seeds: <none>
[15:32:39.046]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:39.046] getGlobalsAndPackages() ...
[15:32:39.046] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:39.047] Resolving globals: FALSE
[15:32:39.047] Tweak future expression to call with '...' arguments ...
[15:32:39.047] {
[15:32:39.047]     do.call(function(...) {
[15:32:39.047]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:39.047]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:39.047]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:39.047]             on.exit(options(oopts), add = TRUE)
[15:32:39.047]         }
[15:32:39.047]         {
[15:32:39.047]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:39.047]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:39.047]                 ...future.FUN(...future.X_jj, ...)
[15:32:39.047]             })
[15:32:39.047]         }
[15:32:39.047]     }, args = future.call.arguments)
[15:32:39.047] }
[15:32:39.048] Tweak future expression to call with '...' arguments ... DONE
[15:32:39.049] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:39.049] 
[15:32:39.049] getGlobalsAndPackages() ... DONE
[15:32:39.050] run() for 'Future' ...
[15:32:39.050] - state: 'created'
[15:32:39.050] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:39.067] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:39.068] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:39.068]   - Field: 'node'
[15:32:39.068]   - Field: 'label'
[15:32:39.068]   - Field: 'local'
[15:32:39.069]   - Field: 'owner'
[15:32:39.069]   - Field: 'envir'
[15:32:39.069]   - Field: 'workers'
[15:32:39.070]   - Field: 'packages'
[15:32:39.070]   - Field: 'gc'
[15:32:39.070]   - Field: 'conditions'
[15:32:39.070]   - Field: 'persistent'
[15:32:39.071]   - Field: 'expr'
[15:32:39.071]   - Field: 'uuid'
[15:32:39.071]   - Field: 'seed'
[15:32:39.072]   - Field: 'version'
[15:32:39.072]   - Field: 'result'
[15:32:39.072]   - Field: 'asynchronous'
[15:32:39.072]   - Field: 'calls'
[15:32:39.073]   - Field: 'globals'
[15:32:39.073]   - Field: 'stdout'
[15:32:39.073]   - Field: 'earlySignal'
[15:32:39.074]   - Field: 'lazy'
[15:32:39.074]   - Field: 'state'
[15:32:39.074] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:39.074] - Launch lazy future ...
[15:32:39.075] Packages needed by the future expression (n = 0): <none>
[15:32:39.075] Packages needed by future strategies (n = 0): <none>
[15:32:39.080] {
[15:32:39.080]     {
[15:32:39.080]         {
[15:32:39.080]             ...future.startTime <- base::Sys.time()
[15:32:39.080]             {
[15:32:39.080]                 {
[15:32:39.080]                   {
[15:32:39.080]                     {
[15:32:39.080]                       base::local({
[15:32:39.080]                         has_future <- base::requireNamespace("future", 
[15:32:39.080]                           quietly = TRUE)
[15:32:39.080]                         if (has_future) {
[15:32:39.080]                           ns <- base::getNamespace("future")
[15:32:39.080]                           version <- ns[[".package"]][["version"]]
[15:32:39.080]                           if (is.null(version)) 
[15:32:39.080]                             version <- utils::packageVersion("future")
[15:32:39.080]                         }
[15:32:39.080]                         else {
[15:32:39.080]                           version <- NULL
[15:32:39.080]                         }
[15:32:39.080]                         if (!has_future || version < "1.8.0") {
[15:32:39.080]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:39.080]                             "", base::R.version$version.string), 
[15:32:39.080]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:39.080]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:39.080]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:39.080]                               "release", "version")], collapse = " "), 
[15:32:39.080]                             hostname = base::Sys.info()[["nodename"]])
[15:32:39.080]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:39.080]                             info)
[15:32:39.080]                           info <- base::paste(info, collapse = "; ")
[15:32:39.080]                           if (!has_future) {
[15:32:39.080]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:39.080]                               info)
[15:32:39.080]                           }
[15:32:39.080]                           else {
[15:32:39.080]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:39.080]                               info, version)
[15:32:39.080]                           }
[15:32:39.080]                           base::stop(msg)
[15:32:39.080]                         }
[15:32:39.080]                       })
[15:32:39.080]                     }
[15:32:39.080]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:39.080]                     base::options(mc.cores = 1L)
[15:32:39.080]                   }
[15:32:39.080]                   ...future.strategy.old <- future::plan("list")
[15:32:39.080]                   options(future.plan = NULL)
[15:32:39.080]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:39.080]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:39.080]                 }
[15:32:39.080]                 ...future.workdir <- getwd()
[15:32:39.080]             }
[15:32:39.080]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:39.080]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:39.080]         }
[15:32:39.080]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:39.080]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:39.080]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:39.080]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:39.080]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:39.080]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:39.080]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:39.080]             base::names(...future.oldOptions))
[15:32:39.080]     }
[15:32:39.080]     if (FALSE) {
[15:32:39.080]     }
[15:32:39.080]     else {
[15:32:39.080]         if (TRUE) {
[15:32:39.080]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:39.080]                 open = "w")
[15:32:39.080]         }
[15:32:39.080]         else {
[15:32:39.080]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:39.080]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:39.080]         }
[15:32:39.080]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:39.080]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:39.080]             base::sink(type = "output", split = FALSE)
[15:32:39.080]             base::close(...future.stdout)
[15:32:39.080]         }, add = TRUE)
[15:32:39.080]     }
[15:32:39.080]     ...future.frame <- base::sys.nframe()
[15:32:39.080]     ...future.conditions <- base::list()
[15:32:39.080]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:39.080]     if (FALSE) {
[15:32:39.080]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:39.080]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:39.080]     }
[15:32:39.080]     ...future.result <- base::tryCatch({
[15:32:39.080]         base::withCallingHandlers({
[15:32:39.080]             ...future.value <- base::withVisible(base::local({
[15:32:39.080]                 ...future.makeSendCondition <- base::local({
[15:32:39.080]                   sendCondition <- NULL
[15:32:39.080]                   function(frame = 1L) {
[15:32:39.080]                     if (is.function(sendCondition)) 
[15:32:39.080]                       return(sendCondition)
[15:32:39.080]                     ns <- getNamespace("parallel")
[15:32:39.080]                     if (exists("sendData", mode = "function", 
[15:32:39.080]                       envir = ns)) {
[15:32:39.080]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:39.080]                         envir = ns)
[15:32:39.080]                       envir <- sys.frame(frame)
[15:32:39.080]                       master <- NULL
[15:32:39.080]                       while (!identical(envir, .GlobalEnv) && 
[15:32:39.080]                         !identical(envir, emptyenv())) {
[15:32:39.080]                         if (exists("master", mode = "list", envir = envir, 
[15:32:39.080]                           inherits = FALSE)) {
[15:32:39.080]                           master <- get("master", mode = "list", 
[15:32:39.080]                             envir = envir, inherits = FALSE)
[15:32:39.080]                           if (inherits(master, c("SOCKnode", 
[15:32:39.080]                             "SOCK0node"))) {
[15:32:39.080]                             sendCondition <<- function(cond) {
[15:32:39.080]                               data <- list(type = "VALUE", value = cond, 
[15:32:39.080]                                 success = TRUE)
[15:32:39.080]                               parallel_sendData(master, data)
[15:32:39.080]                             }
[15:32:39.080]                             return(sendCondition)
[15:32:39.080]                           }
[15:32:39.080]                         }
[15:32:39.080]                         frame <- frame + 1L
[15:32:39.080]                         envir <- sys.frame(frame)
[15:32:39.080]                       }
[15:32:39.080]                     }
[15:32:39.080]                     sendCondition <<- function(cond) NULL
[15:32:39.080]                   }
[15:32:39.080]                 })
[15:32:39.080]                 withCallingHandlers({
[15:32:39.080]                   {
[15:32:39.080]                     do.call(function(...) {
[15:32:39.080]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:39.080]                       if (!identical(...future.globals.maxSize.org, 
[15:32:39.080]                         ...future.globals.maxSize)) {
[15:32:39.080]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:39.080]                         on.exit(options(oopts), add = TRUE)
[15:32:39.080]                       }
[15:32:39.080]                       {
[15:32:39.080]                         lapply(seq_along(...future.elements_ii), 
[15:32:39.080]                           FUN = function(jj) {
[15:32:39.080]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:39.080]                             ...future.FUN(...future.X_jj, ...)
[15:32:39.080]                           })
[15:32:39.080]                       }
[15:32:39.080]                     }, args = future.call.arguments)
[15:32:39.080]                   }
[15:32:39.080]                 }, immediateCondition = function(cond) {
[15:32:39.080]                   sendCondition <- ...future.makeSendCondition()
[15:32:39.080]                   sendCondition(cond)
[15:32:39.080]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:39.080]                   {
[15:32:39.080]                     inherits <- base::inherits
[15:32:39.080]                     invokeRestart <- base::invokeRestart
[15:32:39.080]                     is.null <- base::is.null
[15:32:39.080]                     muffled <- FALSE
[15:32:39.080]                     if (inherits(cond, "message")) {
[15:32:39.080]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:39.080]                       if (muffled) 
[15:32:39.080]                         invokeRestart("muffleMessage")
[15:32:39.080]                     }
[15:32:39.080]                     else if (inherits(cond, "warning")) {
[15:32:39.080]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:39.080]                       if (muffled) 
[15:32:39.080]                         invokeRestart("muffleWarning")
[15:32:39.080]                     }
[15:32:39.080]                     else if (inherits(cond, "condition")) {
[15:32:39.080]                       if (!is.null(pattern)) {
[15:32:39.080]                         computeRestarts <- base::computeRestarts
[15:32:39.080]                         grepl <- base::grepl
[15:32:39.080]                         restarts <- computeRestarts(cond)
[15:32:39.080]                         for (restart in restarts) {
[15:32:39.080]                           name <- restart$name
[15:32:39.080]                           if (is.null(name)) 
[15:32:39.080]                             next
[15:32:39.080]                           if (!grepl(pattern, name)) 
[15:32:39.080]                             next
[15:32:39.080]                           invokeRestart(restart)
[15:32:39.080]                           muffled <- TRUE
[15:32:39.080]                           break
[15:32:39.080]                         }
[15:32:39.080]                       }
[15:32:39.080]                     }
[15:32:39.080]                     invisible(muffled)
[15:32:39.080]                   }
[15:32:39.080]                   muffleCondition(cond)
[15:32:39.080]                 })
[15:32:39.080]             }))
[15:32:39.080]             future::FutureResult(value = ...future.value$value, 
[15:32:39.080]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:39.080]                   ...future.rng), globalenv = if (FALSE) 
[15:32:39.080]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:39.080]                     ...future.globalenv.names))
[15:32:39.080]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:39.080]         }, condition = base::local({
[15:32:39.080]             c <- base::c
[15:32:39.080]             inherits <- base::inherits
[15:32:39.080]             invokeRestart <- base::invokeRestart
[15:32:39.080]             length <- base::length
[15:32:39.080]             list <- base::list
[15:32:39.080]             seq.int <- base::seq.int
[15:32:39.080]             signalCondition <- base::signalCondition
[15:32:39.080]             sys.calls <- base::sys.calls
[15:32:39.080]             `[[` <- base::`[[`
[15:32:39.080]             `+` <- base::`+`
[15:32:39.080]             `<<-` <- base::`<<-`
[15:32:39.080]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:39.080]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:39.080]                   3L)]
[15:32:39.080]             }
[15:32:39.080]             function(cond) {
[15:32:39.080]                 is_error <- inherits(cond, "error")
[15:32:39.080]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:39.080]                   NULL)
[15:32:39.080]                 if (is_error) {
[15:32:39.080]                   sessionInformation <- function() {
[15:32:39.080]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:39.080]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:39.080]                       search = base::search(), system = base::Sys.info())
[15:32:39.080]                   }
[15:32:39.080]                   ...future.conditions[[length(...future.conditions) + 
[15:32:39.080]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:39.080]                     cond$call), session = sessionInformation(), 
[15:32:39.080]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:39.080]                   signalCondition(cond)
[15:32:39.080]                 }
[15:32:39.080]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:39.080]                 "immediateCondition"))) {
[15:32:39.080]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:39.080]                   ...future.conditions[[length(...future.conditions) + 
[15:32:39.080]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:39.080]                   if (TRUE && !signal) {
[15:32:39.080]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:39.080]                     {
[15:32:39.080]                       inherits <- base::inherits
[15:32:39.080]                       invokeRestart <- base::invokeRestart
[15:32:39.080]                       is.null <- base::is.null
[15:32:39.080]                       muffled <- FALSE
[15:32:39.080]                       if (inherits(cond, "message")) {
[15:32:39.080]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:39.080]                         if (muffled) 
[15:32:39.080]                           invokeRestart("muffleMessage")
[15:32:39.080]                       }
[15:32:39.080]                       else if (inherits(cond, "warning")) {
[15:32:39.080]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:39.080]                         if (muffled) 
[15:32:39.080]                           invokeRestart("muffleWarning")
[15:32:39.080]                       }
[15:32:39.080]                       else if (inherits(cond, "condition")) {
[15:32:39.080]                         if (!is.null(pattern)) {
[15:32:39.080]                           computeRestarts <- base::computeRestarts
[15:32:39.080]                           grepl <- base::grepl
[15:32:39.080]                           restarts <- computeRestarts(cond)
[15:32:39.080]                           for (restart in restarts) {
[15:32:39.080]                             name <- restart$name
[15:32:39.080]                             if (is.null(name)) 
[15:32:39.080]                               next
[15:32:39.080]                             if (!grepl(pattern, name)) 
[15:32:39.080]                               next
[15:32:39.080]                             invokeRestart(restart)
[15:32:39.080]                             muffled <- TRUE
[15:32:39.080]                             break
[15:32:39.080]                           }
[15:32:39.080]                         }
[15:32:39.080]                       }
[15:32:39.080]                       invisible(muffled)
[15:32:39.080]                     }
[15:32:39.080]                     muffleCondition(cond, pattern = "^muffle")
[15:32:39.080]                   }
[15:32:39.080]                 }
[15:32:39.080]                 else {
[15:32:39.080]                   if (TRUE) {
[15:32:39.080]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:39.080]                     {
[15:32:39.080]                       inherits <- base::inherits
[15:32:39.080]                       invokeRestart <- base::invokeRestart
[15:32:39.080]                       is.null <- base::is.null
[15:32:39.080]                       muffled <- FALSE
[15:32:39.080]                       if (inherits(cond, "message")) {
[15:32:39.080]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:39.080]                         if (muffled) 
[15:32:39.080]                           invokeRestart("muffleMessage")
[15:32:39.080]                       }
[15:32:39.080]                       else if (inherits(cond, "warning")) {
[15:32:39.080]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:39.080]                         if (muffled) 
[15:32:39.080]                           invokeRestart("muffleWarning")
[15:32:39.080]                       }
[15:32:39.080]                       else if (inherits(cond, "condition")) {
[15:32:39.080]                         if (!is.null(pattern)) {
[15:32:39.080]                           computeRestarts <- base::computeRestarts
[15:32:39.080]                           grepl <- base::grepl
[15:32:39.080]                           restarts <- computeRestarts(cond)
[15:32:39.080]                           for (restart in restarts) {
[15:32:39.080]                             name <- restart$name
[15:32:39.080]                             if (is.null(name)) 
[15:32:39.080]                               next
[15:32:39.080]                             if (!grepl(pattern, name)) 
[15:32:39.080]                               next
[15:32:39.080]                             invokeRestart(restart)
[15:32:39.080]                             muffled <- TRUE
[15:32:39.080]                             break
[15:32:39.080]                           }
[15:32:39.080]                         }
[15:32:39.080]                       }
[15:32:39.080]                       invisible(muffled)
[15:32:39.080]                     }
[15:32:39.080]                     muffleCondition(cond, pattern = "^muffle")
[15:32:39.080]                   }
[15:32:39.080]                 }
[15:32:39.080]             }
[15:32:39.080]         }))
[15:32:39.080]     }, error = function(ex) {
[15:32:39.080]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:39.080]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:39.080]                 ...future.rng), started = ...future.startTime, 
[15:32:39.080]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:39.080]             version = "1.8"), class = "FutureResult")
[15:32:39.080]     }, finally = {
[15:32:39.080]         if (!identical(...future.workdir, getwd())) 
[15:32:39.080]             setwd(...future.workdir)
[15:32:39.080]         {
[15:32:39.080]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:39.080]                 ...future.oldOptions$nwarnings <- NULL
[15:32:39.080]             }
[15:32:39.080]             base::options(...future.oldOptions)
[15:32:39.080]             if (.Platform$OS.type == "windows") {
[15:32:39.080]                 old_names <- names(...future.oldEnvVars)
[15:32:39.080]                 envs <- base::Sys.getenv()
[15:32:39.080]                 names <- names(envs)
[15:32:39.080]                 common <- intersect(names, old_names)
[15:32:39.080]                 added <- setdiff(names, old_names)
[15:32:39.080]                 removed <- setdiff(old_names, names)
[15:32:39.080]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:39.080]                   envs[common]]
[15:32:39.080]                 NAMES <- toupper(changed)
[15:32:39.080]                 args <- list()
[15:32:39.080]                 for (kk in seq_along(NAMES)) {
[15:32:39.080]                   name <- changed[[kk]]
[15:32:39.080]                   NAME <- NAMES[[kk]]
[15:32:39.080]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:39.080]                     next
[15:32:39.080]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:39.080]                 }
[15:32:39.080]                 NAMES <- toupper(added)
[15:32:39.080]                 for (kk in seq_along(NAMES)) {
[15:32:39.080]                   name <- added[[kk]]
[15:32:39.080]                   NAME <- NAMES[[kk]]
[15:32:39.080]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:39.080]                     next
[15:32:39.080]                   args[[name]] <- ""
[15:32:39.080]                 }
[15:32:39.080]                 NAMES <- toupper(removed)
[15:32:39.080]                 for (kk in seq_along(NAMES)) {
[15:32:39.080]                   name <- removed[[kk]]
[15:32:39.080]                   NAME <- NAMES[[kk]]
[15:32:39.080]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:39.080]                     next
[15:32:39.080]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:39.080]                 }
[15:32:39.080]                 if (length(args) > 0) 
[15:32:39.080]                   base::do.call(base::Sys.setenv, args = args)
[15:32:39.080]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:39.080]             }
[15:32:39.080]             else {
[15:32:39.080]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:39.080]             }
[15:32:39.080]             {
[15:32:39.080]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:39.080]                   0L) {
[15:32:39.080]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:39.080]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:39.080]                   base::options(opts)
[15:32:39.080]                 }
[15:32:39.080]                 {
[15:32:39.080]                   {
[15:32:39.080]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:39.080]                     NULL
[15:32:39.080]                   }
[15:32:39.080]                   options(future.plan = NULL)
[15:32:39.080]                   if (is.na(NA_character_)) 
[15:32:39.080]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:39.080]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:39.080]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:39.080]                     .init = FALSE)
[15:32:39.080]                 }
[15:32:39.080]             }
[15:32:39.080]         }
[15:32:39.080]     })
[15:32:39.080]     if (TRUE) {
[15:32:39.080]         base::sink(type = "output", split = FALSE)
[15:32:39.080]         if (TRUE) {
[15:32:39.080]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:39.080]         }
[15:32:39.080]         else {
[15:32:39.080]             ...future.result["stdout"] <- base::list(NULL)
[15:32:39.080]         }
[15:32:39.080]         base::close(...future.stdout)
[15:32:39.080]         ...future.stdout <- NULL
[15:32:39.080]     }
[15:32:39.080]     ...future.result$conditions <- ...future.conditions
[15:32:39.080]     ...future.result$finished <- base::Sys.time()
[15:32:39.080]     ...future.result
[15:32:39.080] }
[15:32:39.087] Exporting 5 global objects (848 bytes) to cluster node #1 ...
[15:32:39.087] Exporting '...future.FUN' (848 bytes) to cluster node #1 ...
[15:32:39.087] Exporting '...future.FUN' (848 bytes) to cluster node #1 ... DONE
[15:32:39.088] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:39.088] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:39.089] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:39.089] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:39.089] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:39.090] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:39.090] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:39.090] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:39.091] Exporting 5 global objects (848 bytes) to cluster node #1 ... DONE
[15:32:39.091] MultisessionFuture started
[15:32:39.092] - Launch lazy future ... done
[15:32:39.092] run() for 'MultisessionFuture' ... done
[15:32:39.092] Created future:
[15:32:39.114] receiveMessageFromWorker() for ClusterFuture ...
[15:32:39.115] - Validating connection of MultisessionFuture
[15:32:39.116] - received message: FutureResult
[15:32:39.116] - Received FutureResult
[15:32:39.117] - Erased future from FutureRegistry
[15:32:39.117] result() for ClusterFuture ...
[15:32:39.117] - result already collected: FutureResult
[15:32:39.118] result() for ClusterFuture ... done
[15:32:39.118] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:39.093] MultisessionFuture:
[15:32:39.093] Label: 'future_sapply-1'
[15:32:39.093] Expression:
[15:32:39.093] {
[15:32:39.093]     do.call(function(...) {
[15:32:39.093]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:39.093]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:39.093]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:39.093]             on.exit(options(oopts), add = TRUE)
[15:32:39.093]         }
[15:32:39.093]         {
[15:32:39.093]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:39.093]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:39.093]                 ...future.FUN(...future.X_jj, ...)
[15:32:39.093]             })
[15:32:39.093]         }
[15:32:39.093]     }, args = future.call.arguments)
[15:32:39.093] }
[15:32:39.093] Lazy evaluation: FALSE
[15:32:39.093] Asynchronous evaluation: TRUE
[15:32:39.093] Local evaluation: TRUE
[15:32:39.093] Environment: R_GlobalEnv
[15:32:39.093] Capture standard output: TRUE
[15:32:39.093] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:39.093] Globals: 5 objects totaling 960 bytes (function '...future.FUN' of 848 bytes, 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)
[15:32:39.093] Packages: <none>
[15:32:39.093] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:39.093] Resolved: TRUE
[15:32:39.093] Value: <not collected>
[15:32:39.093] Conditions captured: <none>
[15:32:39.093] Early signaling: FALSE
[15:32:39.093] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:39.093] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:39.119] Chunk #1 of 2 ... DONE
[15:32:39.119] Chunk #2 of 2 ...
[15:32:39.120]  - Finding globals in 'X' for chunk #2 ...
[15:32:39.120] getGlobalsAndPackages() ...
[15:32:39.121] Searching for globals...
[15:32:39.121] 
[15:32:39.122] Searching for globals ... DONE
[15:32:39.122] - globals: [0] <none>
[15:32:39.123] getGlobalsAndPackages() ... DONE
[15:32:39.123]    + additional globals found: [n=0] 
[15:32:39.123]    + additional namespaces needed: [n=0] 
[15:32:39.124]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:39.124]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:39.124]  - seeds: <none>
[15:32:39.125]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:39.125] getGlobalsAndPackages() ...
[15:32:39.125] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:39.126] Resolving globals: FALSE
[15:32:39.126] Tweak future expression to call with '...' arguments ...
[15:32:39.127] {
[15:32:39.127]     do.call(function(...) {
[15:32:39.127]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:39.127]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:39.127]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:39.127]             on.exit(options(oopts), add = TRUE)
[15:32:39.127]         }
[15:32:39.127]         {
[15:32:39.127]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:39.127]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:39.127]                 ...future.FUN(...future.X_jj, ...)
[15:32:39.127]             })
[15:32:39.127]         }
[15:32:39.127]     }, args = future.call.arguments)
[15:32:39.127] }
[15:32:39.128] Tweak future expression to call with '...' arguments ... DONE
[15:32:39.129] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:39.129] 
[15:32:39.129] getGlobalsAndPackages() ... DONE
[15:32:39.130] run() for 'Future' ...
[15:32:39.131] - state: 'created'
[15:32:39.131] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:39.153] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:39.154] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:39.154]   - Field: 'node'
[15:32:39.155]   - Field: 'label'
[15:32:39.155]   - Field: 'local'
[15:32:39.155]   - Field: 'owner'
[15:32:39.155]   - Field: 'envir'
[15:32:39.156]   - Field: 'workers'
[15:32:39.156]   - Field: 'packages'
[15:32:39.156]   - Field: 'gc'
[15:32:39.157]   - Field: 'conditions'
[15:32:39.157]   - Field: 'persistent'
[15:32:39.157]   - Field: 'expr'
[15:32:39.157]   - Field: 'uuid'
[15:32:39.158]   - Field: 'seed'
[15:32:39.158]   - Field: 'version'
[15:32:39.158]   - Field: 'result'
[15:32:39.158]   - Field: 'asynchronous'
[15:32:39.159]   - Field: 'calls'
[15:32:39.159]   - Field: 'globals'
[15:32:39.159]   - Field: 'stdout'
[15:32:39.159]   - Field: 'earlySignal'
[15:32:39.160]   - Field: 'lazy'
[15:32:39.160]   - Field: 'state'
[15:32:39.160] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:39.161] - Launch lazy future ...
[15:32:39.161] Packages needed by the future expression (n = 0): <none>
[15:32:39.161] Packages needed by future strategies (n = 0): <none>
[15:32:39.162] {
[15:32:39.162]     {
[15:32:39.162]         {
[15:32:39.162]             ...future.startTime <- base::Sys.time()
[15:32:39.162]             {
[15:32:39.162]                 {
[15:32:39.162]                   {
[15:32:39.162]                     {
[15:32:39.162]                       base::local({
[15:32:39.162]                         has_future <- base::requireNamespace("future", 
[15:32:39.162]                           quietly = TRUE)
[15:32:39.162]                         if (has_future) {
[15:32:39.162]                           ns <- base::getNamespace("future")
[15:32:39.162]                           version <- ns[[".package"]][["version"]]
[15:32:39.162]                           if (is.null(version)) 
[15:32:39.162]                             version <- utils::packageVersion("future")
[15:32:39.162]                         }
[15:32:39.162]                         else {
[15:32:39.162]                           version <- NULL
[15:32:39.162]                         }
[15:32:39.162]                         if (!has_future || version < "1.8.0") {
[15:32:39.162]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:39.162]                             "", base::R.version$version.string), 
[15:32:39.162]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:39.162]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:39.162]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:39.162]                               "release", "version")], collapse = " "), 
[15:32:39.162]                             hostname = base::Sys.info()[["nodename"]])
[15:32:39.162]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:39.162]                             info)
[15:32:39.162]                           info <- base::paste(info, collapse = "; ")
[15:32:39.162]                           if (!has_future) {
[15:32:39.162]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:39.162]                               info)
[15:32:39.162]                           }
[15:32:39.162]                           else {
[15:32:39.162]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:39.162]                               info, version)
[15:32:39.162]                           }
[15:32:39.162]                           base::stop(msg)
[15:32:39.162]                         }
[15:32:39.162]                       })
[15:32:39.162]                     }
[15:32:39.162]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:39.162]                     base::options(mc.cores = 1L)
[15:32:39.162]                   }
[15:32:39.162]                   ...future.strategy.old <- future::plan("list")
[15:32:39.162]                   options(future.plan = NULL)
[15:32:39.162]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:39.162]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:39.162]                 }
[15:32:39.162]                 ...future.workdir <- getwd()
[15:32:39.162]             }
[15:32:39.162]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:39.162]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:39.162]         }
[15:32:39.162]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:39.162]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:39.162]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:39.162]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:39.162]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:39.162]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:39.162]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:39.162]             base::names(...future.oldOptions))
[15:32:39.162]     }
[15:32:39.162]     if (FALSE) {
[15:32:39.162]     }
[15:32:39.162]     else {
[15:32:39.162]         if (TRUE) {
[15:32:39.162]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:39.162]                 open = "w")
[15:32:39.162]         }
[15:32:39.162]         else {
[15:32:39.162]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:39.162]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:39.162]         }
[15:32:39.162]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:39.162]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:39.162]             base::sink(type = "output", split = FALSE)
[15:32:39.162]             base::close(...future.stdout)
[15:32:39.162]         }, add = TRUE)
[15:32:39.162]     }
[15:32:39.162]     ...future.frame <- base::sys.nframe()
[15:32:39.162]     ...future.conditions <- base::list()
[15:32:39.162]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:39.162]     if (FALSE) {
[15:32:39.162]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:39.162]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:39.162]     }
[15:32:39.162]     ...future.result <- base::tryCatch({
[15:32:39.162]         base::withCallingHandlers({
[15:32:39.162]             ...future.value <- base::withVisible(base::local({
[15:32:39.162]                 ...future.makeSendCondition <- base::local({
[15:32:39.162]                   sendCondition <- NULL
[15:32:39.162]                   function(frame = 1L) {
[15:32:39.162]                     if (is.function(sendCondition)) 
[15:32:39.162]                       return(sendCondition)
[15:32:39.162]                     ns <- getNamespace("parallel")
[15:32:39.162]                     if (exists("sendData", mode = "function", 
[15:32:39.162]                       envir = ns)) {
[15:32:39.162]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:39.162]                         envir = ns)
[15:32:39.162]                       envir <- sys.frame(frame)
[15:32:39.162]                       master <- NULL
[15:32:39.162]                       while (!identical(envir, .GlobalEnv) && 
[15:32:39.162]                         !identical(envir, emptyenv())) {
[15:32:39.162]                         if (exists("master", mode = "list", envir = envir, 
[15:32:39.162]                           inherits = FALSE)) {
[15:32:39.162]                           master <- get("master", mode = "list", 
[15:32:39.162]                             envir = envir, inherits = FALSE)
[15:32:39.162]                           if (inherits(master, c("SOCKnode", 
[15:32:39.162]                             "SOCK0node"))) {
[15:32:39.162]                             sendCondition <<- function(cond) {
[15:32:39.162]                               data <- list(type = "VALUE", value = cond, 
[15:32:39.162]                                 success = TRUE)
[15:32:39.162]                               parallel_sendData(master, data)
[15:32:39.162]                             }
[15:32:39.162]                             return(sendCondition)
[15:32:39.162]                           }
[15:32:39.162]                         }
[15:32:39.162]                         frame <- frame + 1L
[15:32:39.162]                         envir <- sys.frame(frame)
[15:32:39.162]                       }
[15:32:39.162]                     }
[15:32:39.162]                     sendCondition <<- function(cond) NULL
[15:32:39.162]                   }
[15:32:39.162]                 })
[15:32:39.162]                 withCallingHandlers({
[15:32:39.162]                   {
[15:32:39.162]                     do.call(function(...) {
[15:32:39.162]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:39.162]                       if (!identical(...future.globals.maxSize.org, 
[15:32:39.162]                         ...future.globals.maxSize)) {
[15:32:39.162]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:39.162]                         on.exit(options(oopts), add = TRUE)
[15:32:39.162]                       }
[15:32:39.162]                       {
[15:32:39.162]                         lapply(seq_along(...future.elements_ii), 
[15:32:39.162]                           FUN = function(jj) {
[15:32:39.162]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:39.162]                             ...future.FUN(...future.X_jj, ...)
[15:32:39.162]                           })
[15:32:39.162]                       }
[15:32:39.162]                     }, args = future.call.arguments)
[15:32:39.162]                   }
[15:32:39.162]                 }, immediateCondition = function(cond) {
[15:32:39.162]                   sendCondition <- ...future.makeSendCondition()
[15:32:39.162]                   sendCondition(cond)
[15:32:39.162]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:39.162]                   {
[15:32:39.162]                     inherits <- base::inherits
[15:32:39.162]                     invokeRestart <- base::invokeRestart
[15:32:39.162]                     is.null <- base::is.null
[15:32:39.162]                     muffled <- FALSE
[15:32:39.162]                     if (inherits(cond, "message")) {
[15:32:39.162]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:39.162]                       if (muffled) 
[15:32:39.162]                         invokeRestart("muffleMessage")
[15:32:39.162]                     }
[15:32:39.162]                     else if (inherits(cond, "warning")) {
[15:32:39.162]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:39.162]                       if (muffled) 
[15:32:39.162]                         invokeRestart("muffleWarning")
[15:32:39.162]                     }
[15:32:39.162]                     else if (inherits(cond, "condition")) {
[15:32:39.162]                       if (!is.null(pattern)) {
[15:32:39.162]                         computeRestarts <- base::computeRestarts
[15:32:39.162]                         grepl <- base::grepl
[15:32:39.162]                         restarts <- computeRestarts(cond)
[15:32:39.162]                         for (restart in restarts) {
[15:32:39.162]                           name <- restart$name
[15:32:39.162]                           if (is.null(name)) 
[15:32:39.162]                             next
[15:32:39.162]                           if (!grepl(pattern, name)) 
[15:32:39.162]                             next
[15:32:39.162]                           invokeRestart(restart)
[15:32:39.162]                           muffled <- TRUE
[15:32:39.162]                           break
[15:32:39.162]                         }
[15:32:39.162]                       }
[15:32:39.162]                     }
[15:32:39.162]                     invisible(muffled)
[15:32:39.162]                   }
[15:32:39.162]                   muffleCondition(cond)
[15:32:39.162]                 })
[15:32:39.162]             }))
[15:32:39.162]             future::FutureResult(value = ...future.value$value, 
[15:32:39.162]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:39.162]                   ...future.rng), globalenv = if (FALSE) 
[15:32:39.162]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:39.162]                     ...future.globalenv.names))
[15:32:39.162]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:39.162]         }, condition = base::local({
[15:32:39.162]             c <- base::c
[15:32:39.162]             inherits <- base::inherits
[15:32:39.162]             invokeRestart <- base::invokeRestart
[15:32:39.162]             length <- base::length
[15:32:39.162]             list <- base::list
[15:32:39.162]             seq.int <- base::seq.int
[15:32:39.162]             signalCondition <- base::signalCondition
[15:32:39.162]             sys.calls <- base::sys.calls
[15:32:39.162]             `[[` <- base::`[[`
[15:32:39.162]             `+` <- base::`+`
[15:32:39.162]             `<<-` <- base::`<<-`
[15:32:39.162]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:39.162]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:39.162]                   3L)]
[15:32:39.162]             }
[15:32:39.162]             function(cond) {
[15:32:39.162]                 is_error <- inherits(cond, "error")
[15:32:39.162]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:39.162]                   NULL)
[15:32:39.162]                 if (is_error) {
[15:32:39.162]                   sessionInformation <- function() {
[15:32:39.162]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:39.162]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:39.162]                       search = base::search(), system = base::Sys.info())
[15:32:39.162]                   }
[15:32:39.162]                   ...future.conditions[[length(...future.conditions) + 
[15:32:39.162]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:39.162]                     cond$call), session = sessionInformation(), 
[15:32:39.162]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:39.162]                   signalCondition(cond)
[15:32:39.162]                 }
[15:32:39.162]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:39.162]                 "immediateCondition"))) {
[15:32:39.162]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:39.162]                   ...future.conditions[[length(...future.conditions) + 
[15:32:39.162]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:39.162]                   if (TRUE && !signal) {
[15:32:39.162]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:39.162]                     {
[15:32:39.162]                       inherits <- base::inherits
[15:32:39.162]                       invokeRestart <- base::invokeRestart
[15:32:39.162]                       is.null <- base::is.null
[15:32:39.162]                       muffled <- FALSE
[15:32:39.162]                       if (inherits(cond, "message")) {
[15:32:39.162]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:39.162]                         if (muffled) 
[15:32:39.162]                           invokeRestart("muffleMessage")
[15:32:39.162]                       }
[15:32:39.162]                       else if (inherits(cond, "warning")) {
[15:32:39.162]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:39.162]                         if (muffled) 
[15:32:39.162]                           invokeRestart("muffleWarning")
[15:32:39.162]                       }
[15:32:39.162]                       else if (inherits(cond, "condition")) {
[15:32:39.162]                         if (!is.null(pattern)) {
[15:32:39.162]                           computeRestarts <- base::computeRestarts
[15:32:39.162]                           grepl <- base::grepl
[15:32:39.162]                           restarts <- computeRestarts(cond)
[15:32:39.162]                           for (restart in restarts) {
[15:32:39.162]                             name <- restart$name
[15:32:39.162]                             if (is.null(name)) 
[15:32:39.162]                               next
[15:32:39.162]                             if (!grepl(pattern, name)) 
[15:32:39.162]                               next
[15:32:39.162]                             invokeRestart(restart)
[15:32:39.162]                             muffled <- TRUE
[15:32:39.162]                             break
[15:32:39.162]                           }
[15:32:39.162]                         }
[15:32:39.162]                       }
[15:32:39.162]                       invisible(muffled)
[15:32:39.162]                     }
[15:32:39.162]                     muffleCondition(cond, pattern = "^muffle")
[15:32:39.162]                   }
[15:32:39.162]                 }
[15:32:39.162]                 else {
[15:32:39.162]                   if (TRUE) {
[15:32:39.162]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:39.162]                     {
[15:32:39.162]                       inherits <- base::inherits
[15:32:39.162]                       invokeRestart <- base::invokeRestart
[15:32:39.162]                       is.null <- base::is.null
[15:32:39.162]                       muffled <- FALSE
[15:32:39.162]                       if (inherits(cond, "message")) {
[15:32:39.162]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:39.162]                         if (muffled) 
[15:32:39.162]                           invokeRestart("muffleMessage")
[15:32:39.162]                       }
[15:32:39.162]                       else if (inherits(cond, "warning")) {
[15:32:39.162]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:39.162]                         if (muffled) 
[15:32:39.162]                           invokeRestart("muffleWarning")
[15:32:39.162]                       }
[15:32:39.162]                       else if (inherits(cond, "condition")) {
[15:32:39.162]                         if (!is.null(pattern)) {
[15:32:39.162]                           computeRestarts <- base::computeRestarts
[15:32:39.162]                           grepl <- base::grepl
[15:32:39.162]                           restarts <- computeRestarts(cond)
[15:32:39.162]                           for (restart in restarts) {
[15:32:39.162]                             name <- restart$name
[15:32:39.162]                             if (is.null(name)) 
[15:32:39.162]                               next
[15:32:39.162]                             if (!grepl(pattern, name)) 
[15:32:39.162]                               next
[15:32:39.162]                             invokeRestart(restart)
[15:32:39.162]                             muffled <- TRUE
[15:32:39.162]                             break
[15:32:39.162]                           }
[15:32:39.162]                         }
[15:32:39.162]                       }
[15:32:39.162]                       invisible(muffled)
[15:32:39.162]                     }
[15:32:39.162]                     muffleCondition(cond, pattern = "^muffle")
[15:32:39.162]                   }
[15:32:39.162]                 }
[15:32:39.162]             }
[15:32:39.162]         }))
[15:32:39.162]     }, error = function(ex) {
[15:32:39.162]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:39.162]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:39.162]                 ...future.rng), started = ...future.startTime, 
[15:32:39.162]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:39.162]             version = "1.8"), class = "FutureResult")
[15:32:39.162]     }, finally = {
[15:32:39.162]         if (!identical(...future.workdir, getwd())) 
[15:32:39.162]             setwd(...future.workdir)
[15:32:39.162]         {
[15:32:39.162]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:39.162]                 ...future.oldOptions$nwarnings <- NULL
[15:32:39.162]             }
[15:32:39.162]             base::options(...future.oldOptions)
[15:32:39.162]             if (.Platform$OS.type == "windows") {
[15:32:39.162]                 old_names <- names(...future.oldEnvVars)
[15:32:39.162]                 envs <- base::Sys.getenv()
[15:32:39.162]                 names <- names(envs)
[15:32:39.162]                 common <- intersect(names, old_names)
[15:32:39.162]                 added <- setdiff(names, old_names)
[15:32:39.162]                 removed <- setdiff(old_names, names)
[15:32:39.162]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:39.162]                   envs[common]]
[15:32:39.162]                 NAMES <- toupper(changed)
[15:32:39.162]                 args <- list()
[15:32:39.162]                 for (kk in seq_along(NAMES)) {
[15:32:39.162]                   name <- changed[[kk]]
[15:32:39.162]                   NAME <- NAMES[[kk]]
[15:32:39.162]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:39.162]                     next
[15:32:39.162]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:39.162]                 }
[15:32:39.162]                 NAMES <- toupper(added)
[15:32:39.162]                 for (kk in seq_along(NAMES)) {
[15:32:39.162]                   name <- added[[kk]]
[15:32:39.162]                   NAME <- NAMES[[kk]]
[15:32:39.162]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:39.162]                     next
[15:32:39.162]                   args[[name]] <- ""
[15:32:39.162]                 }
[15:32:39.162]                 NAMES <- toupper(removed)
[15:32:39.162]                 for (kk in seq_along(NAMES)) {
[15:32:39.162]                   name <- removed[[kk]]
[15:32:39.162]                   NAME <- NAMES[[kk]]
[15:32:39.162]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:39.162]                     next
[15:32:39.162]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:39.162]                 }
[15:32:39.162]                 if (length(args) > 0) 
[15:32:39.162]                   base::do.call(base::Sys.setenv, args = args)
[15:32:39.162]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:39.162]             }
[15:32:39.162]             else {
[15:32:39.162]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:39.162]             }
[15:32:39.162]             {
[15:32:39.162]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:39.162]                   0L) {
[15:32:39.162]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:39.162]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:39.162]                   base::options(opts)
[15:32:39.162]                 }
[15:32:39.162]                 {
[15:32:39.162]                   {
[15:32:39.162]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:39.162]                     NULL
[15:32:39.162]                   }
[15:32:39.162]                   options(future.plan = NULL)
[15:32:39.162]                   if (is.na(NA_character_)) 
[15:32:39.162]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:39.162]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:39.162]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:39.162]                     .init = FALSE)
[15:32:39.162]                 }
[15:32:39.162]             }
[15:32:39.162]         }
[15:32:39.162]     })
[15:32:39.162]     if (TRUE) {
[15:32:39.162]         base::sink(type = "output", split = FALSE)
[15:32:39.162]         if (TRUE) {
[15:32:39.162]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:39.162]         }
[15:32:39.162]         else {
[15:32:39.162]             ...future.result["stdout"] <- base::list(NULL)
[15:32:39.162]         }
[15:32:39.162]         base::close(...future.stdout)
[15:32:39.162]         ...future.stdout <- NULL
[15:32:39.162]     }
[15:32:39.162]     ...future.result$conditions <- ...future.conditions
[15:32:39.162]     ...future.result$finished <- base::Sys.time()
[15:32:39.162]     ...future.result
[15:32:39.162] }
[15:32:39.171] Exporting 5 global objects (848 bytes) to cluster node #1 ...
[15:32:39.171] Exporting '...future.FUN' (848 bytes) to cluster node #1 ...
[15:32:39.172] Exporting '...future.FUN' (848 bytes) to cluster node #1 ... DONE
[15:32:39.172] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:39.173] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:39.173] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:39.174] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:39.174] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:39.175] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:39.175] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:39.176] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:39.176] Exporting 5 global objects (848 bytes) to cluster node #1 ... DONE
[15:32:39.177] MultisessionFuture started
[15:32:39.177] - Launch lazy future ... done
[15:32:39.177] run() for 'MultisessionFuture' ... done
[15:32:39.178] Created future:
[15:32:39.210] receiveMessageFromWorker() for ClusterFuture ...
[15:32:39.210] - Validating connection of MultisessionFuture
[15:32:39.211] - received message: FutureResult
[15:32:39.211] - Received FutureResult
[15:32:39.211] - Erased future from FutureRegistry
[15:32:39.212] result() for ClusterFuture ...
[15:32:39.212] - result already collected: FutureResult
[15:32:39.212] result() for ClusterFuture ... done
[15:32:39.213] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:39.178] MultisessionFuture:
[15:32:39.178] Label: 'future_sapply-2'
[15:32:39.178] Expression:
[15:32:39.178] {
[15:32:39.178]     do.call(function(...) {
[15:32:39.178]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:39.178]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:39.178]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:39.178]             on.exit(options(oopts), add = TRUE)
[15:32:39.178]         }
[15:32:39.178]         {
[15:32:39.178]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:39.178]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:39.178]                 ...future.FUN(...future.X_jj, ...)
[15:32:39.178]             })
[15:32:39.178]         }
[15:32:39.178]     }, args = future.call.arguments)
[15:32:39.178] }
[15:32:39.178] Lazy evaluation: FALSE
[15:32:39.178] Asynchronous evaluation: TRUE
[15:32:39.178] Local evaluation: TRUE
[15:32:39.178] Environment: R_GlobalEnv
[15:32:39.178] Capture standard output: TRUE
[15:32:39.178] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:39.178] Globals: 5 objects totaling 960 bytes (function '...future.FUN' of 848 bytes, 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)
[15:32:39.178] Packages: <none>
[15:32:39.178] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:39.178] Resolved: TRUE
[15:32:39.178] Value: <not collected>
[15:32:39.178] Conditions captured: <none>
[15:32:39.178] Early signaling: FALSE
[15:32:39.178] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:39.178] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:39.213] Chunk #2 of 2 ... DONE
[15:32:39.214] Launching 2 futures (chunks) ... DONE
[15:32:39.214] Resolving 2 futures (chunks) ...
[15:32:39.214] resolve() on list ...
[15:32:39.215]  recursive: 0
[15:32:39.215]  length: 2
[15:32:39.215] 
[15:32:39.215] Future #1
[15:32:39.216] result() for ClusterFuture ...
[15:32:39.216] - result already collected: FutureResult
[15:32:39.216] result() for ClusterFuture ... done
[15:32:39.216] result() for ClusterFuture ...
[15:32:39.217] - result already collected: FutureResult
[15:32:39.217] result() for ClusterFuture ... done
[15:32:39.217] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:39.218] - nx: 2
[15:32:39.218] - relay: TRUE
[15:32:39.218] - stdout: TRUE
[15:32:39.218] - signal: TRUE
[15:32:39.219] - resignal: FALSE
[15:32:39.219] - force: TRUE
[15:32:39.219] - relayed: [n=2] FALSE, FALSE
[15:32:39.219] - queued futures: [n=2] FALSE, FALSE
[15:32:39.220]  - until=1
[15:32:39.220]  - relaying element #1
[15:32:39.220] result() for ClusterFuture ...
[15:32:39.221] - result already collected: FutureResult
[15:32:39.221] result() for ClusterFuture ... done
[15:32:39.221] result() for ClusterFuture ...
[15:32:39.221] - result already collected: FutureResult
[15:32:39.222] result() for ClusterFuture ... done
[15:32:39.222] result() for ClusterFuture ...
[15:32:39.222] - result already collected: FutureResult
[15:32:39.223] result() for ClusterFuture ... done
[15:32:39.223] result() for ClusterFuture ...
[15:32:39.223] - result already collected: FutureResult
[15:32:39.224] result() for ClusterFuture ... done
[15:32:39.224] - relayed: [n=2] TRUE, FALSE
[15:32:39.224] - queued futures: [n=2] TRUE, FALSE
[15:32:39.224] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:39.225]  length: 1 (resolved future 1)
[15:32:39.225] Future #2
[15:32:39.225] result() for ClusterFuture ...
[15:32:39.226] - result already collected: FutureResult
[15:32:39.226] result() for ClusterFuture ... done
[15:32:39.226] result() for ClusterFuture ...
[15:32:39.226] - result already collected: FutureResult
[15:32:39.227] result() for ClusterFuture ... done
[15:32:39.227] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:39.227] - nx: 2
[15:32:39.227] - relay: TRUE
[15:32:39.228] - stdout: TRUE
[15:32:39.228] - signal: TRUE
[15:32:39.228] - resignal: FALSE
[15:32:39.228] - force: TRUE
[15:32:39.229] - relayed: [n=2] TRUE, FALSE
[15:32:39.229] - queued futures: [n=2] TRUE, FALSE
[15:32:39.229]  - until=2
[15:32:39.230]  - relaying element #2
[15:32:39.230] result() for ClusterFuture ...
[15:32:39.230] - result already collected: FutureResult
[15:32:39.230] result() for ClusterFuture ... done
[15:32:39.231] result() for ClusterFuture ...
[15:32:39.231] - result already collected: FutureResult
[15:32:39.231] result() for ClusterFuture ... done
[15:32:39.232] result() for ClusterFuture ...
[15:32:39.232] - result already collected: FutureResult
[15:32:39.232] result() for ClusterFuture ... done
[15:32:39.232] result() for ClusterFuture ...
[15:32:39.232] - result already collected: FutureResult
[15:32:39.233] result() for ClusterFuture ... done
[15:32:39.233] - relayed: [n=2] TRUE, TRUE
[15:32:39.233] - queued futures: [n=2] TRUE, TRUE
[15:32:39.233] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:39.234]  length: 0 (resolved future 2)
[15:32:39.234] Relaying remaining futures
[15:32:39.234] signalConditionsASAP(NULL, pos=0) ...
[15:32:39.235] - nx: 2
[15:32:39.235] - relay: TRUE
[15:32:39.235] - stdout: TRUE
[15:32:39.235] - signal: TRUE
[15:32:39.236] - resignal: FALSE
[15:32:39.236] - force: TRUE
[15:32:39.236] - relayed: [n=2] TRUE, TRUE
[15:32:39.236] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:39.237] - relayed: [n=2] TRUE, TRUE
[15:32:39.237] - queued futures: [n=2] TRUE, TRUE
[15:32:39.237] signalConditionsASAP(NULL, pos=0) ... done
[15:32:39.237] resolve() on list ... DONE
[15:32:39.238] result() for ClusterFuture ...
[15:32:39.238] - result already collected: FutureResult
[15:32:39.238] result() for ClusterFuture ... done
[15:32:39.238] result() for ClusterFuture ...
[15:32:39.239] - result already collected: FutureResult
[15:32:39.239] result() for ClusterFuture ... done
[15:32:39.239] result() for ClusterFuture ...
[15:32:39.239] - result already collected: FutureResult
[15:32:39.240] result() for ClusterFuture ... done
[15:32:39.240] result() for ClusterFuture ...
[15:32:39.240] - result already collected: FutureResult
[15:32:39.240] result() for ClusterFuture ... done
[15:32:39.241]  - Number of value chunks collected: 2
[15:32:39.241] Resolving 2 futures (chunks) ... DONE
[15:32:39.241] Reducing values from 2 chunks ...
[15:32:39.242]  - Number of values collected after concatenation: 4
[15:32:39.242]  - Number of values expected: 4
[15:32:39.242] Reducing values from 2 chunks ... DONE
[15:32:39.242] future_lapply() ... DONE
List of 2
 $ y0: Named num [1:4] 50 60 70 80
  ..- attr(*, "names")= chr [1:4] "A" "B" "C" "D"
 $ y1: Named num [1:4] 50 60 70 80
  ..- attr(*, "names")= chr [1:4] "A" "B" "C" "D"
[15:32:39.246] future_lapply() ...
[15:32:39.250] Number of chunks: 2
[15:32:39.250] getGlobalsAndPackagesXApply() ...
[15:32:39.251]  - future.globals: TRUE
[15:32:39.251] getGlobalsAndPackages() ...
[15:32:39.251] Searching for globals...
[15:32:39.253] - globals found: [2] 'FUN', 'UseMethod'
[15:32:39.253] Searching for globals ... DONE
[15:32:39.254] Resolving globals: FALSE
[15:32:39.254] The total size of the 1 globals is 1.22 KiB (1248 bytes)
[15:32:39.255] The total size of the 1 globals exported for future expression ('FUN()') is 1.22 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.22 KiB of class 'function')
[15:32:39.255] - globals: [1] 'FUN'
[15:32:39.256] 
[15:32:39.256] getGlobalsAndPackages() ... DONE
[15:32:39.256]  - globals found/used: [n=1] 'FUN'
[15:32:39.256]  - needed namespaces: [n=0] 
[15:32:39.257] Finding globals ... DONE
[15:32:39.257]  - use_args: TRUE
[15:32:39.257]  - Getting '...' globals ...
[15:32:39.258] resolve() on list ...
[15:32:39.258]  recursive: 0
[15:32:39.258]  length: 1
[15:32:39.258]  elements: '...'
[15:32:39.259]  length: 0 (resolved future 1)
[15:32:39.259] resolve() on list ... DONE
[15:32:39.259]    - '...' content: [n=0] 
[15:32:39.259] List of 1
[15:32:39.259]  $ ...: list()
[15:32:39.259]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:39.259]  - attr(*, "where")=List of 1
[15:32:39.259]   ..$ ...:<environment: 0x00000276e4f5b490> 
[15:32:39.259]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:39.259]  - attr(*, "resolved")= logi TRUE
[15:32:39.259]  - attr(*, "total_size")= num NA
[15:32:39.264]  - Getting '...' globals ... DONE
[15:32:39.264] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:39.265] List of 2
[15:32:39.265]  $ ...future.FUN:function (x, ...)  
[15:32:39.265]  $ ...          : list()
[15:32:39.265]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:39.265]  - attr(*, "where")=List of 2
[15:32:39.265]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:39.265]   ..$ ...          :<environment: 0x00000276e4f5b490> 
[15:32:39.265]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:39.265]  - attr(*, "resolved")= logi FALSE
[15:32:39.265]  - attr(*, "total_size")= num 1248
[15:32:39.270] Packages to be attached in all futures: [n=0] 
[15:32:39.270] getGlobalsAndPackagesXApply() ... DONE
[15:32:39.270] Number of futures (= number of chunks): 2
[15:32:39.271] Launching 2 futures (chunks) ...
[15:32:39.271] Chunk #1 of 2 ...
[15:32:39.271]  - Finding globals in 'X' for chunk #1 ...
[15:32:39.272] getGlobalsAndPackages() ...
[15:32:39.272] Searching for globals...
[15:32:39.272] 
[15:32:39.272] Searching for globals ... DONE
[15:32:39.273] - globals: [0] <none>
[15:32:39.273] getGlobalsAndPackages() ... DONE
[15:32:39.273]    + additional globals found: [n=0] 
[15:32:39.274]    + additional namespaces needed: [n=0] 
[15:32:39.274]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:39.274]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:39.274]  - seeds: <none>
[15:32:39.274]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:39.275] getGlobalsAndPackages() ...
[15:32:39.275] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:39.275] Resolving globals: FALSE
[15:32:39.276] Tweak future expression to call with '...' arguments ...
[15:32:39.276] {
[15:32:39.276]     do.call(function(...) {
[15:32:39.276]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:39.276]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:39.276]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:39.276]             on.exit(options(oopts), add = TRUE)
[15:32:39.276]         }
[15:32:39.276]         {
[15:32:39.276]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:39.276]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:39.276]                 ...future.FUN(...future.X_jj, ...)
[15:32:39.276]             })
[15:32:39.276]         }
[15:32:39.276]     }, args = future.call.arguments)
[15:32:39.276] }
[15:32:39.277] Tweak future expression to call with '...' arguments ... DONE
[15:32:39.277] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:39.278] 
[15:32:39.278] getGlobalsAndPackages() ... DONE
[15:32:39.278] run() for 'Future' ...
[15:32:39.279] - state: 'created'
[15:32:39.279] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:39.295] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:39.295] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:39.295]   - Field: 'node'
[15:32:39.295]   - Field: 'label'
[15:32:39.296]   - Field: 'local'
[15:32:39.296]   - Field: 'owner'
[15:32:39.296]   - Field: 'envir'
[15:32:39.296]   - Field: 'workers'
[15:32:39.296]   - Field: 'packages'
[15:32:39.297]   - Field: 'gc'
[15:32:39.297]   - Field: 'conditions'
[15:32:39.297]   - Field: 'persistent'
[15:32:39.297]   - Field: 'expr'
[15:32:39.297]   - Field: 'uuid'
[15:32:39.298]   - Field: 'seed'
[15:32:39.298]   - Field: 'version'
[15:32:39.298]   - Field: 'result'
[15:32:39.298]   - Field: 'asynchronous'
[15:32:39.298]   - Field: 'calls'
[15:32:39.298]   - Field: 'globals'
[15:32:39.299]   - Field: 'stdout'
[15:32:39.299]   - Field: 'earlySignal'
[15:32:39.299]   - Field: 'lazy'
[15:32:39.299]   - Field: 'state'
[15:32:39.299] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:39.300] - Launch lazy future ...
[15:32:39.300] Packages needed by the future expression (n = 0): <none>
[15:32:39.300] Packages needed by future strategies (n = 0): <none>
[15:32:39.301] {
[15:32:39.301]     {
[15:32:39.301]         {
[15:32:39.301]             ...future.startTime <- base::Sys.time()
[15:32:39.301]             {
[15:32:39.301]                 {
[15:32:39.301]                   {
[15:32:39.301]                     {
[15:32:39.301]                       base::local({
[15:32:39.301]                         has_future <- base::requireNamespace("future", 
[15:32:39.301]                           quietly = TRUE)
[15:32:39.301]                         if (has_future) {
[15:32:39.301]                           ns <- base::getNamespace("future")
[15:32:39.301]                           version <- ns[[".package"]][["version"]]
[15:32:39.301]                           if (is.null(version)) 
[15:32:39.301]                             version <- utils::packageVersion("future")
[15:32:39.301]                         }
[15:32:39.301]                         else {
[15:32:39.301]                           version <- NULL
[15:32:39.301]                         }
[15:32:39.301]                         if (!has_future || version < "1.8.0") {
[15:32:39.301]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:39.301]                             "", base::R.version$version.string), 
[15:32:39.301]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:39.301]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:39.301]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:39.301]                               "release", "version")], collapse = " "), 
[15:32:39.301]                             hostname = base::Sys.info()[["nodename"]])
[15:32:39.301]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:39.301]                             info)
[15:32:39.301]                           info <- base::paste(info, collapse = "; ")
[15:32:39.301]                           if (!has_future) {
[15:32:39.301]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:39.301]                               info)
[15:32:39.301]                           }
[15:32:39.301]                           else {
[15:32:39.301]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:39.301]                               info, version)
[15:32:39.301]                           }
[15:32:39.301]                           base::stop(msg)
[15:32:39.301]                         }
[15:32:39.301]                       })
[15:32:39.301]                     }
[15:32:39.301]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:39.301]                     base::options(mc.cores = 1L)
[15:32:39.301]                   }
[15:32:39.301]                   ...future.strategy.old <- future::plan("list")
[15:32:39.301]                   options(future.plan = NULL)
[15:32:39.301]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:39.301]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:39.301]                 }
[15:32:39.301]                 ...future.workdir <- getwd()
[15:32:39.301]             }
[15:32:39.301]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:39.301]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:39.301]         }
[15:32:39.301]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:39.301]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:39.301]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:39.301]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:39.301]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:39.301]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:39.301]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:39.301]             base::names(...future.oldOptions))
[15:32:39.301]     }
[15:32:39.301]     if (FALSE) {
[15:32:39.301]     }
[15:32:39.301]     else {
[15:32:39.301]         if (TRUE) {
[15:32:39.301]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:39.301]                 open = "w")
[15:32:39.301]         }
[15:32:39.301]         else {
[15:32:39.301]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:39.301]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:39.301]         }
[15:32:39.301]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:39.301]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:39.301]             base::sink(type = "output", split = FALSE)
[15:32:39.301]             base::close(...future.stdout)
[15:32:39.301]         }, add = TRUE)
[15:32:39.301]     }
[15:32:39.301]     ...future.frame <- base::sys.nframe()
[15:32:39.301]     ...future.conditions <- base::list()
[15:32:39.301]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:39.301]     if (FALSE) {
[15:32:39.301]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:39.301]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:39.301]     }
[15:32:39.301]     ...future.result <- base::tryCatch({
[15:32:39.301]         base::withCallingHandlers({
[15:32:39.301]             ...future.value <- base::withVisible(base::local({
[15:32:39.301]                 ...future.makeSendCondition <- base::local({
[15:32:39.301]                   sendCondition <- NULL
[15:32:39.301]                   function(frame = 1L) {
[15:32:39.301]                     if (is.function(sendCondition)) 
[15:32:39.301]                       return(sendCondition)
[15:32:39.301]                     ns <- getNamespace("parallel")
[15:32:39.301]                     if (exists("sendData", mode = "function", 
[15:32:39.301]                       envir = ns)) {
[15:32:39.301]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:39.301]                         envir = ns)
[15:32:39.301]                       envir <- sys.frame(frame)
[15:32:39.301]                       master <- NULL
[15:32:39.301]                       while (!identical(envir, .GlobalEnv) && 
[15:32:39.301]                         !identical(envir, emptyenv())) {
[15:32:39.301]                         if (exists("master", mode = "list", envir = envir, 
[15:32:39.301]                           inherits = FALSE)) {
[15:32:39.301]                           master <- get("master", mode = "list", 
[15:32:39.301]                             envir = envir, inherits = FALSE)
[15:32:39.301]                           if (inherits(master, c("SOCKnode", 
[15:32:39.301]                             "SOCK0node"))) {
[15:32:39.301]                             sendCondition <<- function(cond) {
[15:32:39.301]                               data <- list(type = "VALUE", value = cond, 
[15:32:39.301]                                 success = TRUE)
[15:32:39.301]                               parallel_sendData(master, data)
[15:32:39.301]                             }
[15:32:39.301]                             return(sendCondition)
[15:32:39.301]                           }
[15:32:39.301]                         }
[15:32:39.301]                         frame <- frame + 1L
[15:32:39.301]                         envir <- sys.frame(frame)
[15:32:39.301]                       }
[15:32:39.301]                     }
[15:32:39.301]                     sendCondition <<- function(cond) NULL
[15:32:39.301]                   }
[15:32:39.301]                 })
[15:32:39.301]                 withCallingHandlers({
[15:32:39.301]                   {
[15:32:39.301]                     do.call(function(...) {
[15:32:39.301]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:39.301]                       if (!identical(...future.globals.maxSize.org, 
[15:32:39.301]                         ...future.globals.maxSize)) {
[15:32:39.301]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:39.301]                         on.exit(options(oopts), add = TRUE)
[15:32:39.301]                       }
[15:32:39.301]                       {
[15:32:39.301]                         lapply(seq_along(...future.elements_ii), 
[15:32:39.301]                           FUN = function(jj) {
[15:32:39.301]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:39.301]                             ...future.FUN(...future.X_jj, ...)
[15:32:39.301]                           })
[15:32:39.301]                       }
[15:32:39.301]                     }, args = future.call.arguments)
[15:32:39.301]                   }
[15:32:39.301]                 }, immediateCondition = function(cond) {
[15:32:39.301]                   sendCondition <- ...future.makeSendCondition()
[15:32:39.301]                   sendCondition(cond)
[15:32:39.301]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:39.301]                   {
[15:32:39.301]                     inherits <- base::inherits
[15:32:39.301]                     invokeRestart <- base::invokeRestart
[15:32:39.301]                     is.null <- base::is.null
[15:32:39.301]                     muffled <- FALSE
[15:32:39.301]                     if (inherits(cond, "message")) {
[15:32:39.301]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:39.301]                       if (muffled) 
[15:32:39.301]                         invokeRestart("muffleMessage")
[15:32:39.301]                     }
[15:32:39.301]                     else if (inherits(cond, "warning")) {
[15:32:39.301]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:39.301]                       if (muffled) 
[15:32:39.301]                         invokeRestart("muffleWarning")
[15:32:39.301]                     }
[15:32:39.301]                     else if (inherits(cond, "condition")) {
[15:32:39.301]                       if (!is.null(pattern)) {
[15:32:39.301]                         computeRestarts <- base::computeRestarts
[15:32:39.301]                         grepl <- base::grepl
[15:32:39.301]                         restarts <- computeRestarts(cond)
[15:32:39.301]                         for (restart in restarts) {
[15:32:39.301]                           name <- restart$name
[15:32:39.301]                           if (is.null(name)) 
[15:32:39.301]                             next
[15:32:39.301]                           if (!grepl(pattern, name)) 
[15:32:39.301]                             next
[15:32:39.301]                           invokeRestart(restart)
[15:32:39.301]                           muffled <- TRUE
[15:32:39.301]                           break
[15:32:39.301]                         }
[15:32:39.301]                       }
[15:32:39.301]                     }
[15:32:39.301]                     invisible(muffled)
[15:32:39.301]                   }
[15:32:39.301]                   muffleCondition(cond)
[15:32:39.301]                 })
[15:32:39.301]             }))
[15:32:39.301]             future::FutureResult(value = ...future.value$value, 
[15:32:39.301]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:39.301]                   ...future.rng), globalenv = if (FALSE) 
[15:32:39.301]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:39.301]                     ...future.globalenv.names))
[15:32:39.301]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:39.301]         }, condition = base::local({
[15:32:39.301]             c <- base::c
[15:32:39.301]             inherits <- base::inherits
[15:32:39.301]             invokeRestart <- base::invokeRestart
[15:32:39.301]             length <- base::length
[15:32:39.301]             list <- base::list
[15:32:39.301]             seq.int <- base::seq.int
[15:32:39.301]             signalCondition <- base::signalCondition
[15:32:39.301]             sys.calls <- base::sys.calls
[15:32:39.301]             `[[` <- base::`[[`
[15:32:39.301]             `+` <- base::`+`
[15:32:39.301]             `<<-` <- base::`<<-`
[15:32:39.301]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:39.301]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:39.301]                   3L)]
[15:32:39.301]             }
[15:32:39.301]             function(cond) {
[15:32:39.301]                 is_error <- inherits(cond, "error")
[15:32:39.301]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:39.301]                   NULL)
[15:32:39.301]                 if (is_error) {
[15:32:39.301]                   sessionInformation <- function() {
[15:32:39.301]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:39.301]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:39.301]                       search = base::search(), system = base::Sys.info())
[15:32:39.301]                   }
[15:32:39.301]                   ...future.conditions[[length(...future.conditions) + 
[15:32:39.301]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:39.301]                     cond$call), session = sessionInformation(), 
[15:32:39.301]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:39.301]                   signalCondition(cond)
[15:32:39.301]                 }
[15:32:39.301]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:39.301]                 "immediateCondition"))) {
[15:32:39.301]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:39.301]                   ...future.conditions[[length(...future.conditions) + 
[15:32:39.301]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:39.301]                   if (TRUE && !signal) {
[15:32:39.301]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:39.301]                     {
[15:32:39.301]                       inherits <- base::inherits
[15:32:39.301]                       invokeRestart <- base::invokeRestart
[15:32:39.301]                       is.null <- base::is.null
[15:32:39.301]                       muffled <- FALSE
[15:32:39.301]                       if (inherits(cond, "message")) {
[15:32:39.301]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:39.301]                         if (muffled) 
[15:32:39.301]                           invokeRestart("muffleMessage")
[15:32:39.301]                       }
[15:32:39.301]                       else if (inherits(cond, "warning")) {
[15:32:39.301]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:39.301]                         if (muffled) 
[15:32:39.301]                           invokeRestart("muffleWarning")
[15:32:39.301]                       }
[15:32:39.301]                       else if (inherits(cond, "condition")) {
[15:32:39.301]                         if (!is.null(pattern)) {
[15:32:39.301]                           computeRestarts <- base::computeRestarts
[15:32:39.301]                           grepl <- base::grepl
[15:32:39.301]                           restarts <- computeRestarts(cond)
[15:32:39.301]                           for (restart in restarts) {
[15:32:39.301]                             name <- restart$name
[15:32:39.301]                             if (is.null(name)) 
[15:32:39.301]                               next
[15:32:39.301]                             if (!grepl(pattern, name)) 
[15:32:39.301]                               next
[15:32:39.301]                             invokeRestart(restart)
[15:32:39.301]                             muffled <- TRUE
[15:32:39.301]                             break
[15:32:39.301]                           }
[15:32:39.301]                         }
[15:32:39.301]                       }
[15:32:39.301]                       invisible(muffled)
[15:32:39.301]                     }
[15:32:39.301]                     muffleCondition(cond, pattern = "^muffle")
[15:32:39.301]                   }
[15:32:39.301]                 }
[15:32:39.301]                 else {
[15:32:39.301]                   if (TRUE) {
[15:32:39.301]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:39.301]                     {
[15:32:39.301]                       inherits <- base::inherits
[15:32:39.301]                       invokeRestart <- base::invokeRestart
[15:32:39.301]                       is.null <- base::is.null
[15:32:39.301]                       muffled <- FALSE
[15:32:39.301]                       if (inherits(cond, "message")) {
[15:32:39.301]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:39.301]                         if (muffled) 
[15:32:39.301]                           invokeRestart("muffleMessage")
[15:32:39.301]                       }
[15:32:39.301]                       else if (inherits(cond, "warning")) {
[15:32:39.301]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:39.301]                         if (muffled) 
[15:32:39.301]                           invokeRestart("muffleWarning")
[15:32:39.301]                       }
[15:32:39.301]                       else if (inherits(cond, "condition")) {
[15:32:39.301]                         if (!is.null(pattern)) {
[15:32:39.301]                           computeRestarts <- base::computeRestarts
[15:32:39.301]                           grepl <- base::grepl
[15:32:39.301]                           restarts <- computeRestarts(cond)
[15:32:39.301]                           for (restart in restarts) {
[15:32:39.301]                             name <- restart$name
[15:32:39.301]                             if (is.null(name)) 
[15:32:39.301]                               next
[15:32:39.301]                             if (!grepl(pattern, name)) 
[15:32:39.301]                               next
[15:32:39.301]                             invokeRestart(restart)
[15:32:39.301]                             muffled <- TRUE
[15:32:39.301]                             break
[15:32:39.301]                           }
[15:32:39.301]                         }
[15:32:39.301]                       }
[15:32:39.301]                       invisible(muffled)
[15:32:39.301]                     }
[15:32:39.301]                     muffleCondition(cond, pattern = "^muffle")
[15:32:39.301]                   }
[15:32:39.301]                 }
[15:32:39.301]             }
[15:32:39.301]         }))
[15:32:39.301]     }, error = function(ex) {
[15:32:39.301]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:39.301]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:39.301]                 ...future.rng), started = ...future.startTime, 
[15:32:39.301]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:39.301]             version = "1.8"), class = "FutureResult")
[15:32:39.301]     }, finally = {
[15:32:39.301]         if (!identical(...future.workdir, getwd())) 
[15:32:39.301]             setwd(...future.workdir)
[15:32:39.301]         {
[15:32:39.301]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:39.301]                 ...future.oldOptions$nwarnings <- NULL
[15:32:39.301]             }
[15:32:39.301]             base::options(...future.oldOptions)
[15:32:39.301]             if (.Platform$OS.type == "windows") {
[15:32:39.301]                 old_names <- names(...future.oldEnvVars)
[15:32:39.301]                 envs <- base::Sys.getenv()
[15:32:39.301]                 names <- names(envs)
[15:32:39.301]                 common <- intersect(names, old_names)
[15:32:39.301]                 added <- setdiff(names, old_names)
[15:32:39.301]                 removed <- setdiff(old_names, names)
[15:32:39.301]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:39.301]                   envs[common]]
[15:32:39.301]                 NAMES <- toupper(changed)
[15:32:39.301]                 args <- list()
[15:32:39.301]                 for (kk in seq_along(NAMES)) {
[15:32:39.301]                   name <- changed[[kk]]
[15:32:39.301]                   NAME <- NAMES[[kk]]
[15:32:39.301]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:39.301]                     next
[15:32:39.301]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:39.301]                 }
[15:32:39.301]                 NAMES <- toupper(added)
[15:32:39.301]                 for (kk in seq_along(NAMES)) {
[15:32:39.301]                   name <- added[[kk]]
[15:32:39.301]                   NAME <- NAMES[[kk]]
[15:32:39.301]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:39.301]                     next
[15:32:39.301]                   args[[name]] <- ""
[15:32:39.301]                 }
[15:32:39.301]                 NAMES <- toupper(removed)
[15:32:39.301]                 for (kk in seq_along(NAMES)) {
[15:32:39.301]                   name <- removed[[kk]]
[15:32:39.301]                   NAME <- NAMES[[kk]]
[15:32:39.301]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:39.301]                     next
[15:32:39.301]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:39.301]                 }
[15:32:39.301]                 if (length(args) > 0) 
[15:32:39.301]                   base::do.call(base::Sys.setenv, args = args)
[15:32:39.301]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:39.301]             }
[15:32:39.301]             else {
[15:32:39.301]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:39.301]             }
[15:32:39.301]             {
[15:32:39.301]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:39.301]                   0L) {
[15:32:39.301]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:39.301]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:39.301]                   base::options(opts)
[15:32:39.301]                 }
[15:32:39.301]                 {
[15:32:39.301]                   {
[15:32:39.301]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:39.301]                     NULL
[15:32:39.301]                   }
[15:32:39.301]                   options(future.plan = NULL)
[15:32:39.301]                   if (is.na(NA_character_)) 
[15:32:39.301]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:39.301]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:39.301]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:39.301]                     .init = FALSE)
[15:32:39.301]                 }
[15:32:39.301]             }
[15:32:39.301]         }
[15:32:39.301]     })
[15:32:39.301]     if (TRUE) {
[15:32:39.301]         base::sink(type = "output", split = FALSE)
[15:32:39.301]         if (TRUE) {
[15:32:39.301]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:39.301]         }
[15:32:39.301]         else {
[15:32:39.301]             ...future.result["stdout"] <- base::list(NULL)
[15:32:39.301]         }
[15:32:39.301]         base::close(...future.stdout)
[15:32:39.301]         ...future.stdout <- NULL
[15:32:39.301]     }
[15:32:39.301]     ...future.result$conditions <- ...future.conditions
[15:32:39.301]     ...future.result$finished <- base::Sys.time()
[15:32:39.301]     ...future.result
[15:32:39.301] }
[15:32:39.311] Exporting 5 global objects (1.22 KiB) to cluster node #1 ...
[15:32:39.312] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ...
[15:32:39.313] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ... DONE
[15:32:39.313] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:39.314] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:39.314] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:39.315] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:39.315] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:39.316] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:39.316] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:39.317] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:39.318] Exporting 5 global objects (1.22 KiB) to cluster node #1 ... DONE
[15:32:39.319] MultisessionFuture started
[15:32:39.319] - Launch lazy future ... done
[15:32:39.319] run() for 'MultisessionFuture' ... done
[15:32:39.320] Created future:
[15:32:39.348] receiveMessageFromWorker() for ClusterFuture ...
[15:32:39.349] - Validating connection of MultisessionFuture
[15:32:39.349] - received message: FutureResult
[15:32:39.350] - Received FutureResult
[15:32:39.350] - Erased future from FutureRegistry
[15:32:39.350] result() for ClusterFuture ...
[15:32:39.351] - result already collected: FutureResult
[15:32:39.351] result() for ClusterFuture ... done
[15:32:39.351] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:39.320] MultisessionFuture:
[15:32:39.320] Label: 'future_sapply-1'
[15:32:39.320] Expression:
[15:32:39.320] {
[15:32:39.320]     do.call(function(...) {
[15:32:39.320]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:39.320]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:39.320]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:39.320]             on.exit(options(oopts), add = TRUE)
[15:32:39.320]         }
[15:32:39.320]         {
[15:32:39.320]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:39.320]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:39.320]                 ...future.FUN(...future.X_jj, ...)
[15:32:39.320]             })
[15:32:39.320]         }
[15:32:39.320]     }, args = future.call.arguments)
[15:32:39.320] }
[15:32:39.320] Lazy evaluation: FALSE
[15:32:39.320] Asynchronous evaluation: TRUE
[15:32:39.320] Local evaluation: TRUE
[15:32:39.320] Environment: R_GlobalEnv
[15:32:39.320] Capture standard output: TRUE
[15:32:39.320] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:39.320] Globals: 5 objects totaling 1.33 KiB (function '...future.FUN' of 1.22 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)
[15:32:39.320] Packages: <none>
[15:32:39.320] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:39.320] Resolved: TRUE
[15:32:39.320] Value: <not collected>
[15:32:39.320] Conditions captured: <none>
[15:32:39.320] Early signaling: FALSE
[15:32:39.320] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:39.320] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:39.352] Chunk #1 of 2 ... DONE
[15:32:39.353] Chunk #2 of 2 ...
[15:32:39.353]  - Finding globals in 'X' for chunk #2 ...
[15:32:39.353] getGlobalsAndPackages() ...
[15:32:39.354] Searching for globals...
[15:32:39.354] 
[15:32:39.354] Searching for globals ... DONE
[15:32:39.355] - globals: [0] <none>
[15:32:39.355] getGlobalsAndPackages() ... DONE
[15:32:39.355]    + additional globals found: [n=0] 
[15:32:39.356]    + additional namespaces needed: [n=0] 
[15:32:39.362]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:39.362]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:39.362]  - seeds: <none>
[15:32:39.363]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:39.363] getGlobalsAndPackages() ...
[15:32:39.363] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:39.364] Resolving globals: FALSE
[15:32:39.364] Tweak future expression to call with '...' arguments ...
[15:32:39.365] {
[15:32:39.365]     do.call(function(...) {
[15:32:39.365]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:39.365]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:39.365]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:39.365]             on.exit(options(oopts), add = TRUE)
[15:32:39.365]         }
[15:32:39.365]         {
[15:32:39.365]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:39.365]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:39.365]                 ...future.FUN(...future.X_jj, ...)
[15:32:39.365]             })
[15:32:39.365]         }
[15:32:39.365]     }, args = future.call.arguments)
[15:32:39.365] }
[15:32:39.366] Tweak future expression to call with '...' arguments ... DONE
[15:32:39.366] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:39.367] 
[15:32:39.367] getGlobalsAndPackages() ... DONE
[15:32:39.368] run() for 'Future' ...
[15:32:39.368] - state: 'created'
[15:32:39.369] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:39.388] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:39.388] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:39.389]   - Field: 'node'
[15:32:39.389]   - Field: 'label'
[15:32:39.389]   - Field: 'local'
[15:32:39.390]   - Field: 'owner'
[15:32:39.390]   - Field: 'envir'
[15:32:39.390]   - Field: 'workers'
[15:32:39.391]   - Field: 'packages'
[15:32:39.391]   - Field: 'gc'
[15:32:39.391]   - Field: 'conditions'
[15:32:39.392]   - Field: 'persistent'
[15:32:39.392]   - Field: 'expr'
[15:32:39.392]   - Field: 'uuid'
[15:32:39.393]   - Field: 'seed'
[15:32:39.393]   - Field: 'version'
[15:32:39.393]   - Field: 'result'
[15:32:39.394]   - Field: 'asynchronous'
[15:32:39.394]   - Field: 'calls'
[15:32:39.394]   - Field: 'globals'
[15:32:39.395]   - Field: 'stdout'
[15:32:39.395]   - Field: 'earlySignal'
[15:32:39.395]   - Field: 'lazy'
[15:32:39.396]   - Field: 'state'
[15:32:39.396] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:39.396] - Launch lazy future ...
[15:32:39.397] Packages needed by the future expression (n = 0): <none>
[15:32:39.397] Packages needed by future strategies (n = 0): <none>
[15:32:39.398] {
[15:32:39.398]     {
[15:32:39.398]         {
[15:32:39.398]             ...future.startTime <- base::Sys.time()
[15:32:39.398]             {
[15:32:39.398]                 {
[15:32:39.398]                   {
[15:32:39.398]                     {
[15:32:39.398]                       base::local({
[15:32:39.398]                         has_future <- base::requireNamespace("future", 
[15:32:39.398]                           quietly = TRUE)
[15:32:39.398]                         if (has_future) {
[15:32:39.398]                           ns <- base::getNamespace("future")
[15:32:39.398]                           version <- ns[[".package"]][["version"]]
[15:32:39.398]                           if (is.null(version)) 
[15:32:39.398]                             version <- utils::packageVersion("future")
[15:32:39.398]                         }
[15:32:39.398]                         else {
[15:32:39.398]                           version <- NULL
[15:32:39.398]                         }
[15:32:39.398]                         if (!has_future || version < "1.8.0") {
[15:32:39.398]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:39.398]                             "", base::R.version$version.string), 
[15:32:39.398]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:39.398]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:39.398]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:39.398]                               "release", "version")], collapse = " "), 
[15:32:39.398]                             hostname = base::Sys.info()[["nodename"]])
[15:32:39.398]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:39.398]                             info)
[15:32:39.398]                           info <- base::paste(info, collapse = "; ")
[15:32:39.398]                           if (!has_future) {
[15:32:39.398]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:39.398]                               info)
[15:32:39.398]                           }
[15:32:39.398]                           else {
[15:32:39.398]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:39.398]                               info, version)
[15:32:39.398]                           }
[15:32:39.398]                           base::stop(msg)
[15:32:39.398]                         }
[15:32:39.398]                       })
[15:32:39.398]                     }
[15:32:39.398]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:39.398]                     base::options(mc.cores = 1L)
[15:32:39.398]                   }
[15:32:39.398]                   ...future.strategy.old <- future::plan("list")
[15:32:39.398]                   options(future.plan = NULL)
[15:32:39.398]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:39.398]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:39.398]                 }
[15:32:39.398]                 ...future.workdir <- getwd()
[15:32:39.398]             }
[15:32:39.398]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:39.398]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:39.398]         }
[15:32:39.398]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:39.398]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:39.398]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:39.398]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:39.398]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:39.398]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:39.398]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:39.398]             base::names(...future.oldOptions))
[15:32:39.398]     }
[15:32:39.398]     if (FALSE) {
[15:32:39.398]     }
[15:32:39.398]     else {
[15:32:39.398]         if (TRUE) {
[15:32:39.398]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:39.398]                 open = "w")
[15:32:39.398]         }
[15:32:39.398]         else {
[15:32:39.398]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:39.398]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:39.398]         }
[15:32:39.398]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:39.398]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:39.398]             base::sink(type = "output", split = FALSE)
[15:32:39.398]             base::close(...future.stdout)
[15:32:39.398]         }, add = TRUE)
[15:32:39.398]     }
[15:32:39.398]     ...future.frame <- base::sys.nframe()
[15:32:39.398]     ...future.conditions <- base::list()
[15:32:39.398]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:39.398]     if (FALSE) {
[15:32:39.398]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:39.398]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:39.398]     }
[15:32:39.398]     ...future.result <- base::tryCatch({
[15:32:39.398]         base::withCallingHandlers({
[15:32:39.398]             ...future.value <- base::withVisible(base::local({
[15:32:39.398]                 ...future.makeSendCondition <- base::local({
[15:32:39.398]                   sendCondition <- NULL
[15:32:39.398]                   function(frame = 1L) {
[15:32:39.398]                     if (is.function(sendCondition)) 
[15:32:39.398]                       return(sendCondition)
[15:32:39.398]                     ns <- getNamespace("parallel")
[15:32:39.398]                     if (exists("sendData", mode = "function", 
[15:32:39.398]                       envir = ns)) {
[15:32:39.398]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:39.398]                         envir = ns)
[15:32:39.398]                       envir <- sys.frame(frame)
[15:32:39.398]                       master <- NULL
[15:32:39.398]                       while (!identical(envir, .GlobalEnv) && 
[15:32:39.398]                         !identical(envir, emptyenv())) {
[15:32:39.398]                         if (exists("master", mode = "list", envir = envir, 
[15:32:39.398]                           inherits = FALSE)) {
[15:32:39.398]                           master <- get("master", mode = "list", 
[15:32:39.398]                             envir = envir, inherits = FALSE)
[15:32:39.398]                           if (inherits(master, c("SOCKnode", 
[15:32:39.398]                             "SOCK0node"))) {
[15:32:39.398]                             sendCondition <<- function(cond) {
[15:32:39.398]                               data <- list(type = "VALUE", value = cond, 
[15:32:39.398]                                 success = TRUE)
[15:32:39.398]                               parallel_sendData(master, data)
[15:32:39.398]                             }
[15:32:39.398]                             return(sendCondition)
[15:32:39.398]                           }
[15:32:39.398]                         }
[15:32:39.398]                         frame <- frame + 1L
[15:32:39.398]                         envir <- sys.frame(frame)
[15:32:39.398]                       }
[15:32:39.398]                     }
[15:32:39.398]                     sendCondition <<- function(cond) NULL
[15:32:39.398]                   }
[15:32:39.398]                 })
[15:32:39.398]                 withCallingHandlers({
[15:32:39.398]                   {
[15:32:39.398]                     do.call(function(...) {
[15:32:39.398]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:39.398]                       if (!identical(...future.globals.maxSize.org, 
[15:32:39.398]                         ...future.globals.maxSize)) {
[15:32:39.398]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:39.398]                         on.exit(options(oopts), add = TRUE)
[15:32:39.398]                       }
[15:32:39.398]                       {
[15:32:39.398]                         lapply(seq_along(...future.elements_ii), 
[15:32:39.398]                           FUN = function(jj) {
[15:32:39.398]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:39.398]                             ...future.FUN(...future.X_jj, ...)
[15:32:39.398]                           })
[15:32:39.398]                       }
[15:32:39.398]                     }, args = future.call.arguments)
[15:32:39.398]                   }
[15:32:39.398]                 }, immediateCondition = function(cond) {
[15:32:39.398]                   sendCondition <- ...future.makeSendCondition()
[15:32:39.398]                   sendCondition(cond)
[15:32:39.398]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:39.398]                   {
[15:32:39.398]                     inherits <- base::inherits
[15:32:39.398]                     invokeRestart <- base::invokeRestart
[15:32:39.398]                     is.null <- base::is.null
[15:32:39.398]                     muffled <- FALSE
[15:32:39.398]                     if (inherits(cond, "message")) {
[15:32:39.398]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:39.398]                       if (muffled) 
[15:32:39.398]                         invokeRestart("muffleMessage")
[15:32:39.398]                     }
[15:32:39.398]                     else if (inherits(cond, "warning")) {
[15:32:39.398]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:39.398]                       if (muffled) 
[15:32:39.398]                         invokeRestart("muffleWarning")
[15:32:39.398]                     }
[15:32:39.398]                     else if (inherits(cond, "condition")) {
[15:32:39.398]                       if (!is.null(pattern)) {
[15:32:39.398]                         computeRestarts <- base::computeRestarts
[15:32:39.398]                         grepl <- base::grepl
[15:32:39.398]                         restarts <- computeRestarts(cond)
[15:32:39.398]                         for (restart in restarts) {
[15:32:39.398]                           name <- restart$name
[15:32:39.398]                           if (is.null(name)) 
[15:32:39.398]                             next
[15:32:39.398]                           if (!grepl(pattern, name)) 
[15:32:39.398]                             next
[15:32:39.398]                           invokeRestart(restart)
[15:32:39.398]                           muffled <- TRUE
[15:32:39.398]                           break
[15:32:39.398]                         }
[15:32:39.398]                       }
[15:32:39.398]                     }
[15:32:39.398]                     invisible(muffled)
[15:32:39.398]                   }
[15:32:39.398]                   muffleCondition(cond)
[15:32:39.398]                 })
[15:32:39.398]             }))
[15:32:39.398]             future::FutureResult(value = ...future.value$value, 
[15:32:39.398]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:39.398]                   ...future.rng), globalenv = if (FALSE) 
[15:32:39.398]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:39.398]                     ...future.globalenv.names))
[15:32:39.398]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:39.398]         }, condition = base::local({
[15:32:39.398]             c <- base::c
[15:32:39.398]             inherits <- base::inherits
[15:32:39.398]             invokeRestart <- base::invokeRestart
[15:32:39.398]             length <- base::length
[15:32:39.398]             list <- base::list
[15:32:39.398]             seq.int <- base::seq.int
[15:32:39.398]             signalCondition <- base::signalCondition
[15:32:39.398]             sys.calls <- base::sys.calls
[15:32:39.398]             `[[` <- base::`[[`
[15:32:39.398]             `+` <- base::`+`
[15:32:39.398]             `<<-` <- base::`<<-`
[15:32:39.398]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:39.398]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:39.398]                   3L)]
[15:32:39.398]             }
[15:32:39.398]             function(cond) {
[15:32:39.398]                 is_error <- inherits(cond, "error")
[15:32:39.398]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:39.398]                   NULL)
[15:32:39.398]                 if (is_error) {
[15:32:39.398]                   sessionInformation <- function() {
[15:32:39.398]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:39.398]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:39.398]                       search = base::search(), system = base::Sys.info())
[15:32:39.398]                   }
[15:32:39.398]                   ...future.conditions[[length(...future.conditions) + 
[15:32:39.398]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:39.398]                     cond$call), session = sessionInformation(), 
[15:32:39.398]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:39.398]                   signalCondition(cond)
[15:32:39.398]                 }
[15:32:39.398]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:39.398]                 "immediateCondition"))) {
[15:32:39.398]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:39.398]                   ...future.conditions[[length(...future.conditions) + 
[15:32:39.398]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:39.398]                   if (TRUE && !signal) {
[15:32:39.398]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:39.398]                     {
[15:32:39.398]                       inherits <- base::inherits
[15:32:39.398]                       invokeRestart <- base::invokeRestart
[15:32:39.398]                       is.null <- base::is.null
[15:32:39.398]                       muffled <- FALSE
[15:32:39.398]                       if (inherits(cond, "message")) {
[15:32:39.398]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:39.398]                         if (muffled) 
[15:32:39.398]                           invokeRestart("muffleMessage")
[15:32:39.398]                       }
[15:32:39.398]                       else if (inherits(cond, "warning")) {
[15:32:39.398]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:39.398]                         if (muffled) 
[15:32:39.398]                           invokeRestart("muffleWarning")
[15:32:39.398]                       }
[15:32:39.398]                       else if (inherits(cond, "condition")) {
[15:32:39.398]                         if (!is.null(pattern)) {
[15:32:39.398]                           computeRestarts <- base::computeRestarts
[15:32:39.398]                           grepl <- base::grepl
[15:32:39.398]                           restarts <- computeRestarts(cond)
[15:32:39.398]                           for (restart in restarts) {
[15:32:39.398]                             name <- restart$name
[15:32:39.398]                             if (is.null(name)) 
[15:32:39.398]                               next
[15:32:39.398]                             if (!grepl(pattern, name)) 
[15:32:39.398]                               next
[15:32:39.398]                             invokeRestart(restart)
[15:32:39.398]                             muffled <- TRUE
[15:32:39.398]                             break
[15:32:39.398]                           }
[15:32:39.398]                         }
[15:32:39.398]                       }
[15:32:39.398]                       invisible(muffled)
[15:32:39.398]                     }
[15:32:39.398]                     muffleCondition(cond, pattern = "^muffle")
[15:32:39.398]                   }
[15:32:39.398]                 }
[15:32:39.398]                 else {
[15:32:39.398]                   if (TRUE) {
[15:32:39.398]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:39.398]                     {
[15:32:39.398]                       inherits <- base::inherits
[15:32:39.398]                       invokeRestart <- base::invokeRestart
[15:32:39.398]                       is.null <- base::is.null
[15:32:39.398]                       muffled <- FALSE
[15:32:39.398]                       if (inherits(cond, "message")) {
[15:32:39.398]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:39.398]                         if (muffled) 
[15:32:39.398]                           invokeRestart("muffleMessage")
[15:32:39.398]                       }
[15:32:39.398]                       else if (inherits(cond, "warning")) {
[15:32:39.398]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:39.398]                         if (muffled) 
[15:32:39.398]                           invokeRestart("muffleWarning")
[15:32:39.398]                       }
[15:32:39.398]                       else if (inherits(cond, "condition")) {
[15:32:39.398]                         if (!is.null(pattern)) {
[15:32:39.398]                           computeRestarts <- base::computeRestarts
[15:32:39.398]                           grepl <- base::grepl
[15:32:39.398]                           restarts <- computeRestarts(cond)
[15:32:39.398]                           for (restart in restarts) {
[15:32:39.398]                             name <- restart$name
[15:32:39.398]                             if (is.null(name)) 
[15:32:39.398]                               next
[15:32:39.398]                             if (!grepl(pattern, name)) 
[15:32:39.398]                               next
[15:32:39.398]                             invokeRestart(restart)
[15:32:39.398]                             muffled <- TRUE
[15:32:39.398]                             break
[15:32:39.398]                           }
[15:32:39.398]                         }
[15:32:39.398]                       }
[15:32:39.398]                       invisible(muffled)
[15:32:39.398]                     }
[15:32:39.398]                     muffleCondition(cond, pattern = "^muffle")
[15:32:39.398]                   }
[15:32:39.398]                 }
[15:32:39.398]             }
[15:32:39.398]         }))
[15:32:39.398]     }, error = function(ex) {
[15:32:39.398]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:39.398]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:39.398]                 ...future.rng), started = ...future.startTime, 
[15:32:39.398]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:39.398]             version = "1.8"), class = "FutureResult")
[15:32:39.398]     }, finally = {
[15:32:39.398]         if (!identical(...future.workdir, getwd())) 
[15:32:39.398]             setwd(...future.workdir)
[15:32:39.398]         {
[15:32:39.398]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:39.398]                 ...future.oldOptions$nwarnings <- NULL
[15:32:39.398]             }
[15:32:39.398]             base::options(...future.oldOptions)
[15:32:39.398]             if (.Platform$OS.type == "windows") {
[15:32:39.398]                 old_names <- names(...future.oldEnvVars)
[15:32:39.398]                 envs <- base::Sys.getenv()
[15:32:39.398]                 names <- names(envs)
[15:32:39.398]                 common <- intersect(names, old_names)
[15:32:39.398]                 added <- setdiff(names, old_names)
[15:32:39.398]                 removed <- setdiff(old_names, names)
[15:32:39.398]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:39.398]                   envs[common]]
[15:32:39.398]                 NAMES <- toupper(changed)
[15:32:39.398]                 args <- list()
[15:32:39.398]                 for (kk in seq_along(NAMES)) {
[15:32:39.398]                   name <- changed[[kk]]
[15:32:39.398]                   NAME <- NAMES[[kk]]
[15:32:39.398]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:39.398]                     next
[15:32:39.398]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:39.398]                 }
[15:32:39.398]                 NAMES <- toupper(added)
[15:32:39.398]                 for (kk in seq_along(NAMES)) {
[15:32:39.398]                   name <- added[[kk]]
[15:32:39.398]                   NAME <- NAMES[[kk]]
[15:32:39.398]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:39.398]                     next
[15:32:39.398]                   args[[name]] <- ""
[15:32:39.398]                 }
[15:32:39.398]                 NAMES <- toupper(removed)
[15:32:39.398]                 for (kk in seq_along(NAMES)) {
[15:32:39.398]                   name <- removed[[kk]]
[15:32:39.398]                   NAME <- NAMES[[kk]]
[15:32:39.398]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:39.398]                     next
[15:32:39.398]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:39.398]                 }
[15:32:39.398]                 if (length(args) > 0) 
[15:32:39.398]                   base::do.call(base::Sys.setenv, args = args)
[15:32:39.398]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:39.398]             }
[15:32:39.398]             else {
[15:32:39.398]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:39.398]             }
[15:32:39.398]             {
[15:32:39.398]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:39.398]                   0L) {
[15:32:39.398]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:39.398]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:39.398]                   base::options(opts)
[15:32:39.398]                 }
[15:32:39.398]                 {
[15:32:39.398]                   {
[15:32:39.398]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:39.398]                     NULL
[15:32:39.398]                   }
[15:32:39.398]                   options(future.plan = NULL)
[15:32:39.398]                   if (is.na(NA_character_)) 
[15:32:39.398]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:39.398]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:39.398]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:39.398]                     .init = FALSE)
[15:32:39.398]                 }
[15:32:39.398]             }
[15:32:39.398]         }
[15:32:39.398]     })
[15:32:39.398]     if (TRUE) {
[15:32:39.398]         base::sink(type = "output", split = FALSE)
[15:32:39.398]         if (TRUE) {
[15:32:39.398]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:39.398]         }
[15:32:39.398]         else {
[15:32:39.398]             ...future.result["stdout"] <- base::list(NULL)
[15:32:39.398]         }
[15:32:39.398]         base::close(...future.stdout)
[15:32:39.398]         ...future.stdout <- NULL
[15:32:39.398]     }
[15:32:39.398]     ...future.result$conditions <- ...future.conditions
[15:32:39.398]     ...future.result$finished <- base::Sys.time()
[15:32:39.398]     ...future.result
[15:32:39.398] }
[15:32:39.408] Exporting 5 global objects (1.22 KiB) to cluster node #1 ...
[15:32:39.408] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ...
[15:32:39.409] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ... DONE
[15:32:39.410] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:39.411] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:39.411] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:39.412] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:39.412] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:39.413] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:39.413] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:39.414] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:39.414] Exporting 5 global objects (1.22 KiB) to cluster node #1 ... DONE
[15:32:39.416] MultisessionFuture started
[15:32:39.416] - Launch lazy future ... done
[15:32:39.416] run() for 'MultisessionFuture' ... done
[15:32:39.417] Created future:
[15:32:39.444] receiveMessageFromWorker() for ClusterFuture ...
[15:32:39.444] - Validating connection of MultisessionFuture
[15:32:39.445] - received message: FutureResult
[15:32:39.445] - Received FutureResult
[15:32:39.446] - Erased future from FutureRegistry
[15:32:39.446] result() for ClusterFuture ...
[15:32:39.446] - result already collected: FutureResult
[15:32:39.447] result() for ClusterFuture ... done
[15:32:39.447] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:39.417] MultisessionFuture:
[15:32:39.417] Label: 'future_sapply-2'
[15:32:39.417] Expression:
[15:32:39.417] {
[15:32:39.417]     do.call(function(...) {
[15:32:39.417]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:39.417]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:39.417]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:39.417]             on.exit(options(oopts), add = TRUE)
[15:32:39.417]         }
[15:32:39.417]         {
[15:32:39.417]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:39.417]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:39.417]                 ...future.FUN(...future.X_jj, ...)
[15:32:39.417]             })
[15:32:39.417]         }
[15:32:39.417]     }, args = future.call.arguments)
[15:32:39.417] }
[15:32:39.417] Lazy evaluation: FALSE
[15:32:39.417] Asynchronous evaluation: TRUE
[15:32:39.417] Local evaluation: TRUE
[15:32:39.417] Environment: R_GlobalEnv
[15:32:39.417] Capture standard output: TRUE
[15:32:39.417] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:39.417] Globals: 5 objects totaling 1.33 KiB (function '...future.FUN' of 1.22 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)
[15:32:39.417] Packages: <none>
[15:32:39.417] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:39.417] Resolved: TRUE
[15:32:39.417] Value: <not collected>
[15:32:39.417] Conditions captured: <none>
[15:32:39.417] Early signaling: FALSE
[15:32:39.417] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:39.417] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:39.448] Chunk #2 of 2 ... DONE
[15:32:39.448] Launching 2 futures (chunks) ... DONE
[15:32:39.449] Resolving 2 futures (chunks) ...
[15:32:39.449] resolve() on list ...
[15:32:39.449]  recursive: 0
[15:32:39.450]  length: 2
[15:32:39.450] 
[15:32:39.450] Future #1
[15:32:39.450] result() for ClusterFuture ...
[15:32:39.451] - result already collected: FutureResult
[15:32:39.451] result() for ClusterFuture ... done
[15:32:39.451] result() for ClusterFuture ...
[15:32:39.452] - result already collected: FutureResult
[15:32:39.452] result() for ClusterFuture ... done
[15:32:39.452] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:39.453] - nx: 2
[15:32:39.453] - relay: TRUE
[15:32:39.453] - stdout: TRUE
[15:32:39.454] - signal: TRUE
[15:32:39.454] - resignal: FALSE
[15:32:39.454] - force: TRUE
[15:32:39.454] - relayed: [n=2] FALSE, FALSE
[15:32:39.455] - queued futures: [n=2] FALSE, FALSE
[15:32:39.455]  - until=1
[15:32:39.455]  - relaying element #1
[15:32:39.456] result() for ClusterFuture ...
[15:32:39.456] - result already collected: FutureResult
[15:32:39.456] result() for ClusterFuture ... done
[15:32:39.457] result() for ClusterFuture ...
[15:32:39.457] - result already collected: FutureResult
[15:32:39.457] result() for ClusterFuture ... done
[15:32:39.458] result() for ClusterFuture ...
[15:32:39.458] - result already collected: FutureResult
[15:32:39.458] result() for ClusterFuture ... done
[15:32:39.459] result() for ClusterFuture ...
[15:32:39.459] - result already collected: FutureResult
[15:32:39.459] result() for ClusterFuture ... done
[15:32:39.460] - relayed: [n=2] TRUE, FALSE
[15:32:39.460] - queued futures: [n=2] TRUE, FALSE
[15:32:39.460] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:39.461]  length: 1 (resolved future 1)
[15:32:39.461] Future #2
[15:32:39.461] result() for ClusterFuture ...
[15:32:39.461] - result already collected: FutureResult
[15:32:39.462] result() for ClusterFuture ... done
[15:32:39.462] result() for ClusterFuture ...
[15:32:39.462] - result already collected: FutureResult
[15:32:39.463] result() for ClusterFuture ... done
[15:32:39.463] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:39.463] - nx: 2
[15:32:39.464] - relay: TRUE
[15:32:39.464] - stdout: TRUE
[15:32:39.464] - signal: TRUE
[15:32:39.465] - resignal: FALSE
[15:32:39.465] - force: TRUE
[15:32:39.465] - relayed: [n=2] TRUE, FALSE
[15:32:39.466] - queued futures: [n=2] TRUE, FALSE
[15:32:39.466]  - until=2
[15:32:39.466]  - relaying element #2
[15:32:39.467] result() for ClusterFuture ...
[15:32:39.467] - result already collected: FutureResult
[15:32:39.467] result() for ClusterFuture ... done
[15:32:39.468] result() for ClusterFuture ...
[15:32:39.468] - result already collected: FutureResult
[15:32:39.468] result() for ClusterFuture ... done
[15:32:39.469] result() for ClusterFuture ...
[15:32:39.469] - result already collected: FutureResult
[15:32:39.469] result() for ClusterFuture ... done
[15:32:39.469] result() for ClusterFuture ...
[15:32:39.470] - result already collected: FutureResult
[15:32:39.470] result() for ClusterFuture ... done
[15:32:39.470] - relayed: [n=2] TRUE, TRUE
[15:32:39.471] - queued futures: [n=2] TRUE, TRUE
[15:32:39.471] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:39.471]  length: 0 (resolved future 2)
[15:32:39.472] Relaying remaining futures
[15:32:39.472] signalConditionsASAP(NULL, pos=0) ...
[15:32:39.472] - nx: 2
[15:32:39.473] - relay: TRUE
[15:32:39.473] - stdout: TRUE
[15:32:39.473] - signal: TRUE
[15:32:39.473] - resignal: FALSE
[15:32:39.474] - force: TRUE
[15:32:39.474] - relayed: [n=2] TRUE, TRUE
[15:32:39.474] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:39.475] - relayed: [n=2] TRUE, TRUE
[15:32:39.475] - queued futures: [n=2] TRUE, TRUE
[15:32:39.475] signalConditionsASAP(NULL, pos=0) ... done
[15:32:39.476] resolve() on list ... DONE
[15:32:39.476] result() for ClusterFuture ...
[15:32:39.476] - result already collected: FutureResult
[15:32:39.477] result() for ClusterFuture ... done
[15:32:39.477] result() for ClusterFuture ...
[15:32:39.477] - result already collected: FutureResult
[15:32:39.478] result() for ClusterFuture ... done
[15:32:39.478] result() for ClusterFuture ...
[15:32:39.478] - result already collected: FutureResult
[15:32:39.479] result() for ClusterFuture ... done
[15:32:39.479] result() for ClusterFuture ...
[15:32:39.479] - result already collected: FutureResult
[15:32:39.480] result() for ClusterFuture ... done
[15:32:39.480]  - Number of value chunks collected: 2
[15:32:39.480] Resolving 2 futures (chunks) ... DONE
[15:32:39.481] Reducing values from 2 chunks ...
[15:32:39.481]  - Number of values collected after concatenation: 4
[15:32:39.481]  - Number of values expected: 4
[15:32:39.482] Reducing values from 2 chunks ... DONE
[15:32:39.482] future_lapply() ... DONE
List of 2
 $ y0: Named num [1:4] 50 60 70 80
  ..- attr(*, "names")= chr [1:4] "A" "B" "C" "D"
 $ y1: Named num [1:4] 50 60 70 80
  ..- attr(*, "names")= chr [1:4] "A" "B" "C" "D"
[15:32:39.486] future_lapply() ...
[15:32:39.492] Number of chunks: 2
[15:32:39.493] getGlobalsAndPackagesXApply() ...
[15:32:39.493]  - future.globals: TRUE
[15:32:39.493] getGlobalsAndPackages() ...
[15:32:39.494] Searching for globals...
[15:32:39.497] - globals found: [5] 'FUN', '*', ':', 'outer', 'rep'
[15:32:39.498] Searching for globals ... DONE
[15:32:39.498] Resolving globals: FALSE
[15:32:39.499] The total size of the 1 globals is 4.62 KiB (4728 bytes)
[15:32:39.500] The total size of the 1 globals exported for future expression ('FUN()') is 4.62 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.62 KiB of class 'function')
[15:32:39.500] - globals: [1] 'FUN'
[15:32:39.501] 
[15:32:39.501] getGlobalsAndPackages() ... DONE
[15:32:39.501]  - globals found/used: [n=1] 'FUN'
[15:32:39.501]  - needed namespaces: [n=0] 
[15:32:39.502] Finding globals ... DONE
[15:32:39.502]  - use_args: TRUE
[15:32:39.502]  - Getting '...' globals ...
[15:32:39.503] resolve() on list ...
[15:32:39.503]  recursive: 0
[15:32:39.504]  length: 1
[15:32:39.504]  elements: '...'
[15:32:39.504]  length: 0 (resolved future 1)
[15:32:39.505] resolve() on list ... DONE
[15:32:39.505]    - '...' content: [n=0] 
[15:32:39.505] List of 1
[15:32:39.505]  $ ...: list()
[15:32:39.505]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:39.505]  - attr(*, "where")=List of 1
[15:32:39.505]   ..$ ...:<environment: 0x00000276e5c99990> 
[15:32:39.505]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:39.505]  - attr(*, "resolved")= logi TRUE
[15:32:39.505]  - attr(*, "total_size")= num NA
[15:32:39.511]  - Getting '...' globals ... DONE
[15:32:39.512] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:39.512] List of 2
[15:32:39.512]  $ ...future.FUN:function (x, y = 2 * 1:5)  
[15:32:39.512]  $ ...          : list()
[15:32:39.512]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:39.512]  - attr(*, "where")=List of 2
[15:32:39.512]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:39.512]   ..$ ...          :<environment: 0x00000276e5c99990> 
[15:32:39.512]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:39.512]  - attr(*, "resolved")= logi FALSE
[15:32:39.512]  - attr(*, "total_size")= num 4728
[15:32:39.518] Packages to be attached in all futures: [n=0] 
[15:32:39.518] getGlobalsAndPackagesXApply() ... DONE
[15:32:39.519] Number of futures (= number of chunks): 2
[15:32:39.519] Launching 2 futures (chunks) ...
[15:32:39.520] Chunk #1 of 2 ...
[15:32:39.520]  - Finding globals in 'X' for chunk #1 ...
[15:32:39.520] getGlobalsAndPackages() ...
[15:32:39.521] Searching for globals...
[15:32:39.521] 
[15:32:39.522] Searching for globals ... DONE
[15:32:39.522] - globals: [0] <none>
[15:32:39.522] getGlobalsAndPackages() ... DONE
[15:32:39.522]    + additional globals found: [n=0] 
[15:32:39.523]    + additional namespaces needed: [n=0] 
[15:32:39.523]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:39.523]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:39.524]  - seeds: <none>
[15:32:39.524]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:39.524] getGlobalsAndPackages() ...
[15:32:39.525] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:39.525] Resolving globals: FALSE
[15:32:39.525] Tweak future expression to call with '...' arguments ...
[15:32:39.526] {
[15:32:39.526]     do.call(function(...) {
[15:32:39.526]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:39.526]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:39.526]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:39.526]             on.exit(options(oopts), add = TRUE)
[15:32:39.526]         }
[15:32:39.526]         {
[15:32:39.526]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:39.526]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:39.526]                 ...future.FUN(...future.X_jj, ...)
[15:32:39.526]             })
[15:32:39.526]         }
[15:32:39.526]     }, args = future.call.arguments)
[15:32:39.526] }
[15:32:39.527] Tweak future expression to call with '...' arguments ... DONE
[15:32:39.528] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:39.528] 
[15:32:39.528] getGlobalsAndPackages() ... DONE
[15:32:39.529] run() for 'Future' ...
[15:32:39.529] - state: 'created'
[15:32:39.530] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:39.552] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:39.553] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:39.553]   - Field: 'node'
[15:32:39.553]   - Field: 'label'
[15:32:39.554]   - Field: 'local'
[15:32:39.554]   - Field: 'owner'
[15:32:39.555]   - Field: 'envir'
[15:32:39.555]   - Field: 'workers'
[15:32:39.555]   - Field: 'packages'
[15:32:39.556]   - Field: 'gc'
[15:32:39.556]   - Field: 'conditions'
[15:32:39.556]   - Field: 'persistent'
[15:32:39.557]   - Field: 'expr'
[15:32:39.557]   - Field: 'uuid'
[15:32:39.557]   - Field: 'seed'
[15:32:39.558]   - Field: 'version'
[15:32:39.558]   - Field: 'result'
[15:32:39.558]   - Field: 'asynchronous'
[15:32:39.559]   - Field: 'calls'
[15:32:39.559]   - Field: 'globals'
[15:32:39.559]   - Field: 'stdout'
[15:32:39.560]   - Field: 'earlySignal'
[15:32:39.560]   - Field: 'lazy'
[15:32:39.560]   - Field: 'state'
[15:32:39.561] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:39.561] - Launch lazy future ...
[15:32:39.562] Packages needed by the future expression (n = 0): <none>
[15:32:39.562] Packages needed by future strategies (n = 0): <none>
[15:32:39.563] {
[15:32:39.563]     {
[15:32:39.563]         {
[15:32:39.563]             ...future.startTime <- base::Sys.time()
[15:32:39.563]             {
[15:32:39.563]                 {
[15:32:39.563]                   {
[15:32:39.563]                     {
[15:32:39.563]                       base::local({
[15:32:39.563]                         has_future <- base::requireNamespace("future", 
[15:32:39.563]                           quietly = TRUE)
[15:32:39.563]                         if (has_future) {
[15:32:39.563]                           ns <- base::getNamespace("future")
[15:32:39.563]                           version <- ns[[".package"]][["version"]]
[15:32:39.563]                           if (is.null(version)) 
[15:32:39.563]                             version <- utils::packageVersion("future")
[15:32:39.563]                         }
[15:32:39.563]                         else {
[15:32:39.563]                           version <- NULL
[15:32:39.563]                         }
[15:32:39.563]                         if (!has_future || version < "1.8.0") {
[15:32:39.563]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:39.563]                             "", base::R.version$version.string), 
[15:32:39.563]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:39.563]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:39.563]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:39.563]                               "release", "version")], collapse = " "), 
[15:32:39.563]                             hostname = base::Sys.info()[["nodename"]])
[15:32:39.563]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:39.563]                             info)
[15:32:39.563]                           info <- base::paste(info, collapse = "; ")
[15:32:39.563]                           if (!has_future) {
[15:32:39.563]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:39.563]                               info)
[15:32:39.563]                           }
[15:32:39.563]                           else {
[15:32:39.563]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:39.563]                               info, version)
[15:32:39.563]                           }
[15:32:39.563]                           base::stop(msg)
[15:32:39.563]                         }
[15:32:39.563]                       })
[15:32:39.563]                     }
[15:32:39.563]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:39.563]                     base::options(mc.cores = 1L)
[15:32:39.563]                   }
[15:32:39.563]                   ...future.strategy.old <- future::plan("list")
[15:32:39.563]                   options(future.plan = NULL)
[15:32:39.563]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:39.563]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:39.563]                 }
[15:32:39.563]                 ...future.workdir <- getwd()
[15:32:39.563]             }
[15:32:39.563]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:39.563]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:39.563]         }
[15:32:39.563]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:39.563]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:39.563]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:39.563]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:39.563]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:39.563]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:39.563]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:39.563]             base::names(...future.oldOptions))
[15:32:39.563]     }
[15:32:39.563]     if (FALSE) {
[15:32:39.563]     }
[15:32:39.563]     else {
[15:32:39.563]         if (TRUE) {
[15:32:39.563]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:39.563]                 open = "w")
[15:32:39.563]         }
[15:32:39.563]         else {
[15:32:39.563]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:39.563]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:39.563]         }
[15:32:39.563]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:39.563]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:39.563]             base::sink(type = "output", split = FALSE)
[15:32:39.563]             base::close(...future.stdout)
[15:32:39.563]         }, add = TRUE)
[15:32:39.563]     }
[15:32:39.563]     ...future.frame <- base::sys.nframe()
[15:32:39.563]     ...future.conditions <- base::list()
[15:32:39.563]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:39.563]     if (FALSE) {
[15:32:39.563]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:39.563]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:39.563]     }
[15:32:39.563]     ...future.result <- base::tryCatch({
[15:32:39.563]         base::withCallingHandlers({
[15:32:39.563]             ...future.value <- base::withVisible(base::local({
[15:32:39.563]                 ...future.makeSendCondition <- base::local({
[15:32:39.563]                   sendCondition <- NULL
[15:32:39.563]                   function(frame = 1L) {
[15:32:39.563]                     if (is.function(sendCondition)) 
[15:32:39.563]                       return(sendCondition)
[15:32:39.563]                     ns <- getNamespace("parallel")
[15:32:39.563]                     if (exists("sendData", mode = "function", 
[15:32:39.563]                       envir = ns)) {
[15:32:39.563]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:39.563]                         envir = ns)
[15:32:39.563]                       envir <- sys.frame(frame)
[15:32:39.563]                       master <- NULL
[15:32:39.563]                       while (!identical(envir, .GlobalEnv) && 
[15:32:39.563]                         !identical(envir, emptyenv())) {
[15:32:39.563]                         if (exists("master", mode = "list", envir = envir, 
[15:32:39.563]                           inherits = FALSE)) {
[15:32:39.563]                           master <- get("master", mode = "list", 
[15:32:39.563]                             envir = envir, inherits = FALSE)
[15:32:39.563]                           if (inherits(master, c("SOCKnode", 
[15:32:39.563]                             "SOCK0node"))) {
[15:32:39.563]                             sendCondition <<- function(cond) {
[15:32:39.563]                               data <- list(type = "VALUE", value = cond, 
[15:32:39.563]                                 success = TRUE)
[15:32:39.563]                               parallel_sendData(master, data)
[15:32:39.563]                             }
[15:32:39.563]                             return(sendCondition)
[15:32:39.563]                           }
[15:32:39.563]                         }
[15:32:39.563]                         frame <- frame + 1L
[15:32:39.563]                         envir <- sys.frame(frame)
[15:32:39.563]                       }
[15:32:39.563]                     }
[15:32:39.563]                     sendCondition <<- function(cond) NULL
[15:32:39.563]                   }
[15:32:39.563]                 })
[15:32:39.563]                 withCallingHandlers({
[15:32:39.563]                   {
[15:32:39.563]                     do.call(function(...) {
[15:32:39.563]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:39.563]                       if (!identical(...future.globals.maxSize.org, 
[15:32:39.563]                         ...future.globals.maxSize)) {
[15:32:39.563]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:39.563]                         on.exit(options(oopts), add = TRUE)
[15:32:39.563]                       }
[15:32:39.563]                       {
[15:32:39.563]                         lapply(seq_along(...future.elements_ii), 
[15:32:39.563]                           FUN = function(jj) {
[15:32:39.563]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:39.563]                             ...future.FUN(...future.X_jj, ...)
[15:32:39.563]                           })
[15:32:39.563]                       }
[15:32:39.563]                     }, args = future.call.arguments)
[15:32:39.563]                   }
[15:32:39.563]                 }, immediateCondition = function(cond) {
[15:32:39.563]                   sendCondition <- ...future.makeSendCondition()
[15:32:39.563]                   sendCondition(cond)
[15:32:39.563]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:39.563]                   {
[15:32:39.563]                     inherits <- base::inherits
[15:32:39.563]                     invokeRestart <- base::invokeRestart
[15:32:39.563]                     is.null <- base::is.null
[15:32:39.563]                     muffled <- FALSE
[15:32:39.563]                     if (inherits(cond, "message")) {
[15:32:39.563]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:39.563]                       if (muffled) 
[15:32:39.563]                         invokeRestart("muffleMessage")
[15:32:39.563]                     }
[15:32:39.563]                     else if (inherits(cond, "warning")) {
[15:32:39.563]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:39.563]                       if (muffled) 
[15:32:39.563]                         invokeRestart("muffleWarning")
[15:32:39.563]                     }
[15:32:39.563]                     else if (inherits(cond, "condition")) {
[15:32:39.563]                       if (!is.null(pattern)) {
[15:32:39.563]                         computeRestarts <- base::computeRestarts
[15:32:39.563]                         grepl <- base::grepl
[15:32:39.563]                         restarts <- computeRestarts(cond)
[15:32:39.563]                         for (restart in restarts) {
[15:32:39.563]                           name <- restart$name
[15:32:39.563]                           if (is.null(name)) 
[15:32:39.563]                             next
[15:32:39.563]                           if (!grepl(pattern, name)) 
[15:32:39.563]                             next
[15:32:39.563]                           invokeRestart(restart)
[15:32:39.563]                           muffled <- TRUE
[15:32:39.563]                           break
[15:32:39.563]                         }
[15:32:39.563]                       }
[15:32:39.563]                     }
[15:32:39.563]                     invisible(muffled)
[15:32:39.563]                   }
[15:32:39.563]                   muffleCondition(cond)
[15:32:39.563]                 })
[15:32:39.563]             }))
[15:32:39.563]             future::FutureResult(value = ...future.value$value, 
[15:32:39.563]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:39.563]                   ...future.rng), globalenv = if (FALSE) 
[15:32:39.563]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:39.563]                     ...future.globalenv.names))
[15:32:39.563]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:39.563]         }, condition = base::local({
[15:32:39.563]             c <- base::c
[15:32:39.563]             inherits <- base::inherits
[15:32:39.563]             invokeRestart <- base::invokeRestart
[15:32:39.563]             length <- base::length
[15:32:39.563]             list <- base::list
[15:32:39.563]             seq.int <- base::seq.int
[15:32:39.563]             signalCondition <- base::signalCondition
[15:32:39.563]             sys.calls <- base::sys.calls
[15:32:39.563]             `[[` <- base::`[[`
[15:32:39.563]             `+` <- base::`+`
[15:32:39.563]             `<<-` <- base::`<<-`
[15:32:39.563]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:39.563]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:39.563]                   3L)]
[15:32:39.563]             }
[15:32:39.563]             function(cond) {
[15:32:39.563]                 is_error <- inherits(cond, "error")
[15:32:39.563]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:39.563]                   NULL)
[15:32:39.563]                 if (is_error) {
[15:32:39.563]                   sessionInformation <- function() {
[15:32:39.563]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:39.563]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:39.563]                       search = base::search(), system = base::Sys.info())
[15:32:39.563]                   }
[15:32:39.563]                   ...future.conditions[[length(...future.conditions) + 
[15:32:39.563]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:39.563]                     cond$call), session = sessionInformation(), 
[15:32:39.563]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:39.563]                   signalCondition(cond)
[15:32:39.563]                 }
[15:32:39.563]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:39.563]                 "immediateCondition"))) {
[15:32:39.563]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:39.563]                   ...future.conditions[[length(...future.conditions) + 
[15:32:39.563]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:39.563]                   if (TRUE && !signal) {
[15:32:39.563]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:39.563]                     {
[15:32:39.563]                       inherits <- base::inherits
[15:32:39.563]                       invokeRestart <- base::invokeRestart
[15:32:39.563]                       is.null <- base::is.null
[15:32:39.563]                       muffled <- FALSE
[15:32:39.563]                       if (inherits(cond, "message")) {
[15:32:39.563]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:39.563]                         if (muffled) 
[15:32:39.563]                           invokeRestart("muffleMessage")
[15:32:39.563]                       }
[15:32:39.563]                       else if (inherits(cond, "warning")) {
[15:32:39.563]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:39.563]                         if (muffled) 
[15:32:39.563]                           invokeRestart("muffleWarning")
[15:32:39.563]                       }
[15:32:39.563]                       else if (inherits(cond, "condition")) {
[15:32:39.563]                         if (!is.null(pattern)) {
[15:32:39.563]                           computeRestarts <- base::computeRestarts
[15:32:39.563]                           grepl <- base::grepl
[15:32:39.563]                           restarts <- computeRestarts(cond)
[15:32:39.563]                           for (restart in restarts) {
[15:32:39.563]                             name <- restart$name
[15:32:39.563]                             if (is.null(name)) 
[15:32:39.563]                               next
[15:32:39.563]                             if (!grepl(pattern, name)) 
[15:32:39.563]                               next
[15:32:39.563]                             invokeRestart(restart)
[15:32:39.563]                             muffled <- TRUE
[15:32:39.563]                             break
[15:32:39.563]                           }
[15:32:39.563]                         }
[15:32:39.563]                       }
[15:32:39.563]                       invisible(muffled)
[15:32:39.563]                     }
[15:32:39.563]                     muffleCondition(cond, pattern = "^muffle")
[15:32:39.563]                   }
[15:32:39.563]                 }
[15:32:39.563]                 else {
[15:32:39.563]                   if (TRUE) {
[15:32:39.563]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:39.563]                     {
[15:32:39.563]                       inherits <- base::inherits
[15:32:39.563]                       invokeRestart <- base::invokeRestart
[15:32:39.563]                       is.null <- base::is.null
[15:32:39.563]                       muffled <- FALSE
[15:32:39.563]                       if (inherits(cond, "message")) {
[15:32:39.563]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:39.563]                         if (muffled) 
[15:32:39.563]                           invokeRestart("muffleMessage")
[15:32:39.563]                       }
[15:32:39.563]                       else if (inherits(cond, "warning")) {
[15:32:39.563]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:39.563]                         if (muffled) 
[15:32:39.563]                           invokeRestart("muffleWarning")
[15:32:39.563]                       }
[15:32:39.563]                       else if (inherits(cond, "condition")) {
[15:32:39.563]                         if (!is.null(pattern)) {
[15:32:39.563]                           computeRestarts <- base::computeRestarts
[15:32:39.563]                           grepl <- base::grepl
[15:32:39.563]                           restarts <- computeRestarts(cond)
[15:32:39.563]                           for (restart in restarts) {
[15:32:39.563]                             name <- restart$name
[15:32:39.563]                             if (is.null(name)) 
[15:32:39.563]                               next
[15:32:39.563]                             if (!grepl(pattern, name)) 
[15:32:39.563]                               next
[15:32:39.563]                             invokeRestart(restart)
[15:32:39.563]                             muffled <- TRUE
[15:32:39.563]                             break
[15:32:39.563]                           }
[15:32:39.563]                         }
[15:32:39.563]                       }
[15:32:39.563]                       invisible(muffled)
[15:32:39.563]                     }
[15:32:39.563]                     muffleCondition(cond, pattern = "^muffle")
[15:32:39.563]                   }
[15:32:39.563]                 }
[15:32:39.563]             }
[15:32:39.563]         }))
[15:32:39.563]     }, error = function(ex) {
[15:32:39.563]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:39.563]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:39.563]                 ...future.rng), started = ...future.startTime, 
[15:32:39.563]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:39.563]             version = "1.8"), class = "FutureResult")
[15:32:39.563]     }, finally = {
[15:32:39.563]         if (!identical(...future.workdir, getwd())) 
[15:32:39.563]             setwd(...future.workdir)
[15:32:39.563]         {
[15:32:39.563]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:39.563]                 ...future.oldOptions$nwarnings <- NULL
[15:32:39.563]             }
[15:32:39.563]             base::options(...future.oldOptions)
[15:32:39.563]             if (.Platform$OS.type == "windows") {
[15:32:39.563]                 old_names <- names(...future.oldEnvVars)
[15:32:39.563]                 envs <- base::Sys.getenv()
[15:32:39.563]                 names <- names(envs)
[15:32:39.563]                 common <- intersect(names, old_names)
[15:32:39.563]                 added <- setdiff(names, old_names)
[15:32:39.563]                 removed <- setdiff(old_names, names)
[15:32:39.563]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:39.563]                   envs[common]]
[15:32:39.563]                 NAMES <- toupper(changed)
[15:32:39.563]                 args <- list()
[15:32:39.563]                 for (kk in seq_along(NAMES)) {
[15:32:39.563]                   name <- changed[[kk]]
[15:32:39.563]                   NAME <- NAMES[[kk]]
[15:32:39.563]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:39.563]                     next
[15:32:39.563]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:39.563]                 }
[15:32:39.563]                 NAMES <- toupper(added)
[15:32:39.563]                 for (kk in seq_along(NAMES)) {
[15:32:39.563]                   name <- added[[kk]]
[15:32:39.563]                   NAME <- NAMES[[kk]]
[15:32:39.563]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:39.563]                     next
[15:32:39.563]                   args[[name]] <- ""
[15:32:39.563]                 }
[15:32:39.563]                 NAMES <- toupper(removed)
[15:32:39.563]                 for (kk in seq_along(NAMES)) {
[15:32:39.563]                   name <- removed[[kk]]
[15:32:39.563]                   NAME <- NAMES[[kk]]
[15:32:39.563]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:39.563]                     next
[15:32:39.563]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:39.563]                 }
[15:32:39.563]                 if (length(args) > 0) 
[15:32:39.563]                   base::do.call(base::Sys.setenv, args = args)
[15:32:39.563]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:39.563]             }
[15:32:39.563]             else {
[15:32:39.563]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:39.563]             }
[15:32:39.563]             {
[15:32:39.563]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:39.563]                   0L) {
[15:32:39.563]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:39.563]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:39.563]                   base::options(opts)
[15:32:39.563]                 }
[15:32:39.563]                 {
[15:32:39.563]                   {
[15:32:39.563]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:39.563]                     NULL
[15:32:39.563]                   }
[15:32:39.563]                   options(future.plan = NULL)
[15:32:39.563]                   if (is.na(NA_character_)) 
[15:32:39.563]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:39.563]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:39.563]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:39.563]                     .init = FALSE)
[15:32:39.563]                 }
[15:32:39.563]             }
[15:32:39.563]         }
[15:32:39.563]     })
[15:32:39.563]     if (TRUE) {
[15:32:39.563]         base::sink(type = "output", split = FALSE)
[15:32:39.563]         if (TRUE) {
[15:32:39.563]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:39.563]         }
[15:32:39.563]         else {
[15:32:39.563]             ...future.result["stdout"] <- base::list(NULL)
[15:32:39.563]         }
[15:32:39.563]         base::close(...future.stdout)
[15:32:39.563]         ...future.stdout <- NULL
[15:32:39.563]     }
[15:32:39.563]     ...future.result$conditions <- ...future.conditions
[15:32:39.563]     ...future.result$finished <- base::Sys.time()
[15:32:39.563]     ...future.result
[15:32:39.563] }
[15:32:39.573] Exporting 5 global objects (4.62 KiB) to cluster node #1 ...
[15:32:39.574] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ...
[15:32:39.574] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ... DONE
[15:32:39.575] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:39.576] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:39.576] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:39.577] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:39.577] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:39.578] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:39.578] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:39.579] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:39.579] Exporting 5 global objects (4.62 KiB) to cluster node #1 ... DONE
[15:32:39.580] MultisessionFuture started
[15:32:39.580] - Launch lazy future ... done
[15:32:39.580] run() for 'MultisessionFuture' ... done
[15:32:39.581] Created future:
[15:32:39.607] receiveMessageFromWorker() for ClusterFuture ...
[15:32:39.607] - Validating connection of MultisessionFuture
[15:32:39.608] - received message: FutureResult
[15:32:39.608] - Received FutureResult
[15:32:39.608] - Erased future from FutureRegistry
[15:32:39.609] result() for ClusterFuture ...
[15:32:39.609] - result already collected: FutureResult
[15:32:39.609] result() for ClusterFuture ... done
[15:32:39.609] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:39.581] MultisessionFuture:
[15:32:39.581] Label: 'future_sapply-1'
[15:32:39.581] Expression:
[15:32:39.581] {
[15:32:39.581]     do.call(function(...) {
[15:32:39.581]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:39.581]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:39.581]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:39.581]             on.exit(options(oopts), add = TRUE)
[15:32:39.581]         }
[15:32:39.581]         {
[15:32:39.581]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:39.581]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:39.581]                 ...future.FUN(...future.X_jj, ...)
[15:32:39.581]             })
[15:32:39.581]         }
[15:32:39.581]     }, args = future.call.arguments)
[15:32:39.581] }
[15:32:39.581] Lazy evaluation: FALSE
[15:32:39.581] Asynchronous evaluation: TRUE
[15:32:39.581] Local evaluation: TRUE
[15:32:39.581] Environment: R_GlobalEnv
[15:32:39.581] Capture standard output: TRUE
[15:32:39.581] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:39.581] Globals: 5 objects totaling 4.73 KiB (function '...future.FUN' of 4.62 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)
[15:32:39.581] Packages: <none>
[15:32:39.581] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:39.581] Resolved: TRUE
[15:32:39.581] Value: <not collected>
[15:32:39.581] Conditions captured: <none>
[15:32:39.581] Early signaling: FALSE
[15:32:39.581] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:39.581] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:39.610] Chunk #1 of 2 ... DONE
[15:32:39.611] Chunk #2 of 2 ...
[15:32:39.611]  - Finding globals in 'X' for chunk #2 ...
[15:32:39.611] getGlobalsAndPackages() ...
[15:32:39.611] Searching for globals...
[15:32:39.612] 
[15:32:39.612] Searching for globals ... DONE
[15:32:39.612] - globals: [0] <none>
[15:32:39.613] getGlobalsAndPackages() ... DONE
[15:32:39.613]    + additional globals found: [n=0] 
[15:32:39.613]    + additional namespaces needed: [n=0] 
[15:32:39.613]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:39.614]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:39.614]  - seeds: <none>
[15:32:39.614]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:39.615] getGlobalsAndPackages() ...
[15:32:39.615] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:39.615] Resolving globals: FALSE
[15:32:39.615] Tweak future expression to call with '...' arguments ...
[15:32:39.616] {
[15:32:39.616]     do.call(function(...) {
[15:32:39.616]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:39.616]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:39.616]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:39.616]             on.exit(options(oopts), add = TRUE)
[15:32:39.616]         }
[15:32:39.616]         {
[15:32:39.616]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:39.616]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:39.616]                 ...future.FUN(...future.X_jj, ...)
[15:32:39.616]             })
[15:32:39.616]         }
[15:32:39.616]     }, args = future.call.arguments)
[15:32:39.616] }
[15:32:39.616] Tweak future expression to call with '...' arguments ... DONE
[15:32:39.617] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:39.618] 
[15:32:39.618] getGlobalsAndPackages() ... DONE
[15:32:39.618] run() for 'Future' ...
[15:32:39.619] - state: 'created'
[15:32:39.619] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:39.638] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:39.639] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:39.639]   - Field: 'node'
[15:32:39.639]   - Field: 'label'
[15:32:39.640]   - Field: 'local'
[15:32:39.646]   - Field: 'owner'
[15:32:39.647]   - Field: 'envir'
[15:32:39.647]   - Field: 'workers'
[15:32:39.647]   - Field: 'packages'
[15:32:39.648]   - Field: 'gc'
[15:32:39.648]   - Field: 'conditions'
[15:32:39.648]   - Field: 'persistent'
[15:32:39.649]   - Field: 'expr'
[15:32:39.649]   - Field: 'uuid'
[15:32:39.650]   - Field: 'seed'
[15:32:39.650]   - Field: 'version'
[15:32:39.650]   - Field: 'result'
[15:32:39.651]   - Field: 'asynchronous'
[15:32:39.651]   - Field: 'calls'
[15:32:39.651]   - Field: 'globals'
[15:32:39.652]   - Field: 'stdout'
[15:32:39.652]   - Field: 'earlySignal'
[15:32:39.652]   - Field: 'lazy'
[15:32:39.653]   - Field: 'state'
[15:32:39.653] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:39.653] - Launch lazy future ...
[15:32:39.654] Packages needed by the future expression (n = 0): <none>
[15:32:39.654] Packages needed by future strategies (n = 0): <none>
[15:32:39.655] {
[15:32:39.655]     {
[15:32:39.655]         {
[15:32:39.655]             ...future.startTime <- base::Sys.time()
[15:32:39.655]             {
[15:32:39.655]                 {
[15:32:39.655]                   {
[15:32:39.655]                     {
[15:32:39.655]                       base::local({
[15:32:39.655]                         has_future <- base::requireNamespace("future", 
[15:32:39.655]                           quietly = TRUE)
[15:32:39.655]                         if (has_future) {
[15:32:39.655]                           ns <- base::getNamespace("future")
[15:32:39.655]                           version <- ns[[".package"]][["version"]]
[15:32:39.655]                           if (is.null(version)) 
[15:32:39.655]                             version <- utils::packageVersion("future")
[15:32:39.655]                         }
[15:32:39.655]                         else {
[15:32:39.655]                           version <- NULL
[15:32:39.655]                         }
[15:32:39.655]                         if (!has_future || version < "1.8.0") {
[15:32:39.655]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:39.655]                             "", base::R.version$version.string), 
[15:32:39.655]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:39.655]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:39.655]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:39.655]                               "release", "version")], collapse = " "), 
[15:32:39.655]                             hostname = base::Sys.info()[["nodename"]])
[15:32:39.655]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:39.655]                             info)
[15:32:39.655]                           info <- base::paste(info, collapse = "; ")
[15:32:39.655]                           if (!has_future) {
[15:32:39.655]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:39.655]                               info)
[15:32:39.655]                           }
[15:32:39.655]                           else {
[15:32:39.655]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:39.655]                               info, version)
[15:32:39.655]                           }
[15:32:39.655]                           base::stop(msg)
[15:32:39.655]                         }
[15:32:39.655]                       })
[15:32:39.655]                     }
[15:32:39.655]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:39.655]                     base::options(mc.cores = 1L)
[15:32:39.655]                   }
[15:32:39.655]                   ...future.strategy.old <- future::plan("list")
[15:32:39.655]                   options(future.plan = NULL)
[15:32:39.655]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:39.655]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:39.655]                 }
[15:32:39.655]                 ...future.workdir <- getwd()
[15:32:39.655]             }
[15:32:39.655]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:39.655]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:39.655]         }
[15:32:39.655]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:39.655]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:39.655]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:39.655]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:39.655]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:39.655]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:39.655]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:39.655]             base::names(...future.oldOptions))
[15:32:39.655]     }
[15:32:39.655]     if (FALSE) {
[15:32:39.655]     }
[15:32:39.655]     else {
[15:32:39.655]         if (TRUE) {
[15:32:39.655]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:39.655]                 open = "w")
[15:32:39.655]         }
[15:32:39.655]         else {
[15:32:39.655]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:39.655]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:39.655]         }
[15:32:39.655]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:39.655]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:39.655]             base::sink(type = "output", split = FALSE)
[15:32:39.655]             base::close(...future.stdout)
[15:32:39.655]         }, add = TRUE)
[15:32:39.655]     }
[15:32:39.655]     ...future.frame <- base::sys.nframe()
[15:32:39.655]     ...future.conditions <- base::list()
[15:32:39.655]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:39.655]     if (FALSE) {
[15:32:39.655]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:39.655]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:39.655]     }
[15:32:39.655]     ...future.result <- base::tryCatch({
[15:32:39.655]         base::withCallingHandlers({
[15:32:39.655]             ...future.value <- base::withVisible(base::local({
[15:32:39.655]                 ...future.makeSendCondition <- base::local({
[15:32:39.655]                   sendCondition <- NULL
[15:32:39.655]                   function(frame = 1L) {
[15:32:39.655]                     if (is.function(sendCondition)) 
[15:32:39.655]                       return(sendCondition)
[15:32:39.655]                     ns <- getNamespace("parallel")
[15:32:39.655]                     if (exists("sendData", mode = "function", 
[15:32:39.655]                       envir = ns)) {
[15:32:39.655]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:39.655]                         envir = ns)
[15:32:39.655]                       envir <- sys.frame(frame)
[15:32:39.655]                       master <- NULL
[15:32:39.655]                       while (!identical(envir, .GlobalEnv) && 
[15:32:39.655]                         !identical(envir, emptyenv())) {
[15:32:39.655]                         if (exists("master", mode = "list", envir = envir, 
[15:32:39.655]                           inherits = FALSE)) {
[15:32:39.655]                           master <- get("master", mode = "list", 
[15:32:39.655]                             envir = envir, inherits = FALSE)
[15:32:39.655]                           if (inherits(master, c("SOCKnode", 
[15:32:39.655]                             "SOCK0node"))) {
[15:32:39.655]                             sendCondition <<- function(cond) {
[15:32:39.655]                               data <- list(type = "VALUE", value = cond, 
[15:32:39.655]                                 success = TRUE)
[15:32:39.655]                               parallel_sendData(master, data)
[15:32:39.655]                             }
[15:32:39.655]                             return(sendCondition)
[15:32:39.655]                           }
[15:32:39.655]                         }
[15:32:39.655]                         frame <- frame + 1L
[15:32:39.655]                         envir <- sys.frame(frame)
[15:32:39.655]                       }
[15:32:39.655]                     }
[15:32:39.655]                     sendCondition <<- function(cond) NULL
[15:32:39.655]                   }
[15:32:39.655]                 })
[15:32:39.655]                 withCallingHandlers({
[15:32:39.655]                   {
[15:32:39.655]                     do.call(function(...) {
[15:32:39.655]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:39.655]                       if (!identical(...future.globals.maxSize.org, 
[15:32:39.655]                         ...future.globals.maxSize)) {
[15:32:39.655]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:39.655]                         on.exit(options(oopts), add = TRUE)
[15:32:39.655]                       }
[15:32:39.655]                       {
[15:32:39.655]                         lapply(seq_along(...future.elements_ii), 
[15:32:39.655]                           FUN = function(jj) {
[15:32:39.655]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:39.655]                             ...future.FUN(...future.X_jj, ...)
[15:32:39.655]                           })
[15:32:39.655]                       }
[15:32:39.655]                     }, args = future.call.arguments)
[15:32:39.655]                   }
[15:32:39.655]                 }, immediateCondition = function(cond) {
[15:32:39.655]                   sendCondition <- ...future.makeSendCondition()
[15:32:39.655]                   sendCondition(cond)
[15:32:39.655]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:39.655]                   {
[15:32:39.655]                     inherits <- base::inherits
[15:32:39.655]                     invokeRestart <- base::invokeRestart
[15:32:39.655]                     is.null <- base::is.null
[15:32:39.655]                     muffled <- FALSE
[15:32:39.655]                     if (inherits(cond, "message")) {
[15:32:39.655]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:39.655]                       if (muffled) 
[15:32:39.655]                         invokeRestart("muffleMessage")
[15:32:39.655]                     }
[15:32:39.655]                     else if (inherits(cond, "warning")) {
[15:32:39.655]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:39.655]                       if (muffled) 
[15:32:39.655]                         invokeRestart("muffleWarning")
[15:32:39.655]                     }
[15:32:39.655]                     else if (inherits(cond, "condition")) {
[15:32:39.655]                       if (!is.null(pattern)) {
[15:32:39.655]                         computeRestarts <- base::computeRestarts
[15:32:39.655]                         grepl <- base::grepl
[15:32:39.655]                         restarts <- computeRestarts(cond)
[15:32:39.655]                         for (restart in restarts) {
[15:32:39.655]                           name <- restart$name
[15:32:39.655]                           if (is.null(name)) 
[15:32:39.655]                             next
[15:32:39.655]                           if (!grepl(pattern, name)) 
[15:32:39.655]                             next
[15:32:39.655]                           invokeRestart(restart)
[15:32:39.655]                           muffled <- TRUE
[15:32:39.655]                           break
[15:32:39.655]                         }
[15:32:39.655]                       }
[15:32:39.655]                     }
[15:32:39.655]                     invisible(muffled)
[15:32:39.655]                   }
[15:32:39.655]                   muffleCondition(cond)
[15:32:39.655]                 })
[15:32:39.655]             }))
[15:32:39.655]             future::FutureResult(value = ...future.value$value, 
[15:32:39.655]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:39.655]                   ...future.rng), globalenv = if (FALSE) 
[15:32:39.655]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:39.655]                     ...future.globalenv.names))
[15:32:39.655]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:39.655]         }, condition = base::local({
[15:32:39.655]             c <- base::c
[15:32:39.655]             inherits <- base::inherits
[15:32:39.655]             invokeRestart <- base::invokeRestart
[15:32:39.655]             length <- base::length
[15:32:39.655]             list <- base::list
[15:32:39.655]             seq.int <- base::seq.int
[15:32:39.655]             signalCondition <- base::signalCondition
[15:32:39.655]             sys.calls <- base::sys.calls
[15:32:39.655]             `[[` <- base::`[[`
[15:32:39.655]             `+` <- base::`+`
[15:32:39.655]             `<<-` <- base::`<<-`
[15:32:39.655]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:39.655]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:39.655]                   3L)]
[15:32:39.655]             }
[15:32:39.655]             function(cond) {
[15:32:39.655]                 is_error <- inherits(cond, "error")
[15:32:39.655]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:39.655]                   NULL)
[15:32:39.655]                 if (is_error) {
[15:32:39.655]                   sessionInformation <- function() {
[15:32:39.655]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:39.655]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:39.655]                       search = base::search(), system = base::Sys.info())
[15:32:39.655]                   }
[15:32:39.655]                   ...future.conditions[[length(...future.conditions) + 
[15:32:39.655]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:39.655]                     cond$call), session = sessionInformation(), 
[15:32:39.655]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:39.655]                   signalCondition(cond)
[15:32:39.655]                 }
[15:32:39.655]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:39.655]                 "immediateCondition"))) {
[15:32:39.655]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:39.655]                   ...future.conditions[[length(...future.conditions) + 
[15:32:39.655]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:39.655]                   if (TRUE && !signal) {
[15:32:39.655]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:39.655]                     {
[15:32:39.655]                       inherits <- base::inherits
[15:32:39.655]                       invokeRestart <- base::invokeRestart
[15:32:39.655]                       is.null <- base::is.null
[15:32:39.655]                       muffled <- FALSE
[15:32:39.655]                       if (inherits(cond, "message")) {
[15:32:39.655]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:39.655]                         if (muffled) 
[15:32:39.655]                           invokeRestart("muffleMessage")
[15:32:39.655]                       }
[15:32:39.655]                       else if (inherits(cond, "warning")) {
[15:32:39.655]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:39.655]                         if (muffled) 
[15:32:39.655]                           invokeRestart("muffleWarning")
[15:32:39.655]                       }
[15:32:39.655]                       else if (inherits(cond, "condition")) {
[15:32:39.655]                         if (!is.null(pattern)) {
[15:32:39.655]                           computeRestarts <- base::computeRestarts
[15:32:39.655]                           grepl <- base::grepl
[15:32:39.655]                           restarts <- computeRestarts(cond)
[15:32:39.655]                           for (restart in restarts) {
[15:32:39.655]                             name <- restart$name
[15:32:39.655]                             if (is.null(name)) 
[15:32:39.655]                               next
[15:32:39.655]                             if (!grepl(pattern, name)) 
[15:32:39.655]                               next
[15:32:39.655]                             invokeRestart(restart)
[15:32:39.655]                             muffled <- TRUE
[15:32:39.655]                             break
[15:32:39.655]                           }
[15:32:39.655]                         }
[15:32:39.655]                       }
[15:32:39.655]                       invisible(muffled)
[15:32:39.655]                     }
[15:32:39.655]                     muffleCondition(cond, pattern = "^muffle")
[15:32:39.655]                   }
[15:32:39.655]                 }
[15:32:39.655]                 else {
[15:32:39.655]                   if (TRUE) {
[15:32:39.655]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:39.655]                     {
[15:32:39.655]                       inherits <- base::inherits
[15:32:39.655]                       invokeRestart <- base::invokeRestart
[15:32:39.655]                       is.null <- base::is.null
[15:32:39.655]                       muffled <- FALSE
[15:32:39.655]                       if (inherits(cond, "message")) {
[15:32:39.655]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:39.655]                         if (muffled) 
[15:32:39.655]                           invokeRestart("muffleMessage")
[15:32:39.655]                       }
[15:32:39.655]                       else if (inherits(cond, "warning")) {
[15:32:39.655]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:39.655]                         if (muffled) 
[15:32:39.655]                           invokeRestart("muffleWarning")
[15:32:39.655]                       }
[15:32:39.655]                       else if (inherits(cond, "condition")) {
[15:32:39.655]                         if (!is.null(pattern)) {
[15:32:39.655]                           computeRestarts <- base::computeRestarts
[15:32:39.655]                           grepl <- base::grepl
[15:32:39.655]                           restarts <- computeRestarts(cond)
[15:32:39.655]                           for (restart in restarts) {
[15:32:39.655]                             name <- restart$name
[15:32:39.655]                             if (is.null(name)) 
[15:32:39.655]                               next
[15:32:39.655]                             if (!grepl(pattern, name)) 
[15:32:39.655]                               next
[15:32:39.655]                             invokeRestart(restart)
[15:32:39.655]                             muffled <- TRUE
[15:32:39.655]                             break
[15:32:39.655]                           }
[15:32:39.655]                         }
[15:32:39.655]                       }
[15:32:39.655]                       invisible(muffled)
[15:32:39.655]                     }
[15:32:39.655]                     muffleCondition(cond, pattern = "^muffle")
[15:32:39.655]                   }
[15:32:39.655]                 }
[15:32:39.655]             }
[15:32:39.655]         }))
[15:32:39.655]     }, error = function(ex) {
[15:32:39.655]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:39.655]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:39.655]                 ...future.rng), started = ...future.startTime, 
[15:32:39.655]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:39.655]             version = "1.8"), class = "FutureResult")
[15:32:39.655]     }, finally = {
[15:32:39.655]         if (!identical(...future.workdir, getwd())) 
[15:32:39.655]             setwd(...future.workdir)
[15:32:39.655]         {
[15:32:39.655]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:39.655]                 ...future.oldOptions$nwarnings <- NULL
[15:32:39.655]             }
[15:32:39.655]             base::options(...future.oldOptions)
[15:32:39.655]             if (.Platform$OS.type == "windows") {
[15:32:39.655]                 old_names <- names(...future.oldEnvVars)
[15:32:39.655]                 envs <- base::Sys.getenv()
[15:32:39.655]                 names <- names(envs)
[15:32:39.655]                 common <- intersect(names, old_names)
[15:32:39.655]                 added <- setdiff(names, old_names)
[15:32:39.655]                 removed <- setdiff(old_names, names)
[15:32:39.655]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:39.655]                   envs[common]]
[15:32:39.655]                 NAMES <- toupper(changed)
[15:32:39.655]                 args <- list()
[15:32:39.655]                 for (kk in seq_along(NAMES)) {
[15:32:39.655]                   name <- changed[[kk]]
[15:32:39.655]                   NAME <- NAMES[[kk]]
[15:32:39.655]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:39.655]                     next
[15:32:39.655]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:39.655]                 }
[15:32:39.655]                 NAMES <- toupper(added)
[15:32:39.655]                 for (kk in seq_along(NAMES)) {
[15:32:39.655]                   name <- added[[kk]]
[15:32:39.655]                   NAME <- NAMES[[kk]]
[15:32:39.655]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:39.655]                     next
[15:32:39.655]                   args[[name]] <- ""
[15:32:39.655]                 }
[15:32:39.655]                 NAMES <- toupper(removed)
[15:32:39.655]                 for (kk in seq_along(NAMES)) {
[15:32:39.655]                   name <- removed[[kk]]
[15:32:39.655]                   NAME <- NAMES[[kk]]
[15:32:39.655]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:39.655]                     next
[15:32:39.655]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:39.655]                 }
[15:32:39.655]                 if (length(args) > 0) 
[15:32:39.655]                   base::do.call(base::Sys.setenv, args = args)
[15:32:39.655]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:39.655]             }
[15:32:39.655]             else {
[15:32:39.655]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:39.655]             }
[15:32:39.655]             {
[15:32:39.655]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:39.655]                   0L) {
[15:32:39.655]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:39.655]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:39.655]                   base::options(opts)
[15:32:39.655]                 }
[15:32:39.655]                 {
[15:32:39.655]                   {
[15:32:39.655]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:39.655]                     NULL
[15:32:39.655]                   }
[15:32:39.655]                   options(future.plan = NULL)
[15:32:39.655]                   if (is.na(NA_character_)) 
[15:32:39.655]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:39.655]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:39.655]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:39.655]                     .init = FALSE)
[15:32:39.655]                 }
[15:32:39.655]             }
[15:32:39.655]         }
[15:32:39.655]     })
[15:32:39.655]     if (TRUE) {
[15:32:39.655]         base::sink(type = "output", split = FALSE)
[15:32:39.655]         if (TRUE) {
[15:32:39.655]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:39.655]         }
[15:32:39.655]         else {
[15:32:39.655]             ...future.result["stdout"] <- base::list(NULL)
[15:32:39.655]         }
[15:32:39.655]         base::close(...future.stdout)
[15:32:39.655]         ...future.stdout <- NULL
[15:32:39.655]     }
[15:32:39.655]     ...future.result$conditions <- ...future.conditions
[15:32:39.655]     ...future.result$finished <- base::Sys.time()
[15:32:39.655]     ...future.result
[15:32:39.655] }
[15:32:39.665] Exporting 5 global objects (4.62 KiB) to cluster node #1 ...
[15:32:39.666] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ...
[15:32:39.666] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ... DONE
[15:32:39.667] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:39.668] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:39.668] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:39.669] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:39.669] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:39.670] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:39.671] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:39.671] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:39.672] Exporting 5 global objects (4.62 KiB) to cluster node #1 ... DONE
[15:32:39.673] MultisessionFuture started
[15:32:39.673] - Launch lazy future ... done
[15:32:39.674] run() for 'MultisessionFuture' ... done
[15:32:39.674] Created future:
[15:32:39.704] receiveMessageFromWorker() for ClusterFuture ...
[15:32:39.704] - Validating connection of MultisessionFuture
[15:32:39.704] - received message: FutureResult
[15:32:39.705] - Received FutureResult
[15:32:39.705] - Erased future from FutureRegistry
[15:32:39.705] result() for ClusterFuture ...
[15:32:39.705] - result already collected: FutureResult
[15:32:39.705] result() for ClusterFuture ... done
[15:32:39.706] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:39.674] MultisessionFuture:
[15:32:39.674] Label: 'future_sapply-2'
[15:32:39.674] Expression:
[15:32:39.674] {
[15:32:39.674]     do.call(function(...) {
[15:32:39.674]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:39.674]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:39.674]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:39.674]             on.exit(options(oopts), add = TRUE)
[15:32:39.674]         }
[15:32:39.674]         {
[15:32:39.674]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:39.674]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:39.674]                 ...future.FUN(...future.X_jj, ...)
[15:32:39.674]             })
[15:32:39.674]         }
[15:32:39.674]     }, args = future.call.arguments)
[15:32:39.674] }
[15:32:39.674] Lazy evaluation: FALSE
[15:32:39.674] Asynchronous evaluation: TRUE
[15:32:39.674] Local evaluation: TRUE
[15:32:39.674] Environment: R_GlobalEnv
[15:32:39.674] Capture standard output: TRUE
[15:32:39.674] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:39.674] Globals: 5 objects totaling 4.73 KiB (function '...future.FUN' of 4.62 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)
[15:32:39.674] Packages: <none>
[15:32:39.674] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:39.674] Resolved: TRUE
[15:32:39.674] Value: <not collected>
[15:32:39.674] Conditions captured: <none>
[15:32:39.674] Early signaling: FALSE
[15:32:39.674] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:39.674] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:39.706] Chunk #2 of 2 ... DONE
[15:32:39.706] Launching 2 futures (chunks) ... DONE
[15:32:39.707] Resolving 2 futures (chunks) ...
[15:32:39.707] resolve() on list ...
[15:32:39.707]  recursive: 0
[15:32:39.707]  length: 2
[15:32:39.707] 
[15:32:39.708] Future #1
[15:32:39.708] result() for ClusterFuture ...
[15:32:39.708] - result already collected: FutureResult
[15:32:39.708] result() for ClusterFuture ... done
[15:32:39.708] result() for ClusterFuture ...
[15:32:39.709] - result already collected: FutureResult
[15:32:39.709] result() for ClusterFuture ... done
[15:32:39.709] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:39.709] - nx: 2
[15:32:39.709] - relay: TRUE
[15:32:39.710] - stdout: TRUE
[15:32:39.710] - signal: TRUE
[15:32:39.710] - resignal: FALSE
[15:32:39.710] - force: TRUE
[15:32:39.710] - relayed: [n=2] FALSE, FALSE
[15:32:39.710] - queued futures: [n=2] FALSE, FALSE
[15:32:39.711]  - until=1
[15:32:39.711]  - relaying element #1
[15:32:39.711] result() for ClusterFuture ...
[15:32:39.711] - result already collected: FutureResult
[15:32:39.711] result() for ClusterFuture ... done
[15:32:39.711] result() for ClusterFuture ...
[15:32:39.711] - result already collected: FutureResult
[15:32:39.712] result() for ClusterFuture ... done
[15:32:39.712] result() for ClusterFuture ...
[15:32:39.712] - result already collected: FutureResult
[15:32:39.712] result() for ClusterFuture ... done
[15:32:39.712] result() for ClusterFuture ...
[15:32:39.712] - result already collected: FutureResult
[15:32:39.713] result() for ClusterFuture ... done
[15:32:39.713] - relayed: [n=2] TRUE, FALSE
[15:32:39.713] - queued futures: [n=2] TRUE, FALSE
[15:32:39.713] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:39.713]  length: 1 (resolved future 1)
[15:32:39.714] Future #2
[15:32:39.714] result() for ClusterFuture ...
[15:32:39.714] - result already collected: FutureResult
[15:32:39.714] result() for ClusterFuture ... done
[15:32:39.714] result() for ClusterFuture ...
[15:32:39.714] - result already collected: FutureResult
[15:32:39.714] result() for ClusterFuture ... done
[15:32:39.715] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:39.715] - nx: 2
[15:32:39.715] - relay: TRUE
[15:32:39.715] - stdout: TRUE
[15:32:39.715] - signal: TRUE
[15:32:39.715] - resignal: FALSE
[15:32:39.716] - force: TRUE
[15:32:39.716] - relayed: [n=2] TRUE, FALSE
[15:32:39.716] - queued futures: [n=2] TRUE, FALSE
[15:32:39.716]  - until=2
[15:32:39.716]  - relaying element #2
[15:32:39.716] result() for ClusterFuture ...
[15:32:39.717] - result already collected: FutureResult
[15:32:39.717] result() for ClusterFuture ... done
[15:32:39.717] result() for ClusterFuture ...
[15:32:39.717] - result already collected: FutureResult
[15:32:39.717] result() for ClusterFuture ... done
[15:32:39.717] result() for ClusterFuture ...
[15:32:39.718] - result already collected: FutureResult
[15:32:39.718] result() for ClusterFuture ... done
[15:32:39.718] result() for ClusterFuture ...
[15:32:39.718] - result already collected: FutureResult
[15:32:39.718] result() for ClusterFuture ... done
[15:32:39.718] - relayed: [n=2] TRUE, TRUE
[15:32:39.719] - queued futures: [n=2] TRUE, TRUE
[15:32:39.719] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:39.719]  length: 0 (resolved future 2)
[15:32:39.719] Relaying remaining futures
[15:32:39.719] signalConditionsASAP(NULL, pos=0) ...
[15:32:39.719] - nx: 2
[15:32:39.720] - relay: TRUE
[15:32:39.720] - stdout: TRUE
[15:32:39.720] - signal: TRUE
[15:32:39.720] - resignal: FALSE
[15:32:39.720] - force: TRUE
[15:32:39.720] - relayed: [n=2] TRUE, TRUE
[15:32:39.721] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:39.721] - relayed: [n=2] TRUE, TRUE
[15:32:39.721] - queued futures: [n=2] TRUE, TRUE
[15:32:39.721] signalConditionsASAP(NULL, pos=0) ... done
[15:32:39.721] resolve() on list ... DONE
[15:32:39.721] result() for ClusterFuture ...
[15:32:39.722] - result already collected: FutureResult
[15:32:39.722] result() for ClusterFuture ... done
[15:32:39.722] result() for ClusterFuture ...
[15:32:39.722] - result already collected: FutureResult
[15:32:39.722] result() for ClusterFuture ... done
[15:32:39.722] result() for ClusterFuture ...
[15:32:39.723] - result already collected: FutureResult
[15:32:39.723] result() for ClusterFuture ... done
[15:32:39.723] result() for ClusterFuture ...
[15:32:39.723] - result already collected: FutureResult
[15:32:39.723] result() for ClusterFuture ... done
[15:32:39.723]  - Number of value chunks collected: 2
[15:32:39.724] Resolving 2 futures (chunks) ... DONE
[15:32:39.724] Reducing values from 2 chunks ...
[15:32:39.724]  - Number of values collected after concatenation: 4
[15:32:39.724]  - Number of values expected: 4
[15:32:39.724] Reducing values from 2 chunks ... DONE
[15:32:39.724] future_lapply() ... DONE
List of 2
 $ y0: num [1:3, 1:5, 1:4] 100 100 100 200 200 200 300 300 300 400 ...
  ..- attr(*, "dimnames")=List of 3
  .. ..$ : NULL
  .. ..$ : NULL
  .. ..$ : chr [1:4] "A" "B" "C" "D"
 $ y1: num [1:3, 1:5, 1:4] 100 100 100 200 200 200 300 300 300 400 ...
  ..- attr(*, "dimnames")=List of 3
  .. ..$ : NULL
  .. ..$ : NULL
  .. ..$ : chr [1:4] "A" "B" "C" "D"
[15:32:39.728] future_lapply() ...
[15:32:39.731] Number of chunks: 2
[15:32:39.732] getGlobalsAndPackagesXApply() ...
[15:32:39.732]  - future.globals: TRUE
[15:32:39.732] getGlobalsAndPackages() ...
[15:32:39.732] Searching for globals...
[15:32:39.734] - globals found: [1] 'FUN'
[15:32:39.734] Searching for globals ... DONE
[15:32:39.734] Resolving globals: FALSE
[15:32:39.735] The total size of the 1 globals is 848 bytes (848 bytes)
[15:32:39.735] The total size of the 1 globals exported for future expression ('FUN()') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:32:39.736] - globals: [1] 'FUN'
[15:32:39.736] 
[15:32:39.736] getGlobalsAndPackages() ... DONE
[15:32:39.736]  - globals found/used: [n=1] 'FUN'
[15:32:39.737]  - needed namespaces: [n=0] 
[15:32:39.737] Finding globals ... DONE
[15:32:39.737]  - use_args: TRUE
[15:32:39.737]  - Getting '...' globals ...
[15:32:39.738] resolve() on list ...
[15:32:39.738]  recursive: 0
[15:32:39.738]  length: 1
[15:32:39.739]  elements: '...'
[15:32:39.739]  length: 0 (resolved future 1)
[15:32:39.739] resolve() on list ... DONE
[15:32:39.739]    - '...' content: [n=0] 
[15:32:39.740] List of 1
[15:32:39.740]  $ ...: list()
[15:32:39.740]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:39.740]  - attr(*, "where")=List of 1
[15:32:39.740]   ..$ ...:<environment: 0x00000276e08158e8> 
[15:32:39.740]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:39.740]  - attr(*, "resolved")= logi TRUE
[15:32:39.740]  - attr(*, "total_size")= num NA
[15:32:39.744]  - Getting '...' globals ... DONE
[15:32:39.744] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:39.744] List of 2
[15:32:39.744]  $ ...future.FUN:function (x)  
[15:32:39.744]  $ ...          : list()
[15:32:39.744]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:39.744]  - attr(*, "where")=List of 2
[15:32:39.744]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:39.744]   ..$ ...          :<environment: 0x00000276e08158e8> 
[15:32:39.744]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:39.744]  - attr(*, "resolved")= logi FALSE
[15:32:39.744]  - attr(*, "total_size")= num 848
[15:32:39.749] Packages to be attached in all futures: [n=0] 
[15:32:39.749] getGlobalsAndPackagesXApply() ... DONE
[15:32:39.749] Number of futures (= number of chunks): 2
[15:32:39.750] Launching 2 futures (chunks) ...
[15:32:39.750] Chunk #1 of 2 ...
[15:32:39.750]  - Finding globals in 'X' for chunk #1 ...
[15:32:39.750] getGlobalsAndPackages() ...
[15:32:39.751] Searching for globals...
[15:32:39.751] 
[15:32:39.751] Searching for globals ... DONE
[15:32:39.752] - globals: [0] <none>
[15:32:39.752] getGlobalsAndPackages() ... DONE
[15:32:39.752]    + additional globals found: [n=0] 
[15:32:39.752]    + additional namespaces needed: [n=0] 
[15:32:39.752]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:39.753]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:39.753]  - seeds: <none>
[15:32:39.753]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:39.753] getGlobalsAndPackages() ...
[15:32:39.754] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:39.754] Resolving globals: FALSE
[15:32:39.754] Tweak future expression to call with '...' arguments ...
[15:32:39.754] {
[15:32:39.754]     do.call(function(...) {
[15:32:39.754]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:39.754]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:39.754]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:39.754]             on.exit(options(oopts), add = TRUE)
[15:32:39.754]         }
[15:32:39.754]         {
[15:32:39.754]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:39.754]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:39.754]                 ...future.FUN(...future.X_jj, ...)
[15:32:39.754]             })
[15:32:39.754]         }
[15:32:39.754]     }, args = future.call.arguments)
[15:32:39.754] }
[15:32:39.755] Tweak future expression to call with '...' arguments ... DONE
[15:32:39.756] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:39.756] 
[15:32:39.756] getGlobalsAndPackages() ... DONE
[15:32:39.757] run() for 'Future' ...
[15:32:39.757] - state: 'created'
[15:32:39.757] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:39.774] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:39.774] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:39.774]   - Field: 'node'
[15:32:39.774]   - Field: 'label'
[15:32:39.775]   - Field: 'local'
[15:32:39.775]   - Field: 'owner'
[15:32:39.775]   - Field: 'envir'
[15:32:39.776]   - Field: 'workers'
[15:32:39.776]   - Field: 'packages'
[15:32:39.776]   - Field: 'gc'
[15:32:39.776]   - Field: 'conditions'
[15:32:39.777]   - Field: 'persistent'
[15:32:39.777]   - Field: 'expr'
[15:32:39.777]   - Field: 'uuid'
[15:32:39.777]   - Field: 'seed'
[15:32:39.778]   - Field: 'version'
[15:32:39.778]   - Field: 'result'
[15:32:39.778]   - Field: 'asynchronous'
[15:32:39.778]   - Field: 'calls'
[15:32:39.779]   - Field: 'globals'
[15:32:39.779]   - Field: 'stdout'
[15:32:39.779]   - Field: 'earlySignal'
[15:32:39.779]   - Field: 'lazy'
[15:32:39.780]   - Field: 'state'
[15:32:39.780] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:39.780] - Launch lazy future ...
[15:32:39.781] Packages needed by the future expression (n = 0): <none>
[15:32:39.781] Packages needed by future strategies (n = 0): <none>
[15:32:39.782] {
[15:32:39.782]     {
[15:32:39.782]         {
[15:32:39.782]             ...future.startTime <- base::Sys.time()
[15:32:39.782]             {
[15:32:39.782]                 {
[15:32:39.782]                   {
[15:32:39.782]                     {
[15:32:39.782]                       base::local({
[15:32:39.782]                         has_future <- base::requireNamespace("future", 
[15:32:39.782]                           quietly = TRUE)
[15:32:39.782]                         if (has_future) {
[15:32:39.782]                           ns <- base::getNamespace("future")
[15:32:39.782]                           version <- ns[[".package"]][["version"]]
[15:32:39.782]                           if (is.null(version)) 
[15:32:39.782]                             version <- utils::packageVersion("future")
[15:32:39.782]                         }
[15:32:39.782]                         else {
[15:32:39.782]                           version <- NULL
[15:32:39.782]                         }
[15:32:39.782]                         if (!has_future || version < "1.8.0") {
[15:32:39.782]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:39.782]                             "", base::R.version$version.string), 
[15:32:39.782]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:39.782]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:39.782]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:39.782]                               "release", "version")], collapse = " "), 
[15:32:39.782]                             hostname = base::Sys.info()[["nodename"]])
[15:32:39.782]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:39.782]                             info)
[15:32:39.782]                           info <- base::paste(info, collapse = "; ")
[15:32:39.782]                           if (!has_future) {
[15:32:39.782]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:39.782]                               info)
[15:32:39.782]                           }
[15:32:39.782]                           else {
[15:32:39.782]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:39.782]                               info, version)
[15:32:39.782]                           }
[15:32:39.782]                           base::stop(msg)
[15:32:39.782]                         }
[15:32:39.782]                       })
[15:32:39.782]                     }
[15:32:39.782]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:39.782]                     base::options(mc.cores = 1L)
[15:32:39.782]                   }
[15:32:39.782]                   ...future.strategy.old <- future::plan("list")
[15:32:39.782]                   options(future.plan = NULL)
[15:32:39.782]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:39.782]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:39.782]                 }
[15:32:39.782]                 ...future.workdir <- getwd()
[15:32:39.782]             }
[15:32:39.782]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:39.782]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:39.782]         }
[15:32:39.782]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:39.782]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:39.782]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:39.782]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:39.782]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:39.782]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:39.782]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:39.782]             base::names(...future.oldOptions))
[15:32:39.782]     }
[15:32:39.782]     if (FALSE) {
[15:32:39.782]     }
[15:32:39.782]     else {
[15:32:39.782]         if (TRUE) {
[15:32:39.782]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:39.782]                 open = "w")
[15:32:39.782]         }
[15:32:39.782]         else {
[15:32:39.782]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:39.782]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:39.782]         }
[15:32:39.782]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:39.782]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:39.782]             base::sink(type = "output", split = FALSE)
[15:32:39.782]             base::close(...future.stdout)
[15:32:39.782]         }, add = TRUE)
[15:32:39.782]     }
[15:32:39.782]     ...future.frame <- base::sys.nframe()
[15:32:39.782]     ...future.conditions <- base::list()
[15:32:39.782]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:39.782]     if (FALSE) {
[15:32:39.782]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:39.782]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:39.782]     }
[15:32:39.782]     ...future.result <- base::tryCatch({
[15:32:39.782]         base::withCallingHandlers({
[15:32:39.782]             ...future.value <- base::withVisible(base::local({
[15:32:39.782]                 ...future.makeSendCondition <- base::local({
[15:32:39.782]                   sendCondition <- NULL
[15:32:39.782]                   function(frame = 1L) {
[15:32:39.782]                     if (is.function(sendCondition)) 
[15:32:39.782]                       return(sendCondition)
[15:32:39.782]                     ns <- getNamespace("parallel")
[15:32:39.782]                     if (exists("sendData", mode = "function", 
[15:32:39.782]                       envir = ns)) {
[15:32:39.782]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:39.782]                         envir = ns)
[15:32:39.782]                       envir <- sys.frame(frame)
[15:32:39.782]                       master <- NULL
[15:32:39.782]                       while (!identical(envir, .GlobalEnv) && 
[15:32:39.782]                         !identical(envir, emptyenv())) {
[15:32:39.782]                         if (exists("master", mode = "list", envir = envir, 
[15:32:39.782]                           inherits = FALSE)) {
[15:32:39.782]                           master <- get("master", mode = "list", 
[15:32:39.782]                             envir = envir, inherits = FALSE)
[15:32:39.782]                           if (inherits(master, c("SOCKnode", 
[15:32:39.782]                             "SOCK0node"))) {
[15:32:39.782]                             sendCondition <<- function(cond) {
[15:32:39.782]                               data <- list(type = "VALUE", value = cond, 
[15:32:39.782]                                 success = TRUE)
[15:32:39.782]                               parallel_sendData(master, data)
[15:32:39.782]                             }
[15:32:39.782]                             return(sendCondition)
[15:32:39.782]                           }
[15:32:39.782]                         }
[15:32:39.782]                         frame <- frame + 1L
[15:32:39.782]                         envir <- sys.frame(frame)
[15:32:39.782]                       }
[15:32:39.782]                     }
[15:32:39.782]                     sendCondition <<- function(cond) NULL
[15:32:39.782]                   }
[15:32:39.782]                 })
[15:32:39.782]                 withCallingHandlers({
[15:32:39.782]                   {
[15:32:39.782]                     do.call(function(...) {
[15:32:39.782]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:39.782]                       if (!identical(...future.globals.maxSize.org, 
[15:32:39.782]                         ...future.globals.maxSize)) {
[15:32:39.782]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:39.782]                         on.exit(options(oopts), add = TRUE)
[15:32:39.782]                       }
[15:32:39.782]                       {
[15:32:39.782]                         lapply(seq_along(...future.elements_ii), 
[15:32:39.782]                           FUN = function(jj) {
[15:32:39.782]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:39.782]                             ...future.FUN(...future.X_jj, ...)
[15:32:39.782]                           })
[15:32:39.782]                       }
[15:32:39.782]                     }, args = future.call.arguments)
[15:32:39.782]                   }
[15:32:39.782]                 }, immediateCondition = function(cond) {
[15:32:39.782]                   sendCondition <- ...future.makeSendCondition()
[15:32:39.782]                   sendCondition(cond)
[15:32:39.782]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:39.782]                   {
[15:32:39.782]                     inherits <- base::inherits
[15:32:39.782]                     invokeRestart <- base::invokeRestart
[15:32:39.782]                     is.null <- base::is.null
[15:32:39.782]                     muffled <- FALSE
[15:32:39.782]                     if (inherits(cond, "message")) {
[15:32:39.782]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:39.782]                       if (muffled) 
[15:32:39.782]                         invokeRestart("muffleMessage")
[15:32:39.782]                     }
[15:32:39.782]                     else if (inherits(cond, "warning")) {
[15:32:39.782]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:39.782]                       if (muffled) 
[15:32:39.782]                         invokeRestart("muffleWarning")
[15:32:39.782]                     }
[15:32:39.782]                     else if (inherits(cond, "condition")) {
[15:32:39.782]                       if (!is.null(pattern)) {
[15:32:39.782]                         computeRestarts <- base::computeRestarts
[15:32:39.782]                         grepl <- base::grepl
[15:32:39.782]                         restarts <- computeRestarts(cond)
[15:32:39.782]                         for (restart in restarts) {
[15:32:39.782]                           name <- restart$name
[15:32:39.782]                           if (is.null(name)) 
[15:32:39.782]                             next
[15:32:39.782]                           if (!grepl(pattern, name)) 
[15:32:39.782]                             next
[15:32:39.782]                           invokeRestart(restart)
[15:32:39.782]                           muffled <- TRUE
[15:32:39.782]                           break
[15:32:39.782]                         }
[15:32:39.782]                       }
[15:32:39.782]                     }
[15:32:39.782]                     invisible(muffled)
[15:32:39.782]                   }
[15:32:39.782]                   muffleCondition(cond)
[15:32:39.782]                 })
[15:32:39.782]             }))
[15:32:39.782]             future::FutureResult(value = ...future.value$value, 
[15:32:39.782]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:39.782]                   ...future.rng), globalenv = if (FALSE) 
[15:32:39.782]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:39.782]                     ...future.globalenv.names))
[15:32:39.782]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:39.782]         }, condition = base::local({
[15:32:39.782]             c <- base::c
[15:32:39.782]             inherits <- base::inherits
[15:32:39.782]             invokeRestart <- base::invokeRestart
[15:32:39.782]             length <- base::length
[15:32:39.782]             list <- base::list
[15:32:39.782]             seq.int <- base::seq.int
[15:32:39.782]             signalCondition <- base::signalCondition
[15:32:39.782]             sys.calls <- base::sys.calls
[15:32:39.782]             `[[` <- base::`[[`
[15:32:39.782]             `+` <- base::`+`
[15:32:39.782]             `<<-` <- base::`<<-`
[15:32:39.782]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:39.782]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:39.782]                   3L)]
[15:32:39.782]             }
[15:32:39.782]             function(cond) {
[15:32:39.782]                 is_error <- inherits(cond, "error")
[15:32:39.782]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:39.782]                   NULL)
[15:32:39.782]                 if (is_error) {
[15:32:39.782]                   sessionInformation <- function() {
[15:32:39.782]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:39.782]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:39.782]                       search = base::search(), system = base::Sys.info())
[15:32:39.782]                   }
[15:32:39.782]                   ...future.conditions[[length(...future.conditions) + 
[15:32:39.782]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:39.782]                     cond$call), session = sessionInformation(), 
[15:32:39.782]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:39.782]                   signalCondition(cond)
[15:32:39.782]                 }
[15:32:39.782]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:39.782]                 "immediateCondition"))) {
[15:32:39.782]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:39.782]                   ...future.conditions[[length(...future.conditions) + 
[15:32:39.782]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:39.782]                   if (TRUE && !signal) {
[15:32:39.782]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:39.782]                     {
[15:32:39.782]                       inherits <- base::inherits
[15:32:39.782]                       invokeRestart <- base::invokeRestart
[15:32:39.782]                       is.null <- base::is.null
[15:32:39.782]                       muffled <- FALSE
[15:32:39.782]                       if (inherits(cond, "message")) {
[15:32:39.782]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:39.782]                         if (muffled) 
[15:32:39.782]                           invokeRestart("muffleMessage")
[15:32:39.782]                       }
[15:32:39.782]                       else if (inherits(cond, "warning")) {
[15:32:39.782]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:39.782]                         if (muffled) 
[15:32:39.782]                           invokeRestart("muffleWarning")
[15:32:39.782]                       }
[15:32:39.782]                       else if (inherits(cond, "condition")) {
[15:32:39.782]                         if (!is.null(pattern)) {
[15:32:39.782]                           computeRestarts <- base::computeRestarts
[15:32:39.782]                           grepl <- base::grepl
[15:32:39.782]                           restarts <- computeRestarts(cond)
[15:32:39.782]                           for (restart in restarts) {
[15:32:39.782]                             name <- restart$name
[15:32:39.782]                             if (is.null(name)) 
[15:32:39.782]                               next
[15:32:39.782]                             if (!grepl(pattern, name)) 
[15:32:39.782]                               next
[15:32:39.782]                             invokeRestart(restart)
[15:32:39.782]                             muffled <- TRUE
[15:32:39.782]                             break
[15:32:39.782]                           }
[15:32:39.782]                         }
[15:32:39.782]                       }
[15:32:39.782]                       invisible(muffled)
[15:32:39.782]                     }
[15:32:39.782]                     muffleCondition(cond, pattern = "^muffle")
[15:32:39.782]                   }
[15:32:39.782]                 }
[15:32:39.782]                 else {
[15:32:39.782]                   if (TRUE) {
[15:32:39.782]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:39.782]                     {
[15:32:39.782]                       inherits <- base::inherits
[15:32:39.782]                       invokeRestart <- base::invokeRestart
[15:32:39.782]                       is.null <- base::is.null
[15:32:39.782]                       muffled <- FALSE
[15:32:39.782]                       if (inherits(cond, "message")) {
[15:32:39.782]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:39.782]                         if (muffled) 
[15:32:39.782]                           invokeRestart("muffleMessage")
[15:32:39.782]                       }
[15:32:39.782]                       else if (inherits(cond, "warning")) {
[15:32:39.782]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:39.782]                         if (muffled) 
[15:32:39.782]                           invokeRestart("muffleWarning")
[15:32:39.782]                       }
[15:32:39.782]                       else if (inherits(cond, "condition")) {
[15:32:39.782]                         if (!is.null(pattern)) {
[15:32:39.782]                           computeRestarts <- base::computeRestarts
[15:32:39.782]                           grepl <- base::grepl
[15:32:39.782]                           restarts <- computeRestarts(cond)
[15:32:39.782]                           for (restart in restarts) {
[15:32:39.782]                             name <- restart$name
[15:32:39.782]                             if (is.null(name)) 
[15:32:39.782]                               next
[15:32:39.782]                             if (!grepl(pattern, name)) 
[15:32:39.782]                               next
[15:32:39.782]                             invokeRestart(restart)
[15:32:39.782]                             muffled <- TRUE
[15:32:39.782]                             break
[15:32:39.782]                           }
[15:32:39.782]                         }
[15:32:39.782]                       }
[15:32:39.782]                       invisible(muffled)
[15:32:39.782]                     }
[15:32:39.782]                     muffleCondition(cond, pattern = "^muffle")
[15:32:39.782]                   }
[15:32:39.782]                 }
[15:32:39.782]             }
[15:32:39.782]         }))
[15:32:39.782]     }, error = function(ex) {
[15:32:39.782]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:39.782]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:39.782]                 ...future.rng), started = ...future.startTime, 
[15:32:39.782]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:39.782]             version = "1.8"), class = "FutureResult")
[15:32:39.782]     }, finally = {
[15:32:39.782]         if (!identical(...future.workdir, getwd())) 
[15:32:39.782]             setwd(...future.workdir)
[15:32:39.782]         {
[15:32:39.782]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:39.782]                 ...future.oldOptions$nwarnings <- NULL
[15:32:39.782]             }
[15:32:39.782]             base::options(...future.oldOptions)
[15:32:39.782]             if (.Platform$OS.type == "windows") {
[15:32:39.782]                 old_names <- names(...future.oldEnvVars)
[15:32:39.782]                 envs <- base::Sys.getenv()
[15:32:39.782]                 names <- names(envs)
[15:32:39.782]                 common <- intersect(names, old_names)
[15:32:39.782]                 added <- setdiff(names, old_names)
[15:32:39.782]                 removed <- setdiff(old_names, names)
[15:32:39.782]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:39.782]                   envs[common]]
[15:32:39.782]                 NAMES <- toupper(changed)
[15:32:39.782]                 args <- list()
[15:32:39.782]                 for (kk in seq_along(NAMES)) {
[15:32:39.782]                   name <- changed[[kk]]
[15:32:39.782]                   NAME <- NAMES[[kk]]
[15:32:39.782]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:39.782]                     next
[15:32:39.782]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:39.782]                 }
[15:32:39.782]                 NAMES <- toupper(added)
[15:32:39.782]                 for (kk in seq_along(NAMES)) {
[15:32:39.782]                   name <- added[[kk]]
[15:32:39.782]                   NAME <- NAMES[[kk]]
[15:32:39.782]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:39.782]                     next
[15:32:39.782]                   args[[name]] <- ""
[15:32:39.782]                 }
[15:32:39.782]                 NAMES <- toupper(removed)
[15:32:39.782]                 for (kk in seq_along(NAMES)) {
[15:32:39.782]                   name <- removed[[kk]]
[15:32:39.782]                   NAME <- NAMES[[kk]]
[15:32:39.782]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:39.782]                     next
[15:32:39.782]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:39.782]                 }
[15:32:39.782]                 if (length(args) > 0) 
[15:32:39.782]                   base::do.call(base::Sys.setenv, args = args)
[15:32:39.782]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:39.782]             }
[15:32:39.782]             else {
[15:32:39.782]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:39.782]             }
[15:32:39.782]             {
[15:32:39.782]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:39.782]                   0L) {
[15:32:39.782]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:39.782]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:39.782]                   base::options(opts)
[15:32:39.782]                 }
[15:32:39.782]                 {
[15:32:39.782]                   {
[15:32:39.782]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:39.782]                     NULL
[15:32:39.782]                   }
[15:32:39.782]                   options(future.plan = NULL)
[15:32:39.782]                   if (is.na(NA_character_)) 
[15:32:39.782]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:39.782]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:39.782]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:39.782]                     .init = FALSE)
[15:32:39.782]                 }
[15:32:39.782]             }
[15:32:39.782]         }
[15:32:39.782]     })
[15:32:39.782]     if (TRUE) {
[15:32:39.782]         base::sink(type = "output", split = FALSE)
[15:32:39.782]         if (TRUE) {
[15:32:39.782]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:39.782]         }
[15:32:39.782]         else {
[15:32:39.782]             ...future.result["stdout"] <- base::list(NULL)
[15:32:39.782]         }
[15:32:39.782]         base::close(...future.stdout)
[15:32:39.782]         ...future.stdout <- NULL
[15:32:39.782]     }
[15:32:39.782]     ...future.result$conditions <- ...future.conditions
[15:32:39.782]     ...future.result$finished <- base::Sys.time()
[15:32:39.782]     ...future.result
[15:32:39.782] }
[15:32:39.790] Exporting 5 global objects (848 bytes) to cluster node #1 ...
[15:32:39.790] Exporting '...future.FUN' (848 bytes) to cluster node #1 ...
[15:32:39.791] Exporting '...future.FUN' (848 bytes) to cluster node #1 ... DONE
[15:32:39.791] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:39.792] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:39.792] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:39.792] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:39.793] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:39.793] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:39.793] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:39.794] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:39.794] Exporting 5 global objects (848 bytes) to cluster node #1 ... DONE
[15:32:39.794] MultisessionFuture started
[15:32:39.795] - Launch lazy future ... done
[15:32:39.795] run() for 'MultisessionFuture' ... done
[15:32:39.795] Created future:
[15:32:39.813] receiveMessageFromWorker() for ClusterFuture ...
[15:32:39.813] - Validating connection of MultisessionFuture
[15:32:39.813] - received message: FutureResult
[15:32:39.814] - Received FutureResult
[15:32:39.814] - Erased future from FutureRegistry
[15:32:39.814] result() for ClusterFuture ...
[15:32:39.814] - result already collected: FutureResult
[15:32:39.814] result() for ClusterFuture ... done
[15:32:39.815] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:39.795] MultisessionFuture:
[15:32:39.795] Label: 'future_sapply-1'
[15:32:39.795] Expression:
[15:32:39.795] {
[15:32:39.795]     do.call(function(...) {
[15:32:39.795]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:39.795]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:39.795]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:39.795]             on.exit(options(oopts), add = TRUE)
[15:32:39.795]         }
[15:32:39.795]         {
[15:32:39.795]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:39.795]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:39.795]                 ...future.FUN(...future.X_jj, ...)
[15:32:39.795]             })
[15:32:39.795]         }
[15:32:39.795]     }, args = future.call.arguments)
[15:32:39.795] }
[15:32:39.795] Lazy evaluation: FALSE
[15:32:39.795] Asynchronous evaluation: TRUE
[15:32:39.795] Local evaluation: TRUE
[15:32:39.795] Environment: R_GlobalEnv
[15:32:39.795] Capture standard output: TRUE
[15:32:39.795] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:39.795] Globals: 5 objects totaling 960 bytes (function '...future.FUN' of 848 bytes, 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)
[15:32:39.795] Packages: <none>
[15:32:39.795] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:39.795] Resolved: TRUE
[15:32:39.795] Value: <not collected>
[15:32:39.795] Conditions captured: <none>
[15:32:39.795] Early signaling: FALSE
[15:32:39.795] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:39.795] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:39.815] Chunk #1 of 2 ... DONE
[15:32:39.815] Chunk #2 of 2 ...
[15:32:39.815]  - Finding globals in 'X' for chunk #2 ...
[15:32:39.816] getGlobalsAndPackages() ...
[15:32:39.816] Searching for globals...
[15:32:39.816] 
[15:32:39.816] Searching for globals ... DONE
[15:32:39.816] - globals: [0] <none>
[15:32:39.817] getGlobalsAndPackages() ... DONE
[15:32:39.817]    + additional globals found: [n=0] 
[15:32:39.817]    + additional namespaces needed: [n=0] 
[15:32:39.817]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:39.817]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:39.818]  - seeds: <none>
[15:32:39.818]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:39.818] getGlobalsAndPackages() ...
[15:32:39.818] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:39.818] Resolving globals: FALSE
[15:32:39.818] Tweak future expression to call with '...' arguments ...
[15:32:39.819] {
[15:32:39.819]     do.call(function(...) {
[15:32:39.819]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:39.819]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:39.819]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:39.819]             on.exit(options(oopts), add = TRUE)
[15:32:39.819]         }
[15:32:39.819]         {
[15:32:39.819]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:39.819]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:39.819]                 ...future.FUN(...future.X_jj, ...)
[15:32:39.819]             })
[15:32:39.819]         }
[15:32:39.819]     }, args = future.call.arguments)
[15:32:39.819] }
[15:32:39.819] Tweak future expression to call with '...' arguments ... DONE
[15:32:39.820] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:39.820] 
[15:32:39.820] getGlobalsAndPackages() ... DONE
[15:32:39.820] run() for 'Future' ...
[15:32:39.821] - state: 'created'
[15:32:39.821] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:39.835] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:39.836] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:39.836]   - Field: 'node'
[15:32:39.836]   - Field: 'label'
[15:32:39.836]   - Field: 'local'
[15:32:39.836]   - Field: 'owner'
[15:32:39.837]   - Field: 'envir'
[15:32:39.837]   - Field: 'workers'
[15:32:39.837]   - Field: 'packages'
[15:32:39.837]   - Field: 'gc'
[15:32:39.837]   - Field: 'conditions'
[15:32:39.838]   - Field: 'persistent'
[15:32:39.838]   - Field: 'expr'
[15:32:39.838]   - Field: 'uuid'
[15:32:39.838]   - Field: 'seed'
[15:32:39.838]   - Field: 'version'
[15:32:39.838]   - Field: 'result'
[15:32:39.839]   - Field: 'asynchronous'
[15:32:39.839]   - Field: 'calls'
[15:32:39.839]   - Field: 'globals'
[15:32:39.839]   - Field: 'stdout'
[15:32:39.839]   - Field: 'earlySignal'
[15:32:39.840]   - Field: 'lazy'
[15:32:39.840]   - Field: 'state'
[15:32:39.840] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:39.840] - Launch lazy future ...
[15:32:39.840] Packages needed by the future expression (n = 0): <none>
[15:32:39.841] Packages needed by future strategies (n = 0): <none>
[15:32:39.841] {
[15:32:39.841]     {
[15:32:39.841]         {
[15:32:39.841]             ...future.startTime <- base::Sys.time()
[15:32:39.841]             {
[15:32:39.841]                 {
[15:32:39.841]                   {
[15:32:39.841]                     {
[15:32:39.841]                       base::local({
[15:32:39.841]                         has_future <- base::requireNamespace("future", 
[15:32:39.841]                           quietly = TRUE)
[15:32:39.841]                         if (has_future) {
[15:32:39.841]                           ns <- base::getNamespace("future")
[15:32:39.841]                           version <- ns[[".package"]][["version"]]
[15:32:39.841]                           if (is.null(version)) 
[15:32:39.841]                             version <- utils::packageVersion("future")
[15:32:39.841]                         }
[15:32:39.841]                         else {
[15:32:39.841]                           version <- NULL
[15:32:39.841]                         }
[15:32:39.841]                         if (!has_future || version < "1.8.0") {
[15:32:39.841]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:39.841]                             "", base::R.version$version.string), 
[15:32:39.841]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:39.841]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:39.841]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:39.841]                               "release", "version")], collapse = " "), 
[15:32:39.841]                             hostname = base::Sys.info()[["nodename"]])
[15:32:39.841]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:39.841]                             info)
[15:32:39.841]                           info <- base::paste(info, collapse = "; ")
[15:32:39.841]                           if (!has_future) {
[15:32:39.841]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:39.841]                               info)
[15:32:39.841]                           }
[15:32:39.841]                           else {
[15:32:39.841]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:39.841]                               info, version)
[15:32:39.841]                           }
[15:32:39.841]                           base::stop(msg)
[15:32:39.841]                         }
[15:32:39.841]                       })
[15:32:39.841]                     }
[15:32:39.841]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:39.841]                     base::options(mc.cores = 1L)
[15:32:39.841]                   }
[15:32:39.841]                   ...future.strategy.old <- future::plan("list")
[15:32:39.841]                   options(future.plan = NULL)
[15:32:39.841]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:39.841]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:39.841]                 }
[15:32:39.841]                 ...future.workdir <- getwd()
[15:32:39.841]             }
[15:32:39.841]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:39.841]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:39.841]         }
[15:32:39.841]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:39.841]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:39.841]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:39.841]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:39.841]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:39.841]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:39.841]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:39.841]             base::names(...future.oldOptions))
[15:32:39.841]     }
[15:32:39.841]     if (FALSE) {
[15:32:39.841]     }
[15:32:39.841]     else {
[15:32:39.841]         if (TRUE) {
[15:32:39.841]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:39.841]                 open = "w")
[15:32:39.841]         }
[15:32:39.841]         else {
[15:32:39.841]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:39.841]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:39.841]         }
[15:32:39.841]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:39.841]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:39.841]             base::sink(type = "output", split = FALSE)
[15:32:39.841]             base::close(...future.stdout)
[15:32:39.841]         }, add = TRUE)
[15:32:39.841]     }
[15:32:39.841]     ...future.frame <- base::sys.nframe()
[15:32:39.841]     ...future.conditions <- base::list()
[15:32:39.841]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:39.841]     if (FALSE) {
[15:32:39.841]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:39.841]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:39.841]     }
[15:32:39.841]     ...future.result <- base::tryCatch({
[15:32:39.841]         base::withCallingHandlers({
[15:32:39.841]             ...future.value <- base::withVisible(base::local({
[15:32:39.841]                 ...future.makeSendCondition <- base::local({
[15:32:39.841]                   sendCondition <- NULL
[15:32:39.841]                   function(frame = 1L) {
[15:32:39.841]                     if (is.function(sendCondition)) 
[15:32:39.841]                       return(sendCondition)
[15:32:39.841]                     ns <- getNamespace("parallel")
[15:32:39.841]                     if (exists("sendData", mode = "function", 
[15:32:39.841]                       envir = ns)) {
[15:32:39.841]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:39.841]                         envir = ns)
[15:32:39.841]                       envir <- sys.frame(frame)
[15:32:39.841]                       master <- NULL
[15:32:39.841]                       while (!identical(envir, .GlobalEnv) && 
[15:32:39.841]                         !identical(envir, emptyenv())) {
[15:32:39.841]                         if (exists("master", mode = "list", envir = envir, 
[15:32:39.841]                           inherits = FALSE)) {
[15:32:39.841]                           master <- get("master", mode = "list", 
[15:32:39.841]                             envir = envir, inherits = FALSE)
[15:32:39.841]                           if (inherits(master, c("SOCKnode", 
[15:32:39.841]                             "SOCK0node"))) {
[15:32:39.841]                             sendCondition <<- function(cond) {
[15:32:39.841]                               data <- list(type = "VALUE", value = cond, 
[15:32:39.841]                                 success = TRUE)
[15:32:39.841]                               parallel_sendData(master, data)
[15:32:39.841]                             }
[15:32:39.841]                             return(sendCondition)
[15:32:39.841]                           }
[15:32:39.841]                         }
[15:32:39.841]                         frame <- frame + 1L
[15:32:39.841]                         envir <- sys.frame(frame)
[15:32:39.841]                       }
[15:32:39.841]                     }
[15:32:39.841]                     sendCondition <<- function(cond) NULL
[15:32:39.841]                   }
[15:32:39.841]                 })
[15:32:39.841]                 withCallingHandlers({
[15:32:39.841]                   {
[15:32:39.841]                     do.call(function(...) {
[15:32:39.841]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:39.841]                       if (!identical(...future.globals.maxSize.org, 
[15:32:39.841]                         ...future.globals.maxSize)) {
[15:32:39.841]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:39.841]                         on.exit(options(oopts), add = TRUE)
[15:32:39.841]                       }
[15:32:39.841]                       {
[15:32:39.841]                         lapply(seq_along(...future.elements_ii), 
[15:32:39.841]                           FUN = function(jj) {
[15:32:39.841]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:39.841]                             ...future.FUN(...future.X_jj, ...)
[15:32:39.841]                           })
[15:32:39.841]                       }
[15:32:39.841]                     }, args = future.call.arguments)
[15:32:39.841]                   }
[15:32:39.841]                 }, immediateCondition = function(cond) {
[15:32:39.841]                   sendCondition <- ...future.makeSendCondition()
[15:32:39.841]                   sendCondition(cond)
[15:32:39.841]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:39.841]                   {
[15:32:39.841]                     inherits <- base::inherits
[15:32:39.841]                     invokeRestart <- base::invokeRestart
[15:32:39.841]                     is.null <- base::is.null
[15:32:39.841]                     muffled <- FALSE
[15:32:39.841]                     if (inherits(cond, "message")) {
[15:32:39.841]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:39.841]                       if (muffled) 
[15:32:39.841]                         invokeRestart("muffleMessage")
[15:32:39.841]                     }
[15:32:39.841]                     else if (inherits(cond, "warning")) {
[15:32:39.841]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:39.841]                       if (muffled) 
[15:32:39.841]                         invokeRestart("muffleWarning")
[15:32:39.841]                     }
[15:32:39.841]                     else if (inherits(cond, "condition")) {
[15:32:39.841]                       if (!is.null(pattern)) {
[15:32:39.841]                         computeRestarts <- base::computeRestarts
[15:32:39.841]                         grepl <- base::grepl
[15:32:39.841]                         restarts <- computeRestarts(cond)
[15:32:39.841]                         for (restart in restarts) {
[15:32:39.841]                           name <- restart$name
[15:32:39.841]                           if (is.null(name)) 
[15:32:39.841]                             next
[15:32:39.841]                           if (!grepl(pattern, name)) 
[15:32:39.841]                             next
[15:32:39.841]                           invokeRestart(restart)
[15:32:39.841]                           muffled <- TRUE
[15:32:39.841]                           break
[15:32:39.841]                         }
[15:32:39.841]                       }
[15:32:39.841]                     }
[15:32:39.841]                     invisible(muffled)
[15:32:39.841]                   }
[15:32:39.841]                   muffleCondition(cond)
[15:32:39.841]                 })
[15:32:39.841]             }))
[15:32:39.841]             future::FutureResult(value = ...future.value$value, 
[15:32:39.841]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:39.841]                   ...future.rng), globalenv = if (FALSE) 
[15:32:39.841]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:39.841]                     ...future.globalenv.names))
[15:32:39.841]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:39.841]         }, condition = base::local({
[15:32:39.841]             c <- base::c
[15:32:39.841]             inherits <- base::inherits
[15:32:39.841]             invokeRestart <- base::invokeRestart
[15:32:39.841]             length <- base::length
[15:32:39.841]             list <- base::list
[15:32:39.841]             seq.int <- base::seq.int
[15:32:39.841]             signalCondition <- base::signalCondition
[15:32:39.841]             sys.calls <- base::sys.calls
[15:32:39.841]             `[[` <- base::`[[`
[15:32:39.841]             `+` <- base::`+`
[15:32:39.841]             `<<-` <- base::`<<-`
[15:32:39.841]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:39.841]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:39.841]                   3L)]
[15:32:39.841]             }
[15:32:39.841]             function(cond) {
[15:32:39.841]                 is_error <- inherits(cond, "error")
[15:32:39.841]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:39.841]                   NULL)
[15:32:39.841]                 if (is_error) {
[15:32:39.841]                   sessionInformation <- function() {
[15:32:39.841]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:39.841]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:39.841]                       search = base::search(), system = base::Sys.info())
[15:32:39.841]                   }
[15:32:39.841]                   ...future.conditions[[length(...future.conditions) + 
[15:32:39.841]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:39.841]                     cond$call), session = sessionInformation(), 
[15:32:39.841]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:39.841]                   signalCondition(cond)
[15:32:39.841]                 }
[15:32:39.841]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:39.841]                 "immediateCondition"))) {
[15:32:39.841]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:39.841]                   ...future.conditions[[length(...future.conditions) + 
[15:32:39.841]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:39.841]                   if (TRUE && !signal) {
[15:32:39.841]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:39.841]                     {
[15:32:39.841]                       inherits <- base::inherits
[15:32:39.841]                       invokeRestart <- base::invokeRestart
[15:32:39.841]                       is.null <- base::is.null
[15:32:39.841]                       muffled <- FALSE
[15:32:39.841]                       if (inherits(cond, "message")) {
[15:32:39.841]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:39.841]                         if (muffled) 
[15:32:39.841]                           invokeRestart("muffleMessage")
[15:32:39.841]                       }
[15:32:39.841]                       else if (inherits(cond, "warning")) {
[15:32:39.841]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:39.841]                         if (muffled) 
[15:32:39.841]                           invokeRestart("muffleWarning")
[15:32:39.841]                       }
[15:32:39.841]                       else if (inherits(cond, "condition")) {
[15:32:39.841]                         if (!is.null(pattern)) {
[15:32:39.841]                           computeRestarts <- base::computeRestarts
[15:32:39.841]                           grepl <- base::grepl
[15:32:39.841]                           restarts <- computeRestarts(cond)
[15:32:39.841]                           for (restart in restarts) {
[15:32:39.841]                             name <- restart$name
[15:32:39.841]                             if (is.null(name)) 
[15:32:39.841]                               next
[15:32:39.841]                             if (!grepl(pattern, name)) 
[15:32:39.841]                               next
[15:32:39.841]                             invokeRestart(restart)
[15:32:39.841]                             muffled <- TRUE
[15:32:39.841]                             break
[15:32:39.841]                           }
[15:32:39.841]                         }
[15:32:39.841]                       }
[15:32:39.841]                       invisible(muffled)
[15:32:39.841]                     }
[15:32:39.841]                     muffleCondition(cond, pattern = "^muffle")
[15:32:39.841]                   }
[15:32:39.841]                 }
[15:32:39.841]                 else {
[15:32:39.841]                   if (TRUE) {
[15:32:39.841]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:39.841]                     {
[15:32:39.841]                       inherits <- base::inherits
[15:32:39.841]                       invokeRestart <- base::invokeRestart
[15:32:39.841]                       is.null <- base::is.null
[15:32:39.841]                       muffled <- FALSE
[15:32:39.841]                       if (inherits(cond, "message")) {
[15:32:39.841]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:39.841]                         if (muffled) 
[15:32:39.841]                           invokeRestart("muffleMessage")
[15:32:39.841]                       }
[15:32:39.841]                       else if (inherits(cond, "warning")) {
[15:32:39.841]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:39.841]                         if (muffled) 
[15:32:39.841]                           invokeRestart("muffleWarning")
[15:32:39.841]                       }
[15:32:39.841]                       else if (inherits(cond, "condition")) {
[15:32:39.841]                         if (!is.null(pattern)) {
[15:32:39.841]                           computeRestarts <- base::computeRestarts
[15:32:39.841]                           grepl <- base::grepl
[15:32:39.841]                           restarts <- computeRestarts(cond)
[15:32:39.841]                           for (restart in restarts) {
[15:32:39.841]                             name <- restart$name
[15:32:39.841]                             if (is.null(name)) 
[15:32:39.841]                               next
[15:32:39.841]                             if (!grepl(pattern, name)) 
[15:32:39.841]                               next
[15:32:39.841]                             invokeRestart(restart)
[15:32:39.841]                             muffled <- TRUE
[15:32:39.841]                             break
[15:32:39.841]                           }
[15:32:39.841]                         }
[15:32:39.841]                       }
[15:32:39.841]                       invisible(muffled)
[15:32:39.841]                     }
[15:32:39.841]                     muffleCondition(cond, pattern = "^muffle")
[15:32:39.841]                   }
[15:32:39.841]                 }
[15:32:39.841]             }
[15:32:39.841]         }))
[15:32:39.841]     }, error = function(ex) {
[15:32:39.841]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:39.841]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:39.841]                 ...future.rng), started = ...future.startTime, 
[15:32:39.841]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:39.841]             version = "1.8"), class = "FutureResult")
[15:32:39.841]     }, finally = {
[15:32:39.841]         if (!identical(...future.workdir, getwd())) 
[15:32:39.841]             setwd(...future.workdir)
[15:32:39.841]         {
[15:32:39.841]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:39.841]                 ...future.oldOptions$nwarnings <- NULL
[15:32:39.841]             }
[15:32:39.841]             base::options(...future.oldOptions)
[15:32:39.841]             if (.Platform$OS.type == "windows") {
[15:32:39.841]                 old_names <- names(...future.oldEnvVars)
[15:32:39.841]                 envs <- base::Sys.getenv()
[15:32:39.841]                 names <- names(envs)
[15:32:39.841]                 common <- intersect(names, old_names)
[15:32:39.841]                 added <- setdiff(names, old_names)
[15:32:39.841]                 removed <- setdiff(old_names, names)
[15:32:39.841]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:39.841]                   envs[common]]
[15:32:39.841]                 NAMES <- toupper(changed)
[15:32:39.841]                 args <- list()
[15:32:39.841]                 for (kk in seq_along(NAMES)) {
[15:32:39.841]                   name <- changed[[kk]]
[15:32:39.841]                   NAME <- NAMES[[kk]]
[15:32:39.841]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:39.841]                     next
[15:32:39.841]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:39.841]                 }
[15:32:39.841]                 NAMES <- toupper(added)
[15:32:39.841]                 for (kk in seq_along(NAMES)) {
[15:32:39.841]                   name <- added[[kk]]
[15:32:39.841]                   NAME <- NAMES[[kk]]
[15:32:39.841]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:39.841]                     next
[15:32:39.841]                   args[[name]] <- ""
[15:32:39.841]                 }
[15:32:39.841]                 NAMES <- toupper(removed)
[15:32:39.841]                 for (kk in seq_along(NAMES)) {
[15:32:39.841]                   name <- removed[[kk]]
[15:32:39.841]                   NAME <- NAMES[[kk]]
[15:32:39.841]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:39.841]                     next
[15:32:39.841]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:39.841]                 }
[15:32:39.841]                 if (length(args) > 0) 
[15:32:39.841]                   base::do.call(base::Sys.setenv, args = args)
[15:32:39.841]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:39.841]             }
[15:32:39.841]             else {
[15:32:39.841]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:39.841]             }
[15:32:39.841]             {
[15:32:39.841]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:39.841]                   0L) {
[15:32:39.841]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:39.841]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:39.841]                   base::options(opts)
[15:32:39.841]                 }
[15:32:39.841]                 {
[15:32:39.841]                   {
[15:32:39.841]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:39.841]                     NULL
[15:32:39.841]                   }
[15:32:39.841]                   options(future.plan = NULL)
[15:32:39.841]                   if (is.na(NA_character_)) 
[15:32:39.841]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:39.841]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:39.841]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:39.841]                     .init = FALSE)
[15:32:39.841]                 }
[15:32:39.841]             }
[15:32:39.841]         }
[15:32:39.841]     })
[15:32:39.841]     if (TRUE) {
[15:32:39.841]         base::sink(type = "output", split = FALSE)
[15:32:39.841]         if (TRUE) {
[15:32:39.841]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:39.841]         }
[15:32:39.841]         else {
[15:32:39.841]             ...future.result["stdout"] <- base::list(NULL)
[15:32:39.841]         }
[15:32:39.841]         base::close(...future.stdout)
[15:32:39.841]         ...future.stdout <- NULL
[15:32:39.841]     }
[15:32:39.841]     ...future.result$conditions <- ...future.conditions
[15:32:39.841]     ...future.result$finished <- base::Sys.time()
[15:32:39.841]     ...future.result
[15:32:39.841] }
[15:32:39.847] Exporting 5 global objects (848 bytes) to cluster node #1 ...
[15:32:39.848] Exporting '...future.FUN' (848 bytes) to cluster node #1 ...
[15:32:39.848] Exporting '...future.FUN' (848 bytes) to cluster node #1 ... DONE
[15:32:39.848] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:39.849] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:39.849] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:39.849] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:39.853] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:39.854] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:39.854] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:39.855] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:39.855] Exporting 5 global objects (848 bytes) to cluster node #1 ... DONE
[15:32:39.856] MultisessionFuture started
[15:32:39.856] - Launch lazy future ... done
[15:32:39.856] run() for 'MultisessionFuture' ... done
[15:32:39.856] Created future:
[15:32:39.885] receiveMessageFromWorker() for ClusterFuture ...
[15:32:39.886] - Validating connection of MultisessionFuture
[15:32:39.886] - received message: FutureResult
[15:32:39.887] - Received FutureResult
[15:32:39.887] - Erased future from FutureRegistry
[15:32:39.887] result() for ClusterFuture ...
[15:32:39.888] - result already collected: FutureResult
[15:32:39.888] result() for ClusterFuture ... done
[15:32:39.888] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:39.857] MultisessionFuture:
[15:32:39.857] Label: 'future_sapply-2'
[15:32:39.857] Expression:
[15:32:39.857] {
[15:32:39.857]     do.call(function(...) {
[15:32:39.857]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:39.857]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:39.857]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:39.857]             on.exit(options(oopts), add = TRUE)
[15:32:39.857]         }
[15:32:39.857]         {
[15:32:39.857]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:39.857]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:39.857]                 ...future.FUN(...future.X_jj, ...)
[15:32:39.857]             })
[15:32:39.857]         }
[15:32:39.857]     }, args = future.call.arguments)
[15:32:39.857] }
[15:32:39.857] Lazy evaluation: FALSE
[15:32:39.857] Asynchronous evaluation: TRUE
[15:32:39.857] Local evaluation: TRUE
[15:32:39.857] Environment: R_GlobalEnv
[15:32:39.857] Capture standard output: TRUE
[15:32:39.857] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:39.857] Globals: 5 objects totaling 960 bytes (function '...future.FUN' of 848 bytes, 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)
[15:32:39.857] Packages: <none>
[15:32:39.857] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:39.857] Resolved: TRUE
[15:32:39.857] Value: <not collected>
[15:32:39.857] Conditions captured: <none>
[15:32:39.857] Early signaling: FALSE
[15:32:39.857] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:39.857] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:39.889] Chunk #2 of 2 ... DONE
[15:32:39.889] Launching 2 futures (chunks) ... DONE
[15:32:39.889] Resolving 2 futures (chunks) ...
[15:32:39.890] resolve() on list ...
[15:32:39.890]  recursive: 0
[15:32:39.890]  length: 2
[15:32:39.890] 
[15:32:39.891] Future #1
[15:32:39.891] result() for ClusterFuture ...
[15:32:39.891] - result already collected: FutureResult
[15:32:39.891] result() for ClusterFuture ... done
[15:32:39.892] result() for ClusterFuture ...
[15:32:39.892] - result already collected: FutureResult
[15:32:39.892] result() for ClusterFuture ... done
[15:32:39.893] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:39.893] - nx: 2
[15:32:39.893] - relay: TRUE
[15:32:39.893] - stdout: TRUE
[15:32:39.893] - signal: TRUE
[15:32:39.894] - resignal: FALSE
[15:32:39.894] - force: TRUE
[15:32:39.894] - relayed: [n=2] FALSE, FALSE
[15:32:39.894] - queued futures: [n=2] FALSE, FALSE
[15:32:39.895]  - until=1
[15:32:39.895]  - relaying element #1
[15:32:39.895] result() for ClusterFuture ...
[15:32:39.896] - result already collected: FutureResult
[15:32:39.896] result() for ClusterFuture ... done
[15:32:39.896] result() for ClusterFuture ...
[15:32:39.896] - result already collected: FutureResult
[15:32:39.897] result() for ClusterFuture ... done
[15:32:39.897] result() for ClusterFuture ...
[15:32:39.897] - result already collected: FutureResult
[15:32:39.898] result() for ClusterFuture ... done
[15:32:39.898] result() for ClusterFuture ...
[15:32:39.898] - result already collected: FutureResult
[15:32:39.898] result() for ClusterFuture ... done
[15:32:39.899] - relayed: [n=2] TRUE, FALSE
[15:32:39.899] - queued futures: [n=2] TRUE, FALSE
[15:32:39.899] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:39.900]  length: 1 (resolved future 1)
[15:32:39.900] Future #2
[15:32:39.900] result() for ClusterFuture ...
[15:32:39.900] - result already collected: FutureResult
[15:32:39.901] result() for ClusterFuture ... done
[15:32:39.901] result() for ClusterFuture ...
[15:32:39.901] - result already collected: FutureResult
[15:32:39.901] result() for ClusterFuture ... done
[15:32:39.902] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:39.902] - nx: 2
[15:32:39.902] - relay: TRUE
[15:32:39.903] - stdout: TRUE
[15:32:39.903] - signal: TRUE
[15:32:39.903] - resignal: FALSE
[15:32:39.903] - force: TRUE
[15:32:39.904] - relayed: [n=2] TRUE, FALSE
[15:32:39.904] - queued futures: [n=2] TRUE, FALSE
[15:32:39.904]  - until=2
[15:32:39.904]  - relaying element #2
[15:32:39.905] result() for ClusterFuture ...
[15:32:39.905] - result already collected: FutureResult
[15:32:39.905] result() for ClusterFuture ... done
[15:32:39.906] result() for ClusterFuture ...
[15:32:39.906] - result already collected: FutureResult
[15:32:39.906] result() for ClusterFuture ... done
[15:32:39.906] result() for ClusterFuture ...
[15:32:39.907] - result already collected: FutureResult
[15:32:39.907] result() for ClusterFuture ... done
[15:32:39.907] result() for ClusterFuture ...
[15:32:39.908] - result already collected: FutureResult
[15:32:39.908] result() for ClusterFuture ... done
[15:32:39.908] - relayed: [n=2] TRUE, TRUE
[15:32:39.908] - queued futures: [n=2] TRUE, TRUE
[15:32:39.909] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:39.909]  length: 0 (resolved future 2)
[15:32:39.909] Relaying remaining futures
[15:32:39.909] signalConditionsASAP(NULL, pos=0) ...
[15:32:39.910] - nx: 2
[15:32:39.910] - relay: TRUE
[15:32:39.910] - stdout: TRUE
[15:32:39.910] - signal: TRUE
[15:32:39.911] - resignal: FALSE
[15:32:39.911] - force: TRUE
[15:32:39.911] - relayed: [n=2] TRUE, TRUE
[15:32:39.912] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:39.912] - relayed: [n=2] TRUE, TRUE
[15:32:39.912] - queued futures: [n=2] TRUE, TRUE
[15:32:39.913] signalConditionsASAP(NULL, pos=0) ... done
[15:32:39.913] resolve() on list ... DONE
[15:32:39.913] result() for ClusterFuture ...
[15:32:39.913] - result already collected: FutureResult
[15:32:39.914] result() for ClusterFuture ... done
[15:32:39.914] result() for ClusterFuture ...
[15:32:39.914] - result already collected: FutureResult
[15:32:39.914] result() for ClusterFuture ... done
[15:32:39.915] result() for ClusterFuture ...
[15:32:39.915] - result already collected: FutureResult
[15:32:39.915] result() for ClusterFuture ... done
[15:32:39.916] result() for ClusterFuture ...
[15:32:39.916] - result already collected: FutureResult
[15:32:39.916] result() for ClusterFuture ... done
[15:32:39.916]  - Number of value chunks collected: 2
[15:32:39.917] Resolving 2 futures (chunks) ... DONE
[15:32:39.917] Reducing values from 2 chunks ...
[15:32:39.917]  - Number of values collected after concatenation: 4
[15:32:39.918]  - Number of values expected: 4
[15:32:39.918] Reducing values from 2 chunks ... DONE
[15:32:39.918] future_lapply() ... DONE
List of 2
 $ y0:List of 4
  ..$ A: num 50
  ..$ B: num 60
  ..$ C: num 70
  ..$ D: num 80
 $ y1:List of 4
  ..$ A: num 50
  ..$ B: num 60
  ..$ C: num 70
  ..$ D: num 80
List of 2
 $ y0:List of 4
  ..$ A: num 50
  ..$ B: num 60
  ..$ C: num 70
  ..$ D: num 80
 $ y2:List of 4
  ..$ A: num 50
  ..$ B: num 60
  ..$ C: num 70
  ..$ D: num 80
[15:32:39.932] future_lapply() ...
[15:32:39.937] Number of chunks: 2
[15:32:39.937] getGlobalsAndPackagesXApply() ...
[15:32:39.938]  - future.globals: TRUE
[15:32:39.938] getGlobalsAndPackages() ...
[15:32:39.938] Searching for globals...
[15:32:39.940] - globals found: [2] 'FUN', 'UseMethod'
[15:32:39.941] Searching for globals ... DONE
[15:32:39.941] Resolving globals: FALSE
[15:32:39.942] The total size of the 1 globals is 1.22 KiB (1248 bytes)
[15:32:39.943] The total size of the 1 globals exported for future expression ('FUN()') is 1.22 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.22 KiB of class 'function')
[15:32:39.943] - globals: [1] 'FUN'
[15:32:39.943] 
[15:32:39.944] getGlobalsAndPackages() ... DONE
[15:32:39.944]  - globals found/used: [n=1] 'FUN'
[15:32:39.944]  - needed namespaces: [n=0] 
[15:32:39.944] Finding globals ... DONE
[15:32:39.945]  - use_args: TRUE
[15:32:39.945]  - Getting '...' globals ...
[15:32:39.946] resolve() on list ...
[15:32:39.946]  recursive: 0
[15:32:39.946]  length: 1
[15:32:39.947]  elements: '...'
[15:32:39.947]  length: 0 (resolved future 1)
[15:32:39.947] resolve() on list ... DONE
[15:32:39.947]    - '...' content: [n=0] 
[15:32:39.948] List of 1
[15:32:39.948]  $ ...: list()
[15:32:39.948]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:39.948]  - attr(*, "where")=List of 1
[15:32:39.948]   ..$ ...:<environment: 0x00000276e0a60878> 
[15:32:39.948]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:39.948]  - attr(*, "resolved")= logi TRUE
[15:32:39.948]  - attr(*, "total_size")= num NA
[15:32:39.953]  - Getting '...' globals ... DONE
[15:32:39.953] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:39.954] List of 2
[15:32:39.954]  $ ...future.FUN:function (x, ...)  
[15:32:39.954]  $ ...          : list()
[15:32:39.954]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:39.954]  - attr(*, "where")=List of 2
[15:32:39.954]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:39.954]   ..$ ...          :<environment: 0x00000276e0a60878> 
[15:32:39.954]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:39.954]  - attr(*, "resolved")= logi FALSE
[15:32:39.954]  - attr(*, "total_size")= num 1248
[15:32:39.959] Packages to be attached in all futures: [n=0] 
[15:32:39.959] getGlobalsAndPackagesXApply() ... DONE
[15:32:39.960] Number of futures (= number of chunks): 2
[15:32:39.960] Launching 2 futures (chunks) ...
[15:32:39.960] Chunk #1 of 2 ...
[15:32:39.961]  - Finding globals in 'X' for chunk #1 ...
[15:32:39.961] getGlobalsAndPackages() ...
[15:32:39.961] Searching for globals...
[15:32:39.962] 
[15:32:39.962] Searching for globals ... DONE
[15:32:39.962] - globals: [0] <none>
[15:32:39.963] getGlobalsAndPackages() ... DONE
[15:32:39.963]    + additional globals found: [n=0] 
[15:32:39.963]    + additional namespaces needed: [n=0] 
[15:32:39.963]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:39.964]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:39.964]  - seeds: <none>
[15:32:39.964]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:39.965] getGlobalsAndPackages() ...
[15:32:39.965] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:39.965] Resolving globals: FALSE
[15:32:39.965] Tweak future expression to call with '...' arguments ...
[15:32:39.966] {
[15:32:39.966]     do.call(function(...) {
[15:32:39.966]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:39.966]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:39.966]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:39.966]             on.exit(options(oopts), add = TRUE)
[15:32:39.966]         }
[15:32:39.966]         {
[15:32:39.966]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:39.966]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:39.966]                 ...future.FUN(...future.X_jj, ...)
[15:32:39.966]             })
[15:32:39.966]         }
[15:32:39.966]     }, args = future.call.arguments)
[15:32:39.966] }
[15:32:39.967] Tweak future expression to call with '...' arguments ... DONE
[15:32:39.967] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:39.968] 
[15:32:39.968] getGlobalsAndPackages() ... DONE
[15:32:39.969] run() for 'Future' ...
[15:32:39.969] - state: 'created'
[15:32:39.969] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:39.988] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:39.988] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:39.989]   - Field: 'node'
[15:32:39.989]   - Field: 'label'
[15:32:39.989]   - Field: 'local'
[15:32:39.990]   - Field: 'owner'
[15:32:39.990]   - Field: 'envir'
[15:32:39.990]   - Field: 'workers'
[15:32:39.991]   - Field: 'packages'
[15:32:39.991]   - Field: 'gc'
[15:32:39.991]   - Field: 'conditions'
[15:32:39.991]   - Field: 'persistent'
[15:32:39.992]   - Field: 'expr'
[15:32:39.992]   - Field: 'uuid'
[15:32:39.992]   - Field: 'seed'
[15:32:39.993]   - Field: 'version'
[15:32:39.993]   - Field: 'result'
[15:32:39.993]   - Field: 'asynchronous'
[15:32:39.994]   - Field: 'calls'
[15:32:39.994]   - Field: 'globals'
[15:32:39.994]   - Field: 'stdout'
[15:32:39.994]   - Field: 'earlySignal'
[15:32:39.995]   - Field: 'lazy'
[15:32:39.995]   - Field: 'state'
[15:32:39.995] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:39.996] - Launch lazy future ...
[15:32:39.996] Packages needed by the future expression (n = 0): <none>
[15:32:39.997] Packages needed by future strategies (n = 0): <none>
[15:32:39.998] {
[15:32:39.998]     {
[15:32:39.998]         {
[15:32:39.998]             ...future.startTime <- base::Sys.time()
[15:32:39.998]             {
[15:32:39.998]                 {
[15:32:39.998]                   {
[15:32:39.998]                     {
[15:32:39.998]                       base::local({
[15:32:39.998]                         has_future <- base::requireNamespace("future", 
[15:32:39.998]                           quietly = TRUE)
[15:32:39.998]                         if (has_future) {
[15:32:39.998]                           ns <- base::getNamespace("future")
[15:32:39.998]                           version <- ns[[".package"]][["version"]]
[15:32:39.998]                           if (is.null(version)) 
[15:32:39.998]                             version <- utils::packageVersion("future")
[15:32:39.998]                         }
[15:32:39.998]                         else {
[15:32:39.998]                           version <- NULL
[15:32:39.998]                         }
[15:32:39.998]                         if (!has_future || version < "1.8.0") {
[15:32:39.998]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:39.998]                             "", base::R.version$version.string), 
[15:32:39.998]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:39.998]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:39.998]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:39.998]                               "release", "version")], collapse = " "), 
[15:32:39.998]                             hostname = base::Sys.info()[["nodename"]])
[15:32:39.998]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:39.998]                             info)
[15:32:39.998]                           info <- base::paste(info, collapse = "; ")
[15:32:39.998]                           if (!has_future) {
[15:32:39.998]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:39.998]                               info)
[15:32:39.998]                           }
[15:32:39.998]                           else {
[15:32:39.998]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:39.998]                               info, version)
[15:32:39.998]                           }
[15:32:39.998]                           base::stop(msg)
[15:32:39.998]                         }
[15:32:39.998]                       })
[15:32:39.998]                     }
[15:32:39.998]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:39.998]                     base::options(mc.cores = 1L)
[15:32:39.998]                   }
[15:32:39.998]                   ...future.strategy.old <- future::plan("list")
[15:32:39.998]                   options(future.plan = NULL)
[15:32:39.998]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:39.998]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:39.998]                 }
[15:32:39.998]                 ...future.workdir <- getwd()
[15:32:39.998]             }
[15:32:39.998]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:39.998]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:39.998]         }
[15:32:39.998]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:39.998]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:39.998]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:39.998]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:39.998]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:39.998]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:39.998]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:39.998]             base::names(...future.oldOptions))
[15:32:39.998]     }
[15:32:39.998]     if (FALSE) {
[15:32:39.998]     }
[15:32:39.998]     else {
[15:32:39.998]         if (TRUE) {
[15:32:39.998]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:39.998]                 open = "w")
[15:32:39.998]         }
[15:32:39.998]         else {
[15:32:39.998]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:39.998]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:39.998]         }
[15:32:39.998]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:39.998]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:39.998]             base::sink(type = "output", split = FALSE)
[15:32:39.998]             base::close(...future.stdout)
[15:32:39.998]         }, add = TRUE)
[15:32:39.998]     }
[15:32:39.998]     ...future.frame <- base::sys.nframe()
[15:32:39.998]     ...future.conditions <- base::list()
[15:32:39.998]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:39.998]     if (FALSE) {
[15:32:39.998]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:39.998]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:39.998]     }
[15:32:39.998]     ...future.result <- base::tryCatch({
[15:32:39.998]         base::withCallingHandlers({
[15:32:39.998]             ...future.value <- base::withVisible(base::local({
[15:32:39.998]                 ...future.makeSendCondition <- base::local({
[15:32:39.998]                   sendCondition <- NULL
[15:32:39.998]                   function(frame = 1L) {
[15:32:39.998]                     if (is.function(sendCondition)) 
[15:32:39.998]                       return(sendCondition)
[15:32:39.998]                     ns <- getNamespace("parallel")
[15:32:39.998]                     if (exists("sendData", mode = "function", 
[15:32:39.998]                       envir = ns)) {
[15:32:39.998]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:39.998]                         envir = ns)
[15:32:39.998]                       envir <- sys.frame(frame)
[15:32:39.998]                       master <- NULL
[15:32:39.998]                       while (!identical(envir, .GlobalEnv) && 
[15:32:39.998]                         !identical(envir, emptyenv())) {
[15:32:39.998]                         if (exists("master", mode = "list", envir = envir, 
[15:32:39.998]                           inherits = FALSE)) {
[15:32:39.998]                           master <- get("master", mode = "list", 
[15:32:39.998]                             envir = envir, inherits = FALSE)
[15:32:39.998]                           if (inherits(master, c("SOCKnode", 
[15:32:39.998]                             "SOCK0node"))) {
[15:32:39.998]                             sendCondition <<- function(cond) {
[15:32:39.998]                               data <- list(type = "VALUE", value = cond, 
[15:32:39.998]                                 success = TRUE)
[15:32:39.998]                               parallel_sendData(master, data)
[15:32:39.998]                             }
[15:32:39.998]                             return(sendCondition)
[15:32:39.998]                           }
[15:32:39.998]                         }
[15:32:39.998]                         frame <- frame + 1L
[15:32:39.998]                         envir <- sys.frame(frame)
[15:32:39.998]                       }
[15:32:39.998]                     }
[15:32:39.998]                     sendCondition <<- function(cond) NULL
[15:32:39.998]                   }
[15:32:39.998]                 })
[15:32:39.998]                 withCallingHandlers({
[15:32:39.998]                   {
[15:32:39.998]                     do.call(function(...) {
[15:32:39.998]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:39.998]                       if (!identical(...future.globals.maxSize.org, 
[15:32:39.998]                         ...future.globals.maxSize)) {
[15:32:39.998]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:39.998]                         on.exit(options(oopts), add = TRUE)
[15:32:39.998]                       }
[15:32:39.998]                       {
[15:32:39.998]                         lapply(seq_along(...future.elements_ii), 
[15:32:39.998]                           FUN = function(jj) {
[15:32:39.998]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:39.998]                             ...future.FUN(...future.X_jj, ...)
[15:32:39.998]                           })
[15:32:39.998]                       }
[15:32:39.998]                     }, args = future.call.arguments)
[15:32:39.998]                   }
[15:32:39.998]                 }, immediateCondition = function(cond) {
[15:32:39.998]                   sendCondition <- ...future.makeSendCondition()
[15:32:39.998]                   sendCondition(cond)
[15:32:39.998]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:39.998]                   {
[15:32:39.998]                     inherits <- base::inherits
[15:32:39.998]                     invokeRestart <- base::invokeRestart
[15:32:39.998]                     is.null <- base::is.null
[15:32:39.998]                     muffled <- FALSE
[15:32:39.998]                     if (inherits(cond, "message")) {
[15:32:39.998]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:39.998]                       if (muffled) 
[15:32:39.998]                         invokeRestart("muffleMessage")
[15:32:39.998]                     }
[15:32:39.998]                     else if (inherits(cond, "warning")) {
[15:32:39.998]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:39.998]                       if (muffled) 
[15:32:39.998]                         invokeRestart("muffleWarning")
[15:32:39.998]                     }
[15:32:39.998]                     else if (inherits(cond, "condition")) {
[15:32:39.998]                       if (!is.null(pattern)) {
[15:32:39.998]                         computeRestarts <- base::computeRestarts
[15:32:39.998]                         grepl <- base::grepl
[15:32:39.998]                         restarts <- computeRestarts(cond)
[15:32:39.998]                         for (restart in restarts) {
[15:32:39.998]                           name <- restart$name
[15:32:39.998]                           if (is.null(name)) 
[15:32:39.998]                             next
[15:32:39.998]                           if (!grepl(pattern, name)) 
[15:32:39.998]                             next
[15:32:39.998]                           invokeRestart(restart)
[15:32:39.998]                           muffled <- TRUE
[15:32:39.998]                           break
[15:32:39.998]                         }
[15:32:39.998]                       }
[15:32:39.998]                     }
[15:32:39.998]                     invisible(muffled)
[15:32:39.998]                   }
[15:32:39.998]                   muffleCondition(cond)
[15:32:39.998]                 })
[15:32:39.998]             }))
[15:32:39.998]             future::FutureResult(value = ...future.value$value, 
[15:32:39.998]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:39.998]                   ...future.rng), globalenv = if (FALSE) 
[15:32:39.998]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:39.998]                     ...future.globalenv.names))
[15:32:39.998]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:39.998]         }, condition = base::local({
[15:32:39.998]             c <- base::c
[15:32:39.998]             inherits <- base::inherits
[15:32:39.998]             invokeRestart <- base::invokeRestart
[15:32:39.998]             length <- base::length
[15:32:39.998]             list <- base::list
[15:32:39.998]             seq.int <- base::seq.int
[15:32:39.998]             signalCondition <- base::signalCondition
[15:32:39.998]             sys.calls <- base::sys.calls
[15:32:39.998]             `[[` <- base::`[[`
[15:32:39.998]             `+` <- base::`+`
[15:32:39.998]             `<<-` <- base::`<<-`
[15:32:39.998]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:39.998]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:39.998]                   3L)]
[15:32:39.998]             }
[15:32:39.998]             function(cond) {
[15:32:39.998]                 is_error <- inherits(cond, "error")
[15:32:39.998]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:39.998]                   NULL)
[15:32:39.998]                 if (is_error) {
[15:32:39.998]                   sessionInformation <- function() {
[15:32:39.998]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:39.998]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:39.998]                       search = base::search(), system = base::Sys.info())
[15:32:39.998]                   }
[15:32:39.998]                   ...future.conditions[[length(...future.conditions) + 
[15:32:39.998]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:39.998]                     cond$call), session = sessionInformation(), 
[15:32:39.998]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:39.998]                   signalCondition(cond)
[15:32:39.998]                 }
[15:32:39.998]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:39.998]                 "immediateCondition"))) {
[15:32:39.998]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:39.998]                   ...future.conditions[[length(...future.conditions) + 
[15:32:39.998]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:39.998]                   if (TRUE && !signal) {
[15:32:39.998]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:39.998]                     {
[15:32:39.998]                       inherits <- base::inherits
[15:32:39.998]                       invokeRestart <- base::invokeRestart
[15:32:39.998]                       is.null <- base::is.null
[15:32:39.998]                       muffled <- FALSE
[15:32:39.998]                       if (inherits(cond, "message")) {
[15:32:39.998]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:39.998]                         if (muffled) 
[15:32:39.998]                           invokeRestart("muffleMessage")
[15:32:39.998]                       }
[15:32:39.998]                       else if (inherits(cond, "warning")) {
[15:32:39.998]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:39.998]                         if (muffled) 
[15:32:39.998]                           invokeRestart("muffleWarning")
[15:32:39.998]                       }
[15:32:39.998]                       else if (inherits(cond, "condition")) {
[15:32:39.998]                         if (!is.null(pattern)) {
[15:32:39.998]                           computeRestarts <- base::computeRestarts
[15:32:39.998]                           grepl <- base::grepl
[15:32:39.998]                           restarts <- computeRestarts(cond)
[15:32:39.998]                           for (restart in restarts) {
[15:32:39.998]                             name <- restart$name
[15:32:39.998]                             if (is.null(name)) 
[15:32:39.998]                               next
[15:32:39.998]                             if (!grepl(pattern, name)) 
[15:32:39.998]                               next
[15:32:39.998]                             invokeRestart(restart)
[15:32:39.998]                             muffled <- TRUE
[15:32:39.998]                             break
[15:32:39.998]                           }
[15:32:39.998]                         }
[15:32:39.998]                       }
[15:32:39.998]                       invisible(muffled)
[15:32:39.998]                     }
[15:32:39.998]                     muffleCondition(cond, pattern = "^muffle")
[15:32:39.998]                   }
[15:32:39.998]                 }
[15:32:39.998]                 else {
[15:32:39.998]                   if (TRUE) {
[15:32:39.998]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:39.998]                     {
[15:32:39.998]                       inherits <- base::inherits
[15:32:39.998]                       invokeRestart <- base::invokeRestart
[15:32:39.998]                       is.null <- base::is.null
[15:32:39.998]                       muffled <- FALSE
[15:32:39.998]                       if (inherits(cond, "message")) {
[15:32:39.998]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:39.998]                         if (muffled) 
[15:32:39.998]                           invokeRestart("muffleMessage")
[15:32:39.998]                       }
[15:32:39.998]                       else if (inherits(cond, "warning")) {
[15:32:39.998]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:39.998]                         if (muffled) 
[15:32:39.998]                           invokeRestart("muffleWarning")
[15:32:39.998]                       }
[15:32:39.998]                       else if (inherits(cond, "condition")) {
[15:32:39.998]                         if (!is.null(pattern)) {
[15:32:39.998]                           computeRestarts <- base::computeRestarts
[15:32:39.998]                           grepl <- base::grepl
[15:32:39.998]                           restarts <- computeRestarts(cond)
[15:32:39.998]                           for (restart in restarts) {
[15:32:39.998]                             name <- restart$name
[15:32:39.998]                             if (is.null(name)) 
[15:32:39.998]                               next
[15:32:39.998]                             if (!grepl(pattern, name)) 
[15:32:39.998]                               next
[15:32:39.998]                             invokeRestart(restart)
[15:32:39.998]                             muffled <- TRUE
[15:32:39.998]                             break
[15:32:39.998]                           }
[15:32:39.998]                         }
[15:32:39.998]                       }
[15:32:39.998]                       invisible(muffled)
[15:32:39.998]                     }
[15:32:39.998]                     muffleCondition(cond, pattern = "^muffle")
[15:32:39.998]                   }
[15:32:39.998]                 }
[15:32:39.998]             }
[15:32:39.998]         }))
[15:32:39.998]     }, error = function(ex) {
[15:32:39.998]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:39.998]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:39.998]                 ...future.rng), started = ...future.startTime, 
[15:32:39.998]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:39.998]             version = "1.8"), class = "FutureResult")
[15:32:39.998]     }, finally = {
[15:32:39.998]         if (!identical(...future.workdir, getwd())) 
[15:32:39.998]             setwd(...future.workdir)
[15:32:39.998]         {
[15:32:39.998]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:39.998]                 ...future.oldOptions$nwarnings <- NULL
[15:32:39.998]             }
[15:32:39.998]             base::options(...future.oldOptions)
[15:32:39.998]             if (.Platform$OS.type == "windows") {
[15:32:39.998]                 old_names <- names(...future.oldEnvVars)
[15:32:39.998]                 envs <- base::Sys.getenv()
[15:32:39.998]                 names <- names(envs)
[15:32:39.998]                 common <- intersect(names, old_names)
[15:32:39.998]                 added <- setdiff(names, old_names)
[15:32:39.998]                 removed <- setdiff(old_names, names)
[15:32:39.998]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:39.998]                   envs[common]]
[15:32:39.998]                 NAMES <- toupper(changed)
[15:32:39.998]                 args <- list()
[15:32:39.998]                 for (kk in seq_along(NAMES)) {
[15:32:39.998]                   name <- changed[[kk]]
[15:32:39.998]                   NAME <- NAMES[[kk]]
[15:32:39.998]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:39.998]                     next
[15:32:39.998]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:39.998]                 }
[15:32:39.998]                 NAMES <- toupper(added)
[15:32:39.998]                 for (kk in seq_along(NAMES)) {
[15:32:39.998]                   name <- added[[kk]]
[15:32:39.998]                   NAME <- NAMES[[kk]]
[15:32:39.998]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:39.998]                     next
[15:32:39.998]                   args[[name]] <- ""
[15:32:39.998]                 }
[15:32:39.998]                 NAMES <- toupper(removed)
[15:32:39.998]                 for (kk in seq_along(NAMES)) {
[15:32:39.998]                   name <- removed[[kk]]
[15:32:39.998]                   NAME <- NAMES[[kk]]
[15:32:39.998]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:39.998]                     next
[15:32:39.998]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:39.998]                 }
[15:32:39.998]                 if (length(args) > 0) 
[15:32:39.998]                   base::do.call(base::Sys.setenv, args = args)
[15:32:39.998]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:39.998]             }
[15:32:39.998]             else {
[15:32:39.998]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:39.998]             }
[15:32:39.998]             {
[15:32:39.998]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:39.998]                   0L) {
[15:32:39.998]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:39.998]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:39.998]                   base::options(opts)
[15:32:39.998]                 }
[15:32:39.998]                 {
[15:32:39.998]                   {
[15:32:39.998]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:39.998]                     NULL
[15:32:39.998]                   }
[15:32:39.998]                   options(future.plan = NULL)
[15:32:39.998]                   if (is.na(NA_character_)) 
[15:32:39.998]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:39.998]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:39.998]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:39.998]                     .init = FALSE)
[15:32:39.998]                 }
[15:32:39.998]             }
[15:32:39.998]         }
[15:32:39.998]     })
[15:32:39.998]     if (TRUE) {
[15:32:39.998]         base::sink(type = "output", split = FALSE)
[15:32:39.998]         if (TRUE) {
[15:32:39.998]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:39.998]         }
[15:32:39.998]         else {
[15:32:39.998]             ...future.result["stdout"] <- base::list(NULL)
[15:32:39.998]         }
[15:32:39.998]         base::close(...future.stdout)
[15:32:39.998]         ...future.stdout <- NULL
[15:32:39.998]     }
[15:32:39.998]     ...future.result$conditions <- ...future.conditions
[15:32:39.998]     ...future.result$finished <- base::Sys.time()
[15:32:39.998]     ...future.result
[15:32:39.998] }
[15:32:40.007] Exporting 5 global objects (1.22 KiB) to cluster node #1 ...
[15:32:40.008] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ...
[15:32:40.009] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ... DONE
[15:32:40.009] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:40.010] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:40.010] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:40.011] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:40.011] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:40.012] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:40.012] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:40.013] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:40.013] Exporting 5 global objects (1.22 KiB) to cluster node #1 ... DONE
[15:32:40.014] MultisessionFuture started
[15:32:40.014] - Launch lazy future ... done
[15:32:40.015] run() for 'MultisessionFuture' ... done
[15:32:40.015] Created future:
[15:32:40.044] receiveMessageFromWorker() for ClusterFuture ...
[15:32:40.044] - Validating connection of MultisessionFuture
[15:32:40.045] - received message: FutureResult
[15:32:40.045] - Received FutureResult
[15:32:40.045] - Erased future from FutureRegistry
[15:32:40.046] result() for ClusterFuture ...
[15:32:40.046] - result already collected: FutureResult
[15:32:40.046] result() for ClusterFuture ... done
[15:32:40.046] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:40.015] MultisessionFuture:
[15:32:40.015] Label: 'future_sapply-1'
[15:32:40.015] Expression:
[15:32:40.015] {
[15:32:40.015]     do.call(function(...) {
[15:32:40.015]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:40.015]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:40.015]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:40.015]             on.exit(options(oopts), add = TRUE)
[15:32:40.015]         }
[15:32:40.015]         {
[15:32:40.015]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:40.015]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:40.015]                 ...future.FUN(...future.X_jj, ...)
[15:32:40.015]             })
[15:32:40.015]         }
[15:32:40.015]     }, args = future.call.arguments)
[15:32:40.015] }
[15:32:40.015] Lazy evaluation: FALSE
[15:32:40.015] Asynchronous evaluation: TRUE
[15:32:40.015] Local evaluation: TRUE
[15:32:40.015] Environment: R_GlobalEnv
[15:32:40.015] Capture standard output: TRUE
[15:32:40.015] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:40.015] Globals: 5 objects totaling 1.33 KiB (function '...future.FUN' of 1.22 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)
[15:32:40.015] Packages: <none>
[15:32:40.015] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:40.015] Resolved: TRUE
[15:32:40.015] Value: <not collected>
[15:32:40.015] Conditions captured: <none>
[15:32:40.015] Early signaling: FALSE
[15:32:40.015] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:40.015] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:40.047] Chunk #1 of 2 ... DONE
[15:32:40.047] Chunk #2 of 2 ...
[15:32:40.048]  - Finding globals in 'X' for chunk #2 ...
[15:32:40.048] getGlobalsAndPackages() ...
[15:32:40.048] Searching for globals...
[15:32:40.049] 
[15:32:40.049] Searching for globals ... DONE
[15:32:40.050] - globals: [0] <none>
[15:32:40.050] getGlobalsAndPackages() ... DONE
[15:32:40.050]    + additional globals found: [n=0] 
[15:32:40.050]    + additional namespaces needed: [n=0] 
[15:32:40.051]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:40.051]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:40.051]  - seeds: <none>
[15:32:40.051]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:40.052] getGlobalsAndPackages() ...
[15:32:40.052] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:40.052] Resolving globals: FALSE
[15:32:40.053] Tweak future expression to call with '...' arguments ...
[15:32:40.053] {
[15:32:40.053]     do.call(function(...) {
[15:32:40.053]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:40.053]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:40.053]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:40.053]             on.exit(options(oopts), add = TRUE)
[15:32:40.053]         }
[15:32:40.053]         {
[15:32:40.053]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:40.053]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:40.053]                 ...future.FUN(...future.X_jj, ...)
[15:32:40.053]             })
[15:32:40.053]         }
[15:32:40.053]     }, args = future.call.arguments)
[15:32:40.053] }
[15:32:40.054] Tweak future expression to call with '...' arguments ... DONE
[15:32:40.054] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:40.055] 
[15:32:40.055] getGlobalsAndPackages() ... DONE
[15:32:40.056] run() for 'Future' ...
[15:32:40.056] - state: 'created'
[15:32:40.056] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:40.074] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:40.075] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:40.075]   - Field: 'node'
[15:32:40.075]   - Field: 'label'
[15:32:40.076]   - Field: 'local'
[15:32:40.076]   - Field: 'owner'
[15:32:40.076]   - Field: 'envir'
[15:32:40.077]   - Field: 'workers'
[15:32:40.077]   - Field: 'packages'
[15:32:40.077]   - Field: 'gc'
[15:32:40.078]   - Field: 'conditions'
[15:32:40.078]   - Field: 'persistent'
[15:32:40.078]   - Field: 'expr'
[15:32:40.078]   - Field: 'uuid'
[15:32:40.079]   - Field: 'seed'
[15:32:40.079]   - Field: 'version'
[15:32:40.079]   - Field: 'result'
[15:32:40.080]   - Field: 'asynchronous'
[15:32:40.080]   - Field: 'calls'
[15:32:40.080]   - Field: 'globals'
[15:32:40.080]   - Field: 'stdout'
[15:32:40.081]   - Field: 'earlySignal'
[15:32:40.081]   - Field: 'lazy'
[15:32:40.081]   - Field: 'state'
[15:32:40.082] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:40.082] - Launch lazy future ...
[15:32:40.082] Packages needed by the future expression (n = 0): <none>
[15:32:40.083] Packages needed by future strategies (n = 0): <none>
[15:32:40.084] {
[15:32:40.084]     {
[15:32:40.084]         {
[15:32:40.084]             ...future.startTime <- base::Sys.time()
[15:32:40.084]             {
[15:32:40.084]                 {
[15:32:40.084]                   {
[15:32:40.084]                     {
[15:32:40.084]                       base::local({
[15:32:40.084]                         has_future <- base::requireNamespace("future", 
[15:32:40.084]                           quietly = TRUE)
[15:32:40.084]                         if (has_future) {
[15:32:40.084]                           ns <- base::getNamespace("future")
[15:32:40.084]                           version <- ns[[".package"]][["version"]]
[15:32:40.084]                           if (is.null(version)) 
[15:32:40.084]                             version <- utils::packageVersion("future")
[15:32:40.084]                         }
[15:32:40.084]                         else {
[15:32:40.084]                           version <- NULL
[15:32:40.084]                         }
[15:32:40.084]                         if (!has_future || version < "1.8.0") {
[15:32:40.084]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:40.084]                             "", base::R.version$version.string), 
[15:32:40.084]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:40.084]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:40.084]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:40.084]                               "release", "version")], collapse = " "), 
[15:32:40.084]                             hostname = base::Sys.info()[["nodename"]])
[15:32:40.084]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:40.084]                             info)
[15:32:40.084]                           info <- base::paste(info, collapse = "; ")
[15:32:40.084]                           if (!has_future) {
[15:32:40.084]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:40.084]                               info)
[15:32:40.084]                           }
[15:32:40.084]                           else {
[15:32:40.084]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:40.084]                               info, version)
[15:32:40.084]                           }
[15:32:40.084]                           base::stop(msg)
[15:32:40.084]                         }
[15:32:40.084]                       })
[15:32:40.084]                     }
[15:32:40.084]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:40.084]                     base::options(mc.cores = 1L)
[15:32:40.084]                   }
[15:32:40.084]                   ...future.strategy.old <- future::plan("list")
[15:32:40.084]                   options(future.plan = NULL)
[15:32:40.084]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:40.084]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:40.084]                 }
[15:32:40.084]                 ...future.workdir <- getwd()
[15:32:40.084]             }
[15:32:40.084]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:40.084]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:40.084]         }
[15:32:40.084]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:40.084]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:40.084]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:40.084]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:40.084]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:40.084]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:40.084]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:40.084]             base::names(...future.oldOptions))
[15:32:40.084]     }
[15:32:40.084]     if (FALSE) {
[15:32:40.084]     }
[15:32:40.084]     else {
[15:32:40.084]         if (TRUE) {
[15:32:40.084]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:40.084]                 open = "w")
[15:32:40.084]         }
[15:32:40.084]         else {
[15:32:40.084]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:40.084]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:40.084]         }
[15:32:40.084]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:40.084]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:40.084]             base::sink(type = "output", split = FALSE)
[15:32:40.084]             base::close(...future.stdout)
[15:32:40.084]         }, add = TRUE)
[15:32:40.084]     }
[15:32:40.084]     ...future.frame <- base::sys.nframe()
[15:32:40.084]     ...future.conditions <- base::list()
[15:32:40.084]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:40.084]     if (FALSE) {
[15:32:40.084]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:40.084]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:40.084]     }
[15:32:40.084]     ...future.result <- base::tryCatch({
[15:32:40.084]         base::withCallingHandlers({
[15:32:40.084]             ...future.value <- base::withVisible(base::local({
[15:32:40.084]                 ...future.makeSendCondition <- base::local({
[15:32:40.084]                   sendCondition <- NULL
[15:32:40.084]                   function(frame = 1L) {
[15:32:40.084]                     if (is.function(sendCondition)) 
[15:32:40.084]                       return(sendCondition)
[15:32:40.084]                     ns <- getNamespace("parallel")
[15:32:40.084]                     if (exists("sendData", mode = "function", 
[15:32:40.084]                       envir = ns)) {
[15:32:40.084]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:40.084]                         envir = ns)
[15:32:40.084]                       envir <- sys.frame(frame)
[15:32:40.084]                       master <- NULL
[15:32:40.084]                       while (!identical(envir, .GlobalEnv) && 
[15:32:40.084]                         !identical(envir, emptyenv())) {
[15:32:40.084]                         if (exists("master", mode = "list", envir = envir, 
[15:32:40.084]                           inherits = FALSE)) {
[15:32:40.084]                           master <- get("master", mode = "list", 
[15:32:40.084]                             envir = envir, inherits = FALSE)
[15:32:40.084]                           if (inherits(master, c("SOCKnode", 
[15:32:40.084]                             "SOCK0node"))) {
[15:32:40.084]                             sendCondition <<- function(cond) {
[15:32:40.084]                               data <- list(type = "VALUE", value = cond, 
[15:32:40.084]                                 success = TRUE)
[15:32:40.084]                               parallel_sendData(master, data)
[15:32:40.084]                             }
[15:32:40.084]                             return(sendCondition)
[15:32:40.084]                           }
[15:32:40.084]                         }
[15:32:40.084]                         frame <- frame + 1L
[15:32:40.084]                         envir <- sys.frame(frame)
[15:32:40.084]                       }
[15:32:40.084]                     }
[15:32:40.084]                     sendCondition <<- function(cond) NULL
[15:32:40.084]                   }
[15:32:40.084]                 })
[15:32:40.084]                 withCallingHandlers({
[15:32:40.084]                   {
[15:32:40.084]                     do.call(function(...) {
[15:32:40.084]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:40.084]                       if (!identical(...future.globals.maxSize.org, 
[15:32:40.084]                         ...future.globals.maxSize)) {
[15:32:40.084]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:40.084]                         on.exit(options(oopts), add = TRUE)
[15:32:40.084]                       }
[15:32:40.084]                       {
[15:32:40.084]                         lapply(seq_along(...future.elements_ii), 
[15:32:40.084]                           FUN = function(jj) {
[15:32:40.084]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:40.084]                             ...future.FUN(...future.X_jj, ...)
[15:32:40.084]                           })
[15:32:40.084]                       }
[15:32:40.084]                     }, args = future.call.arguments)
[15:32:40.084]                   }
[15:32:40.084]                 }, immediateCondition = function(cond) {
[15:32:40.084]                   sendCondition <- ...future.makeSendCondition()
[15:32:40.084]                   sendCondition(cond)
[15:32:40.084]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:40.084]                   {
[15:32:40.084]                     inherits <- base::inherits
[15:32:40.084]                     invokeRestart <- base::invokeRestart
[15:32:40.084]                     is.null <- base::is.null
[15:32:40.084]                     muffled <- FALSE
[15:32:40.084]                     if (inherits(cond, "message")) {
[15:32:40.084]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:40.084]                       if (muffled) 
[15:32:40.084]                         invokeRestart("muffleMessage")
[15:32:40.084]                     }
[15:32:40.084]                     else if (inherits(cond, "warning")) {
[15:32:40.084]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:40.084]                       if (muffled) 
[15:32:40.084]                         invokeRestart("muffleWarning")
[15:32:40.084]                     }
[15:32:40.084]                     else if (inherits(cond, "condition")) {
[15:32:40.084]                       if (!is.null(pattern)) {
[15:32:40.084]                         computeRestarts <- base::computeRestarts
[15:32:40.084]                         grepl <- base::grepl
[15:32:40.084]                         restarts <- computeRestarts(cond)
[15:32:40.084]                         for (restart in restarts) {
[15:32:40.084]                           name <- restart$name
[15:32:40.084]                           if (is.null(name)) 
[15:32:40.084]                             next
[15:32:40.084]                           if (!grepl(pattern, name)) 
[15:32:40.084]                             next
[15:32:40.084]                           invokeRestart(restart)
[15:32:40.084]                           muffled <- TRUE
[15:32:40.084]                           break
[15:32:40.084]                         }
[15:32:40.084]                       }
[15:32:40.084]                     }
[15:32:40.084]                     invisible(muffled)
[15:32:40.084]                   }
[15:32:40.084]                   muffleCondition(cond)
[15:32:40.084]                 })
[15:32:40.084]             }))
[15:32:40.084]             future::FutureResult(value = ...future.value$value, 
[15:32:40.084]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:40.084]                   ...future.rng), globalenv = if (FALSE) 
[15:32:40.084]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:40.084]                     ...future.globalenv.names))
[15:32:40.084]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:40.084]         }, condition = base::local({
[15:32:40.084]             c <- base::c
[15:32:40.084]             inherits <- base::inherits
[15:32:40.084]             invokeRestart <- base::invokeRestart
[15:32:40.084]             length <- base::length
[15:32:40.084]             list <- base::list
[15:32:40.084]             seq.int <- base::seq.int
[15:32:40.084]             signalCondition <- base::signalCondition
[15:32:40.084]             sys.calls <- base::sys.calls
[15:32:40.084]             `[[` <- base::`[[`
[15:32:40.084]             `+` <- base::`+`
[15:32:40.084]             `<<-` <- base::`<<-`
[15:32:40.084]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:40.084]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:40.084]                   3L)]
[15:32:40.084]             }
[15:32:40.084]             function(cond) {
[15:32:40.084]                 is_error <- inherits(cond, "error")
[15:32:40.084]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:40.084]                   NULL)
[15:32:40.084]                 if (is_error) {
[15:32:40.084]                   sessionInformation <- function() {
[15:32:40.084]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:40.084]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:40.084]                       search = base::search(), system = base::Sys.info())
[15:32:40.084]                   }
[15:32:40.084]                   ...future.conditions[[length(...future.conditions) + 
[15:32:40.084]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:40.084]                     cond$call), session = sessionInformation(), 
[15:32:40.084]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:40.084]                   signalCondition(cond)
[15:32:40.084]                 }
[15:32:40.084]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:40.084]                 "immediateCondition"))) {
[15:32:40.084]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:40.084]                   ...future.conditions[[length(...future.conditions) + 
[15:32:40.084]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:40.084]                   if (TRUE && !signal) {
[15:32:40.084]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:40.084]                     {
[15:32:40.084]                       inherits <- base::inherits
[15:32:40.084]                       invokeRestart <- base::invokeRestart
[15:32:40.084]                       is.null <- base::is.null
[15:32:40.084]                       muffled <- FALSE
[15:32:40.084]                       if (inherits(cond, "message")) {
[15:32:40.084]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:40.084]                         if (muffled) 
[15:32:40.084]                           invokeRestart("muffleMessage")
[15:32:40.084]                       }
[15:32:40.084]                       else if (inherits(cond, "warning")) {
[15:32:40.084]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:40.084]                         if (muffled) 
[15:32:40.084]                           invokeRestart("muffleWarning")
[15:32:40.084]                       }
[15:32:40.084]                       else if (inherits(cond, "condition")) {
[15:32:40.084]                         if (!is.null(pattern)) {
[15:32:40.084]                           computeRestarts <- base::computeRestarts
[15:32:40.084]                           grepl <- base::grepl
[15:32:40.084]                           restarts <- computeRestarts(cond)
[15:32:40.084]                           for (restart in restarts) {
[15:32:40.084]                             name <- restart$name
[15:32:40.084]                             if (is.null(name)) 
[15:32:40.084]                               next
[15:32:40.084]                             if (!grepl(pattern, name)) 
[15:32:40.084]                               next
[15:32:40.084]                             invokeRestart(restart)
[15:32:40.084]                             muffled <- TRUE
[15:32:40.084]                             break
[15:32:40.084]                           }
[15:32:40.084]                         }
[15:32:40.084]                       }
[15:32:40.084]                       invisible(muffled)
[15:32:40.084]                     }
[15:32:40.084]                     muffleCondition(cond, pattern = "^muffle")
[15:32:40.084]                   }
[15:32:40.084]                 }
[15:32:40.084]                 else {
[15:32:40.084]                   if (TRUE) {
[15:32:40.084]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:40.084]                     {
[15:32:40.084]                       inherits <- base::inherits
[15:32:40.084]                       invokeRestart <- base::invokeRestart
[15:32:40.084]                       is.null <- base::is.null
[15:32:40.084]                       muffled <- FALSE
[15:32:40.084]                       if (inherits(cond, "message")) {
[15:32:40.084]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:40.084]                         if (muffled) 
[15:32:40.084]                           invokeRestart("muffleMessage")
[15:32:40.084]                       }
[15:32:40.084]                       else if (inherits(cond, "warning")) {
[15:32:40.084]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:40.084]                         if (muffled) 
[15:32:40.084]                           invokeRestart("muffleWarning")
[15:32:40.084]                       }
[15:32:40.084]                       else if (inherits(cond, "condition")) {
[15:32:40.084]                         if (!is.null(pattern)) {
[15:32:40.084]                           computeRestarts <- base::computeRestarts
[15:32:40.084]                           grepl <- base::grepl
[15:32:40.084]                           restarts <- computeRestarts(cond)
[15:32:40.084]                           for (restart in restarts) {
[15:32:40.084]                             name <- restart$name
[15:32:40.084]                             if (is.null(name)) 
[15:32:40.084]                               next
[15:32:40.084]                             if (!grepl(pattern, name)) 
[15:32:40.084]                               next
[15:32:40.084]                             invokeRestart(restart)
[15:32:40.084]                             muffled <- TRUE
[15:32:40.084]                             break
[15:32:40.084]                           }
[15:32:40.084]                         }
[15:32:40.084]                       }
[15:32:40.084]                       invisible(muffled)
[15:32:40.084]                     }
[15:32:40.084]                     muffleCondition(cond, pattern = "^muffle")
[15:32:40.084]                   }
[15:32:40.084]                 }
[15:32:40.084]             }
[15:32:40.084]         }))
[15:32:40.084]     }, error = function(ex) {
[15:32:40.084]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:40.084]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:40.084]                 ...future.rng), started = ...future.startTime, 
[15:32:40.084]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:40.084]             version = "1.8"), class = "FutureResult")
[15:32:40.084]     }, finally = {
[15:32:40.084]         if (!identical(...future.workdir, getwd())) 
[15:32:40.084]             setwd(...future.workdir)
[15:32:40.084]         {
[15:32:40.084]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:40.084]                 ...future.oldOptions$nwarnings <- NULL
[15:32:40.084]             }
[15:32:40.084]             base::options(...future.oldOptions)
[15:32:40.084]             if (.Platform$OS.type == "windows") {
[15:32:40.084]                 old_names <- names(...future.oldEnvVars)
[15:32:40.084]                 envs <- base::Sys.getenv()
[15:32:40.084]                 names <- names(envs)
[15:32:40.084]                 common <- intersect(names, old_names)
[15:32:40.084]                 added <- setdiff(names, old_names)
[15:32:40.084]                 removed <- setdiff(old_names, names)
[15:32:40.084]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:40.084]                   envs[common]]
[15:32:40.084]                 NAMES <- toupper(changed)
[15:32:40.084]                 args <- list()
[15:32:40.084]                 for (kk in seq_along(NAMES)) {
[15:32:40.084]                   name <- changed[[kk]]
[15:32:40.084]                   NAME <- NAMES[[kk]]
[15:32:40.084]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:40.084]                     next
[15:32:40.084]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:40.084]                 }
[15:32:40.084]                 NAMES <- toupper(added)
[15:32:40.084]                 for (kk in seq_along(NAMES)) {
[15:32:40.084]                   name <- added[[kk]]
[15:32:40.084]                   NAME <- NAMES[[kk]]
[15:32:40.084]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:40.084]                     next
[15:32:40.084]                   args[[name]] <- ""
[15:32:40.084]                 }
[15:32:40.084]                 NAMES <- toupper(removed)
[15:32:40.084]                 for (kk in seq_along(NAMES)) {
[15:32:40.084]                   name <- removed[[kk]]
[15:32:40.084]                   NAME <- NAMES[[kk]]
[15:32:40.084]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:40.084]                     next
[15:32:40.084]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:40.084]                 }
[15:32:40.084]                 if (length(args) > 0) 
[15:32:40.084]                   base::do.call(base::Sys.setenv, args = args)
[15:32:40.084]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:40.084]             }
[15:32:40.084]             else {
[15:32:40.084]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:40.084]             }
[15:32:40.084]             {
[15:32:40.084]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:40.084]                   0L) {
[15:32:40.084]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:40.084]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:40.084]                   base::options(opts)
[15:32:40.084]                 }
[15:32:40.084]                 {
[15:32:40.084]                   {
[15:32:40.084]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:40.084]                     NULL
[15:32:40.084]                   }
[15:32:40.084]                   options(future.plan = NULL)
[15:32:40.084]                   if (is.na(NA_character_)) 
[15:32:40.084]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:40.084]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:40.084]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:40.084]                     .init = FALSE)
[15:32:40.084]                 }
[15:32:40.084]             }
[15:32:40.084]         }
[15:32:40.084]     })
[15:32:40.084]     if (TRUE) {
[15:32:40.084]         base::sink(type = "output", split = FALSE)
[15:32:40.084]         if (TRUE) {
[15:32:40.084]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:40.084]         }
[15:32:40.084]         else {
[15:32:40.084]             ...future.result["stdout"] <- base::list(NULL)
[15:32:40.084]         }
[15:32:40.084]         base::close(...future.stdout)
[15:32:40.084]         ...future.stdout <- NULL
[15:32:40.084]     }
[15:32:40.084]     ...future.result$conditions <- ...future.conditions
[15:32:40.084]     ...future.result$finished <- base::Sys.time()
[15:32:40.084]     ...future.result
[15:32:40.084] }
[15:32:40.093] Exporting 5 global objects (1.22 KiB) to cluster node #1 ...
[15:32:40.093] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ...
[15:32:40.094] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ... DONE
[15:32:40.094] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:40.095] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:40.095] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:40.102] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:40.102] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:40.103] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:40.103] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:40.104] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:40.104] Exporting 5 global objects (1.22 KiB) to cluster node #1 ... DONE
[15:32:40.105] MultisessionFuture started
[15:32:40.106] - Launch lazy future ... done
[15:32:40.106] run() for 'MultisessionFuture' ... done
[15:32:40.106] Created future:
[15:32:40.134] receiveMessageFromWorker() for ClusterFuture ...
[15:32:40.135] - Validating connection of MultisessionFuture
[15:32:40.136] - received message: FutureResult
[15:32:40.137] - Received FutureResult
[15:32:40.137] - Erased future from FutureRegistry
[15:32:40.137] result() for ClusterFuture ...
[15:32:40.138] - result already collected: FutureResult
[15:32:40.138] result() for ClusterFuture ... done
[15:32:40.138] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:40.107] MultisessionFuture:
[15:32:40.107] Label: 'future_sapply-2'
[15:32:40.107] Expression:
[15:32:40.107] {
[15:32:40.107]     do.call(function(...) {
[15:32:40.107]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:40.107]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:40.107]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:40.107]             on.exit(options(oopts), add = TRUE)
[15:32:40.107]         }
[15:32:40.107]         {
[15:32:40.107]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:40.107]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:40.107]                 ...future.FUN(...future.X_jj, ...)
[15:32:40.107]             })
[15:32:40.107]         }
[15:32:40.107]     }, args = future.call.arguments)
[15:32:40.107] }
[15:32:40.107] Lazy evaluation: FALSE
[15:32:40.107] Asynchronous evaluation: TRUE
[15:32:40.107] Local evaluation: TRUE
[15:32:40.107] Environment: R_GlobalEnv
[15:32:40.107] Capture standard output: TRUE
[15:32:40.107] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:40.107] Globals: 5 objects totaling 1.33 KiB (function '...future.FUN' of 1.22 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)
[15:32:40.107] Packages: <none>
[15:32:40.107] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:40.107] Resolved: TRUE
[15:32:40.107] Value: <not collected>
[15:32:40.107] Conditions captured: <none>
[15:32:40.107] Early signaling: FALSE
[15:32:40.107] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:40.107] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:40.139] Chunk #2 of 2 ... DONE
[15:32:40.140] Launching 2 futures (chunks) ... DONE
[15:32:40.140] Resolving 2 futures (chunks) ...
[15:32:40.140] resolve() on list ...
[15:32:40.140]  recursive: 0
[15:32:40.141]  length: 2
[15:32:40.141] 
[15:32:40.142] Future #1
[15:32:40.142] result() for ClusterFuture ...
[15:32:40.142] - result already collected: FutureResult
[15:32:40.142] result() for ClusterFuture ... done
[15:32:40.143] result() for ClusterFuture ...
[15:32:40.143] - result already collected: FutureResult
[15:32:40.143] result() for ClusterFuture ... done
[15:32:40.144] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:40.144] - nx: 2
[15:32:40.144] - relay: TRUE
[15:32:40.145] - stdout: TRUE
[15:32:40.145] - signal: TRUE
[15:32:40.145] - resignal: FALSE
[15:32:40.145] - force: TRUE
[15:32:40.146] - relayed: [n=2] FALSE, FALSE
[15:32:40.146] - queued futures: [n=2] FALSE, FALSE
[15:32:40.146]  - until=1
[15:32:40.147]  - relaying element #1
[15:32:40.147] result() for ClusterFuture ...
[15:32:40.147] - result already collected: FutureResult
[15:32:40.148] result() for ClusterFuture ... done
[15:32:40.148] result() for ClusterFuture ...
[15:32:40.148] - result already collected: FutureResult
[15:32:40.148] result() for ClusterFuture ... done
[15:32:40.149] result() for ClusterFuture ...
[15:32:40.149] - result already collected: FutureResult
[15:32:40.149] result() for ClusterFuture ... done
[15:32:40.150] result() for ClusterFuture ...
[15:32:40.150] - result already collected: FutureResult
[15:32:40.150] result() for ClusterFuture ... done
[15:32:40.150] - relayed: [n=2] TRUE, FALSE
[15:32:40.151] - queued futures: [n=2] TRUE, FALSE
[15:32:40.151] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:40.151]  length: 1 (resolved future 1)
[15:32:40.152] Future #2
[15:32:40.152] result() for ClusterFuture ...
[15:32:40.152] - result already collected: FutureResult
[15:32:40.153] result() for ClusterFuture ... done
[15:32:40.153] result() for ClusterFuture ...
[15:32:40.153] - result already collected: FutureResult
[15:32:40.153] result() for ClusterFuture ... done
[15:32:40.154] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:40.154] - nx: 2
[15:32:40.154] - relay: TRUE
[15:32:40.154] - stdout: TRUE
[15:32:40.155] - signal: TRUE
[15:32:40.155] - resignal: FALSE
[15:32:40.155] - force: TRUE
[15:32:40.156] - relayed: [n=2] TRUE, FALSE
[15:32:40.156] - queued futures: [n=2] TRUE, FALSE
[15:32:40.156]  - until=2
[15:32:40.157]  - relaying element #2
[15:32:40.157] result() for ClusterFuture ...
[15:32:40.157] - result already collected: FutureResult
[15:32:40.158] result() for ClusterFuture ... done
[15:32:40.158] result() for ClusterFuture ...
[15:32:40.158] - result already collected: FutureResult
[15:32:40.158] result() for ClusterFuture ... done
[15:32:40.159] result() for ClusterFuture ...
[15:32:40.159] - result already collected: FutureResult
[15:32:40.159] result() for ClusterFuture ... done
[15:32:40.160] result() for ClusterFuture ...
[15:32:40.160] - result already collected: FutureResult
[15:32:40.160] result() for ClusterFuture ... done
[15:32:40.161] - relayed: [n=2] TRUE, TRUE
[15:32:40.161] - queued futures: [n=2] TRUE, TRUE
[15:32:40.161] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:40.162]  length: 0 (resolved future 2)
[15:32:40.162] Relaying remaining futures
[15:32:40.162] signalConditionsASAP(NULL, pos=0) ...
[15:32:40.163] - nx: 2
[15:32:40.163] - relay: TRUE
[15:32:40.163] - stdout: TRUE
[15:32:40.164] - signal: TRUE
[15:32:40.164] - resignal: FALSE
[15:32:40.164] - force: TRUE
[15:32:40.164] - relayed: [n=2] TRUE, TRUE
[15:32:40.165] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:40.165] - relayed: [n=2] TRUE, TRUE
[15:32:40.166] - queued futures: [n=2] TRUE, TRUE
[15:32:40.166] signalConditionsASAP(NULL, pos=0) ... done
[15:32:40.166] resolve() on list ... DONE
[15:32:40.166] result() for ClusterFuture ...
[15:32:40.167] - result already collected: FutureResult
[15:32:40.167] result() for ClusterFuture ... done
[15:32:40.167] result() for ClusterFuture ...
[15:32:40.168] - result already collected: FutureResult
[15:32:40.168] result() for ClusterFuture ... done
[15:32:40.168] result() for ClusterFuture ...
[15:32:40.169] - result already collected: FutureResult
[15:32:40.169] result() for ClusterFuture ... done
[15:32:40.169] result() for ClusterFuture ...
[15:32:40.170] - result already collected: FutureResult
[15:32:40.170] result() for ClusterFuture ... done
[15:32:40.170]  - Number of value chunks collected: 2
[15:32:40.171] Resolving 2 futures (chunks) ... DONE
[15:32:40.171] Reducing values from 2 chunks ...
[15:32:40.171]  - Number of values collected after concatenation: 4
[15:32:40.171]  - Number of values expected: 4
[15:32:40.172] Reducing values from 2 chunks ... DONE
[15:32:40.172] future_lapply() ... DONE
List of 2
 $ y0:List of 4
  ..$ A: num [1, 1] 50
  ..$ B: num [1, 1] 60
  ..$ C: num [1, 1] 70
  ..$ D: num [1, 1] 80
 $ y1:List of 4
  ..$ A: num [1, 1] 50
  ..$ B: num [1, 1] 60
  ..$ C: num [1, 1] 70
  ..$ D: num [1, 1] 80
List of 2
 $ y0:List of 4
  ..$ A: num [1, 1] 50
  ..$ B: num [1, 1] 60
  ..$ C: num [1, 1] 70
  ..$ D: num [1, 1] 80
 $ y2:List of 4
  ..$ A: num [1, 1] 50
  ..$ B: num [1, 1] 60
  ..$ C: num [1, 1] 70
  ..$ D: num [1, 1] 80
[15:32:40.188] future_lapply() ...
[15:32:40.194] Number of chunks: 2
[15:32:40.195] getGlobalsAndPackagesXApply() ...
[15:32:40.195]  - future.globals: TRUE
[15:32:40.195] getGlobalsAndPackages() ...
[15:32:40.196] Searching for globals...
[15:32:40.199] - globals found: [5] 'FUN', '*', ':', 'outer', 'rep'
[15:32:40.200] Searching for globals ... DONE
[15:32:40.200] Resolving globals: FALSE
[15:32:40.201] The total size of the 1 globals is 4.62 KiB (4728 bytes)
[15:32:40.202] The total size of the 1 globals exported for future expression ('FUN()') is 4.62 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.62 KiB of class 'function')
[15:32:40.202] - globals: [1] 'FUN'
[15:32:40.202] 
[15:32:40.203] getGlobalsAndPackages() ... DONE
[15:32:40.203]  - globals found/used: [n=1] 'FUN'
[15:32:40.203]  - needed namespaces: [n=0] 
[15:32:40.204] Finding globals ... DONE
[15:32:40.204]  - use_args: TRUE
[15:32:40.204]  - Getting '...' globals ...
[15:32:40.205] resolve() on list ...
[15:32:40.205]  recursive: 0
[15:32:40.206]  length: 1
[15:32:40.206]  elements: '...'
[15:32:40.206]  length: 0 (resolved future 1)
[15:32:40.207] resolve() on list ... DONE
[15:32:40.207]    - '...' content: [n=0] 
[15:32:40.207] List of 1
[15:32:40.207]  $ ...: list()
[15:32:40.207]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:40.207]  - attr(*, "where")=List of 1
[15:32:40.207]   ..$ ...:<environment: 0x00000276e0585f48> 
[15:32:40.207]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:40.207]  - attr(*, "resolved")= logi TRUE
[15:32:40.207]  - attr(*, "total_size")= num NA
[15:32:40.213]  - Getting '...' globals ... DONE
[15:32:40.213] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:40.214] List of 2
[15:32:40.214]  $ ...future.FUN:function (x, y = 2 * 1:5)  
[15:32:40.214]  $ ...          : list()
[15:32:40.214]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:40.214]  - attr(*, "where")=List of 2
[15:32:40.214]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:40.214]   ..$ ...          :<environment: 0x00000276e0585f48> 
[15:32:40.214]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:40.214]  - attr(*, "resolved")= logi FALSE
[15:32:40.214]  - attr(*, "total_size")= num 4728
[15:32:40.220] Packages to be attached in all futures: [n=0] 
[15:32:40.220] getGlobalsAndPackagesXApply() ... DONE
[15:32:40.220] Number of futures (= number of chunks): 2
[15:32:40.221] Launching 2 futures (chunks) ...
[15:32:40.221] Chunk #1 of 2 ...
[15:32:40.221]  - Finding globals in 'X' for chunk #1 ...
[15:32:40.222] getGlobalsAndPackages() ...
[15:32:40.222] Searching for globals...
[15:32:40.223] 
[15:32:40.223] Searching for globals ... DONE
[15:32:40.223] - globals: [0] <none>
[15:32:40.223] getGlobalsAndPackages() ... DONE
[15:32:40.224]    + additional globals found: [n=0] 
[15:32:40.224]    + additional namespaces needed: [n=0] 
[15:32:40.224]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:40.225]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:40.225]  - seeds: <none>
[15:32:40.225]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:40.226] getGlobalsAndPackages() ...
[15:32:40.226] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:40.226] Resolving globals: FALSE
[15:32:40.227] Tweak future expression to call with '...' arguments ...
[15:32:40.227] {
[15:32:40.227]     do.call(function(...) {
[15:32:40.227]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:40.227]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:40.227]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:40.227]             on.exit(options(oopts), add = TRUE)
[15:32:40.227]         }
[15:32:40.227]         {
[15:32:40.227]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:40.227]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:40.227]                 ...future.FUN(...future.X_jj, ...)
[15:32:40.227]             })
[15:32:40.227]         }
[15:32:40.227]     }, args = future.call.arguments)
[15:32:40.227] }
[15:32:40.228] Tweak future expression to call with '...' arguments ... DONE
[15:32:40.229] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:40.229] 
[15:32:40.229] getGlobalsAndPackages() ... DONE
[15:32:40.230] run() for 'Future' ...
[15:32:40.231] - state: 'created'
[15:32:40.231] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:40.251] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:40.251] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:40.252]   - Field: 'node'
[15:32:40.252]   - Field: 'label'
[15:32:40.252]   - Field: 'local'
[15:32:40.253]   - Field: 'owner'
[15:32:40.253]   - Field: 'envir'
[15:32:40.253]   - Field: 'workers'
[15:32:40.254]   - Field: 'packages'
[15:32:40.254]   - Field: 'gc'
[15:32:40.254]   - Field: 'conditions'
[15:32:40.254]   - Field: 'persistent'
[15:32:40.255]   - Field: 'expr'
[15:32:40.255]   - Field: 'uuid'
[15:32:40.255]   - Field: 'seed'
[15:32:40.256]   - Field: 'version'
[15:32:40.256]   - Field: 'result'
[15:32:40.256]   - Field: 'asynchronous'
[15:32:40.257]   - Field: 'calls'
[15:32:40.257]   - Field: 'globals'
[15:32:40.257]   - Field: 'stdout'
[15:32:40.258]   - Field: 'earlySignal'
[15:32:40.258]   - Field: 'lazy'
[15:32:40.258]   - Field: 'state'
[15:32:40.259] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:40.259] - Launch lazy future ...
[15:32:40.260] Packages needed by the future expression (n = 0): <none>
[15:32:40.261] Packages needed by future strategies (n = 0): <none>
[15:32:40.262] {
[15:32:40.262]     {
[15:32:40.262]         {
[15:32:40.262]             ...future.startTime <- base::Sys.time()
[15:32:40.262]             {
[15:32:40.262]                 {
[15:32:40.262]                   {
[15:32:40.262]                     {
[15:32:40.262]                       base::local({
[15:32:40.262]                         has_future <- base::requireNamespace("future", 
[15:32:40.262]                           quietly = TRUE)
[15:32:40.262]                         if (has_future) {
[15:32:40.262]                           ns <- base::getNamespace("future")
[15:32:40.262]                           version <- ns[[".package"]][["version"]]
[15:32:40.262]                           if (is.null(version)) 
[15:32:40.262]                             version <- utils::packageVersion("future")
[15:32:40.262]                         }
[15:32:40.262]                         else {
[15:32:40.262]                           version <- NULL
[15:32:40.262]                         }
[15:32:40.262]                         if (!has_future || version < "1.8.0") {
[15:32:40.262]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:40.262]                             "", base::R.version$version.string), 
[15:32:40.262]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:40.262]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:40.262]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:40.262]                               "release", "version")], collapse = " "), 
[15:32:40.262]                             hostname = base::Sys.info()[["nodename"]])
[15:32:40.262]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:40.262]                             info)
[15:32:40.262]                           info <- base::paste(info, collapse = "; ")
[15:32:40.262]                           if (!has_future) {
[15:32:40.262]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:40.262]                               info)
[15:32:40.262]                           }
[15:32:40.262]                           else {
[15:32:40.262]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:40.262]                               info, version)
[15:32:40.262]                           }
[15:32:40.262]                           base::stop(msg)
[15:32:40.262]                         }
[15:32:40.262]                       })
[15:32:40.262]                     }
[15:32:40.262]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:40.262]                     base::options(mc.cores = 1L)
[15:32:40.262]                   }
[15:32:40.262]                   ...future.strategy.old <- future::plan("list")
[15:32:40.262]                   options(future.plan = NULL)
[15:32:40.262]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:40.262]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:40.262]                 }
[15:32:40.262]                 ...future.workdir <- getwd()
[15:32:40.262]             }
[15:32:40.262]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:40.262]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:40.262]         }
[15:32:40.262]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:40.262]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:40.262]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:40.262]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:40.262]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:40.262]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:40.262]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:40.262]             base::names(...future.oldOptions))
[15:32:40.262]     }
[15:32:40.262]     if (FALSE) {
[15:32:40.262]     }
[15:32:40.262]     else {
[15:32:40.262]         if (TRUE) {
[15:32:40.262]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:40.262]                 open = "w")
[15:32:40.262]         }
[15:32:40.262]         else {
[15:32:40.262]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:40.262]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:40.262]         }
[15:32:40.262]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:40.262]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:40.262]             base::sink(type = "output", split = FALSE)
[15:32:40.262]             base::close(...future.stdout)
[15:32:40.262]         }, add = TRUE)
[15:32:40.262]     }
[15:32:40.262]     ...future.frame <- base::sys.nframe()
[15:32:40.262]     ...future.conditions <- base::list()
[15:32:40.262]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:40.262]     if (FALSE) {
[15:32:40.262]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:40.262]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:40.262]     }
[15:32:40.262]     ...future.result <- base::tryCatch({
[15:32:40.262]         base::withCallingHandlers({
[15:32:40.262]             ...future.value <- base::withVisible(base::local({
[15:32:40.262]                 ...future.makeSendCondition <- base::local({
[15:32:40.262]                   sendCondition <- NULL
[15:32:40.262]                   function(frame = 1L) {
[15:32:40.262]                     if (is.function(sendCondition)) 
[15:32:40.262]                       return(sendCondition)
[15:32:40.262]                     ns <- getNamespace("parallel")
[15:32:40.262]                     if (exists("sendData", mode = "function", 
[15:32:40.262]                       envir = ns)) {
[15:32:40.262]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:40.262]                         envir = ns)
[15:32:40.262]                       envir <- sys.frame(frame)
[15:32:40.262]                       master <- NULL
[15:32:40.262]                       while (!identical(envir, .GlobalEnv) && 
[15:32:40.262]                         !identical(envir, emptyenv())) {
[15:32:40.262]                         if (exists("master", mode = "list", envir = envir, 
[15:32:40.262]                           inherits = FALSE)) {
[15:32:40.262]                           master <- get("master", mode = "list", 
[15:32:40.262]                             envir = envir, inherits = FALSE)
[15:32:40.262]                           if (inherits(master, c("SOCKnode", 
[15:32:40.262]                             "SOCK0node"))) {
[15:32:40.262]                             sendCondition <<- function(cond) {
[15:32:40.262]                               data <- list(type = "VALUE", value = cond, 
[15:32:40.262]                                 success = TRUE)
[15:32:40.262]                               parallel_sendData(master, data)
[15:32:40.262]                             }
[15:32:40.262]                             return(sendCondition)
[15:32:40.262]                           }
[15:32:40.262]                         }
[15:32:40.262]                         frame <- frame + 1L
[15:32:40.262]                         envir <- sys.frame(frame)
[15:32:40.262]                       }
[15:32:40.262]                     }
[15:32:40.262]                     sendCondition <<- function(cond) NULL
[15:32:40.262]                   }
[15:32:40.262]                 })
[15:32:40.262]                 withCallingHandlers({
[15:32:40.262]                   {
[15:32:40.262]                     do.call(function(...) {
[15:32:40.262]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:40.262]                       if (!identical(...future.globals.maxSize.org, 
[15:32:40.262]                         ...future.globals.maxSize)) {
[15:32:40.262]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:40.262]                         on.exit(options(oopts), add = TRUE)
[15:32:40.262]                       }
[15:32:40.262]                       {
[15:32:40.262]                         lapply(seq_along(...future.elements_ii), 
[15:32:40.262]                           FUN = function(jj) {
[15:32:40.262]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:40.262]                             ...future.FUN(...future.X_jj, ...)
[15:32:40.262]                           })
[15:32:40.262]                       }
[15:32:40.262]                     }, args = future.call.arguments)
[15:32:40.262]                   }
[15:32:40.262]                 }, immediateCondition = function(cond) {
[15:32:40.262]                   sendCondition <- ...future.makeSendCondition()
[15:32:40.262]                   sendCondition(cond)
[15:32:40.262]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:40.262]                   {
[15:32:40.262]                     inherits <- base::inherits
[15:32:40.262]                     invokeRestart <- base::invokeRestart
[15:32:40.262]                     is.null <- base::is.null
[15:32:40.262]                     muffled <- FALSE
[15:32:40.262]                     if (inherits(cond, "message")) {
[15:32:40.262]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:40.262]                       if (muffled) 
[15:32:40.262]                         invokeRestart("muffleMessage")
[15:32:40.262]                     }
[15:32:40.262]                     else if (inherits(cond, "warning")) {
[15:32:40.262]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:40.262]                       if (muffled) 
[15:32:40.262]                         invokeRestart("muffleWarning")
[15:32:40.262]                     }
[15:32:40.262]                     else if (inherits(cond, "condition")) {
[15:32:40.262]                       if (!is.null(pattern)) {
[15:32:40.262]                         computeRestarts <- base::computeRestarts
[15:32:40.262]                         grepl <- base::grepl
[15:32:40.262]                         restarts <- computeRestarts(cond)
[15:32:40.262]                         for (restart in restarts) {
[15:32:40.262]                           name <- restart$name
[15:32:40.262]                           if (is.null(name)) 
[15:32:40.262]                             next
[15:32:40.262]                           if (!grepl(pattern, name)) 
[15:32:40.262]                             next
[15:32:40.262]                           invokeRestart(restart)
[15:32:40.262]                           muffled <- TRUE
[15:32:40.262]                           break
[15:32:40.262]                         }
[15:32:40.262]                       }
[15:32:40.262]                     }
[15:32:40.262]                     invisible(muffled)
[15:32:40.262]                   }
[15:32:40.262]                   muffleCondition(cond)
[15:32:40.262]                 })
[15:32:40.262]             }))
[15:32:40.262]             future::FutureResult(value = ...future.value$value, 
[15:32:40.262]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:40.262]                   ...future.rng), globalenv = if (FALSE) 
[15:32:40.262]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:40.262]                     ...future.globalenv.names))
[15:32:40.262]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:40.262]         }, condition = base::local({
[15:32:40.262]             c <- base::c
[15:32:40.262]             inherits <- base::inherits
[15:32:40.262]             invokeRestart <- base::invokeRestart
[15:32:40.262]             length <- base::length
[15:32:40.262]             list <- base::list
[15:32:40.262]             seq.int <- base::seq.int
[15:32:40.262]             signalCondition <- base::signalCondition
[15:32:40.262]             sys.calls <- base::sys.calls
[15:32:40.262]             `[[` <- base::`[[`
[15:32:40.262]             `+` <- base::`+`
[15:32:40.262]             `<<-` <- base::`<<-`
[15:32:40.262]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:40.262]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:40.262]                   3L)]
[15:32:40.262]             }
[15:32:40.262]             function(cond) {
[15:32:40.262]                 is_error <- inherits(cond, "error")
[15:32:40.262]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:40.262]                   NULL)
[15:32:40.262]                 if (is_error) {
[15:32:40.262]                   sessionInformation <- function() {
[15:32:40.262]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:40.262]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:40.262]                       search = base::search(), system = base::Sys.info())
[15:32:40.262]                   }
[15:32:40.262]                   ...future.conditions[[length(...future.conditions) + 
[15:32:40.262]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:40.262]                     cond$call), session = sessionInformation(), 
[15:32:40.262]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:40.262]                   signalCondition(cond)
[15:32:40.262]                 }
[15:32:40.262]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:40.262]                 "immediateCondition"))) {
[15:32:40.262]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:40.262]                   ...future.conditions[[length(...future.conditions) + 
[15:32:40.262]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:40.262]                   if (TRUE && !signal) {
[15:32:40.262]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:40.262]                     {
[15:32:40.262]                       inherits <- base::inherits
[15:32:40.262]                       invokeRestart <- base::invokeRestart
[15:32:40.262]                       is.null <- base::is.null
[15:32:40.262]                       muffled <- FALSE
[15:32:40.262]                       if (inherits(cond, "message")) {
[15:32:40.262]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:40.262]                         if (muffled) 
[15:32:40.262]                           invokeRestart("muffleMessage")
[15:32:40.262]                       }
[15:32:40.262]                       else if (inherits(cond, "warning")) {
[15:32:40.262]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:40.262]                         if (muffled) 
[15:32:40.262]                           invokeRestart("muffleWarning")
[15:32:40.262]                       }
[15:32:40.262]                       else if (inherits(cond, "condition")) {
[15:32:40.262]                         if (!is.null(pattern)) {
[15:32:40.262]                           computeRestarts <- base::computeRestarts
[15:32:40.262]                           grepl <- base::grepl
[15:32:40.262]                           restarts <- computeRestarts(cond)
[15:32:40.262]                           for (restart in restarts) {
[15:32:40.262]                             name <- restart$name
[15:32:40.262]                             if (is.null(name)) 
[15:32:40.262]                               next
[15:32:40.262]                             if (!grepl(pattern, name)) 
[15:32:40.262]                               next
[15:32:40.262]                             invokeRestart(restart)
[15:32:40.262]                             muffled <- TRUE
[15:32:40.262]                             break
[15:32:40.262]                           }
[15:32:40.262]                         }
[15:32:40.262]                       }
[15:32:40.262]                       invisible(muffled)
[15:32:40.262]                     }
[15:32:40.262]                     muffleCondition(cond, pattern = "^muffle")
[15:32:40.262]                   }
[15:32:40.262]                 }
[15:32:40.262]                 else {
[15:32:40.262]                   if (TRUE) {
[15:32:40.262]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:40.262]                     {
[15:32:40.262]                       inherits <- base::inherits
[15:32:40.262]                       invokeRestart <- base::invokeRestart
[15:32:40.262]                       is.null <- base::is.null
[15:32:40.262]                       muffled <- FALSE
[15:32:40.262]                       if (inherits(cond, "message")) {
[15:32:40.262]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:40.262]                         if (muffled) 
[15:32:40.262]                           invokeRestart("muffleMessage")
[15:32:40.262]                       }
[15:32:40.262]                       else if (inherits(cond, "warning")) {
[15:32:40.262]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:40.262]                         if (muffled) 
[15:32:40.262]                           invokeRestart("muffleWarning")
[15:32:40.262]                       }
[15:32:40.262]                       else if (inherits(cond, "condition")) {
[15:32:40.262]                         if (!is.null(pattern)) {
[15:32:40.262]                           computeRestarts <- base::computeRestarts
[15:32:40.262]                           grepl <- base::grepl
[15:32:40.262]                           restarts <- computeRestarts(cond)
[15:32:40.262]                           for (restart in restarts) {
[15:32:40.262]                             name <- restart$name
[15:32:40.262]                             if (is.null(name)) 
[15:32:40.262]                               next
[15:32:40.262]                             if (!grepl(pattern, name)) 
[15:32:40.262]                               next
[15:32:40.262]                             invokeRestart(restart)
[15:32:40.262]                             muffled <- TRUE
[15:32:40.262]                             break
[15:32:40.262]                           }
[15:32:40.262]                         }
[15:32:40.262]                       }
[15:32:40.262]                       invisible(muffled)
[15:32:40.262]                     }
[15:32:40.262]                     muffleCondition(cond, pattern = "^muffle")
[15:32:40.262]                   }
[15:32:40.262]                 }
[15:32:40.262]             }
[15:32:40.262]         }))
[15:32:40.262]     }, error = function(ex) {
[15:32:40.262]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:40.262]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:40.262]                 ...future.rng), started = ...future.startTime, 
[15:32:40.262]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:40.262]             version = "1.8"), class = "FutureResult")
[15:32:40.262]     }, finally = {
[15:32:40.262]         if (!identical(...future.workdir, getwd())) 
[15:32:40.262]             setwd(...future.workdir)
[15:32:40.262]         {
[15:32:40.262]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:40.262]                 ...future.oldOptions$nwarnings <- NULL
[15:32:40.262]             }
[15:32:40.262]             base::options(...future.oldOptions)
[15:32:40.262]             if (.Platform$OS.type == "windows") {
[15:32:40.262]                 old_names <- names(...future.oldEnvVars)
[15:32:40.262]                 envs <- base::Sys.getenv()
[15:32:40.262]                 names <- names(envs)
[15:32:40.262]                 common <- intersect(names, old_names)
[15:32:40.262]                 added <- setdiff(names, old_names)
[15:32:40.262]                 removed <- setdiff(old_names, names)
[15:32:40.262]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:40.262]                   envs[common]]
[15:32:40.262]                 NAMES <- toupper(changed)
[15:32:40.262]                 args <- list()
[15:32:40.262]                 for (kk in seq_along(NAMES)) {
[15:32:40.262]                   name <- changed[[kk]]
[15:32:40.262]                   NAME <- NAMES[[kk]]
[15:32:40.262]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:40.262]                     next
[15:32:40.262]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:40.262]                 }
[15:32:40.262]                 NAMES <- toupper(added)
[15:32:40.262]                 for (kk in seq_along(NAMES)) {
[15:32:40.262]                   name <- added[[kk]]
[15:32:40.262]                   NAME <- NAMES[[kk]]
[15:32:40.262]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:40.262]                     next
[15:32:40.262]                   args[[name]] <- ""
[15:32:40.262]                 }
[15:32:40.262]                 NAMES <- toupper(removed)
[15:32:40.262]                 for (kk in seq_along(NAMES)) {
[15:32:40.262]                   name <- removed[[kk]]
[15:32:40.262]                   NAME <- NAMES[[kk]]
[15:32:40.262]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:40.262]                     next
[15:32:40.262]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:40.262]                 }
[15:32:40.262]                 if (length(args) > 0) 
[15:32:40.262]                   base::do.call(base::Sys.setenv, args = args)
[15:32:40.262]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:40.262]             }
[15:32:40.262]             else {
[15:32:40.262]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:40.262]             }
[15:32:40.262]             {
[15:32:40.262]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:40.262]                   0L) {
[15:32:40.262]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:40.262]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:40.262]                   base::options(opts)
[15:32:40.262]                 }
[15:32:40.262]                 {
[15:32:40.262]                   {
[15:32:40.262]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:40.262]                     NULL
[15:32:40.262]                   }
[15:32:40.262]                   options(future.plan = NULL)
[15:32:40.262]                   if (is.na(NA_character_)) 
[15:32:40.262]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:40.262]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:40.262]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:40.262]                     .init = FALSE)
[15:32:40.262]                 }
[15:32:40.262]             }
[15:32:40.262]         }
[15:32:40.262]     })
[15:32:40.262]     if (TRUE) {
[15:32:40.262]         base::sink(type = "output", split = FALSE)
[15:32:40.262]         if (TRUE) {
[15:32:40.262]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:40.262]         }
[15:32:40.262]         else {
[15:32:40.262]             ...future.result["stdout"] <- base::list(NULL)
[15:32:40.262]         }
[15:32:40.262]         base::close(...future.stdout)
[15:32:40.262]         ...future.stdout <- NULL
[15:32:40.262]     }
[15:32:40.262]     ...future.result$conditions <- ...future.conditions
[15:32:40.262]     ...future.result$finished <- base::Sys.time()
[15:32:40.262]     ...future.result
[15:32:40.262] }
[15:32:40.272] Exporting 5 global objects (4.62 KiB) to cluster node #1 ...
[15:32:40.273] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ...
[15:32:40.273] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ... DONE
[15:32:40.274] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:40.275] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:40.275] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:40.276] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:40.276] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:40.277] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:40.277] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:40.278] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:40.278] Exporting 5 global objects (4.62 KiB) to cluster node #1 ... DONE
[15:32:40.279] MultisessionFuture started
[15:32:40.279] - Launch lazy future ... done
[15:32:40.280] run() for 'MultisessionFuture' ... done
[15:32:40.280] Created future:
[15:32:40.306] receiveMessageFromWorker() for ClusterFuture ...
[15:32:40.307] - Validating connection of MultisessionFuture
[15:32:40.307] - received message: FutureResult
[15:32:40.308] - Received FutureResult
[15:32:40.308] - Erased future from FutureRegistry
[15:32:40.308] result() for ClusterFuture ...
[15:32:40.309] - result already collected: FutureResult
[15:32:40.309] result() for ClusterFuture ... done
[15:32:40.309] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:40.280] MultisessionFuture:
[15:32:40.280] Label: 'future_sapply-1'
[15:32:40.280] Expression:
[15:32:40.280] {
[15:32:40.280]     do.call(function(...) {
[15:32:40.280]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:40.280]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:40.280]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:40.280]             on.exit(options(oopts), add = TRUE)
[15:32:40.280]         }
[15:32:40.280]         {
[15:32:40.280]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:40.280]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:40.280]                 ...future.FUN(...future.X_jj, ...)
[15:32:40.280]             })
[15:32:40.280]         }
[15:32:40.280]     }, args = future.call.arguments)
[15:32:40.280] }
[15:32:40.280] Lazy evaluation: FALSE
[15:32:40.280] Asynchronous evaluation: TRUE
[15:32:40.280] Local evaluation: TRUE
[15:32:40.280] Environment: R_GlobalEnv
[15:32:40.280] Capture standard output: TRUE
[15:32:40.280] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:40.280] Globals: 5 objects totaling 4.73 KiB (function '...future.FUN' of 4.62 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)
[15:32:40.280] Packages: <none>
[15:32:40.280] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:40.280] Resolved: TRUE
[15:32:40.280] Value: <not collected>
[15:32:40.280] Conditions captured: <none>
[15:32:40.280] Early signaling: FALSE
[15:32:40.280] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:40.280] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:40.310] Chunk #1 of 2 ... DONE
[15:32:40.310] Chunk #2 of 2 ...
[15:32:40.310]  - Finding globals in 'X' for chunk #2 ...
[15:32:40.311] getGlobalsAndPackages() ...
[15:32:40.311] Searching for globals...
[15:32:40.312] 
[15:32:40.312] Searching for globals ... DONE
[15:32:40.312] - globals: [0] <none>
[15:32:40.312] getGlobalsAndPackages() ... DONE
[15:32:40.313]    + additional globals found: [n=0] 
[15:32:40.313]    + additional namespaces needed: [n=0] 
[15:32:40.313]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:40.313]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:40.314]  - seeds: <none>
[15:32:40.314]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:40.314] getGlobalsAndPackages() ...
[15:32:40.314] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:40.315] Resolving globals: FALSE
[15:32:40.315] Tweak future expression to call with '...' arguments ...
[15:32:40.315] {
[15:32:40.315]     do.call(function(...) {
[15:32:40.315]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:40.315]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:40.315]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:40.315]             on.exit(options(oopts), add = TRUE)
[15:32:40.315]         }
[15:32:40.315]         {
[15:32:40.315]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:40.315]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:40.315]                 ...future.FUN(...future.X_jj, ...)
[15:32:40.315]             })
[15:32:40.315]         }
[15:32:40.315]     }, args = future.call.arguments)
[15:32:40.315] }
[15:32:40.316] Tweak future expression to call with '...' arguments ... DONE
[15:32:40.317] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:40.317] 
[15:32:40.318] getGlobalsAndPackages() ... DONE
[15:32:40.318] run() for 'Future' ...
[15:32:40.319] - state: 'created'
[15:32:40.319] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:40.337] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:40.337] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:40.337]   - Field: 'node'
[15:32:40.338]   - Field: 'label'
[15:32:40.338]   - Field: 'local'
[15:32:40.338]   - Field: 'owner'
[15:32:40.339]   - Field: 'envir'
[15:32:40.339]   - Field: 'workers'
[15:32:40.339]   - Field: 'packages'
[15:32:40.340]   - Field: 'gc'
[15:32:40.340]   - Field: 'conditions'
[15:32:40.340]   - Field: 'persistent'
[15:32:40.341]   - Field: 'expr'
[15:32:40.341]   - Field: 'uuid'
[15:32:40.341]   - Field: 'seed'
[15:32:40.342]   - Field: 'version'
[15:32:40.342]   - Field: 'result'
[15:32:40.342]   - Field: 'asynchronous'
[15:32:40.342]   - Field: 'calls'
[15:32:40.343]   - Field: 'globals'
[15:32:40.343]   - Field: 'stdout'
[15:32:40.343]   - Field: 'earlySignal'
[15:32:40.344]   - Field: 'lazy'
[15:32:40.344]   - Field: 'state'
[15:32:40.344] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:40.345] - Launch lazy future ...
[15:32:40.345] Packages needed by the future expression (n = 0): <none>
[15:32:40.352] Packages needed by future strategies (n = 0): <none>
[15:32:40.353] {
[15:32:40.353]     {
[15:32:40.353]         {
[15:32:40.353]             ...future.startTime <- base::Sys.time()
[15:32:40.353]             {
[15:32:40.353]                 {
[15:32:40.353]                   {
[15:32:40.353]                     {
[15:32:40.353]                       base::local({
[15:32:40.353]                         has_future <- base::requireNamespace("future", 
[15:32:40.353]                           quietly = TRUE)
[15:32:40.353]                         if (has_future) {
[15:32:40.353]                           ns <- base::getNamespace("future")
[15:32:40.353]                           version <- ns[[".package"]][["version"]]
[15:32:40.353]                           if (is.null(version)) 
[15:32:40.353]                             version <- utils::packageVersion("future")
[15:32:40.353]                         }
[15:32:40.353]                         else {
[15:32:40.353]                           version <- NULL
[15:32:40.353]                         }
[15:32:40.353]                         if (!has_future || version < "1.8.0") {
[15:32:40.353]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:40.353]                             "", base::R.version$version.string), 
[15:32:40.353]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:40.353]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:40.353]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:40.353]                               "release", "version")], collapse = " "), 
[15:32:40.353]                             hostname = base::Sys.info()[["nodename"]])
[15:32:40.353]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:40.353]                             info)
[15:32:40.353]                           info <- base::paste(info, collapse = "; ")
[15:32:40.353]                           if (!has_future) {
[15:32:40.353]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:40.353]                               info)
[15:32:40.353]                           }
[15:32:40.353]                           else {
[15:32:40.353]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:40.353]                               info, version)
[15:32:40.353]                           }
[15:32:40.353]                           base::stop(msg)
[15:32:40.353]                         }
[15:32:40.353]                       })
[15:32:40.353]                     }
[15:32:40.353]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:40.353]                     base::options(mc.cores = 1L)
[15:32:40.353]                   }
[15:32:40.353]                   ...future.strategy.old <- future::plan("list")
[15:32:40.353]                   options(future.plan = NULL)
[15:32:40.353]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:40.353]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:40.353]                 }
[15:32:40.353]                 ...future.workdir <- getwd()
[15:32:40.353]             }
[15:32:40.353]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:40.353]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:40.353]         }
[15:32:40.353]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:40.353]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:40.353]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:40.353]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:40.353]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:40.353]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:40.353]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:40.353]             base::names(...future.oldOptions))
[15:32:40.353]     }
[15:32:40.353]     if (FALSE) {
[15:32:40.353]     }
[15:32:40.353]     else {
[15:32:40.353]         if (TRUE) {
[15:32:40.353]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:40.353]                 open = "w")
[15:32:40.353]         }
[15:32:40.353]         else {
[15:32:40.353]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:40.353]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:40.353]         }
[15:32:40.353]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:40.353]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:40.353]             base::sink(type = "output", split = FALSE)
[15:32:40.353]             base::close(...future.stdout)
[15:32:40.353]         }, add = TRUE)
[15:32:40.353]     }
[15:32:40.353]     ...future.frame <- base::sys.nframe()
[15:32:40.353]     ...future.conditions <- base::list()
[15:32:40.353]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:40.353]     if (FALSE) {
[15:32:40.353]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:40.353]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:40.353]     }
[15:32:40.353]     ...future.result <- base::tryCatch({
[15:32:40.353]         base::withCallingHandlers({
[15:32:40.353]             ...future.value <- base::withVisible(base::local({
[15:32:40.353]                 ...future.makeSendCondition <- base::local({
[15:32:40.353]                   sendCondition <- NULL
[15:32:40.353]                   function(frame = 1L) {
[15:32:40.353]                     if (is.function(sendCondition)) 
[15:32:40.353]                       return(sendCondition)
[15:32:40.353]                     ns <- getNamespace("parallel")
[15:32:40.353]                     if (exists("sendData", mode = "function", 
[15:32:40.353]                       envir = ns)) {
[15:32:40.353]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:40.353]                         envir = ns)
[15:32:40.353]                       envir <- sys.frame(frame)
[15:32:40.353]                       master <- NULL
[15:32:40.353]                       while (!identical(envir, .GlobalEnv) && 
[15:32:40.353]                         !identical(envir, emptyenv())) {
[15:32:40.353]                         if (exists("master", mode = "list", envir = envir, 
[15:32:40.353]                           inherits = FALSE)) {
[15:32:40.353]                           master <- get("master", mode = "list", 
[15:32:40.353]                             envir = envir, inherits = FALSE)
[15:32:40.353]                           if (inherits(master, c("SOCKnode", 
[15:32:40.353]                             "SOCK0node"))) {
[15:32:40.353]                             sendCondition <<- function(cond) {
[15:32:40.353]                               data <- list(type = "VALUE", value = cond, 
[15:32:40.353]                                 success = TRUE)
[15:32:40.353]                               parallel_sendData(master, data)
[15:32:40.353]                             }
[15:32:40.353]                             return(sendCondition)
[15:32:40.353]                           }
[15:32:40.353]                         }
[15:32:40.353]                         frame <- frame + 1L
[15:32:40.353]                         envir <- sys.frame(frame)
[15:32:40.353]                       }
[15:32:40.353]                     }
[15:32:40.353]                     sendCondition <<- function(cond) NULL
[15:32:40.353]                   }
[15:32:40.353]                 })
[15:32:40.353]                 withCallingHandlers({
[15:32:40.353]                   {
[15:32:40.353]                     do.call(function(...) {
[15:32:40.353]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:40.353]                       if (!identical(...future.globals.maxSize.org, 
[15:32:40.353]                         ...future.globals.maxSize)) {
[15:32:40.353]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:40.353]                         on.exit(options(oopts), add = TRUE)
[15:32:40.353]                       }
[15:32:40.353]                       {
[15:32:40.353]                         lapply(seq_along(...future.elements_ii), 
[15:32:40.353]                           FUN = function(jj) {
[15:32:40.353]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:40.353]                             ...future.FUN(...future.X_jj, ...)
[15:32:40.353]                           })
[15:32:40.353]                       }
[15:32:40.353]                     }, args = future.call.arguments)
[15:32:40.353]                   }
[15:32:40.353]                 }, immediateCondition = function(cond) {
[15:32:40.353]                   sendCondition <- ...future.makeSendCondition()
[15:32:40.353]                   sendCondition(cond)
[15:32:40.353]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:40.353]                   {
[15:32:40.353]                     inherits <- base::inherits
[15:32:40.353]                     invokeRestart <- base::invokeRestart
[15:32:40.353]                     is.null <- base::is.null
[15:32:40.353]                     muffled <- FALSE
[15:32:40.353]                     if (inherits(cond, "message")) {
[15:32:40.353]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:40.353]                       if (muffled) 
[15:32:40.353]                         invokeRestart("muffleMessage")
[15:32:40.353]                     }
[15:32:40.353]                     else if (inherits(cond, "warning")) {
[15:32:40.353]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:40.353]                       if (muffled) 
[15:32:40.353]                         invokeRestart("muffleWarning")
[15:32:40.353]                     }
[15:32:40.353]                     else if (inherits(cond, "condition")) {
[15:32:40.353]                       if (!is.null(pattern)) {
[15:32:40.353]                         computeRestarts <- base::computeRestarts
[15:32:40.353]                         grepl <- base::grepl
[15:32:40.353]                         restarts <- computeRestarts(cond)
[15:32:40.353]                         for (restart in restarts) {
[15:32:40.353]                           name <- restart$name
[15:32:40.353]                           if (is.null(name)) 
[15:32:40.353]                             next
[15:32:40.353]                           if (!grepl(pattern, name)) 
[15:32:40.353]                             next
[15:32:40.353]                           invokeRestart(restart)
[15:32:40.353]                           muffled <- TRUE
[15:32:40.353]                           break
[15:32:40.353]                         }
[15:32:40.353]                       }
[15:32:40.353]                     }
[15:32:40.353]                     invisible(muffled)
[15:32:40.353]                   }
[15:32:40.353]                   muffleCondition(cond)
[15:32:40.353]                 })
[15:32:40.353]             }))
[15:32:40.353]             future::FutureResult(value = ...future.value$value, 
[15:32:40.353]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:40.353]                   ...future.rng), globalenv = if (FALSE) 
[15:32:40.353]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:40.353]                     ...future.globalenv.names))
[15:32:40.353]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:40.353]         }, condition = base::local({
[15:32:40.353]             c <- base::c
[15:32:40.353]             inherits <- base::inherits
[15:32:40.353]             invokeRestart <- base::invokeRestart
[15:32:40.353]             length <- base::length
[15:32:40.353]             list <- base::list
[15:32:40.353]             seq.int <- base::seq.int
[15:32:40.353]             signalCondition <- base::signalCondition
[15:32:40.353]             sys.calls <- base::sys.calls
[15:32:40.353]             `[[` <- base::`[[`
[15:32:40.353]             `+` <- base::`+`
[15:32:40.353]             `<<-` <- base::`<<-`
[15:32:40.353]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:40.353]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:40.353]                   3L)]
[15:32:40.353]             }
[15:32:40.353]             function(cond) {
[15:32:40.353]                 is_error <- inherits(cond, "error")
[15:32:40.353]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:40.353]                   NULL)
[15:32:40.353]                 if (is_error) {
[15:32:40.353]                   sessionInformation <- function() {
[15:32:40.353]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:40.353]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:40.353]                       search = base::search(), system = base::Sys.info())
[15:32:40.353]                   }
[15:32:40.353]                   ...future.conditions[[length(...future.conditions) + 
[15:32:40.353]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:40.353]                     cond$call), session = sessionInformation(), 
[15:32:40.353]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:40.353]                   signalCondition(cond)
[15:32:40.353]                 }
[15:32:40.353]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:40.353]                 "immediateCondition"))) {
[15:32:40.353]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:40.353]                   ...future.conditions[[length(...future.conditions) + 
[15:32:40.353]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:40.353]                   if (TRUE && !signal) {
[15:32:40.353]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:40.353]                     {
[15:32:40.353]                       inherits <- base::inherits
[15:32:40.353]                       invokeRestart <- base::invokeRestart
[15:32:40.353]                       is.null <- base::is.null
[15:32:40.353]                       muffled <- FALSE
[15:32:40.353]                       if (inherits(cond, "message")) {
[15:32:40.353]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:40.353]                         if (muffled) 
[15:32:40.353]                           invokeRestart("muffleMessage")
[15:32:40.353]                       }
[15:32:40.353]                       else if (inherits(cond, "warning")) {
[15:32:40.353]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:40.353]                         if (muffled) 
[15:32:40.353]                           invokeRestart("muffleWarning")
[15:32:40.353]                       }
[15:32:40.353]                       else if (inherits(cond, "condition")) {
[15:32:40.353]                         if (!is.null(pattern)) {
[15:32:40.353]                           computeRestarts <- base::computeRestarts
[15:32:40.353]                           grepl <- base::grepl
[15:32:40.353]                           restarts <- computeRestarts(cond)
[15:32:40.353]                           for (restart in restarts) {
[15:32:40.353]                             name <- restart$name
[15:32:40.353]                             if (is.null(name)) 
[15:32:40.353]                               next
[15:32:40.353]                             if (!grepl(pattern, name)) 
[15:32:40.353]                               next
[15:32:40.353]                             invokeRestart(restart)
[15:32:40.353]                             muffled <- TRUE
[15:32:40.353]                             break
[15:32:40.353]                           }
[15:32:40.353]                         }
[15:32:40.353]                       }
[15:32:40.353]                       invisible(muffled)
[15:32:40.353]                     }
[15:32:40.353]                     muffleCondition(cond, pattern = "^muffle")
[15:32:40.353]                   }
[15:32:40.353]                 }
[15:32:40.353]                 else {
[15:32:40.353]                   if (TRUE) {
[15:32:40.353]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:40.353]                     {
[15:32:40.353]                       inherits <- base::inherits
[15:32:40.353]                       invokeRestart <- base::invokeRestart
[15:32:40.353]                       is.null <- base::is.null
[15:32:40.353]                       muffled <- FALSE
[15:32:40.353]                       if (inherits(cond, "message")) {
[15:32:40.353]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:40.353]                         if (muffled) 
[15:32:40.353]                           invokeRestart("muffleMessage")
[15:32:40.353]                       }
[15:32:40.353]                       else if (inherits(cond, "warning")) {
[15:32:40.353]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:40.353]                         if (muffled) 
[15:32:40.353]                           invokeRestart("muffleWarning")
[15:32:40.353]                       }
[15:32:40.353]                       else if (inherits(cond, "condition")) {
[15:32:40.353]                         if (!is.null(pattern)) {
[15:32:40.353]                           computeRestarts <- base::computeRestarts
[15:32:40.353]                           grepl <- base::grepl
[15:32:40.353]                           restarts <- computeRestarts(cond)
[15:32:40.353]                           for (restart in restarts) {
[15:32:40.353]                             name <- restart$name
[15:32:40.353]                             if (is.null(name)) 
[15:32:40.353]                               next
[15:32:40.353]                             if (!grepl(pattern, name)) 
[15:32:40.353]                               next
[15:32:40.353]                             invokeRestart(restart)
[15:32:40.353]                             muffled <- TRUE
[15:32:40.353]                             break
[15:32:40.353]                           }
[15:32:40.353]                         }
[15:32:40.353]                       }
[15:32:40.353]                       invisible(muffled)
[15:32:40.353]                     }
[15:32:40.353]                     muffleCondition(cond, pattern = "^muffle")
[15:32:40.353]                   }
[15:32:40.353]                 }
[15:32:40.353]             }
[15:32:40.353]         }))
[15:32:40.353]     }, error = function(ex) {
[15:32:40.353]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:40.353]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:40.353]                 ...future.rng), started = ...future.startTime, 
[15:32:40.353]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:40.353]             version = "1.8"), class = "FutureResult")
[15:32:40.353]     }, finally = {
[15:32:40.353]         if (!identical(...future.workdir, getwd())) 
[15:32:40.353]             setwd(...future.workdir)
[15:32:40.353]         {
[15:32:40.353]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:40.353]                 ...future.oldOptions$nwarnings <- NULL
[15:32:40.353]             }
[15:32:40.353]             base::options(...future.oldOptions)
[15:32:40.353]             if (.Platform$OS.type == "windows") {
[15:32:40.353]                 old_names <- names(...future.oldEnvVars)
[15:32:40.353]                 envs <- base::Sys.getenv()
[15:32:40.353]                 names <- names(envs)
[15:32:40.353]                 common <- intersect(names, old_names)
[15:32:40.353]                 added <- setdiff(names, old_names)
[15:32:40.353]                 removed <- setdiff(old_names, names)
[15:32:40.353]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:40.353]                   envs[common]]
[15:32:40.353]                 NAMES <- toupper(changed)
[15:32:40.353]                 args <- list()
[15:32:40.353]                 for (kk in seq_along(NAMES)) {
[15:32:40.353]                   name <- changed[[kk]]
[15:32:40.353]                   NAME <- NAMES[[kk]]
[15:32:40.353]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:40.353]                     next
[15:32:40.353]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:40.353]                 }
[15:32:40.353]                 NAMES <- toupper(added)
[15:32:40.353]                 for (kk in seq_along(NAMES)) {
[15:32:40.353]                   name <- added[[kk]]
[15:32:40.353]                   NAME <- NAMES[[kk]]
[15:32:40.353]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:40.353]                     next
[15:32:40.353]                   args[[name]] <- ""
[15:32:40.353]                 }
[15:32:40.353]                 NAMES <- toupper(removed)
[15:32:40.353]                 for (kk in seq_along(NAMES)) {
[15:32:40.353]                   name <- removed[[kk]]
[15:32:40.353]                   NAME <- NAMES[[kk]]
[15:32:40.353]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:40.353]                     next
[15:32:40.353]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:40.353]                 }
[15:32:40.353]                 if (length(args) > 0) 
[15:32:40.353]                   base::do.call(base::Sys.setenv, args = args)
[15:32:40.353]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:40.353]             }
[15:32:40.353]             else {
[15:32:40.353]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:40.353]             }
[15:32:40.353]             {
[15:32:40.353]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:40.353]                   0L) {
[15:32:40.353]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:40.353]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:40.353]                   base::options(opts)
[15:32:40.353]                 }
[15:32:40.353]                 {
[15:32:40.353]                   {
[15:32:40.353]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:40.353]                     NULL
[15:32:40.353]                   }
[15:32:40.353]                   options(future.plan = NULL)
[15:32:40.353]                   if (is.na(NA_character_)) 
[15:32:40.353]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:40.353]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:40.353]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:40.353]                     .init = FALSE)
[15:32:40.353]                 }
[15:32:40.353]             }
[15:32:40.353]         }
[15:32:40.353]     })
[15:32:40.353]     if (TRUE) {
[15:32:40.353]         base::sink(type = "output", split = FALSE)
[15:32:40.353]         if (TRUE) {
[15:32:40.353]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:40.353]         }
[15:32:40.353]         else {
[15:32:40.353]             ...future.result["stdout"] <- base::list(NULL)
[15:32:40.353]         }
[15:32:40.353]         base::close(...future.stdout)
[15:32:40.353]         ...future.stdout <- NULL
[15:32:40.353]     }
[15:32:40.353]     ...future.result$conditions <- ...future.conditions
[15:32:40.353]     ...future.result$finished <- base::Sys.time()
[15:32:40.353]     ...future.result
[15:32:40.353] }
[15:32:40.363] Exporting 5 global objects (4.62 KiB) to cluster node #1 ...
[15:32:40.363] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ...
[15:32:40.364] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ... DONE
[15:32:40.364] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:40.365] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:40.365] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:40.366] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:40.366] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:40.367] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:40.367] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:40.368] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:40.368] Exporting 5 global objects (4.62 KiB) to cluster node #1 ... DONE
[15:32:40.369] MultisessionFuture started
[15:32:40.369] - Launch lazy future ... done
[15:32:40.370] run() for 'MultisessionFuture' ... done
[15:32:40.370] Created future:
[15:32:40.396] receiveMessageFromWorker() for ClusterFuture ...
[15:32:40.397] - Validating connection of MultisessionFuture
[15:32:40.397] - received message: FutureResult
[15:32:40.398] - Received FutureResult
[15:32:40.398] - Erased future from FutureRegistry
[15:32:40.398] result() for ClusterFuture ...
[15:32:40.399] - result already collected: FutureResult
[15:32:40.399] result() for ClusterFuture ... done
[15:32:40.399] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:40.370] MultisessionFuture:
[15:32:40.370] Label: 'future_sapply-2'
[15:32:40.370] Expression:
[15:32:40.370] {
[15:32:40.370]     do.call(function(...) {
[15:32:40.370]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:40.370]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:40.370]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:40.370]             on.exit(options(oopts), add = TRUE)
[15:32:40.370]         }
[15:32:40.370]         {
[15:32:40.370]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:40.370]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:40.370]                 ...future.FUN(...future.X_jj, ...)
[15:32:40.370]             })
[15:32:40.370]         }
[15:32:40.370]     }, args = future.call.arguments)
[15:32:40.370] }
[15:32:40.370] Lazy evaluation: FALSE
[15:32:40.370] Asynchronous evaluation: TRUE
[15:32:40.370] Local evaluation: TRUE
[15:32:40.370] Environment: R_GlobalEnv
[15:32:40.370] Capture standard output: TRUE
[15:32:40.370] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:40.370] Globals: 5 objects totaling 4.73 KiB (function '...future.FUN' of 4.62 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)
[15:32:40.370] Packages: <none>
[15:32:40.370] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:40.370] Resolved: TRUE
[15:32:40.370] Value: <not collected>
[15:32:40.370] Conditions captured: <none>
[15:32:40.370] Early signaling: FALSE
[15:32:40.370] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:40.370] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:40.400] Chunk #2 of 2 ... DONE
[15:32:40.400] Launching 2 futures (chunks) ... DONE
[15:32:40.401] Resolving 2 futures (chunks) ...
[15:32:40.401] resolve() on list ...
[15:32:40.401]  recursive: 0
[15:32:40.401]  length: 2
[15:32:40.402] 
[15:32:40.402] Future #1
[15:32:40.402] result() for ClusterFuture ...
[15:32:40.403] - result already collected: FutureResult
[15:32:40.403] result() for ClusterFuture ... done
[15:32:40.403] result() for ClusterFuture ...
[15:32:40.403] - result already collected: FutureResult
[15:32:40.404] result() for ClusterFuture ... done
[15:32:40.404] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:40.404] - nx: 2
[15:32:40.404] - relay: TRUE
[15:32:40.405] - stdout: TRUE
[15:32:40.405] - signal: TRUE
[15:32:40.405] - resignal: FALSE
[15:32:40.405] - force: TRUE
[15:32:40.406] - relayed: [n=2] FALSE, FALSE
[15:32:40.406] - queued futures: [n=2] FALSE, FALSE
[15:32:40.406]  - until=1
[15:32:40.406]  - relaying element #1
[15:32:40.407] result() for ClusterFuture ...
[15:32:40.407] - result already collected: FutureResult
[15:32:40.407] result() for ClusterFuture ... done
[15:32:40.408] result() for ClusterFuture ...
[15:32:40.408] - result already collected: FutureResult
[15:32:40.408] result() for ClusterFuture ... done
[15:32:40.408] result() for ClusterFuture ...
[15:32:40.409] - result already collected: FutureResult
[15:32:40.409] result() for ClusterFuture ... done
[15:32:40.409] result() for ClusterFuture ...
[15:32:40.409] - result already collected: FutureResult
[15:32:40.410] result() for ClusterFuture ... done
[15:32:40.410] - relayed: [n=2] TRUE, FALSE
[15:32:40.410] - queued futures: [n=2] TRUE, FALSE
[15:32:40.410] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:40.411]  length: 1 (resolved future 1)
[15:32:40.411] Future #2
[15:32:40.411] result() for ClusterFuture ...
[15:32:40.412] - result already collected: FutureResult
[15:32:40.412] result() for ClusterFuture ... done
[15:32:40.412] result() for ClusterFuture ...
[15:32:40.412] - result already collected: FutureResult
[15:32:40.413] result() for ClusterFuture ... done
[15:32:40.413] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:40.413] - nx: 2
[15:32:40.414] - relay: TRUE
[15:32:40.414] - stdout: TRUE
[15:32:40.414] - signal: TRUE
[15:32:40.414] - resignal: FALSE
[15:32:40.415] - force: TRUE
[15:32:40.415] - relayed: [n=2] TRUE, FALSE
[15:32:40.415] - queued futures: [n=2] TRUE, FALSE
[15:32:40.415]  - until=2
[15:32:40.416]  - relaying element #2
[15:32:40.416] result() for ClusterFuture ...
[15:32:40.416] - result already collected: FutureResult
[15:32:40.416] result() for ClusterFuture ... done
[15:32:40.417] result() for ClusterFuture ...
[15:32:40.417] - result already collected: FutureResult
[15:32:40.417] result() for ClusterFuture ... done
[15:32:40.418] result() for ClusterFuture ...
[15:32:40.418] - result already collected: FutureResult
[15:32:40.418] result() for ClusterFuture ... done
[15:32:40.418] result() for ClusterFuture ...
[15:32:40.419] - result already collected: FutureResult
[15:32:40.419] result() for ClusterFuture ... done
[15:32:40.419] - relayed: [n=2] TRUE, TRUE
[15:32:40.419] - queued futures: [n=2] TRUE, TRUE
[15:32:40.420] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:40.420]  length: 0 (resolved future 2)
[15:32:40.420] Relaying remaining futures
[15:32:40.421] signalConditionsASAP(NULL, pos=0) ...
[15:32:40.421] - nx: 2
[15:32:40.421] - relay: TRUE
[15:32:40.421] - stdout: TRUE
[15:32:40.422] - signal: TRUE
[15:32:40.422] - resignal: FALSE
[15:32:40.422] - force: TRUE
[15:32:40.422] - relayed: [n=2] TRUE, TRUE
[15:32:40.423] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:40.423] - relayed: [n=2] TRUE, TRUE
[15:32:40.423] - queued futures: [n=2] TRUE, TRUE
[15:32:40.424] signalConditionsASAP(NULL, pos=0) ... done
[15:32:40.424] resolve() on list ... DONE
[15:32:40.424] result() for ClusterFuture ...
[15:32:40.425] - result already collected: FutureResult
[15:32:40.425] result() for ClusterFuture ... done
[15:32:40.425] result() for ClusterFuture ...
[15:32:40.425] - result already collected: FutureResult
[15:32:40.426] result() for ClusterFuture ... done
[15:32:40.426] result() for ClusterFuture ...
[15:32:40.426] - result already collected: FutureResult
[15:32:40.426] result() for ClusterFuture ... done
[15:32:40.427] result() for ClusterFuture ...
[15:32:40.427] - result already collected: FutureResult
[15:32:40.427] result() for ClusterFuture ... done
[15:32:40.428]  - Number of value chunks collected: 2
[15:32:40.428] Resolving 2 futures (chunks) ... DONE
[15:32:40.428] Reducing values from 2 chunks ...
[15:32:40.428]  - Number of values collected after concatenation: 4
[15:32:40.429]  - Number of values expected: 4
[15:32:40.429] Reducing values from 2 chunks ... DONE
[15:32:40.429] future_lapply() ... DONE
List of 2
 $ y0:List of 4
  ..$ A: num [1:3, 1:5] 100 100 100 200 200 200 300 300 300 400 ...
  ..$ B: num [1:3, 1:5] 120 120 120 240 240 240 360 360 360 480 ...
  ..$ C: num [1:3, 1:5] 140 140 140 280 280 280 420 420 420 560 ...
  ..$ D: num [1:3, 1:5] 160 160 160 320 320 320 480 480 480 640 ...
 $ y1:List of 4
  ..$ A: num [1:3, 1:5] 100 100 100 200 200 200 300 300 300 400 ...
  ..$ B: num [1:3, 1:5] 120 120 120 240 240 240 360 360 360 480 ...
  ..$ C: num [1:3, 1:5] 140 140 140 280 280 280 420 420 420 560 ...
  ..$ D: num [1:3, 1:5] 160 160 160 320 320 320 480 480 480 640 ...
List of 2
 $ y0:List of 4
  ..$ A: num [1:3, 1:5] 100 100 100 200 200 200 300 300 300 400 ...
  ..$ B: num [1:3, 1:5] 120 120 120 240 240 240 360 360 360 480 ...
  ..$ C: num [1:3, 1:5] 140 140 140 280 280 280 420 420 420 560 ...
  ..$ D: num [1:3, 1:5] 160 160 160 320 320 320 480 480 480 640 ...
 $ y2:List of 4
  ..$ A: num [1:3, 1:5] 100 100 100 200 200 200 300 300 300 400 ...
  ..$ B: num [1:3, 1:5] 120 120 120 240 240 240 360 360 360 480 ...
  ..$ C: num [1:3, 1:5] 140 140 140 280 280 280 420 420 420 560 ...
  ..$ D: num [1:3, 1:5] 160 160 160 320 320 320 480 480 480 640 ...
[15:32:40.444] future_lapply() ...
[15:32:40.449] Number of chunks: 2
[15:32:40.449] getGlobalsAndPackagesXApply() ...
[15:32:40.450]  - future.globals: TRUE
[15:32:40.450] getGlobalsAndPackages() ...
[15:32:40.450] Searching for globals...
[15:32:40.452] - globals found: [1] 'FUN'
[15:32:40.453] Searching for globals ... DONE
[15:32:40.453] Resolving globals: FALSE
[15:32:40.454] The total size of the 1 globals is 848 bytes (848 bytes)
[15:32:40.454] The total size of the 1 globals exported for future expression ('FUN()') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:32:40.455] - globals: [1] 'FUN'
[15:32:40.455] 
[15:32:40.455] getGlobalsAndPackages() ... DONE
[15:32:40.455]  - globals found/used: [n=1] 'FUN'
[15:32:40.456]  - needed namespaces: [n=0] 
[15:32:40.456] Finding globals ... DONE
[15:32:40.456]  - use_args: TRUE
[15:32:40.456]  - Getting '...' globals ...
[15:32:40.457] resolve() on list ...
[15:32:40.457]  recursive: 0
[15:32:40.458]  length: 1
[15:32:40.458]  elements: '...'
[15:32:40.458]  length: 0 (resolved future 1)
[15:32:40.459] resolve() on list ... DONE
[15:32:40.459]    - '...' content: [n=0] 
[15:32:40.459] List of 1
[15:32:40.459]  $ ...: list()
[15:32:40.459]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:40.459]  - attr(*, "where")=List of 1
[15:32:40.459]   ..$ ...:<environment: 0x00000276de89aac8> 
[15:32:40.459]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:40.459]  - attr(*, "resolved")= logi TRUE
[15:32:40.459]  - attr(*, "total_size")= num NA
[15:32:40.464]  - Getting '...' globals ... DONE
[15:32:40.464] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:40.465] List of 2
[15:32:40.465]  $ ...future.FUN:function (x)  
[15:32:40.465]  $ ...          : list()
[15:32:40.465]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:40.465]  - attr(*, "where")=List of 2
[15:32:40.465]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:40.465]   ..$ ...          :<environment: 0x00000276de89aac8> 
[15:32:40.465]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:40.465]  - attr(*, "resolved")= logi FALSE
[15:32:40.465]  - attr(*, "total_size")= num 848
[15:32:40.469] Packages to be attached in all futures: [n=0] 
[15:32:40.470] getGlobalsAndPackagesXApply() ... DONE
[15:32:40.470] Number of futures (= number of chunks): 2
[15:32:40.470] Launching 2 futures (chunks) ...
[15:32:40.471] Chunk #1 of 2 ...
[15:32:40.471]  - Finding globals in 'X' for chunk #1 ...
[15:32:40.471] getGlobalsAndPackages() ...
[15:32:40.472] Searching for globals...
[15:32:40.472] 
[15:32:40.472] Searching for globals ... DONE
[15:32:40.473] - globals: [0] <none>
[15:32:40.473] getGlobalsAndPackages() ... DONE
[15:32:40.473]    + additional globals found: [n=0] 
[15:32:40.473]    + additional namespaces needed: [n=0] 
[15:32:40.474]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:40.474]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:40.474]  - seeds: <none>
[15:32:40.474]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:40.475] getGlobalsAndPackages() ...
[15:32:40.475] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:40.475] Resolving globals: FALSE
[15:32:40.476] Tweak future expression to call with '...' arguments ...
[15:32:40.476] {
[15:32:40.476]     do.call(function(...) {
[15:32:40.476]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:40.476]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:40.476]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:40.476]             on.exit(options(oopts), add = TRUE)
[15:32:40.476]         }
[15:32:40.476]         {
[15:32:40.476]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:40.476]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:40.476]                 ...future.FUN(...future.X_jj, ...)
[15:32:40.476]             })
[15:32:40.476]         }
[15:32:40.476]     }, args = future.call.arguments)
[15:32:40.476] }
[15:32:40.477] Tweak future expression to call with '...' arguments ... DONE
[15:32:40.478] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:40.478] 
[15:32:40.478] getGlobalsAndPackages() ... DONE
[15:32:40.479] run() for 'Future' ...
[15:32:40.479] - state: 'created'
[15:32:40.479] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:40.496] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:40.497] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:40.497]   - Field: 'node'
[15:32:40.497]   - Field: 'label'
[15:32:40.498]   - Field: 'local'
[15:32:40.498]   - Field: 'owner'
[15:32:40.498]   - Field: 'envir'
[15:32:40.499]   - Field: 'workers'
[15:32:40.499]   - Field: 'packages'
[15:32:40.499]   - Field: 'gc'
[15:32:40.500]   - Field: 'conditions'
[15:32:40.500]   - Field: 'persistent'
[15:32:40.500]   - Field: 'expr'
[15:32:40.500]   - Field: 'uuid'
[15:32:40.501]   - Field: 'seed'
[15:32:40.501]   - Field: 'version'
[15:32:40.501]   - Field: 'result'
[15:32:40.502]   - Field: 'asynchronous'
[15:32:40.502]   - Field: 'calls'
[15:32:40.502]   - Field: 'globals'
[15:32:40.502]   - Field: 'stdout'
[15:32:40.503]   - Field: 'earlySignal'
[15:32:40.503]   - Field: 'lazy'
[15:32:40.503]   - Field: 'state'
[15:32:40.504] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:40.504] - Launch lazy future ...
[15:32:40.505] Packages needed by the future expression (n = 0): <none>
[15:32:40.505] Packages needed by future strategies (n = 0): <none>
[15:32:40.506] {
[15:32:40.506]     {
[15:32:40.506]         {
[15:32:40.506]             ...future.startTime <- base::Sys.time()
[15:32:40.506]             {
[15:32:40.506]                 {
[15:32:40.506]                   {
[15:32:40.506]                     {
[15:32:40.506]                       base::local({
[15:32:40.506]                         has_future <- base::requireNamespace("future", 
[15:32:40.506]                           quietly = TRUE)
[15:32:40.506]                         if (has_future) {
[15:32:40.506]                           ns <- base::getNamespace("future")
[15:32:40.506]                           version <- ns[[".package"]][["version"]]
[15:32:40.506]                           if (is.null(version)) 
[15:32:40.506]                             version <- utils::packageVersion("future")
[15:32:40.506]                         }
[15:32:40.506]                         else {
[15:32:40.506]                           version <- NULL
[15:32:40.506]                         }
[15:32:40.506]                         if (!has_future || version < "1.8.0") {
[15:32:40.506]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:40.506]                             "", base::R.version$version.string), 
[15:32:40.506]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:40.506]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:40.506]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:40.506]                               "release", "version")], collapse = " "), 
[15:32:40.506]                             hostname = base::Sys.info()[["nodename"]])
[15:32:40.506]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:40.506]                             info)
[15:32:40.506]                           info <- base::paste(info, collapse = "; ")
[15:32:40.506]                           if (!has_future) {
[15:32:40.506]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:40.506]                               info)
[15:32:40.506]                           }
[15:32:40.506]                           else {
[15:32:40.506]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:40.506]                               info, version)
[15:32:40.506]                           }
[15:32:40.506]                           base::stop(msg)
[15:32:40.506]                         }
[15:32:40.506]                       })
[15:32:40.506]                     }
[15:32:40.506]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:40.506]                     base::options(mc.cores = 1L)
[15:32:40.506]                   }
[15:32:40.506]                   ...future.strategy.old <- future::plan("list")
[15:32:40.506]                   options(future.plan = NULL)
[15:32:40.506]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:40.506]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:40.506]                 }
[15:32:40.506]                 ...future.workdir <- getwd()
[15:32:40.506]             }
[15:32:40.506]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:40.506]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:40.506]         }
[15:32:40.506]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:40.506]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:40.506]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:40.506]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:40.506]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:40.506]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:40.506]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:40.506]             base::names(...future.oldOptions))
[15:32:40.506]     }
[15:32:40.506]     if (FALSE) {
[15:32:40.506]     }
[15:32:40.506]     else {
[15:32:40.506]         if (TRUE) {
[15:32:40.506]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:40.506]                 open = "w")
[15:32:40.506]         }
[15:32:40.506]         else {
[15:32:40.506]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:40.506]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:40.506]         }
[15:32:40.506]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:40.506]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:40.506]             base::sink(type = "output", split = FALSE)
[15:32:40.506]             base::close(...future.stdout)
[15:32:40.506]         }, add = TRUE)
[15:32:40.506]     }
[15:32:40.506]     ...future.frame <- base::sys.nframe()
[15:32:40.506]     ...future.conditions <- base::list()
[15:32:40.506]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:40.506]     if (FALSE) {
[15:32:40.506]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:40.506]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:40.506]     }
[15:32:40.506]     ...future.result <- base::tryCatch({
[15:32:40.506]         base::withCallingHandlers({
[15:32:40.506]             ...future.value <- base::withVisible(base::local({
[15:32:40.506]                 ...future.makeSendCondition <- base::local({
[15:32:40.506]                   sendCondition <- NULL
[15:32:40.506]                   function(frame = 1L) {
[15:32:40.506]                     if (is.function(sendCondition)) 
[15:32:40.506]                       return(sendCondition)
[15:32:40.506]                     ns <- getNamespace("parallel")
[15:32:40.506]                     if (exists("sendData", mode = "function", 
[15:32:40.506]                       envir = ns)) {
[15:32:40.506]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:40.506]                         envir = ns)
[15:32:40.506]                       envir <- sys.frame(frame)
[15:32:40.506]                       master <- NULL
[15:32:40.506]                       while (!identical(envir, .GlobalEnv) && 
[15:32:40.506]                         !identical(envir, emptyenv())) {
[15:32:40.506]                         if (exists("master", mode = "list", envir = envir, 
[15:32:40.506]                           inherits = FALSE)) {
[15:32:40.506]                           master <- get("master", mode = "list", 
[15:32:40.506]                             envir = envir, inherits = FALSE)
[15:32:40.506]                           if (inherits(master, c("SOCKnode", 
[15:32:40.506]                             "SOCK0node"))) {
[15:32:40.506]                             sendCondition <<- function(cond) {
[15:32:40.506]                               data <- list(type = "VALUE", value = cond, 
[15:32:40.506]                                 success = TRUE)
[15:32:40.506]                               parallel_sendData(master, data)
[15:32:40.506]                             }
[15:32:40.506]                             return(sendCondition)
[15:32:40.506]                           }
[15:32:40.506]                         }
[15:32:40.506]                         frame <- frame + 1L
[15:32:40.506]                         envir <- sys.frame(frame)
[15:32:40.506]                       }
[15:32:40.506]                     }
[15:32:40.506]                     sendCondition <<- function(cond) NULL
[15:32:40.506]                   }
[15:32:40.506]                 })
[15:32:40.506]                 withCallingHandlers({
[15:32:40.506]                   {
[15:32:40.506]                     do.call(function(...) {
[15:32:40.506]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:40.506]                       if (!identical(...future.globals.maxSize.org, 
[15:32:40.506]                         ...future.globals.maxSize)) {
[15:32:40.506]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:40.506]                         on.exit(options(oopts), add = TRUE)
[15:32:40.506]                       }
[15:32:40.506]                       {
[15:32:40.506]                         lapply(seq_along(...future.elements_ii), 
[15:32:40.506]                           FUN = function(jj) {
[15:32:40.506]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:40.506]                             ...future.FUN(...future.X_jj, ...)
[15:32:40.506]                           })
[15:32:40.506]                       }
[15:32:40.506]                     }, args = future.call.arguments)
[15:32:40.506]                   }
[15:32:40.506]                 }, immediateCondition = function(cond) {
[15:32:40.506]                   sendCondition <- ...future.makeSendCondition()
[15:32:40.506]                   sendCondition(cond)
[15:32:40.506]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:40.506]                   {
[15:32:40.506]                     inherits <- base::inherits
[15:32:40.506]                     invokeRestart <- base::invokeRestart
[15:32:40.506]                     is.null <- base::is.null
[15:32:40.506]                     muffled <- FALSE
[15:32:40.506]                     if (inherits(cond, "message")) {
[15:32:40.506]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:40.506]                       if (muffled) 
[15:32:40.506]                         invokeRestart("muffleMessage")
[15:32:40.506]                     }
[15:32:40.506]                     else if (inherits(cond, "warning")) {
[15:32:40.506]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:40.506]                       if (muffled) 
[15:32:40.506]                         invokeRestart("muffleWarning")
[15:32:40.506]                     }
[15:32:40.506]                     else if (inherits(cond, "condition")) {
[15:32:40.506]                       if (!is.null(pattern)) {
[15:32:40.506]                         computeRestarts <- base::computeRestarts
[15:32:40.506]                         grepl <- base::grepl
[15:32:40.506]                         restarts <- computeRestarts(cond)
[15:32:40.506]                         for (restart in restarts) {
[15:32:40.506]                           name <- restart$name
[15:32:40.506]                           if (is.null(name)) 
[15:32:40.506]                             next
[15:32:40.506]                           if (!grepl(pattern, name)) 
[15:32:40.506]                             next
[15:32:40.506]                           invokeRestart(restart)
[15:32:40.506]                           muffled <- TRUE
[15:32:40.506]                           break
[15:32:40.506]                         }
[15:32:40.506]                       }
[15:32:40.506]                     }
[15:32:40.506]                     invisible(muffled)
[15:32:40.506]                   }
[15:32:40.506]                   muffleCondition(cond)
[15:32:40.506]                 })
[15:32:40.506]             }))
[15:32:40.506]             future::FutureResult(value = ...future.value$value, 
[15:32:40.506]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:40.506]                   ...future.rng), globalenv = if (FALSE) 
[15:32:40.506]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:40.506]                     ...future.globalenv.names))
[15:32:40.506]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:40.506]         }, condition = base::local({
[15:32:40.506]             c <- base::c
[15:32:40.506]             inherits <- base::inherits
[15:32:40.506]             invokeRestart <- base::invokeRestart
[15:32:40.506]             length <- base::length
[15:32:40.506]             list <- base::list
[15:32:40.506]             seq.int <- base::seq.int
[15:32:40.506]             signalCondition <- base::signalCondition
[15:32:40.506]             sys.calls <- base::sys.calls
[15:32:40.506]             `[[` <- base::`[[`
[15:32:40.506]             `+` <- base::`+`
[15:32:40.506]             `<<-` <- base::`<<-`
[15:32:40.506]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:40.506]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:40.506]                   3L)]
[15:32:40.506]             }
[15:32:40.506]             function(cond) {
[15:32:40.506]                 is_error <- inherits(cond, "error")
[15:32:40.506]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:40.506]                   NULL)
[15:32:40.506]                 if (is_error) {
[15:32:40.506]                   sessionInformation <- function() {
[15:32:40.506]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:40.506]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:40.506]                       search = base::search(), system = base::Sys.info())
[15:32:40.506]                   }
[15:32:40.506]                   ...future.conditions[[length(...future.conditions) + 
[15:32:40.506]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:40.506]                     cond$call), session = sessionInformation(), 
[15:32:40.506]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:40.506]                   signalCondition(cond)
[15:32:40.506]                 }
[15:32:40.506]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:40.506]                 "immediateCondition"))) {
[15:32:40.506]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:40.506]                   ...future.conditions[[length(...future.conditions) + 
[15:32:40.506]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:40.506]                   if (TRUE && !signal) {
[15:32:40.506]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:40.506]                     {
[15:32:40.506]                       inherits <- base::inherits
[15:32:40.506]                       invokeRestart <- base::invokeRestart
[15:32:40.506]                       is.null <- base::is.null
[15:32:40.506]                       muffled <- FALSE
[15:32:40.506]                       if (inherits(cond, "message")) {
[15:32:40.506]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:40.506]                         if (muffled) 
[15:32:40.506]                           invokeRestart("muffleMessage")
[15:32:40.506]                       }
[15:32:40.506]                       else if (inherits(cond, "warning")) {
[15:32:40.506]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:40.506]                         if (muffled) 
[15:32:40.506]                           invokeRestart("muffleWarning")
[15:32:40.506]                       }
[15:32:40.506]                       else if (inherits(cond, "condition")) {
[15:32:40.506]                         if (!is.null(pattern)) {
[15:32:40.506]                           computeRestarts <- base::computeRestarts
[15:32:40.506]                           grepl <- base::grepl
[15:32:40.506]                           restarts <- computeRestarts(cond)
[15:32:40.506]                           for (restart in restarts) {
[15:32:40.506]                             name <- restart$name
[15:32:40.506]                             if (is.null(name)) 
[15:32:40.506]                               next
[15:32:40.506]                             if (!grepl(pattern, name)) 
[15:32:40.506]                               next
[15:32:40.506]                             invokeRestart(restart)
[15:32:40.506]                             muffled <- TRUE
[15:32:40.506]                             break
[15:32:40.506]                           }
[15:32:40.506]                         }
[15:32:40.506]                       }
[15:32:40.506]                       invisible(muffled)
[15:32:40.506]                     }
[15:32:40.506]                     muffleCondition(cond, pattern = "^muffle")
[15:32:40.506]                   }
[15:32:40.506]                 }
[15:32:40.506]                 else {
[15:32:40.506]                   if (TRUE) {
[15:32:40.506]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:40.506]                     {
[15:32:40.506]                       inherits <- base::inherits
[15:32:40.506]                       invokeRestart <- base::invokeRestart
[15:32:40.506]                       is.null <- base::is.null
[15:32:40.506]                       muffled <- FALSE
[15:32:40.506]                       if (inherits(cond, "message")) {
[15:32:40.506]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:40.506]                         if (muffled) 
[15:32:40.506]                           invokeRestart("muffleMessage")
[15:32:40.506]                       }
[15:32:40.506]                       else if (inherits(cond, "warning")) {
[15:32:40.506]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:40.506]                         if (muffled) 
[15:32:40.506]                           invokeRestart("muffleWarning")
[15:32:40.506]                       }
[15:32:40.506]                       else if (inherits(cond, "condition")) {
[15:32:40.506]                         if (!is.null(pattern)) {
[15:32:40.506]                           computeRestarts <- base::computeRestarts
[15:32:40.506]                           grepl <- base::grepl
[15:32:40.506]                           restarts <- computeRestarts(cond)
[15:32:40.506]                           for (restart in restarts) {
[15:32:40.506]                             name <- restart$name
[15:32:40.506]                             if (is.null(name)) 
[15:32:40.506]                               next
[15:32:40.506]                             if (!grepl(pattern, name)) 
[15:32:40.506]                               next
[15:32:40.506]                             invokeRestart(restart)
[15:32:40.506]                             muffled <- TRUE
[15:32:40.506]                             break
[15:32:40.506]                           }
[15:32:40.506]                         }
[15:32:40.506]                       }
[15:32:40.506]                       invisible(muffled)
[15:32:40.506]                     }
[15:32:40.506]                     muffleCondition(cond, pattern = "^muffle")
[15:32:40.506]                   }
[15:32:40.506]                 }
[15:32:40.506]             }
[15:32:40.506]         }))
[15:32:40.506]     }, error = function(ex) {
[15:32:40.506]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:40.506]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:40.506]                 ...future.rng), started = ...future.startTime, 
[15:32:40.506]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:40.506]             version = "1.8"), class = "FutureResult")
[15:32:40.506]     }, finally = {
[15:32:40.506]         if (!identical(...future.workdir, getwd())) 
[15:32:40.506]             setwd(...future.workdir)
[15:32:40.506]         {
[15:32:40.506]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:40.506]                 ...future.oldOptions$nwarnings <- NULL
[15:32:40.506]             }
[15:32:40.506]             base::options(...future.oldOptions)
[15:32:40.506]             if (.Platform$OS.type == "windows") {
[15:32:40.506]                 old_names <- names(...future.oldEnvVars)
[15:32:40.506]                 envs <- base::Sys.getenv()
[15:32:40.506]                 names <- names(envs)
[15:32:40.506]                 common <- intersect(names, old_names)
[15:32:40.506]                 added <- setdiff(names, old_names)
[15:32:40.506]                 removed <- setdiff(old_names, names)
[15:32:40.506]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:40.506]                   envs[common]]
[15:32:40.506]                 NAMES <- toupper(changed)
[15:32:40.506]                 args <- list()
[15:32:40.506]                 for (kk in seq_along(NAMES)) {
[15:32:40.506]                   name <- changed[[kk]]
[15:32:40.506]                   NAME <- NAMES[[kk]]
[15:32:40.506]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:40.506]                     next
[15:32:40.506]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:40.506]                 }
[15:32:40.506]                 NAMES <- toupper(added)
[15:32:40.506]                 for (kk in seq_along(NAMES)) {
[15:32:40.506]                   name <- added[[kk]]
[15:32:40.506]                   NAME <- NAMES[[kk]]
[15:32:40.506]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:40.506]                     next
[15:32:40.506]                   args[[name]] <- ""
[15:32:40.506]                 }
[15:32:40.506]                 NAMES <- toupper(removed)
[15:32:40.506]                 for (kk in seq_along(NAMES)) {
[15:32:40.506]                   name <- removed[[kk]]
[15:32:40.506]                   NAME <- NAMES[[kk]]
[15:32:40.506]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:40.506]                     next
[15:32:40.506]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:40.506]                 }
[15:32:40.506]                 if (length(args) > 0) 
[15:32:40.506]                   base::do.call(base::Sys.setenv, args = args)
[15:32:40.506]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:40.506]             }
[15:32:40.506]             else {
[15:32:40.506]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:40.506]             }
[15:32:40.506]             {
[15:32:40.506]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:40.506]                   0L) {
[15:32:40.506]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:40.506]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:40.506]                   base::options(opts)
[15:32:40.506]                 }
[15:32:40.506]                 {
[15:32:40.506]                   {
[15:32:40.506]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:40.506]                     NULL
[15:32:40.506]                   }
[15:32:40.506]                   options(future.plan = NULL)
[15:32:40.506]                   if (is.na(NA_character_)) 
[15:32:40.506]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:40.506]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:40.506]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:40.506]                     .init = FALSE)
[15:32:40.506]                 }
[15:32:40.506]             }
[15:32:40.506]         }
[15:32:40.506]     })
[15:32:40.506]     if (TRUE) {
[15:32:40.506]         base::sink(type = "output", split = FALSE)
[15:32:40.506]         if (TRUE) {
[15:32:40.506]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:40.506]         }
[15:32:40.506]         else {
[15:32:40.506]             ...future.result["stdout"] <- base::list(NULL)
[15:32:40.506]         }
[15:32:40.506]         base::close(...future.stdout)
[15:32:40.506]         ...future.stdout <- NULL
[15:32:40.506]     }
[15:32:40.506]     ...future.result$conditions <- ...future.conditions
[15:32:40.506]     ...future.result$finished <- base::Sys.time()
[15:32:40.506]     ...future.result
[15:32:40.506] }
[15:32:40.514] Exporting 5 global objects (848 bytes) to cluster node #1 ...
[15:32:40.515] Exporting '...future.FUN' (848 bytes) to cluster node #1 ...
[15:32:40.515] Exporting '...future.FUN' (848 bytes) to cluster node #1 ... DONE
[15:32:40.516] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:40.517] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:40.517] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:40.517] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:40.518] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:40.518] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:40.519] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:40.519] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:40.520] Exporting 5 global objects (848 bytes) to cluster node #1 ... DONE
[15:32:40.520] MultisessionFuture started
[15:32:40.521] - Launch lazy future ... done
[15:32:40.521] run() for 'MultisessionFuture' ... done
[15:32:40.521] Created future:
[15:32:40.553] receiveMessageFromWorker() for ClusterFuture ...
[15:32:40.553] - Validating connection of MultisessionFuture
[15:32:40.554] - received message: FutureResult
[15:32:40.554] - Received FutureResult
[15:32:40.554] - Erased future from FutureRegistry
[15:32:40.555] result() for ClusterFuture ...
[15:32:40.555] - result already collected: FutureResult
[15:32:40.555] result() for ClusterFuture ... done
[15:32:40.556] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:40.522] MultisessionFuture:
[15:32:40.522] Label: 'future_sapply-1'
[15:32:40.522] Expression:
[15:32:40.522] {
[15:32:40.522]     do.call(function(...) {
[15:32:40.522]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:40.522]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:40.522]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:40.522]             on.exit(options(oopts), add = TRUE)
[15:32:40.522]         }
[15:32:40.522]         {
[15:32:40.522]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:40.522]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:40.522]                 ...future.FUN(...future.X_jj, ...)
[15:32:40.522]             })
[15:32:40.522]         }
[15:32:40.522]     }, args = future.call.arguments)
[15:32:40.522] }
[15:32:40.522] Lazy evaluation: FALSE
[15:32:40.522] Asynchronous evaluation: TRUE
[15:32:40.522] Local evaluation: TRUE
[15:32:40.522] Environment: R_GlobalEnv
[15:32:40.522] Capture standard output: TRUE
[15:32:40.522] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:40.522] Globals: 5 objects totaling 960 bytes (function '...future.FUN' of 848 bytes, 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)
[15:32:40.522] Packages: <none>
[15:32:40.522] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:40.522] Resolved: TRUE
[15:32:40.522] Value: <not collected>
[15:32:40.522] Conditions captured: <none>
[15:32:40.522] Early signaling: FALSE
[15:32:40.522] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:40.522] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:40.556] Chunk #1 of 2 ... DONE
[15:32:40.557] Chunk #2 of 2 ...
[15:32:40.557]  - Finding globals in 'X' for chunk #2 ...
[15:32:40.557] getGlobalsAndPackages() ...
[15:32:40.557] Searching for globals...
[15:32:40.558] 
[15:32:40.558] Searching for globals ... DONE
[15:32:40.559] - globals: [0] <none>
[15:32:40.559] getGlobalsAndPackages() ... DONE
[15:32:40.559]    + additional globals found: [n=0] 
[15:32:40.559]    + additional namespaces needed: [n=0] 
[15:32:40.560]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:40.560]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:40.560]  - seeds: <none>
[15:32:40.560]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:40.561] getGlobalsAndPackages() ...
[15:32:40.561] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:40.561] Resolving globals: FALSE
[15:32:40.562] Tweak future expression to call with '...' arguments ...
[15:32:40.562] {
[15:32:40.562]     do.call(function(...) {
[15:32:40.562]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:40.562]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:40.562]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:40.562]             on.exit(options(oopts), add = TRUE)
[15:32:40.562]         }
[15:32:40.562]         {
[15:32:40.562]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:40.562]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:40.562]                 ...future.FUN(...future.X_jj, ...)
[15:32:40.562]             })
[15:32:40.562]         }
[15:32:40.562]     }, args = future.call.arguments)
[15:32:40.562] }
[15:32:40.563] Tweak future expression to call with '...' arguments ... DONE
[15:32:40.564] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:40.564] 
[15:32:40.564] getGlobalsAndPackages() ... DONE
[15:32:40.565] run() for 'Future' ...
[15:32:40.565] - state: 'created'
[15:32:40.565] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:40.584] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:40.584] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:40.585]   - Field: 'node'
[15:32:40.585]   - Field: 'label'
[15:32:40.585]   - Field: 'local'
[15:32:40.585]   - Field: 'owner'
[15:32:40.586]   - Field: 'envir'
[15:32:40.586]   - Field: 'workers'
[15:32:40.586]   - Field: 'packages'
[15:32:40.587]   - Field: 'gc'
[15:32:40.587]   - Field: 'conditions'
[15:32:40.587]   - Field: 'persistent'
[15:32:40.587]   - Field: 'expr'
[15:32:40.588]   - Field: 'uuid'
[15:32:40.588]   - Field: 'seed'
[15:32:40.595]   - Field: 'version'
[15:32:40.596]   - Field: 'result'
[15:32:40.596]   - Field: 'asynchronous'
[15:32:40.597]   - Field: 'calls'
[15:32:40.597]   - Field: 'globals'
[15:32:40.597]   - Field: 'stdout'
[15:32:40.598]   - Field: 'earlySignal'
[15:32:40.598]   - Field: 'lazy'
[15:32:40.598]   - Field: 'state'
[15:32:40.599] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:40.599] - Launch lazy future ...
[15:32:40.600] Packages needed by the future expression (n = 0): <none>
[15:32:40.600] Packages needed by future strategies (n = 0): <none>
[15:32:40.601] {
[15:32:40.601]     {
[15:32:40.601]         {
[15:32:40.601]             ...future.startTime <- base::Sys.time()
[15:32:40.601]             {
[15:32:40.601]                 {
[15:32:40.601]                   {
[15:32:40.601]                     {
[15:32:40.601]                       base::local({
[15:32:40.601]                         has_future <- base::requireNamespace("future", 
[15:32:40.601]                           quietly = TRUE)
[15:32:40.601]                         if (has_future) {
[15:32:40.601]                           ns <- base::getNamespace("future")
[15:32:40.601]                           version <- ns[[".package"]][["version"]]
[15:32:40.601]                           if (is.null(version)) 
[15:32:40.601]                             version <- utils::packageVersion("future")
[15:32:40.601]                         }
[15:32:40.601]                         else {
[15:32:40.601]                           version <- NULL
[15:32:40.601]                         }
[15:32:40.601]                         if (!has_future || version < "1.8.0") {
[15:32:40.601]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:40.601]                             "", base::R.version$version.string), 
[15:32:40.601]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:40.601]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:40.601]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:40.601]                               "release", "version")], collapse = " "), 
[15:32:40.601]                             hostname = base::Sys.info()[["nodename"]])
[15:32:40.601]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:40.601]                             info)
[15:32:40.601]                           info <- base::paste(info, collapse = "; ")
[15:32:40.601]                           if (!has_future) {
[15:32:40.601]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:40.601]                               info)
[15:32:40.601]                           }
[15:32:40.601]                           else {
[15:32:40.601]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:40.601]                               info, version)
[15:32:40.601]                           }
[15:32:40.601]                           base::stop(msg)
[15:32:40.601]                         }
[15:32:40.601]                       })
[15:32:40.601]                     }
[15:32:40.601]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:40.601]                     base::options(mc.cores = 1L)
[15:32:40.601]                   }
[15:32:40.601]                   ...future.strategy.old <- future::plan("list")
[15:32:40.601]                   options(future.plan = NULL)
[15:32:40.601]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:40.601]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:40.601]                 }
[15:32:40.601]                 ...future.workdir <- getwd()
[15:32:40.601]             }
[15:32:40.601]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:40.601]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:40.601]         }
[15:32:40.601]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:40.601]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:40.601]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:40.601]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:40.601]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:40.601]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:40.601]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:40.601]             base::names(...future.oldOptions))
[15:32:40.601]     }
[15:32:40.601]     if (FALSE) {
[15:32:40.601]     }
[15:32:40.601]     else {
[15:32:40.601]         if (TRUE) {
[15:32:40.601]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:40.601]                 open = "w")
[15:32:40.601]         }
[15:32:40.601]         else {
[15:32:40.601]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:40.601]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:40.601]         }
[15:32:40.601]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:40.601]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:40.601]             base::sink(type = "output", split = FALSE)
[15:32:40.601]             base::close(...future.stdout)
[15:32:40.601]         }, add = TRUE)
[15:32:40.601]     }
[15:32:40.601]     ...future.frame <- base::sys.nframe()
[15:32:40.601]     ...future.conditions <- base::list()
[15:32:40.601]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:40.601]     if (FALSE) {
[15:32:40.601]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:40.601]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:40.601]     }
[15:32:40.601]     ...future.result <- base::tryCatch({
[15:32:40.601]         base::withCallingHandlers({
[15:32:40.601]             ...future.value <- base::withVisible(base::local({
[15:32:40.601]                 ...future.makeSendCondition <- base::local({
[15:32:40.601]                   sendCondition <- NULL
[15:32:40.601]                   function(frame = 1L) {
[15:32:40.601]                     if (is.function(sendCondition)) 
[15:32:40.601]                       return(sendCondition)
[15:32:40.601]                     ns <- getNamespace("parallel")
[15:32:40.601]                     if (exists("sendData", mode = "function", 
[15:32:40.601]                       envir = ns)) {
[15:32:40.601]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:40.601]                         envir = ns)
[15:32:40.601]                       envir <- sys.frame(frame)
[15:32:40.601]                       master <- NULL
[15:32:40.601]                       while (!identical(envir, .GlobalEnv) && 
[15:32:40.601]                         !identical(envir, emptyenv())) {
[15:32:40.601]                         if (exists("master", mode = "list", envir = envir, 
[15:32:40.601]                           inherits = FALSE)) {
[15:32:40.601]                           master <- get("master", mode = "list", 
[15:32:40.601]                             envir = envir, inherits = FALSE)
[15:32:40.601]                           if (inherits(master, c("SOCKnode", 
[15:32:40.601]                             "SOCK0node"))) {
[15:32:40.601]                             sendCondition <<- function(cond) {
[15:32:40.601]                               data <- list(type = "VALUE", value = cond, 
[15:32:40.601]                                 success = TRUE)
[15:32:40.601]                               parallel_sendData(master, data)
[15:32:40.601]                             }
[15:32:40.601]                             return(sendCondition)
[15:32:40.601]                           }
[15:32:40.601]                         }
[15:32:40.601]                         frame <- frame + 1L
[15:32:40.601]                         envir <- sys.frame(frame)
[15:32:40.601]                       }
[15:32:40.601]                     }
[15:32:40.601]                     sendCondition <<- function(cond) NULL
[15:32:40.601]                   }
[15:32:40.601]                 })
[15:32:40.601]                 withCallingHandlers({
[15:32:40.601]                   {
[15:32:40.601]                     do.call(function(...) {
[15:32:40.601]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:40.601]                       if (!identical(...future.globals.maxSize.org, 
[15:32:40.601]                         ...future.globals.maxSize)) {
[15:32:40.601]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:40.601]                         on.exit(options(oopts), add = TRUE)
[15:32:40.601]                       }
[15:32:40.601]                       {
[15:32:40.601]                         lapply(seq_along(...future.elements_ii), 
[15:32:40.601]                           FUN = function(jj) {
[15:32:40.601]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:40.601]                             ...future.FUN(...future.X_jj, ...)
[15:32:40.601]                           })
[15:32:40.601]                       }
[15:32:40.601]                     }, args = future.call.arguments)
[15:32:40.601]                   }
[15:32:40.601]                 }, immediateCondition = function(cond) {
[15:32:40.601]                   sendCondition <- ...future.makeSendCondition()
[15:32:40.601]                   sendCondition(cond)
[15:32:40.601]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:40.601]                   {
[15:32:40.601]                     inherits <- base::inherits
[15:32:40.601]                     invokeRestart <- base::invokeRestart
[15:32:40.601]                     is.null <- base::is.null
[15:32:40.601]                     muffled <- FALSE
[15:32:40.601]                     if (inherits(cond, "message")) {
[15:32:40.601]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:40.601]                       if (muffled) 
[15:32:40.601]                         invokeRestart("muffleMessage")
[15:32:40.601]                     }
[15:32:40.601]                     else if (inherits(cond, "warning")) {
[15:32:40.601]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:40.601]                       if (muffled) 
[15:32:40.601]                         invokeRestart("muffleWarning")
[15:32:40.601]                     }
[15:32:40.601]                     else if (inherits(cond, "condition")) {
[15:32:40.601]                       if (!is.null(pattern)) {
[15:32:40.601]                         computeRestarts <- base::computeRestarts
[15:32:40.601]                         grepl <- base::grepl
[15:32:40.601]                         restarts <- computeRestarts(cond)
[15:32:40.601]                         for (restart in restarts) {
[15:32:40.601]                           name <- restart$name
[15:32:40.601]                           if (is.null(name)) 
[15:32:40.601]                             next
[15:32:40.601]                           if (!grepl(pattern, name)) 
[15:32:40.601]                             next
[15:32:40.601]                           invokeRestart(restart)
[15:32:40.601]                           muffled <- TRUE
[15:32:40.601]                           break
[15:32:40.601]                         }
[15:32:40.601]                       }
[15:32:40.601]                     }
[15:32:40.601]                     invisible(muffled)
[15:32:40.601]                   }
[15:32:40.601]                   muffleCondition(cond)
[15:32:40.601]                 })
[15:32:40.601]             }))
[15:32:40.601]             future::FutureResult(value = ...future.value$value, 
[15:32:40.601]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:40.601]                   ...future.rng), globalenv = if (FALSE) 
[15:32:40.601]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:40.601]                     ...future.globalenv.names))
[15:32:40.601]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:40.601]         }, condition = base::local({
[15:32:40.601]             c <- base::c
[15:32:40.601]             inherits <- base::inherits
[15:32:40.601]             invokeRestart <- base::invokeRestart
[15:32:40.601]             length <- base::length
[15:32:40.601]             list <- base::list
[15:32:40.601]             seq.int <- base::seq.int
[15:32:40.601]             signalCondition <- base::signalCondition
[15:32:40.601]             sys.calls <- base::sys.calls
[15:32:40.601]             `[[` <- base::`[[`
[15:32:40.601]             `+` <- base::`+`
[15:32:40.601]             `<<-` <- base::`<<-`
[15:32:40.601]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:40.601]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:40.601]                   3L)]
[15:32:40.601]             }
[15:32:40.601]             function(cond) {
[15:32:40.601]                 is_error <- inherits(cond, "error")
[15:32:40.601]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:40.601]                   NULL)
[15:32:40.601]                 if (is_error) {
[15:32:40.601]                   sessionInformation <- function() {
[15:32:40.601]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:40.601]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:40.601]                       search = base::search(), system = base::Sys.info())
[15:32:40.601]                   }
[15:32:40.601]                   ...future.conditions[[length(...future.conditions) + 
[15:32:40.601]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:40.601]                     cond$call), session = sessionInformation(), 
[15:32:40.601]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:40.601]                   signalCondition(cond)
[15:32:40.601]                 }
[15:32:40.601]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:40.601]                 "immediateCondition"))) {
[15:32:40.601]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:40.601]                   ...future.conditions[[length(...future.conditions) + 
[15:32:40.601]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:40.601]                   if (TRUE && !signal) {
[15:32:40.601]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:40.601]                     {
[15:32:40.601]                       inherits <- base::inherits
[15:32:40.601]                       invokeRestart <- base::invokeRestart
[15:32:40.601]                       is.null <- base::is.null
[15:32:40.601]                       muffled <- FALSE
[15:32:40.601]                       if (inherits(cond, "message")) {
[15:32:40.601]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:40.601]                         if (muffled) 
[15:32:40.601]                           invokeRestart("muffleMessage")
[15:32:40.601]                       }
[15:32:40.601]                       else if (inherits(cond, "warning")) {
[15:32:40.601]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:40.601]                         if (muffled) 
[15:32:40.601]                           invokeRestart("muffleWarning")
[15:32:40.601]                       }
[15:32:40.601]                       else if (inherits(cond, "condition")) {
[15:32:40.601]                         if (!is.null(pattern)) {
[15:32:40.601]                           computeRestarts <- base::computeRestarts
[15:32:40.601]                           grepl <- base::grepl
[15:32:40.601]                           restarts <- computeRestarts(cond)
[15:32:40.601]                           for (restart in restarts) {
[15:32:40.601]                             name <- restart$name
[15:32:40.601]                             if (is.null(name)) 
[15:32:40.601]                               next
[15:32:40.601]                             if (!grepl(pattern, name)) 
[15:32:40.601]                               next
[15:32:40.601]                             invokeRestart(restart)
[15:32:40.601]                             muffled <- TRUE
[15:32:40.601]                             break
[15:32:40.601]                           }
[15:32:40.601]                         }
[15:32:40.601]                       }
[15:32:40.601]                       invisible(muffled)
[15:32:40.601]                     }
[15:32:40.601]                     muffleCondition(cond, pattern = "^muffle")
[15:32:40.601]                   }
[15:32:40.601]                 }
[15:32:40.601]                 else {
[15:32:40.601]                   if (TRUE) {
[15:32:40.601]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:40.601]                     {
[15:32:40.601]                       inherits <- base::inherits
[15:32:40.601]                       invokeRestart <- base::invokeRestart
[15:32:40.601]                       is.null <- base::is.null
[15:32:40.601]                       muffled <- FALSE
[15:32:40.601]                       if (inherits(cond, "message")) {
[15:32:40.601]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:40.601]                         if (muffled) 
[15:32:40.601]                           invokeRestart("muffleMessage")
[15:32:40.601]                       }
[15:32:40.601]                       else if (inherits(cond, "warning")) {
[15:32:40.601]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:40.601]                         if (muffled) 
[15:32:40.601]                           invokeRestart("muffleWarning")
[15:32:40.601]                       }
[15:32:40.601]                       else if (inherits(cond, "condition")) {
[15:32:40.601]                         if (!is.null(pattern)) {
[15:32:40.601]                           computeRestarts <- base::computeRestarts
[15:32:40.601]                           grepl <- base::grepl
[15:32:40.601]                           restarts <- computeRestarts(cond)
[15:32:40.601]                           for (restart in restarts) {
[15:32:40.601]                             name <- restart$name
[15:32:40.601]                             if (is.null(name)) 
[15:32:40.601]                               next
[15:32:40.601]                             if (!grepl(pattern, name)) 
[15:32:40.601]                               next
[15:32:40.601]                             invokeRestart(restart)
[15:32:40.601]                             muffled <- TRUE
[15:32:40.601]                             break
[15:32:40.601]                           }
[15:32:40.601]                         }
[15:32:40.601]                       }
[15:32:40.601]                       invisible(muffled)
[15:32:40.601]                     }
[15:32:40.601]                     muffleCondition(cond, pattern = "^muffle")
[15:32:40.601]                   }
[15:32:40.601]                 }
[15:32:40.601]             }
[15:32:40.601]         }))
[15:32:40.601]     }, error = function(ex) {
[15:32:40.601]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:40.601]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:40.601]                 ...future.rng), started = ...future.startTime, 
[15:32:40.601]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:40.601]             version = "1.8"), class = "FutureResult")
[15:32:40.601]     }, finally = {
[15:32:40.601]         if (!identical(...future.workdir, getwd())) 
[15:32:40.601]             setwd(...future.workdir)
[15:32:40.601]         {
[15:32:40.601]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:40.601]                 ...future.oldOptions$nwarnings <- NULL
[15:32:40.601]             }
[15:32:40.601]             base::options(...future.oldOptions)
[15:32:40.601]             if (.Platform$OS.type == "windows") {
[15:32:40.601]                 old_names <- names(...future.oldEnvVars)
[15:32:40.601]                 envs <- base::Sys.getenv()
[15:32:40.601]                 names <- names(envs)
[15:32:40.601]                 common <- intersect(names, old_names)
[15:32:40.601]                 added <- setdiff(names, old_names)
[15:32:40.601]                 removed <- setdiff(old_names, names)
[15:32:40.601]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:40.601]                   envs[common]]
[15:32:40.601]                 NAMES <- toupper(changed)
[15:32:40.601]                 args <- list()
[15:32:40.601]                 for (kk in seq_along(NAMES)) {
[15:32:40.601]                   name <- changed[[kk]]
[15:32:40.601]                   NAME <- NAMES[[kk]]
[15:32:40.601]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:40.601]                     next
[15:32:40.601]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:40.601]                 }
[15:32:40.601]                 NAMES <- toupper(added)
[15:32:40.601]                 for (kk in seq_along(NAMES)) {
[15:32:40.601]                   name <- added[[kk]]
[15:32:40.601]                   NAME <- NAMES[[kk]]
[15:32:40.601]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:40.601]                     next
[15:32:40.601]                   args[[name]] <- ""
[15:32:40.601]                 }
[15:32:40.601]                 NAMES <- toupper(removed)
[15:32:40.601]                 for (kk in seq_along(NAMES)) {
[15:32:40.601]                   name <- removed[[kk]]
[15:32:40.601]                   NAME <- NAMES[[kk]]
[15:32:40.601]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:40.601]                     next
[15:32:40.601]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:40.601]                 }
[15:32:40.601]                 if (length(args) > 0) 
[15:32:40.601]                   base::do.call(base::Sys.setenv, args = args)
[15:32:40.601]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:40.601]             }
[15:32:40.601]             else {
[15:32:40.601]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:40.601]             }
[15:32:40.601]             {
[15:32:40.601]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:40.601]                   0L) {
[15:32:40.601]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:40.601]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:40.601]                   base::options(opts)
[15:32:40.601]                 }
[15:32:40.601]                 {
[15:32:40.601]                   {
[15:32:40.601]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:40.601]                     NULL
[15:32:40.601]                   }
[15:32:40.601]                   options(future.plan = NULL)
[15:32:40.601]                   if (is.na(NA_character_)) 
[15:32:40.601]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:40.601]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:40.601]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:40.601]                     .init = FALSE)
[15:32:40.601]                 }
[15:32:40.601]             }
[15:32:40.601]         }
[15:32:40.601]     })
[15:32:40.601]     if (TRUE) {
[15:32:40.601]         base::sink(type = "output", split = FALSE)
[15:32:40.601]         if (TRUE) {
[15:32:40.601]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:40.601]         }
[15:32:40.601]         else {
[15:32:40.601]             ...future.result["stdout"] <- base::list(NULL)
[15:32:40.601]         }
[15:32:40.601]         base::close(...future.stdout)
[15:32:40.601]         ...future.stdout <- NULL
[15:32:40.601]     }
[15:32:40.601]     ...future.result$conditions <- ...future.conditions
[15:32:40.601]     ...future.result$finished <- base::Sys.time()
[15:32:40.601]     ...future.result
[15:32:40.601] }
[15:32:40.610] Exporting 5 global objects (848 bytes) to cluster node #1 ...
[15:32:40.611] Exporting '...future.FUN' (848 bytes) to cluster node #1 ...
[15:32:40.611] Exporting '...future.FUN' (848 bytes) to cluster node #1 ... DONE
[15:32:40.612] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:40.612] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:40.613] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:40.613] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:40.614] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:40.614] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:40.615] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:40.615] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:40.616] Exporting 5 global objects (848 bytes) to cluster node #1 ... DONE
[15:32:40.617] MultisessionFuture started
[15:32:40.617] - Launch lazy future ... done
[15:32:40.617] run() for 'MultisessionFuture' ... done
[15:32:40.618] Created future:
[15:32:40.643] receiveMessageFromWorker() for ClusterFuture ...
[15:32:40.644] - Validating connection of MultisessionFuture
[15:32:40.644] - received message: FutureResult
[15:32:40.644] - Received FutureResult
[15:32:40.644] - Erased future from FutureRegistry
[15:32:40.645] result() for ClusterFuture ...
[15:32:40.645] - result already collected: FutureResult
[15:32:40.645] result() for ClusterFuture ... done
[15:32:40.645] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:40.618] MultisessionFuture:
[15:32:40.618] Label: 'future_sapply-2'
[15:32:40.618] Expression:
[15:32:40.618] {
[15:32:40.618]     do.call(function(...) {
[15:32:40.618]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:40.618]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:40.618]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:40.618]             on.exit(options(oopts), add = TRUE)
[15:32:40.618]         }
[15:32:40.618]         {
[15:32:40.618]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:40.618]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:40.618]                 ...future.FUN(...future.X_jj, ...)
[15:32:40.618]             })
[15:32:40.618]         }
[15:32:40.618]     }, args = future.call.arguments)
[15:32:40.618] }
[15:32:40.618] Lazy evaluation: FALSE
[15:32:40.618] Asynchronous evaluation: TRUE
[15:32:40.618] Local evaluation: TRUE
[15:32:40.618] Environment: R_GlobalEnv
[15:32:40.618] Capture standard output: TRUE
[15:32:40.618] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:40.618] Globals: 5 objects totaling 960 bytes (function '...future.FUN' of 848 bytes, 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)
[15:32:40.618] Packages: <none>
[15:32:40.618] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:40.618] Resolved: TRUE
[15:32:40.618] Value: <not collected>
[15:32:40.618] Conditions captured: <none>
[15:32:40.618] Early signaling: FALSE
[15:32:40.618] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:40.618] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:40.646] Chunk #2 of 2 ... DONE
[15:32:40.647] Launching 2 futures (chunks) ... DONE
[15:32:40.647] Resolving 2 futures (chunks) ...
[15:32:40.647] resolve() on list ...
[15:32:40.647]  recursive: 0
[15:32:40.648]  length: 2
[15:32:40.648] 
[15:32:40.648] Future #1
[15:32:40.648] result() for ClusterFuture ...
[15:32:40.649] - result already collected: FutureResult
[15:32:40.649] result() for ClusterFuture ... done
[15:32:40.649] result() for ClusterFuture ...
[15:32:40.650] - result already collected: FutureResult
[15:32:40.650] result() for ClusterFuture ... done
[15:32:40.650] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:40.650] - nx: 2
[15:32:40.651] - relay: TRUE
[15:32:40.651] - stdout: TRUE
[15:32:40.651] - signal: TRUE
[15:32:40.651] - resignal: FALSE
[15:32:40.652] - force: TRUE
[15:32:40.652] - relayed: [n=2] FALSE, FALSE
[15:32:40.652] - queued futures: [n=2] FALSE, FALSE
[15:32:40.652]  - until=1
[15:32:40.653]  - relaying element #1
[15:32:40.653] result() for ClusterFuture ...
[15:32:40.653] - result already collected: FutureResult
[15:32:40.653] result() for ClusterFuture ... done
[15:32:40.654] result() for ClusterFuture ...
[15:32:40.654] - result already collected: FutureResult
[15:32:40.654] result() for ClusterFuture ... done
[15:32:40.655] result() for ClusterFuture ...
[15:32:40.655] - result already collected: FutureResult
[15:32:40.655] result() for ClusterFuture ... done
[15:32:40.656] result() for ClusterFuture ...
[15:32:40.656] - result already collected: FutureResult
[15:32:40.656] result() for ClusterFuture ... done
[15:32:40.656] - relayed: [n=2] TRUE, FALSE
[15:32:40.657] - queued futures: [n=2] TRUE, FALSE
[15:32:40.657] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:40.657]  length: 1 (resolved future 1)
[15:32:40.657] Future #2
[15:32:40.658] result() for ClusterFuture ...
[15:32:40.658] - result already collected: FutureResult
[15:32:40.658] result() for ClusterFuture ... done
[15:32:40.658] result() for ClusterFuture ...
[15:32:40.659] - result already collected: FutureResult
[15:32:40.659] result() for ClusterFuture ... done
[15:32:40.659] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:40.659] - nx: 2
[15:32:40.660] - relay: TRUE
[15:32:40.660] - stdout: TRUE
[15:32:40.660] - signal: TRUE
[15:32:40.660] - resignal: FALSE
[15:32:40.661] - force: TRUE
[15:32:40.661] - relayed: [n=2] TRUE, FALSE
[15:32:40.661] - queued futures: [n=2] TRUE, FALSE
[15:32:40.661]  - until=2
[15:32:40.662]  - relaying element #2
[15:32:40.662] result() for ClusterFuture ...
[15:32:40.662] - result already collected: FutureResult
[15:32:40.662] result() for ClusterFuture ... done
[15:32:40.663] result() for ClusterFuture ...
[15:32:40.663] - result already collected: FutureResult
[15:32:40.663] result() for ClusterFuture ... done
[15:32:40.663] result() for ClusterFuture ...
[15:32:40.664] - result already collected: FutureResult
[15:32:40.664] result() for ClusterFuture ... done
[15:32:40.664] result() for ClusterFuture ...
[15:32:40.664] - result already collected: FutureResult
[15:32:40.665] result() for ClusterFuture ... done
[15:32:40.665] - relayed: [n=2] TRUE, TRUE
[15:32:40.665] - queued futures: [n=2] TRUE, TRUE
[15:32:40.665] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:40.666]  length: 0 (resolved future 2)
[15:32:40.666] Relaying remaining futures
[15:32:40.666] signalConditionsASAP(NULL, pos=0) ...
[15:32:40.666] - nx: 2
[15:32:40.667] - relay: TRUE
[15:32:40.667] - stdout: TRUE
[15:32:40.667] - signal: TRUE
[15:32:40.667] - resignal: FALSE
[15:32:40.668] - force: TRUE
[15:32:40.668] - relayed: [n=2] TRUE, TRUE
[15:32:40.668] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:40.669] - relayed: [n=2] TRUE, TRUE
[15:32:40.669] - queued futures: [n=2] TRUE, TRUE
[15:32:40.669] signalConditionsASAP(NULL, pos=0) ... done
[15:32:40.669] resolve() on list ... DONE
[15:32:40.670] result() for ClusterFuture ...
[15:32:40.670] - result already collected: FutureResult
[15:32:40.670] result() for ClusterFuture ... done
[15:32:40.670] result() for ClusterFuture ...
[15:32:40.671] - result already collected: FutureResult
[15:32:40.671] result() for ClusterFuture ... done
[15:32:40.671] result() for ClusterFuture ...
[15:32:40.672] - result already collected: FutureResult
[15:32:40.672] result() for ClusterFuture ... done
[15:32:40.672] result() for ClusterFuture ...
[15:32:40.672] - result already collected: FutureResult
[15:32:40.673] result() for ClusterFuture ... done
[15:32:40.673]  - Number of value chunks collected: 2
[15:32:40.673] Resolving 2 futures (chunks) ... DONE
[15:32:40.673] Reducing values from 2 chunks ...
[15:32:40.674]  - Number of values collected after concatenation: 4
[15:32:40.674]  - Number of values expected: 4
[15:32:40.674] Reducing values from 2 chunks ... DONE
[15:32:40.675] future_lapply() ... DONE
List of 2
 $ y0: Named num [1:4] 50 60 70 80
  ..- attr(*, "names")= chr [1:4] "A" "B" "C" "D"
 $ y1: Named num [1:4] 50 60 70 80
  ..- attr(*, "names")= chr [1:4] "A" "B" "C" "D"
[15:32:40.678] future_lapply() ...
[15:32:40.683] Number of chunks: 2
[15:32:40.683] getGlobalsAndPackagesXApply() ...
[15:32:40.684]  - future.globals: TRUE
[15:32:40.684] getGlobalsAndPackages() ...
[15:32:40.684] Searching for globals...
[15:32:40.686] - globals found: [2] 'FUN', 'UseMethod'
[15:32:40.687] Searching for globals ... DONE
[15:32:40.687] Resolving globals: FALSE
[15:32:40.688] The total size of the 1 globals is 1.22 KiB (1248 bytes)
[15:32:40.688] The total size of the 1 globals exported for future expression ('FUN()') is 1.22 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.22 KiB of class 'function')
[15:32:40.689] - globals: [1] 'FUN'
[15:32:40.689] 
[15:32:40.689] getGlobalsAndPackages() ... DONE
[15:32:40.689]  - globals found/used: [n=1] 'FUN'
[15:32:40.690]  - needed namespaces: [n=0] 
[15:32:40.690] Finding globals ... DONE
[15:32:40.690]  - use_args: TRUE
[15:32:40.691]  - Getting '...' globals ...
[15:32:40.691] resolve() on list ...
[15:32:40.692]  recursive: 0
[15:32:40.692]  length: 1
[15:32:40.692]  elements: '...'
[15:32:40.692]  length: 0 (resolved future 1)
[15:32:40.693] resolve() on list ... DONE
[15:32:40.693]    - '...' content: [n=0] 
[15:32:40.693] List of 1
[15:32:40.693]  $ ...: list()
[15:32:40.693]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:40.693]  - attr(*, "where")=List of 1
[15:32:40.693]   ..$ ...:<environment: 0x00000276e0395300> 
[15:32:40.693]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:40.693]  - attr(*, "resolved")= logi TRUE
[15:32:40.693]  - attr(*, "total_size")= num NA
[15:32:40.698]  - Getting '...' globals ... DONE
[15:32:40.699] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:40.699] List of 2
[15:32:40.699]  $ ...future.FUN:function (x, ...)  
[15:32:40.699]  $ ...          : list()
[15:32:40.699]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:40.699]  - attr(*, "where")=List of 2
[15:32:40.699]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:40.699]   ..$ ...          :<environment: 0x00000276e0395300> 
[15:32:40.699]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:40.699]  - attr(*, "resolved")= logi FALSE
[15:32:40.699]  - attr(*, "total_size")= num 1248
[15:32:40.704] Packages to be attached in all futures: [n=0] 
[15:32:40.704] getGlobalsAndPackagesXApply() ... DONE
[15:32:40.705] Number of futures (= number of chunks): 2
[15:32:40.705] Launching 2 futures (chunks) ...
[15:32:40.705] Chunk #1 of 2 ...
[15:32:40.706]  - Finding globals in 'X' for chunk #1 ...
[15:32:40.706] getGlobalsAndPackages() ...
[15:32:40.706] Searching for globals...
[15:32:40.707] 
[15:32:40.707] Searching for globals ... DONE
[15:32:40.707] - globals: [0] <none>
[15:32:40.708] getGlobalsAndPackages() ... DONE
[15:32:40.708]    + additional globals found: [n=0] 
[15:32:40.708]    + additional namespaces needed: [n=0] 
[15:32:40.709]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:40.709]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:40.709]  - seeds: <none>
[15:32:40.709]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:40.710] getGlobalsAndPackages() ...
[15:32:40.710] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:40.710] Resolving globals: FALSE
[15:32:40.710] Tweak future expression to call with '...' arguments ...
[15:32:40.711] {
[15:32:40.711]     do.call(function(...) {
[15:32:40.711]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:40.711]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:40.711]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:40.711]             on.exit(options(oopts), add = TRUE)
[15:32:40.711]         }
[15:32:40.711]         {
[15:32:40.711]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:40.711]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:40.711]                 ...future.FUN(...future.X_jj, ...)
[15:32:40.711]             })
[15:32:40.711]         }
[15:32:40.711]     }, args = future.call.arguments)
[15:32:40.711] }
[15:32:40.711] Tweak future expression to call with '...' arguments ... DONE
[15:32:40.712] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:40.713] 
[15:32:40.713] getGlobalsAndPackages() ... DONE
[15:32:40.714] run() for 'Future' ...
[15:32:40.714] - state: 'created'
[15:32:40.714] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:40.734] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:40.735] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:40.735]   - Field: 'node'
[15:32:40.735]   - Field: 'label'
[15:32:40.736]   - Field: 'local'
[15:32:40.736]   - Field: 'owner'
[15:32:40.736]   - Field: 'envir'
[15:32:40.737]   - Field: 'workers'
[15:32:40.737]   - Field: 'packages'
[15:32:40.737]   - Field: 'gc'
[15:32:40.737]   - Field: 'conditions'
[15:32:40.738]   - Field: 'persistent'
[15:32:40.738]   - Field: 'expr'
[15:32:40.738]   - Field: 'uuid'
[15:32:40.739]   - Field: 'seed'
[15:32:40.739]   - Field: 'version'
[15:32:40.739]   - Field: 'result'
[15:32:40.740]   - Field: 'asynchronous'
[15:32:40.740]   - Field: 'calls'
[15:32:40.740]   - Field: 'globals'
[15:32:40.740]   - Field: 'stdout'
[15:32:40.741]   - Field: 'earlySignal'
[15:32:40.741]   - Field: 'lazy'
[15:32:40.741]   - Field: 'state'
[15:32:40.742] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:40.742] - Launch lazy future ...
[15:32:40.743] Packages needed by the future expression (n = 0): <none>
[15:32:40.743] Packages needed by future strategies (n = 0): <none>
[15:32:40.744] {
[15:32:40.744]     {
[15:32:40.744]         {
[15:32:40.744]             ...future.startTime <- base::Sys.time()
[15:32:40.744]             {
[15:32:40.744]                 {
[15:32:40.744]                   {
[15:32:40.744]                     {
[15:32:40.744]                       base::local({
[15:32:40.744]                         has_future <- base::requireNamespace("future", 
[15:32:40.744]                           quietly = TRUE)
[15:32:40.744]                         if (has_future) {
[15:32:40.744]                           ns <- base::getNamespace("future")
[15:32:40.744]                           version <- ns[[".package"]][["version"]]
[15:32:40.744]                           if (is.null(version)) 
[15:32:40.744]                             version <- utils::packageVersion("future")
[15:32:40.744]                         }
[15:32:40.744]                         else {
[15:32:40.744]                           version <- NULL
[15:32:40.744]                         }
[15:32:40.744]                         if (!has_future || version < "1.8.0") {
[15:32:40.744]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:40.744]                             "", base::R.version$version.string), 
[15:32:40.744]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:40.744]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:40.744]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:40.744]                               "release", "version")], collapse = " "), 
[15:32:40.744]                             hostname = base::Sys.info()[["nodename"]])
[15:32:40.744]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:40.744]                             info)
[15:32:40.744]                           info <- base::paste(info, collapse = "; ")
[15:32:40.744]                           if (!has_future) {
[15:32:40.744]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:40.744]                               info)
[15:32:40.744]                           }
[15:32:40.744]                           else {
[15:32:40.744]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:40.744]                               info, version)
[15:32:40.744]                           }
[15:32:40.744]                           base::stop(msg)
[15:32:40.744]                         }
[15:32:40.744]                       })
[15:32:40.744]                     }
[15:32:40.744]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:40.744]                     base::options(mc.cores = 1L)
[15:32:40.744]                   }
[15:32:40.744]                   ...future.strategy.old <- future::plan("list")
[15:32:40.744]                   options(future.plan = NULL)
[15:32:40.744]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:40.744]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:40.744]                 }
[15:32:40.744]                 ...future.workdir <- getwd()
[15:32:40.744]             }
[15:32:40.744]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:40.744]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:40.744]         }
[15:32:40.744]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:40.744]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:40.744]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:40.744]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:40.744]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:40.744]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:40.744]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:40.744]             base::names(...future.oldOptions))
[15:32:40.744]     }
[15:32:40.744]     if (FALSE) {
[15:32:40.744]     }
[15:32:40.744]     else {
[15:32:40.744]         if (TRUE) {
[15:32:40.744]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:40.744]                 open = "w")
[15:32:40.744]         }
[15:32:40.744]         else {
[15:32:40.744]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:40.744]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:40.744]         }
[15:32:40.744]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:40.744]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:40.744]             base::sink(type = "output", split = FALSE)
[15:32:40.744]             base::close(...future.stdout)
[15:32:40.744]         }, add = TRUE)
[15:32:40.744]     }
[15:32:40.744]     ...future.frame <- base::sys.nframe()
[15:32:40.744]     ...future.conditions <- base::list()
[15:32:40.744]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:40.744]     if (FALSE) {
[15:32:40.744]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:40.744]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:40.744]     }
[15:32:40.744]     ...future.result <- base::tryCatch({
[15:32:40.744]         base::withCallingHandlers({
[15:32:40.744]             ...future.value <- base::withVisible(base::local({
[15:32:40.744]                 ...future.makeSendCondition <- base::local({
[15:32:40.744]                   sendCondition <- NULL
[15:32:40.744]                   function(frame = 1L) {
[15:32:40.744]                     if (is.function(sendCondition)) 
[15:32:40.744]                       return(sendCondition)
[15:32:40.744]                     ns <- getNamespace("parallel")
[15:32:40.744]                     if (exists("sendData", mode = "function", 
[15:32:40.744]                       envir = ns)) {
[15:32:40.744]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:40.744]                         envir = ns)
[15:32:40.744]                       envir <- sys.frame(frame)
[15:32:40.744]                       master <- NULL
[15:32:40.744]                       while (!identical(envir, .GlobalEnv) && 
[15:32:40.744]                         !identical(envir, emptyenv())) {
[15:32:40.744]                         if (exists("master", mode = "list", envir = envir, 
[15:32:40.744]                           inherits = FALSE)) {
[15:32:40.744]                           master <- get("master", mode = "list", 
[15:32:40.744]                             envir = envir, inherits = FALSE)
[15:32:40.744]                           if (inherits(master, c("SOCKnode", 
[15:32:40.744]                             "SOCK0node"))) {
[15:32:40.744]                             sendCondition <<- function(cond) {
[15:32:40.744]                               data <- list(type = "VALUE", value = cond, 
[15:32:40.744]                                 success = TRUE)
[15:32:40.744]                               parallel_sendData(master, data)
[15:32:40.744]                             }
[15:32:40.744]                             return(sendCondition)
[15:32:40.744]                           }
[15:32:40.744]                         }
[15:32:40.744]                         frame <- frame + 1L
[15:32:40.744]                         envir <- sys.frame(frame)
[15:32:40.744]                       }
[15:32:40.744]                     }
[15:32:40.744]                     sendCondition <<- function(cond) NULL
[15:32:40.744]                   }
[15:32:40.744]                 })
[15:32:40.744]                 withCallingHandlers({
[15:32:40.744]                   {
[15:32:40.744]                     do.call(function(...) {
[15:32:40.744]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:40.744]                       if (!identical(...future.globals.maxSize.org, 
[15:32:40.744]                         ...future.globals.maxSize)) {
[15:32:40.744]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:40.744]                         on.exit(options(oopts), add = TRUE)
[15:32:40.744]                       }
[15:32:40.744]                       {
[15:32:40.744]                         lapply(seq_along(...future.elements_ii), 
[15:32:40.744]                           FUN = function(jj) {
[15:32:40.744]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:40.744]                             ...future.FUN(...future.X_jj, ...)
[15:32:40.744]                           })
[15:32:40.744]                       }
[15:32:40.744]                     }, args = future.call.arguments)
[15:32:40.744]                   }
[15:32:40.744]                 }, immediateCondition = function(cond) {
[15:32:40.744]                   sendCondition <- ...future.makeSendCondition()
[15:32:40.744]                   sendCondition(cond)
[15:32:40.744]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:40.744]                   {
[15:32:40.744]                     inherits <- base::inherits
[15:32:40.744]                     invokeRestart <- base::invokeRestart
[15:32:40.744]                     is.null <- base::is.null
[15:32:40.744]                     muffled <- FALSE
[15:32:40.744]                     if (inherits(cond, "message")) {
[15:32:40.744]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:40.744]                       if (muffled) 
[15:32:40.744]                         invokeRestart("muffleMessage")
[15:32:40.744]                     }
[15:32:40.744]                     else if (inherits(cond, "warning")) {
[15:32:40.744]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:40.744]                       if (muffled) 
[15:32:40.744]                         invokeRestart("muffleWarning")
[15:32:40.744]                     }
[15:32:40.744]                     else if (inherits(cond, "condition")) {
[15:32:40.744]                       if (!is.null(pattern)) {
[15:32:40.744]                         computeRestarts <- base::computeRestarts
[15:32:40.744]                         grepl <- base::grepl
[15:32:40.744]                         restarts <- computeRestarts(cond)
[15:32:40.744]                         for (restart in restarts) {
[15:32:40.744]                           name <- restart$name
[15:32:40.744]                           if (is.null(name)) 
[15:32:40.744]                             next
[15:32:40.744]                           if (!grepl(pattern, name)) 
[15:32:40.744]                             next
[15:32:40.744]                           invokeRestart(restart)
[15:32:40.744]                           muffled <- TRUE
[15:32:40.744]                           break
[15:32:40.744]                         }
[15:32:40.744]                       }
[15:32:40.744]                     }
[15:32:40.744]                     invisible(muffled)
[15:32:40.744]                   }
[15:32:40.744]                   muffleCondition(cond)
[15:32:40.744]                 })
[15:32:40.744]             }))
[15:32:40.744]             future::FutureResult(value = ...future.value$value, 
[15:32:40.744]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:40.744]                   ...future.rng), globalenv = if (FALSE) 
[15:32:40.744]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:40.744]                     ...future.globalenv.names))
[15:32:40.744]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:40.744]         }, condition = base::local({
[15:32:40.744]             c <- base::c
[15:32:40.744]             inherits <- base::inherits
[15:32:40.744]             invokeRestart <- base::invokeRestart
[15:32:40.744]             length <- base::length
[15:32:40.744]             list <- base::list
[15:32:40.744]             seq.int <- base::seq.int
[15:32:40.744]             signalCondition <- base::signalCondition
[15:32:40.744]             sys.calls <- base::sys.calls
[15:32:40.744]             `[[` <- base::`[[`
[15:32:40.744]             `+` <- base::`+`
[15:32:40.744]             `<<-` <- base::`<<-`
[15:32:40.744]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:40.744]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:40.744]                   3L)]
[15:32:40.744]             }
[15:32:40.744]             function(cond) {
[15:32:40.744]                 is_error <- inherits(cond, "error")
[15:32:40.744]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:40.744]                   NULL)
[15:32:40.744]                 if (is_error) {
[15:32:40.744]                   sessionInformation <- function() {
[15:32:40.744]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:40.744]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:40.744]                       search = base::search(), system = base::Sys.info())
[15:32:40.744]                   }
[15:32:40.744]                   ...future.conditions[[length(...future.conditions) + 
[15:32:40.744]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:40.744]                     cond$call), session = sessionInformation(), 
[15:32:40.744]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:40.744]                   signalCondition(cond)
[15:32:40.744]                 }
[15:32:40.744]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:40.744]                 "immediateCondition"))) {
[15:32:40.744]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:40.744]                   ...future.conditions[[length(...future.conditions) + 
[15:32:40.744]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:40.744]                   if (TRUE && !signal) {
[15:32:40.744]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:40.744]                     {
[15:32:40.744]                       inherits <- base::inherits
[15:32:40.744]                       invokeRestart <- base::invokeRestart
[15:32:40.744]                       is.null <- base::is.null
[15:32:40.744]                       muffled <- FALSE
[15:32:40.744]                       if (inherits(cond, "message")) {
[15:32:40.744]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:40.744]                         if (muffled) 
[15:32:40.744]                           invokeRestart("muffleMessage")
[15:32:40.744]                       }
[15:32:40.744]                       else if (inherits(cond, "warning")) {
[15:32:40.744]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:40.744]                         if (muffled) 
[15:32:40.744]                           invokeRestart("muffleWarning")
[15:32:40.744]                       }
[15:32:40.744]                       else if (inherits(cond, "condition")) {
[15:32:40.744]                         if (!is.null(pattern)) {
[15:32:40.744]                           computeRestarts <- base::computeRestarts
[15:32:40.744]                           grepl <- base::grepl
[15:32:40.744]                           restarts <- computeRestarts(cond)
[15:32:40.744]                           for (restart in restarts) {
[15:32:40.744]                             name <- restart$name
[15:32:40.744]                             if (is.null(name)) 
[15:32:40.744]                               next
[15:32:40.744]                             if (!grepl(pattern, name)) 
[15:32:40.744]                               next
[15:32:40.744]                             invokeRestart(restart)
[15:32:40.744]                             muffled <- TRUE
[15:32:40.744]                             break
[15:32:40.744]                           }
[15:32:40.744]                         }
[15:32:40.744]                       }
[15:32:40.744]                       invisible(muffled)
[15:32:40.744]                     }
[15:32:40.744]                     muffleCondition(cond, pattern = "^muffle")
[15:32:40.744]                   }
[15:32:40.744]                 }
[15:32:40.744]                 else {
[15:32:40.744]                   if (TRUE) {
[15:32:40.744]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:40.744]                     {
[15:32:40.744]                       inherits <- base::inherits
[15:32:40.744]                       invokeRestart <- base::invokeRestart
[15:32:40.744]                       is.null <- base::is.null
[15:32:40.744]                       muffled <- FALSE
[15:32:40.744]                       if (inherits(cond, "message")) {
[15:32:40.744]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:40.744]                         if (muffled) 
[15:32:40.744]                           invokeRestart("muffleMessage")
[15:32:40.744]                       }
[15:32:40.744]                       else if (inherits(cond, "warning")) {
[15:32:40.744]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:40.744]                         if (muffled) 
[15:32:40.744]                           invokeRestart("muffleWarning")
[15:32:40.744]                       }
[15:32:40.744]                       else if (inherits(cond, "condition")) {
[15:32:40.744]                         if (!is.null(pattern)) {
[15:32:40.744]                           computeRestarts <- base::computeRestarts
[15:32:40.744]                           grepl <- base::grepl
[15:32:40.744]                           restarts <- computeRestarts(cond)
[15:32:40.744]                           for (restart in restarts) {
[15:32:40.744]                             name <- restart$name
[15:32:40.744]                             if (is.null(name)) 
[15:32:40.744]                               next
[15:32:40.744]                             if (!grepl(pattern, name)) 
[15:32:40.744]                               next
[15:32:40.744]                             invokeRestart(restart)
[15:32:40.744]                             muffled <- TRUE
[15:32:40.744]                             break
[15:32:40.744]                           }
[15:32:40.744]                         }
[15:32:40.744]                       }
[15:32:40.744]                       invisible(muffled)
[15:32:40.744]                     }
[15:32:40.744]                     muffleCondition(cond, pattern = "^muffle")
[15:32:40.744]                   }
[15:32:40.744]                 }
[15:32:40.744]             }
[15:32:40.744]         }))
[15:32:40.744]     }, error = function(ex) {
[15:32:40.744]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:40.744]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:40.744]                 ...future.rng), started = ...future.startTime, 
[15:32:40.744]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:40.744]             version = "1.8"), class = "FutureResult")
[15:32:40.744]     }, finally = {
[15:32:40.744]         if (!identical(...future.workdir, getwd())) 
[15:32:40.744]             setwd(...future.workdir)
[15:32:40.744]         {
[15:32:40.744]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:40.744]                 ...future.oldOptions$nwarnings <- NULL
[15:32:40.744]             }
[15:32:40.744]             base::options(...future.oldOptions)
[15:32:40.744]             if (.Platform$OS.type == "windows") {
[15:32:40.744]                 old_names <- names(...future.oldEnvVars)
[15:32:40.744]                 envs <- base::Sys.getenv()
[15:32:40.744]                 names <- names(envs)
[15:32:40.744]                 common <- intersect(names, old_names)
[15:32:40.744]                 added <- setdiff(names, old_names)
[15:32:40.744]                 removed <- setdiff(old_names, names)
[15:32:40.744]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:40.744]                   envs[common]]
[15:32:40.744]                 NAMES <- toupper(changed)
[15:32:40.744]                 args <- list()
[15:32:40.744]                 for (kk in seq_along(NAMES)) {
[15:32:40.744]                   name <- changed[[kk]]
[15:32:40.744]                   NAME <- NAMES[[kk]]
[15:32:40.744]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:40.744]                     next
[15:32:40.744]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:40.744]                 }
[15:32:40.744]                 NAMES <- toupper(added)
[15:32:40.744]                 for (kk in seq_along(NAMES)) {
[15:32:40.744]                   name <- added[[kk]]
[15:32:40.744]                   NAME <- NAMES[[kk]]
[15:32:40.744]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:40.744]                     next
[15:32:40.744]                   args[[name]] <- ""
[15:32:40.744]                 }
[15:32:40.744]                 NAMES <- toupper(removed)
[15:32:40.744]                 for (kk in seq_along(NAMES)) {
[15:32:40.744]                   name <- removed[[kk]]
[15:32:40.744]                   NAME <- NAMES[[kk]]
[15:32:40.744]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:40.744]                     next
[15:32:40.744]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:40.744]                 }
[15:32:40.744]                 if (length(args) > 0) 
[15:32:40.744]                   base::do.call(base::Sys.setenv, args = args)
[15:32:40.744]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:40.744]             }
[15:32:40.744]             else {
[15:32:40.744]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:40.744]             }
[15:32:40.744]             {
[15:32:40.744]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:40.744]                   0L) {
[15:32:40.744]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:40.744]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:40.744]                   base::options(opts)
[15:32:40.744]                 }
[15:32:40.744]                 {
[15:32:40.744]                   {
[15:32:40.744]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:40.744]                     NULL
[15:32:40.744]                   }
[15:32:40.744]                   options(future.plan = NULL)
[15:32:40.744]                   if (is.na(NA_character_)) 
[15:32:40.744]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:40.744]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:40.744]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:40.744]                     .init = FALSE)
[15:32:40.744]                 }
[15:32:40.744]             }
[15:32:40.744]         }
[15:32:40.744]     })
[15:32:40.744]     if (TRUE) {
[15:32:40.744]         base::sink(type = "output", split = FALSE)
[15:32:40.744]         if (TRUE) {
[15:32:40.744]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:40.744]         }
[15:32:40.744]         else {
[15:32:40.744]             ...future.result["stdout"] <- base::list(NULL)
[15:32:40.744]         }
[15:32:40.744]         base::close(...future.stdout)
[15:32:40.744]         ...future.stdout <- NULL
[15:32:40.744]     }
[15:32:40.744]     ...future.result$conditions <- ...future.conditions
[15:32:40.744]     ...future.result$finished <- base::Sys.time()
[15:32:40.744]     ...future.result
[15:32:40.744] }
[15:32:40.754] Exporting 5 global objects (1.22 KiB) to cluster node #1 ...
[15:32:40.754] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ...
[15:32:40.755] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ... DONE
[15:32:40.756] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:40.756] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:40.757] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:40.757] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:40.758] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:40.758] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:40.758] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:40.759] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:40.759] Exporting 5 global objects (1.22 KiB) to cluster node #1 ... DONE
[15:32:40.760] MultisessionFuture started
[15:32:40.761] - Launch lazy future ... done
[15:32:40.761] run() for 'MultisessionFuture' ... done
[15:32:40.761] Created future:
[15:32:40.785] receiveMessageFromWorker() for ClusterFuture ...
[15:32:40.786] - Validating connection of MultisessionFuture
[15:32:40.786] - received message: FutureResult
[15:32:40.787] - Received FutureResult
[15:32:40.787] - Erased future from FutureRegistry
[15:32:40.787] result() for ClusterFuture ...
[15:32:40.788] - result already collected: FutureResult
[15:32:40.788] result() for ClusterFuture ... done
[15:32:40.788] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:40.762] MultisessionFuture:
[15:32:40.762] Label: 'future_sapply-1'
[15:32:40.762] Expression:
[15:32:40.762] {
[15:32:40.762]     do.call(function(...) {
[15:32:40.762]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:40.762]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:40.762]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:40.762]             on.exit(options(oopts), add = TRUE)
[15:32:40.762]         }
[15:32:40.762]         {
[15:32:40.762]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:40.762]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:40.762]                 ...future.FUN(...future.X_jj, ...)
[15:32:40.762]             })
[15:32:40.762]         }
[15:32:40.762]     }, args = future.call.arguments)
[15:32:40.762] }
[15:32:40.762] Lazy evaluation: FALSE
[15:32:40.762] Asynchronous evaluation: TRUE
[15:32:40.762] Local evaluation: TRUE
[15:32:40.762] Environment: R_GlobalEnv
[15:32:40.762] Capture standard output: TRUE
[15:32:40.762] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:40.762] Globals: 5 objects totaling 1.33 KiB (function '...future.FUN' of 1.22 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)
[15:32:40.762] Packages: <none>
[15:32:40.762] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:40.762] Resolved: TRUE
[15:32:40.762] Value: <not collected>
[15:32:40.762] Conditions captured: <none>
[15:32:40.762] Early signaling: FALSE
[15:32:40.762] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:40.762] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:40.789] Chunk #1 of 2 ... DONE
[15:32:40.789] Chunk #2 of 2 ...
[15:32:40.789]  - Finding globals in 'X' for chunk #2 ...
[15:32:40.790] getGlobalsAndPackages() ...
[15:32:40.790] Searching for globals...
[15:32:40.791] 
[15:32:40.791] Searching for globals ... DONE
[15:32:40.791] - globals: [0] <none>
[15:32:40.791] getGlobalsAndPackages() ... DONE
[15:32:40.792]    + additional globals found: [n=0] 
[15:32:40.792]    + additional namespaces needed: [n=0] 
[15:32:40.792]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:40.792]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:40.793]  - seeds: <none>
[15:32:40.793]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:40.793] getGlobalsAndPackages() ...
[15:32:40.794] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:40.794] Resolving globals: FALSE
[15:32:40.794] Tweak future expression to call with '...' arguments ...
[15:32:40.795] {
[15:32:40.795]     do.call(function(...) {
[15:32:40.795]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:40.795]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:40.795]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:40.795]             on.exit(options(oopts), add = TRUE)
[15:32:40.795]         }
[15:32:40.795]         {
[15:32:40.795]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:40.795]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:40.795]                 ...future.FUN(...future.X_jj, ...)
[15:32:40.795]             })
[15:32:40.795]         }
[15:32:40.795]     }, args = future.call.arguments)
[15:32:40.795] }
[15:32:40.795] Tweak future expression to call with '...' arguments ... DONE
[15:32:40.796] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:40.797] 
[15:32:40.797] getGlobalsAndPackages() ... DONE
[15:32:40.797] run() for 'Future' ...
[15:32:40.798] - state: 'created'
[15:32:40.798] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:40.818] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:40.818] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:40.818]   - Field: 'node'
[15:32:40.819]   - Field: 'label'
[15:32:40.819]   - Field: 'local'
[15:32:40.819]   - Field: 'owner'
[15:32:40.820]   - Field: 'envir'
[15:32:40.820]   - Field: 'workers'
[15:32:40.820]   - Field: 'packages'
[15:32:40.821]   - Field: 'gc'
[15:32:40.821]   - Field: 'conditions'
[15:32:40.821]   - Field: 'persistent'
[15:32:40.821]   - Field: 'expr'
[15:32:40.822]   - Field: 'uuid'
[15:32:40.822]   - Field: 'seed'
[15:32:40.822]   - Field: 'version'
[15:32:40.823]   - Field: 'result'
[15:32:40.823]   - Field: 'asynchronous'
[15:32:40.823]   - Field: 'calls'
[15:32:40.823]   - Field: 'globals'
[15:32:40.824]   - Field: 'stdout'
[15:32:40.824]   - Field: 'earlySignal'
[15:32:40.824]   - Field: 'lazy'
[15:32:40.825]   - Field: 'state'
[15:32:40.825] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:40.825] - Launch lazy future ...
[15:32:40.826] Packages needed by the future expression (n = 0): <none>
[15:32:40.826] Packages needed by future strategies (n = 0): <none>
[15:32:40.827] {
[15:32:40.827]     {
[15:32:40.827]         {
[15:32:40.827]             ...future.startTime <- base::Sys.time()
[15:32:40.827]             {
[15:32:40.827]                 {
[15:32:40.827]                   {
[15:32:40.827]                     {
[15:32:40.827]                       base::local({
[15:32:40.827]                         has_future <- base::requireNamespace("future", 
[15:32:40.827]                           quietly = TRUE)
[15:32:40.827]                         if (has_future) {
[15:32:40.827]                           ns <- base::getNamespace("future")
[15:32:40.827]                           version <- ns[[".package"]][["version"]]
[15:32:40.827]                           if (is.null(version)) 
[15:32:40.827]                             version <- utils::packageVersion("future")
[15:32:40.827]                         }
[15:32:40.827]                         else {
[15:32:40.827]                           version <- NULL
[15:32:40.827]                         }
[15:32:40.827]                         if (!has_future || version < "1.8.0") {
[15:32:40.827]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:40.827]                             "", base::R.version$version.string), 
[15:32:40.827]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:40.827]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:40.827]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:40.827]                               "release", "version")], collapse = " "), 
[15:32:40.827]                             hostname = base::Sys.info()[["nodename"]])
[15:32:40.827]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:40.827]                             info)
[15:32:40.827]                           info <- base::paste(info, collapse = "; ")
[15:32:40.827]                           if (!has_future) {
[15:32:40.827]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:40.827]                               info)
[15:32:40.827]                           }
[15:32:40.827]                           else {
[15:32:40.827]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:40.827]                               info, version)
[15:32:40.827]                           }
[15:32:40.827]                           base::stop(msg)
[15:32:40.827]                         }
[15:32:40.827]                       })
[15:32:40.827]                     }
[15:32:40.827]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:40.827]                     base::options(mc.cores = 1L)
[15:32:40.827]                   }
[15:32:40.827]                   ...future.strategy.old <- future::plan("list")
[15:32:40.827]                   options(future.plan = NULL)
[15:32:40.827]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:40.827]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:40.827]                 }
[15:32:40.827]                 ...future.workdir <- getwd()
[15:32:40.827]             }
[15:32:40.827]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:40.827]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:40.827]         }
[15:32:40.827]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:40.827]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:40.827]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:40.827]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:40.827]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:40.827]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:40.827]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:40.827]             base::names(...future.oldOptions))
[15:32:40.827]     }
[15:32:40.827]     if (FALSE) {
[15:32:40.827]     }
[15:32:40.827]     else {
[15:32:40.827]         if (TRUE) {
[15:32:40.827]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:40.827]                 open = "w")
[15:32:40.827]         }
[15:32:40.827]         else {
[15:32:40.827]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:40.827]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:40.827]         }
[15:32:40.827]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:40.827]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:40.827]             base::sink(type = "output", split = FALSE)
[15:32:40.827]             base::close(...future.stdout)
[15:32:40.827]         }, add = TRUE)
[15:32:40.827]     }
[15:32:40.827]     ...future.frame <- base::sys.nframe()
[15:32:40.827]     ...future.conditions <- base::list()
[15:32:40.827]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:40.827]     if (FALSE) {
[15:32:40.827]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:40.827]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:40.827]     }
[15:32:40.827]     ...future.result <- base::tryCatch({
[15:32:40.827]         base::withCallingHandlers({
[15:32:40.827]             ...future.value <- base::withVisible(base::local({
[15:32:40.827]                 ...future.makeSendCondition <- base::local({
[15:32:40.827]                   sendCondition <- NULL
[15:32:40.827]                   function(frame = 1L) {
[15:32:40.827]                     if (is.function(sendCondition)) 
[15:32:40.827]                       return(sendCondition)
[15:32:40.827]                     ns <- getNamespace("parallel")
[15:32:40.827]                     if (exists("sendData", mode = "function", 
[15:32:40.827]                       envir = ns)) {
[15:32:40.827]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:40.827]                         envir = ns)
[15:32:40.827]                       envir <- sys.frame(frame)
[15:32:40.827]                       master <- NULL
[15:32:40.827]                       while (!identical(envir, .GlobalEnv) && 
[15:32:40.827]                         !identical(envir, emptyenv())) {
[15:32:40.827]                         if (exists("master", mode = "list", envir = envir, 
[15:32:40.827]                           inherits = FALSE)) {
[15:32:40.827]                           master <- get("master", mode = "list", 
[15:32:40.827]                             envir = envir, inherits = FALSE)
[15:32:40.827]                           if (inherits(master, c("SOCKnode", 
[15:32:40.827]                             "SOCK0node"))) {
[15:32:40.827]                             sendCondition <<- function(cond) {
[15:32:40.827]                               data <- list(type = "VALUE", value = cond, 
[15:32:40.827]                                 success = TRUE)
[15:32:40.827]                               parallel_sendData(master, data)
[15:32:40.827]                             }
[15:32:40.827]                             return(sendCondition)
[15:32:40.827]                           }
[15:32:40.827]                         }
[15:32:40.827]                         frame <- frame + 1L
[15:32:40.827]                         envir <- sys.frame(frame)
[15:32:40.827]                       }
[15:32:40.827]                     }
[15:32:40.827]                     sendCondition <<- function(cond) NULL
[15:32:40.827]                   }
[15:32:40.827]                 })
[15:32:40.827]                 withCallingHandlers({
[15:32:40.827]                   {
[15:32:40.827]                     do.call(function(...) {
[15:32:40.827]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:40.827]                       if (!identical(...future.globals.maxSize.org, 
[15:32:40.827]                         ...future.globals.maxSize)) {
[15:32:40.827]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:40.827]                         on.exit(options(oopts), add = TRUE)
[15:32:40.827]                       }
[15:32:40.827]                       {
[15:32:40.827]                         lapply(seq_along(...future.elements_ii), 
[15:32:40.827]                           FUN = function(jj) {
[15:32:40.827]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:40.827]                             ...future.FUN(...future.X_jj, ...)
[15:32:40.827]                           })
[15:32:40.827]                       }
[15:32:40.827]                     }, args = future.call.arguments)
[15:32:40.827]                   }
[15:32:40.827]                 }, immediateCondition = function(cond) {
[15:32:40.827]                   sendCondition <- ...future.makeSendCondition()
[15:32:40.827]                   sendCondition(cond)
[15:32:40.827]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:40.827]                   {
[15:32:40.827]                     inherits <- base::inherits
[15:32:40.827]                     invokeRestart <- base::invokeRestart
[15:32:40.827]                     is.null <- base::is.null
[15:32:40.827]                     muffled <- FALSE
[15:32:40.827]                     if (inherits(cond, "message")) {
[15:32:40.827]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:40.827]                       if (muffled) 
[15:32:40.827]                         invokeRestart("muffleMessage")
[15:32:40.827]                     }
[15:32:40.827]                     else if (inherits(cond, "warning")) {
[15:32:40.827]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:40.827]                       if (muffled) 
[15:32:40.827]                         invokeRestart("muffleWarning")
[15:32:40.827]                     }
[15:32:40.827]                     else if (inherits(cond, "condition")) {
[15:32:40.827]                       if (!is.null(pattern)) {
[15:32:40.827]                         computeRestarts <- base::computeRestarts
[15:32:40.827]                         grepl <- base::grepl
[15:32:40.827]                         restarts <- computeRestarts(cond)
[15:32:40.827]                         for (restart in restarts) {
[15:32:40.827]                           name <- restart$name
[15:32:40.827]                           if (is.null(name)) 
[15:32:40.827]                             next
[15:32:40.827]                           if (!grepl(pattern, name)) 
[15:32:40.827]                             next
[15:32:40.827]                           invokeRestart(restart)
[15:32:40.827]                           muffled <- TRUE
[15:32:40.827]                           break
[15:32:40.827]                         }
[15:32:40.827]                       }
[15:32:40.827]                     }
[15:32:40.827]                     invisible(muffled)
[15:32:40.827]                   }
[15:32:40.827]                   muffleCondition(cond)
[15:32:40.827]                 })
[15:32:40.827]             }))
[15:32:40.827]             future::FutureResult(value = ...future.value$value, 
[15:32:40.827]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:40.827]                   ...future.rng), globalenv = if (FALSE) 
[15:32:40.827]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:40.827]                     ...future.globalenv.names))
[15:32:40.827]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:40.827]         }, condition = base::local({
[15:32:40.827]             c <- base::c
[15:32:40.827]             inherits <- base::inherits
[15:32:40.827]             invokeRestart <- base::invokeRestart
[15:32:40.827]             length <- base::length
[15:32:40.827]             list <- base::list
[15:32:40.827]             seq.int <- base::seq.int
[15:32:40.827]             signalCondition <- base::signalCondition
[15:32:40.827]             sys.calls <- base::sys.calls
[15:32:40.827]             `[[` <- base::`[[`
[15:32:40.827]             `+` <- base::`+`
[15:32:40.827]             `<<-` <- base::`<<-`
[15:32:40.827]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:40.827]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:40.827]                   3L)]
[15:32:40.827]             }
[15:32:40.827]             function(cond) {
[15:32:40.827]                 is_error <- inherits(cond, "error")
[15:32:40.827]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:40.827]                   NULL)
[15:32:40.827]                 if (is_error) {
[15:32:40.827]                   sessionInformation <- function() {
[15:32:40.827]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:40.827]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:40.827]                       search = base::search(), system = base::Sys.info())
[15:32:40.827]                   }
[15:32:40.827]                   ...future.conditions[[length(...future.conditions) + 
[15:32:40.827]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:40.827]                     cond$call), session = sessionInformation(), 
[15:32:40.827]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:40.827]                   signalCondition(cond)
[15:32:40.827]                 }
[15:32:40.827]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:40.827]                 "immediateCondition"))) {
[15:32:40.827]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:40.827]                   ...future.conditions[[length(...future.conditions) + 
[15:32:40.827]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:40.827]                   if (TRUE && !signal) {
[15:32:40.827]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:40.827]                     {
[15:32:40.827]                       inherits <- base::inherits
[15:32:40.827]                       invokeRestart <- base::invokeRestart
[15:32:40.827]                       is.null <- base::is.null
[15:32:40.827]                       muffled <- FALSE
[15:32:40.827]                       if (inherits(cond, "message")) {
[15:32:40.827]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:40.827]                         if (muffled) 
[15:32:40.827]                           invokeRestart("muffleMessage")
[15:32:40.827]                       }
[15:32:40.827]                       else if (inherits(cond, "warning")) {
[15:32:40.827]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:40.827]                         if (muffled) 
[15:32:40.827]                           invokeRestart("muffleWarning")
[15:32:40.827]                       }
[15:32:40.827]                       else if (inherits(cond, "condition")) {
[15:32:40.827]                         if (!is.null(pattern)) {
[15:32:40.827]                           computeRestarts <- base::computeRestarts
[15:32:40.827]                           grepl <- base::grepl
[15:32:40.827]                           restarts <- computeRestarts(cond)
[15:32:40.827]                           for (restart in restarts) {
[15:32:40.827]                             name <- restart$name
[15:32:40.827]                             if (is.null(name)) 
[15:32:40.827]                               next
[15:32:40.827]                             if (!grepl(pattern, name)) 
[15:32:40.827]                               next
[15:32:40.827]                             invokeRestart(restart)
[15:32:40.827]                             muffled <- TRUE
[15:32:40.827]                             break
[15:32:40.827]                           }
[15:32:40.827]                         }
[15:32:40.827]                       }
[15:32:40.827]                       invisible(muffled)
[15:32:40.827]                     }
[15:32:40.827]                     muffleCondition(cond, pattern = "^muffle")
[15:32:40.827]                   }
[15:32:40.827]                 }
[15:32:40.827]                 else {
[15:32:40.827]                   if (TRUE) {
[15:32:40.827]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:40.827]                     {
[15:32:40.827]                       inherits <- base::inherits
[15:32:40.827]                       invokeRestart <- base::invokeRestart
[15:32:40.827]                       is.null <- base::is.null
[15:32:40.827]                       muffled <- FALSE
[15:32:40.827]                       if (inherits(cond, "message")) {
[15:32:40.827]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:40.827]                         if (muffled) 
[15:32:40.827]                           invokeRestart("muffleMessage")
[15:32:40.827]                       }
[15:32:40.827]                       else if (inherits(cond, "warning")) {
[15:32:40.827]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:40.827]                         if (muffled) 
[15:32:40.827]                           invokeRestart("muffleWarning")
[15:32:40.827]                       }
[15:32:40.827]                       else if (inherits(cond, "condition")) {
[15:32:40.827]                         if (!is.null(pattern)) {
[15:32:40.827]                           computeRestarts <- base::computeRestarts
[15:32:40.827]                           grepl <- base::grepl
[15:32:40.827]                           restarts <- computeRestarts(cond)
[15:32:40.827]                           for (restart in restarts) {
[15:32:40.827]                             name <- restart$name
[15:32:40.827]                             if (is.null(name)) 
[15:32:40.827]                               next
[15:32:40.827]                             if (!grepl(pattern, name)) 
[15:32:40.827]                               next
[15:32:40.827]                             invokeRestart(restart)
[15:32:40.827]                             muffled <- TRUE
[15:32:40.827]                             break
[15:32:40.827]                           }
[15:32:40.827]                         }
[15:32:40.827]                       }
[15:32:40.827]                       invisible(muffled)
[15:32:40.827]                     }
[15:32:40.827]                     muffleCondition(cond, pattern = "^muffle")
[15:32:40.827]                   }
[15:32:40.827]                 }
[15:32:40.827]             }
[15:32:40.827]         }))
[15:32:40.827]     }, error = function(ex) {
[15:32:40.827]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:40.827]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:40.827]                 ...future.rng), started = ...future.startTime, 
[15:32:40.827]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:40.827]             version = "1.8"), class = "FutureResult")
[15:32:40.827]     }, finally = {
[15:32:40.827]         if (!identical(...future.workdir, getwd())) 
[15:32:40.827]             setwd(...future.workdir)
[15:32:40.827]         {
[15:32:40.827]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:40.827]                 ...future.oldOptions$nwarnings <- NULL
[15:32:40.827]             }
[15:32:40.827]             base::options(...future.oldOptions)
[15:32:40.827]             if (.Platform$OS.type == "windows") {
[15:32:40.827]                 old_names <- names(...future.oldEnvVars)
[15:32:40.827]                 envs <- base::Sys.getenv()
[15:32:40.827]                 names <- names(envs)
[15:32:40.827]                 common <- intersect(names, old_names)
[15:32:40.827]                 added <- setdiff(names, old_names)
[15:32:40.827]                 removed <- setdiff(old_names, names)
[15:32:40.827]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:40.827]                   envs[common]]
[15:32:40.827]                 NAMES <- toupper(changed)
[15:32:40.827]                 args <- list()
[15:32:40.827]                 for (kk in seq_along(NAMES)) {
[15:32:40.827]                   name <- changed[[kk]]
[15:32:40.827]                   NAME <- NAMES[[kk]]
[15:32:40.827]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:40.827]                     next
[15:32:40.827]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:40.827]                 }
[15:32:40.827]                 NAMES <- toupper(added)
[15:32:40.827]                 for (kk in seq_along(NAMES)) {
[15:32:40.827]                   name <- added[[kk]]
[15:32:40.827]                   NAME <- NAMES[[kk]]
[15:32:40.827]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:40.827]                     next
[15:32:40.827]                   args[[name]] <- ""
[15:32:40.827]                 }
[15:32:40.827]                 NAMES <- toupper(removed)
[15:32:40.827]                 for (kk in seq_along(NAMES)) {
[15:32:40.827]                   name <- removed[[kk]]
[15:32:40.827]                   NAME <- NAMES[[kk]]
[15:32:40.827]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:40.827]                     next
[15:32:40.827]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:40.827]                 }
[15:32:40.827]                 if (length(args) > 0) 
[15:32:40.827]                   base::do.call(base::Sys.setenv, args = args)
[15:32:40.827]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:40.827]             }
[15:32:40.827]             else {
[15:32:40.827]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:40.827]             }
[15:32:40.827]             {
[15:32:40.827]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:40.827]                   0L) {
[15:32:40.827]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:40.827]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:40.827]                   base::options(opts)
[15:32:40.827]                 }
[15:32:40.827]                 {
[15:32:40.827]                   {
[15:32:40.827]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:40.827]                     NULL
[15:32:40.827]                   }
[15:32:40.827]                   options(future.plan = NULL)
[15:32:40.827]                   if (is.na(NA_character_)) 
[15:32:40.827]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:40.827]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:40.827]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:40.827]                     .init = FALSE)
[15:32:40.827]                 }
[15:32:40.827]             }
[15:32:40.827]         }
[15:32:40.827]     })
[15:32:40.827]     if (TRUE) {
[15:32:40.827]         base::sink(type = "output", split = FALSE)
[15:32:40.827]         if (TRUE) {
[15:32:40.827]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:40.827]         }
[15:32:40.827]         else {
[15:32:40.827]             ...future.result["stdout"] <- base::list(NULL)
[15:32:40.827]         }
[15:32:40.827]         base::close(...future.stdout)
[15:32:40.827]         ...future.stdout <- NULL
[15:32:40.827]     }
[15:32:40.827]     ...future.result$conditions <- ...future.conditions
[15:32:40.827]     ...future.result$finished <- base::Sys.time()
[15:32:40.827]     ...future.result
[15:32:40.827] }
[15:32:40.836] Exporting 5 global objects (1.22 KiB) to cluster node #1 ...
[15:32:40.836] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ...
[15:32:40.837] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ... DONE
[15:32:40.837] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:40.838] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:40.838] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:40.838] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:40.838] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:40.839] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:40.839] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:40.840] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:40.840] Exporting 5 global objects (1.22 KiB) to cluster node #1 ... DONE
[15:32:40.840] MultisessionFuture started
[15:32:40.841] - Launch lazy future ... done
[15:32:40.845] run() for 'MultisessionFuture' ... done
[15:32:40.845] Created future:
[15:32:40.857] receiveMessageFromWorker() for ClusterFuture ...
[15:32:40.858] - Validating connection of MultisessionFuture
[15:32:40.858] - received message: FutureResult
[15:32:40.859] - Received FutureResult
[15:32:40.859] - Erased future from FutureRegistry
[15:32:40.859] result() for ClusterFuture ...
[15:32:40.859] - result already collected: FutureResult
[15:32:40.860] result() for ClusterFuture ... done
[15:32:40.860] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:40.846] MultisessionFuture:
[15:32:40.846] Label: 'future_sapply-2'
[15:32:40.846] Expression:
[15:32:40.846] {
[15:32:40.846]     do.call(function(...) {
[15:32:40.846]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:40.846]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:40.846]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:40.846]             on.exit(options(oopts), add = TRUE)
[15:32:40.846]         }
[15:32:40.846]         {
[15:32:40.846]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:40.846]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:40.846]                 ...future.FUN(...future.X_jj, ...)
[15:32:40.846]             })
[15:32:40.846]         }
[15:32:40.846]     }, args = future.call.arguments)
[15:32:40.846] }
[15:32:40.846] Lazy evaluation: FALSE
[15:32:40.846] Asynchronous evaluation: TRUE
[15:32:40.846] Local evaluation: TRUE
[15:32:40.846] Environment: R_GlobalEnv
[15:32:40.846] Capture standard output: TRUE
[15:32:40.846] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:40.846] Globals: 5 objects totaling 1.33 KiB (function '...future.FUN' of 1.22 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)
[15:32:40.846] Packages: <none>
[15:32:40.846] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:40.846] Resolved: TRUE
[15:32:40.846] Value: <not collected>
[15:32:40.846] Conditions captured: <none>
[15:32:40.846] Early signaling: FALSE
[15:32:40.846] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:40.846] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:40.861] Chunk #2 of 2 ... DONE
[15:32:40.861] Launching 2 futures (chunks) ... DONE
[15:32:40.861] Resolving 2 futures (chunks) ...
[15:32:40.862] resolve() on list ...
[15:32:40.862]  recursive: 0
[15:32:40.862]  length: 2
[15:32:40.862] 
[15:32:40.863] Future #1
[15:32:40.863] result() for ClusterFuture ...
[15:32:40.863] - result already collected: FutureResult
[15:32:40.863] result() for ClusterFuture ... done
[15:32:40.864] result() for ClusterFuture ...
[15:32:40.864] - result already collected: FutureResult
[15:32:40.864] result() for ClusterFuture ... done
[15:32:40.864] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:40.865] - nx: 2
[15:32:40.865] - relay: TRUE
[15:32:40.865] - stdout: TRUE
[15:32:40.865] - signal: TRUE
[15:32:40.865] - resignal: FALSE
[15:32:40.866] - force: TRUE
[15:32:40.866] - relayed: [n=2] FALSE, FALSE
[15:32:40.866] - queued futures: [n=2] FALSE, FALSE
[15:32:40.866]  - until=1
[15:32:40.867]  - relaying element #1
[15:32:40.867] result() for ClusterFuture ...
[15:32:40.867] - result already collected: FutureResult
[15:32:40.867] result() for ClusterFuture ... done
[15:32:40.868] result() for ClusterFuture ...
[15:32:40.868] - result already collected: FutureResult
[15:32:40.868] result() for ClusterFuture ... done
[15:32:40.868] result() for ClusterFuture ...
[15:32:40.869] - result already collected: FutureResult
[15:32:40.869] result() for ClusterFuture ... done
[15:32:40.869] result() for ClusterFuture ...
[15:32:40.869] - result already collected: FutureResult
[15:32:40.870] result() for ClusterFuture ... done
[15:32:40.870] - relayed: [n=2] TRUE, FALSE
[15:32:40.870] - queued futures: [n=2] TRUE, FALSE
[15:32:40.870] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:40.871]  length: 1 (resolved future 1)
[15:32:40.871] Future #2
[15:32:40.871] result() for ClusterFuture ...
[15:32:40.871] - result already collected: FutureResult
[15:32:40.872] result() for ClusterFuture ... done
[15:32:40.872] result() for ClusterFuture ...
[15:32:40.872] - result already collected: FutureResult
[15:32:40.872] result() for ClusterFuture ... done
[15:32:40.873] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:40.873] - nx: 2
[15:32:40.873] - relay: TRUE
[15:32:40.873] - stdout: TRUE
[15:32:40.873] - signal: TRUE
[15:32:40.874] - resignal: FALSE
[15:32:40.874] - force: TRUE
[15:32:40.874] - relayed: [n=2] TRUE, FALSE
[15:32:40.874] - queued futures: [n=2] TRUE, FALSE
[15:32:40.875]  - until=2
[15:32:40.875]  - relaying element #2
[15:32:40.875] result() for ClusterFuture ...
[15:32:40.875] - result already collected: FutureResult
[15:32:40.875] result() for ClusterFuture ... done
[15:32:40.876] result() for ClusterFuture ...
[15:32:40.876] - result already collected: FutureResult
[15:32:40.876] result() for ClusterFuture ... done
[15:32:40.876] result() for ClusterFuture ...
[15:32:40.877] - result already collected: FutureResult
[15:32:40.877] result() for ClusterFuture ... done
[15:32:40.877] result() for ClusterFuture ...
[15:32:40.877] - result already collected: FutureResult
[15:32:40.878] result() for ClusterFuture ... done
[15:32:40.878] - relayed: [n=2] TRUE, TRUE
[15:32:40.878] - queued futures: [n=2] TRUE, TRUE
[15:32:40.878] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:40.879]  length: 0 (resolved future 2)
[15:32:40.879] Relaying remaining futures
[15:32:40.879] signalConditionsASAP(NULL, pos=0) ...
[15:32:40.879] - nx: 2
[15:32:40.879] - relay: TRUE
[15:32:40.880] - stdout: TRUE
[15:32:40.880] - signal: TRUE
[15:32:40.880] - resignal: FALSE
[15:32:40.880] - force: TRUE
[15:32:40.881] - relayed: [n=2] TRUE, TRUE
[15:32:40.881] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:40.881] - relayed: [n=2] TRUE, TRUE
[15:32:40.882] - queued futures: [n=2] TRUE, TRUE
[15:32:40.882] signalConditionsASAP(NULL, pos=0) ... done
[15:32:40.882] resolve() on list ... DONE
[15:32:40.882] result() for ClusterFuture ...
[15:32:40.882] - result already collected: FutureResult
[15:32:40.883] result() for ClusterFuture ... done
[15:32:40.883] result() for ClusterFuture ...
[15:32:40.883] - result already collected: FutureResult
[15:32:40.883] result() for ClusterFuture ... done
[15:32:40.884] result() for ClusterFuture ...
[15:32:40.884] - result already collected: FutureResult
[15:32:40.884] result() for ClusterFuture ... done
[15:32:40.884] result() for ClusterFuture ...
[15:32:40.885] - result already collected: FutureResult
[15:32:40.885] result() for ClusterFuture ... done
[15:32:40.885]  - Number of value chunks collected: 2
[15:32:40.885] Resolving 2 futures (chunks) ... DONE
[15:32:40.886] Reducing values from 2 chunks ...
[15:32:40.886]  - Number of values collected after concatenation: 4
[15:32:40.886]  - Number of values expected: 4
[15:32:40.886] Reducing values from 2 chunks ... DONE
[15:32:40.887] future_lapply() ... DONE
List of 2
 $ y0: Named num [1:4] 50 60 70 80
  ..- attr(*, "names")= chr [1:4] "A" "B" "C" "D"
 $ y1: Named num [1:4] 50 60 70 80
  ..- attr(*, "names")= chr [1:4] "A" "B" "C" "D"
[15:32:40.890] future_lapply() ...
[15:32:40.895] Number of chunks: 2
[15:32:40.895] getGlobalsAndPackagesXApply() ...
[15:32:40.895]  - future.globals: TRUE
[15:32:40.895] getGlobalsAndPackages() ...
[15:32:40.895] Searching for globals...
[15:32:40.897] - globals found: [5] 'FUN', '*', ':', 'outer', 'rep'
[15:32:40.898] Searching for globals ... DONE
[15:32:40.898] Resolving globals: FALSE
[15:32:40.898] The total size of the 1 globals is 4.62 KiB (4728 bytes)
[15:32:40.899] The total size of the 1 globals exported for future expression ('FUN()') is 4.62 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.62 KiB of class 'function')
[15:32:40.899] - globals: [1] 'FUN'
[15:32:40.899] 
[15:32:40.899] getGlobalsAndPackages() ... DONE
[15:32:40.900]  - globals found/used: [n=1] 'FUN'
[15:32:40.900]  - needed namespaces: [n=0] 
[15:32:40.900] Finding globals ... DONE
[15:32:40.900]  - use_args: TRUE
[15:32:40.900]  - Getting '...' globals ...
[15:32:40.901] resolve() on list ...
[15:32:40.901]  recursive: 0
[15:32:40.901]  length: 1
[15:32:40.901]  elements: '...'
[15:32:40.902]  length: 0 (resolved future 1)
[15:32:40.902] resolve() on list ... DONE
[15:32:40.902]    - '...' content: [n=0] 
[15:32:40.902] List of 1
[15:32:40.902]  $ ...: list()
[15:32:40.902]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:40.902]  - attr(*, "where")=List of 1
[15:32:40.902]   ..$ ...:<environment: 0x00000276e1c7fc70> 
[15:32:40.902]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:40.902]  - attr(*, "resolved")= logi TRUE
[15:32:40.902]  - attr(*, "total_size")= num NA
[15:32:40.906]  - Getting '...' globals ... DONE
[15:32:40.906] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:40.906] List of 2
[15:32:40.906]  $ ...future.FUN:function (x, y = 2 * 1:5)  
[15:32:40.906]  $ ...          : list()
[15:32:40.906]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:40.906]  - attr(*, "where")=List of 2
[15:32:40.906]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:40.906]   ..$ ...          :<environment: 0x00000276e1c7fc70> 
[15:32:40.906]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:40.906]  - attr(*, "resolved")= logi FALSE
[15:32:40.906]  - attr(*, "total_size")= num 4728
[15:32:40.912] Packages to be attached in all futures: [n=0] 
[15:32:40.912] getGlobalsAndPackagesXApply() ... DONE
[15:32:40.913] Number of futures (= number of chunks): 2
[15:32:40.913] Launching 2 futures (chunks) ...
[15:32:40.913] Chunk #1 of 2 ...
[15:32:40.914]  - Finding globals in 'X' for chunk #1 ...
[15:32:40.914] getGlobalsAndPackages() ...
[15:32:40.914] Searching for globals...
[15:32:40.915] 
[15:32:40.915] Searching for globals ... DONE
[15:32:40.915] - globals: [0] <none>
[15:32:40.916] getGlobalsAndPackages() ... DONE
[15:32:40.916]    + additional globals found: [n=0] 
[15:32:40.916]    + additional namespaces needed: [n=0] 
[15:32:40.916]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:40.917]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:40.917]  - seeds: <none>
[15:32:40.917]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:40.918] getGlobalsAndPackages() ...
[15:32:40.918] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:40.918] Resolving globals: FALSE
[15:32:40.919] Tweak future expression to call with '...' arguments ...
[15:32:40.919] {
[15:32:40.919]     do.call(function(...) {
[15:32:40.919]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:40.919]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:40.919]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:40.919]             on.exit(options(oopts), add = TRUE)
[15:32:40.919]         }
[15:32:40.919]         {
[15:32:40.919]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:40.919]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:40.919]                 ...future.FUN(...future.X_jj, ...)
[15:32:40.919]             })
[15:32:40.919]         }
[15:32:40.919]     }, args = future.call.arguments)
[15:32:40.919] }
[15:32:40.920] Tweak future expression to call with '...' arguments ... DONE
[15:32:40.920] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:40.921] 
[15:32:40.921] getGlobalsAndPackages() ... DONE
[15:32:40.922] run() for 'Future' ...
[15:32:40.922] - state: 'created'
[15:32:40.922] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:40.939] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:40.939] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:40.939]   - Field: 'node'
[15:32:40.940]   - Field: 'label'
[15:32:40.940]   - Field: 'local'
[15:32:40.940]   - Field: 'owner'
[15:32:40.940]   - Field: 'envir'
[15:32:40.940]   - Field: 'workers'
[15:32:40.941]   - Field: 'packages'
[15:32:40.941]   - Field: 'gc'
[15:32:40.941]   - Field: 'conditions'
[15:32:40.941]   - Field: 'persistent'
[15:32:40.941]   - Field: 'expr'
[15:32:40.941]   - Field: 'uuid'
[15:32:40.942]   - Field: 'seed'
[15:32:40.942]   - Field: 'version'
[15:32:40.942]   - Field: 'result'
[15:32:40.942]   - Field: 'asynchronous'
[15:32:40.942]   - Field: 'calls'
[15:32:40.943]   - Field: 'globals'
[15:32:40.943]   - Field: 'stdout'
[15:32:40.943]   - Field: 'earlySignal'
[15:32:40.943]   - Field: 'lazy'
[15:32:40.943]   - Field: 'state'
[15:32:40.944] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:40.944] - Launch lazy future ...
[15:32:40.944] Packages needed by the future expression (n = 0): <none>
[15:32:40.944] Packages needed by future strategies (n = 0): <none>
[15:32:40.945] {
[15:32:40.945]     {
[15:32:40.945]         {
[15:32:40.945]             ...future.startTime <- base::Sys.time()
[15:32:40.945]             {
[15:32:40.945]                 {
[15:32:40.945]                   {
[15:32:40.945]                     {
[15:32:40.945]                       base::local({
[15:32:40.945]                         has_future <- base::requireNamespace("future", 
[15:32:40.945]                           quietly = TRUE)
[15:32:40.945]                         if (has_future) {
[15:32:40.945]                           ns <- base::getNamespace("future")
[15:32:40.945]                           version <- ns[[".package"]][["version"]]
[15:32:40.945]                           if (is.null(version)) 
[15:32:40.945]                             version <- utils::packageVersion("future")
[15:32:40.945]                         }
[15:32:40.945]                         else {
[15:32:40.945]                           version <- NULL
[15:32:40.945]                         }
[15:32:40.945]                         if (!has_future || version < "1.8.0") {
[15:32:40.945]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:40.945]                             "", base::R.version$version.string), 
[15:32:40.945]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:40.945]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:40.945]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:40.945]                               "release", "version")], collapse = " "), 
[15:32:40.945]                             hostname = base::Sys.info()[["nodename"]])
[15:32:40.945]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:40.945]                             info)
[15:32:40.945]                           info <- base::paste(info, collapse = "; ")
[15:32:40.945]                           if (!has_future) {
[15:32:40.945]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:40.945]                               info)
[15:32:40.945]                           }
[15:32:40.945]                           else {
[15:32:40.945]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:40.945]                               info, version)
[15:32:40.945]                           }
[15:32:40.945]                           base::stop(msg)
[15:32:40.945]                         }
[15:32:40.945]                       })
[15:32:40.945]                     }
[15:32:40.945]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:40.945]                     base::options(mc.cores = 1L)
[15:32:40.945]                   }
[15:32:40.945]                   ...future.strategy.old <- future::plan("list")
[15:32:40.945]                   options(future.plan = NULL)
[15:32:40.945]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:40.945]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:40.945]                 }
[15:32:40.945]                 ...future.workdir <- getwd()
[15:32:40.945]             }
[15:32:40.945]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:40.945]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:40.945]         }
[15:32:40.945]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:40.945]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:40.945]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:40.945]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:40.945]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:40.945]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:40.945]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:40.945]             base::names(...future.oldOptions))
[15:32:40.945]     }
[15:32:40.945]     if (FALSE) {
[15:32:40.945]     }
[15:32:40.945]     else {
[15:32:40.945]         if (TRUE) {
[15:32:40.945]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:40.945]                 open = "w")
[15:32:40.945]         }
[15:32:40.945]         else {
[15:32:40.945]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:40.945]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:40.945]         }
[15:32:40.945]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:40.945]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:40.945]             base::sink(type = "output", split = FALSE)
[15:32:40.945]             base::close(...future.stdout)
[15:32:40.945]         }, add = TRUE)
[15:32:40.945]     }
[15:32:40.945]     ...future.frame <- base::sys.nframe()
[15:32:40.945]     ...future.conditions <- base::list()
[15:32:40.945]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:40.945]     if (FALSE) {
[15:32:40.945]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:40.945]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:40.945]     }
[15:32:40.945]     ...future.result <- base::tryCatch({
[15:32:40.945]         base::withCallingHandlers({
[15:32:40.945]             ...future.value <- base::withVisible(base::local({
[15:32:40.945]                 ...future.makeSendCondition <- base::local({
[15:32:40.945]                   sendCondition <- NULL
[15:32:40.945]                   function(frame = 1L) {
[15:32:40.945]                     if (is.function(sendCondition)) 
[15:32:40.945]                       return(sendCondition)
[15:32:40.945]                     ns <- getNamespace("parallel")
[15:32:40.945]                     if (exists("sendData", mode = "function", 
[15:32:40.945]                       envir = ns)) {
[15:32:40.945]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:40.945]                         envir = ns)
[15:32:40.945]                       envir <- sys.frame(frame)
[15:32:40.945]                       master <- NULL
[15:32:40.945]                       while (!identical(envir, .GlobalEnv) && 
[15:32:40.945]                         !identical(envir, emptyenv())) {
[15:32:40.945]                         if (exists("master", mode = "list", envir = envir, 
[15:32:40.945]                           inherits = FALSE)) {
[15:32:40.945]                           master <- get("master", mode = "list", 
[15:32:40.945]                             envir = envir, inherits = FALSE)
[15:32:40.945]                           if (inherits(master, c("SOCKnode", 
[15:32:40.945]                             "SOCK0node"))) {
[15:32:40.945]                             sendCondition <<- function(cond) {
[15:32:40.945]                               data <- list(type = "VALUE", value = cond, 
[15:32:40.945]                                 success = TRUE)
[15:32:40.945]                               parallel_sendData(master, data)
[15:32:40.945]                             }
[15:32:40.945]                             return(sendCondition)
[15:32:40.945]                           }
[15:32:40.945]                         }
[15:32:40.945]                         frame <- frame + 1L
[15:32:40.945]                         envir <- sys.frame(frame)
[15:32:40.945]                       }
[15:32:40.945]                     }
[15:32:40.945]                     sendCondition <<- function(cond) NULL
[15:32:40.945]                   }
[15:32:40.945]                 })
[15:32:40.945]                 withCallingHandlers({
[15:32:40.945]                   {
[15:32:40.945]                     do.call(function(...) {
[15:32:40.945]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:40.945]                       if (!identical(...future.globals.maxSize.org, 
[15:32:40.945]                         ...future.globals.maxSize)) {
[15:32:40.945]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:40.945]                         on.exit(options(oopts), add = TRUE)
[15:32:40.945]                       }
[15:32:40.945]                       {
[15:32:40.945]                         lapply(seq_along(...future.elements_ii), 
[15:32:40.945]                           FUN = function(jj) {
[15:32:40.945]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:40.945]                             ...future.FUN(...future.X_jj, ...)
[15:32:40.945]                           })
[15:32:40.945]                       }
[15:32:40.945]                     }, args = future.call.arguments)
[15:32:40.945]                   }
[15:32:40.945]                 }, immediateCondition = function(cond) {
[15:32:40.945]                   sendCondition <- ...future.makeSendCondition()
[15:32:40.945]                   sendCondition(cond)
[15:32:40.945]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:40.945]                   {
[15:32:40.945]                     inherits <- base::inherits
[15:32:40.945]                     invokeRestart <- base::invokeRestart
[15:32:40.945]                     is.null <- base::is.null
[15:32:40.945]                     muffled <- FALSE
[15:32:40.945]                     if (inherits(cond, "message")) {
[15:32:40.945]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:40.945]                       if (muffled) 
[15:32:40.945]                         invokeRestart("muffleMessage")
[15:32:40.945]                     }
[15:32:40.945]                     else if (inherits(cond, "warning")) {
[15:32:40.945]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:40.945]                       if (muffled) 
[15:32:40.945]                         invokeRestart("muffleWarning")
[15:32:40.945]                     }
[15:32:40.945]                     else if (inherits(cond, "condition")) {
[15:32:40.945]                       if (!is.null(pattern)) {
[15:32:40.945]                         computeRestarts <- base::computeRestarts
[15:32:40.945]                         grepl <- base::grepl
[15:32:40.945]                         restarts <- computeRestarts(cond)
[15:32:40.945]                         for (restart in restarts) {
[15:32:40.945]                           name <- restart$name
[15:32:40.945]                           if (is.null(name)) 
[15:32:40.945]                             next
[15:32:40.945]                           if (!grepl(pattern, name)) 
[15:32:40.945]                             next
[15:32:40.945]                           invokeRestart(restart)
[15:32:40.945]                           muffled <- TRUE
[15:32:40.945]                           break
[15:32:40.945]                         }
[15:32:40.945]                       }
[15:32:40.945]                     }
[15:32:40.945]                     invisible(muffled)
[15:32:40.945]                   }
[15:32:40.945]                   muffleCondition(cond)
[15:32:40.945]                 })
[15:32:40.945]             }))
[15:32:40.945]             future::FutureResult(value = ...future.value$value, 
[15:32:40.945]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:40.945]                   ...future.rng), globalenv = if (FALSE) 
[15:32:40.945]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:40.945]                     ...future.globalenv.names))
[15:32:40.945]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:40.945]         }, condition = base::local({
[15:32:40.945]             c <- base::c
[15:32:40.945]             inherits <- base::inherits
[15:32:40.945]             invokeRestart <- base::invokeRestart
[15:32:40.945]             length <- base::length
[15:32:40.945]             list <- base::list
[15:32:40.945]             seq.int <- base::seq.int
[15:32:40.945]             signalCondition <- base::signalCondition
[15:32:40.945]             sys.calls <- base::sys.calls
[15:32:40.945]             `[[` <- base::`[[`
[15:32:40.945]             `+` <- base::`+`
[15:32:40.945]             `<<-` <- base::`<<-`
[15:32:40.945]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:40.945]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:40.945]                   3L)]
[15:32:40.945]             }
[15:32:40.945]             function(cond) {
[15:32:40.945]                 is_error <- inherits(cond, "error")
[15:32:40.945]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:40.945]                   NULL)
[15:32:40.945]                 if (is_error) {
[15:32:40.945]                   sessionInformation <- function() {
[15:32:40.945]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:40.945]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:40.945]                       search = base::search(), system = base::Sys.info())
[15:32:40.945]                   }
[15:32:40.945]                   ...future.conditions[[length(...future.conditions) + 
[15:32:40.945]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:40.945]                     cond$call), session = sessionInformation(), 
[15:32:40.945]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:40.945]                   signalCondition(cond)
[15:32:40.945]                 }
[15:32:40.945]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:40.945]                 "immediateCondition"))) {
[15:32:40.945]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:40.945]                   ...future.conditions[[length(...future.conditions) + 
[15:32:40.945]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:40.945]                   if (TRUE && !signal) {
[15:32:40.945]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:40.945]                     {
[15:32:40.945]                       inherits <- base::inherits
[15:32:40.945]                       invokeRestart <- base::invokeRestart
[15:32:40.945]                       is.null <- base::is.null
[15:32:40.945]                       muffled <- FALSE
[15:32:40.945]                       if (inherits(cond, "message")) {
[15:32:40.945]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:40.945]                         if (muffled) 
[15:32:40.945]                           invokeRestart("muffleMessage")
[15:32:40.945]                       }
[15:32:40.945]                       else if (inherits(cond, "warning")) {
[15:32:40.945]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:40.945]                         if (muffled) 
[15:32:40.945]                           invokeRestart("muffleWarning")
[15:32:40.945]                       }
[15:32:40.945]                       else if (inherits(cond, "condition")) {
[15:32:40.945]                         if (!is.null(pattern)) {
[15:32:40.945]                           computeRestarts <- base::computeRestarts
[15:32:40.945]                           grepl <- base::grepl
[15:32:40.945]                           restarts <- computeRestarts(cond)
[15:32:40.945]                           for (restart in restarts) {
[15:32:40.945]                             name <- restart$name
[15:32:40.945]                             if (is.null(name)) 
[15:32:40.945]                               next
[15:32:40.945]                             if (!grepl(pattern, name)) 
[15:32:40.945]                               next
[15:32:40.945]                             invokeRestart(restart)
[15:32:40.945]                             muffled <- TRUE
[15:32:40.945]                             break
[15:32:40.945]                           }
[15:32:40.945]                         }
[15:32:40.945]                       }
[15:32:40.945]                       invisible(muffled)
[15:32:40.945]                     }
[15:32:40.945]                     muffleCondition(cond, pattern = "^muffle")
[15:32:40.945]                   }
[15:32:40.945]                 }
[15:32:40.945]                 else {
[15:32:40.945]                   if (TRUE) {
[15:32:40.945]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:40.945]                     {
[15:32:40.945]                       inherits <- base::inherits
[15:32:40.945]                       invokeRestart <- base::invokeRestart
[15:32:40.945]                       is.null <- base::is.null
[15:32:40.945]                       muffled <- FALSE
[15:32:40.945]                       if (inherits(cond, "message")) {
[15:32:40.945]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:40.945]                         if (muffled) 
[15:32:40.945]                           invokeRestart("muffleMessage")
[15:32:40.945]                       }
[15:32:40.945]                       else if (inherits(cond, "warning")) {
[15:32:40.945]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:40.945]                         if (muffled) 
[15:32:40.945]                           invokeRestart("muffleWarning")
[15:32:40.945]                       }
[15:32:40.945]                       else if (inherits(cond, "condition")) {
[15:32:40.945]                         if (!is.null(pattern)) {
[15:32:40.945]                           computeRestarts <- base::computeRestarts
[15:32:40.945]                           grepl <- base::grepl
[15:32:40.945]                           restarts <- computeRestarts(cond)
[15:32:40.945]                           for (restart in restarts) {
[15:32:40.945]                             name <- restart$name
[15:32:40.945]                             if (is.null(name)) 
[15:32:40.945]                               next
[15:32:40.945]                             if (!grepl(pattern, name)) 
[15:32:40.945]                               next
[15:32:40.945]                             invokeRestart(restart)
[15:32:40.945]                             muffled <- TRUE
[15:32:40.945]                             break
[15:32:40.945]                           }
[15:32:40.945]                         }
[15:32:40.945]                       }
[15:32:40.945]                       invisible(muffled)
[15:32:40.945]                     }
[15:32:40.945]                     muffleCondition(cond, pattern = "^muffle")
[15:32:40.945]                   }
[15:32:40.945]                 }
[15:32:40.945]             }
[15:32:40.945]         }))
[15:32:40.945]     }, error = function(ex) {
[15:32:40.945]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:40.945]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:40.945]                 ...future.rng), started = ...future.startTime, 
[15:32:40.945]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:40.945]             version = "1.8"), class = "FutureResult")
[15:32:40.945]     }, finally = {
[15:32:40.945]         if (!identical(...future.workdir, getwd())) 
[15:32:40.945]             setwd(...future.workdir)
[15:32:40.945]         {
[15:32:40.945]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:40.945]                 ...future.oldOptions$nwarnings <- NULL
[15:32:40.945]             }
[15:32:40.945]             base::options(...future.oldOptions)
[15:32:40.945]             if (.Platform$OS.type == "windows") {
[15:32:40.945]                 old_names <- names(...future.oldEnvVars)
[15:32:40.945]                 envs <- base::Sys.getenv()
[15:32:40.945]                 names <- names(envs)
[15:32:40.945]                 common <- intersect(names, old_names)
[15:32:40.945]                 added <- setdiff(names, old_names)
[15:32:40.945]                 removed <- setdiff(old_names, names)
[15:32:40.945]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:40.945]                   envs[common]]
[15:32:40.945]                 NAMES <- toupper(changed)
[15:32:40.945]                 args <- list()
[15:32:40.945]                 for (kk in seq_along(NAMES)) {
[15:32:40.945]                   name <- changed[[kk]]
[15:32:40.945]                   NAME <- NAMES[[kk]]
[15:32:40.945]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:40.945]                     next
[15:32:40.945]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:40.945]                 }
[15:32:40.945]                 NAMES <- toupper(added)
[15:32:40.945]                 for (kk in seq_along(NAMES)) {
[15:32:40.945]                   name <- added[[kk]]
[15:32:40.945]                   NAME <- NAMES[[kk]]
[15:32:40.945]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:40.945]                     next
[15:32:40.945]                   args[[name]] <- ""
[15:32:40.945]                 }
[15:32:40.945]                 NAMES <- toupper(removed)
[15:32:40.945]                 for (kk in seq_along(NAMES)) {
[15:32:40.945]                   name <- removed[[kk]]
[15:32:40.945]                   NAME <- NAMES[[kk]]
[15:32:40.945]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:40.945]                     next
[15:32:40.945]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:40.945]                 }
[15:32:40.945]                 if (length(args) > 0) 
[15:32:40.945]                   base::do.call(base::Sys.setenv, args = args)
[15:32:40.945]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:40.945]             }
[15:32:40.945]             else {
[15:32:40.945]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:40.945]             }
[15:32:40.945]             {
[15:32:40.945]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:40.945]                   0L) {
[15:32:40.945]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:40.945]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:40.945]                   base::options(opts)
[15:32:40.945]                 }
[15:32:40.945]                 {
[15:32:40.945]                   {
[15:32:40.945]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:40.945]                     NULL
[15:32:40.945]                   }
[15:32:40.945]                   options(future.plan = NULL)
[15:32:40.945]                   if (is.na(NA_character_)) 
[15:32:40.945]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:40.945]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:40.945]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:40.945]                     .init = FALSE)
[15:32:40.945]                 }
[15:32:40.945]             }
[15:32:40.945]         }
[15:32:40.945]     })
[15:32:40.945]     if (TRUE) {
[15:32:40.945]         base::sink(type = "output", split = FALSE)
[15:32:40.945]         if (TRUE) {
[15:32:40.945]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:40.945]         }
[15:32:40.945]         else {
[15:32:40.945]             ...future.result["stdout"] <- base::list(NULL)
[15:32:40.945]         }
[15:32:40.945]         base::close(...future.stdout)
[15:32:40.945]         ...future.stdout <- NULL
[15:32:40.945]     }
[15:32:40.945]     ...future.result$conditions <- ...future.conditions
[15:32:40.945]     ...future.result$finished <- base::Sys.time()
[15:32:40.945]     ...future.result
[15:32:40.945] }
[15:32:40.952] Exporting 5 global objects (4.62 KiB) to cluster node #1 ...
[15:32:40.952] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ...
[15:32:40.952] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ... DONE
[15:32:40.953] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:40.953] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:40.954] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:40.955] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:40.955] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:40.955] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:40.956] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:40.956] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:40.957] Exporting 5 global objects (4.62 KiB) to cluster node #1 ... DONE
[15:32:40.958] MultisessionFuture started
[15:32:40.958] - Launch lazy future ... done
[15:32:40.958] run() for 'MultisessionFuture' ... done
[15:32:40.959] Created future:
[15:32:40.988] receiveMessageFromWorker() for ClusterFuture ...
[15:32:40.989] - Validating connection of MultisessionFuture
[15:32:40.989] - received message: FutureResult
[15:32:40.989] - Received FutureResult
[15:32:40.990] - Erased future from FutureRegistry
[15:32:40.990] result() for ClusterFuture ...
[15:32:40.990] - result already collected: FutureResult
[15:32:40.990] result() for ClusterFuture ... done
[15:32:40.991] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:40.959] MultisessionFuture:
[15:32:40.959] Label: 'future_sapply-1'
[15:32:40.959] Expression:
[15:32:40.959] {
[15:32:40.959]     do.call(function(...) {
[15:32:40.959]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:40.959]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:40.959]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:40.959]             on.exit(options(oopts), add = TRUE)
[15:32:40.959]         }
[15:32:40.959]         {
[15:32:40.959]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:40.959]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:40.959]                 ...future.FUN(...future.X_jj, ...)
[15:32:40.959]             })
[15:32:40.959]         }
[15:32:40.959]     }, args = future.call.arguments)
[15:32:40.959] }
[15:32:40.959] Lazy evaluation: FALSE
[15:32:40.959] Asynchronous evaluation: TRUE
[15:32:40.959] Local evaluation: TRUE
[15:32:40.959] Environment: R_GlobalEnv
[15:32:40.959] Capture standard output: TRUE
[15:32:40.959] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:40.959] Globals: 5 objects totaling 4.73 KiB (function '...future.FUN' of 4.62 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)
[15:32:40.959] Packages: <none>
[15:32:40.959] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:40.959] Resolved: TRUE
[15:32:40.959] Value: <not collected>
[15:32:40.959] Conditions captured: <none>
[15:32:40.959] Early signaling: FALSE
[15:32:40.959] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:40.959] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:40.991] Chunk #1 of 2 ... DONE
[15:32:40.992] Chunk #2 of 2 ...
[15:32:40.992]  - Finding globals in 'X' for chunk #2 ...
[15:32:40.992] getGlobalsAndPackages() ...
[15:32:40.993] Searching for globals...
[15:32:40.993] 
[15:32:40.994] Searching for globals ... DONE
[15:32:40.994] - globals: [0] <none>
[15:32:40.994] getGlobalsAndPackages() ... DONE
[15:32:40.994]    + additional globals found: [n=0] 
[15:32:40.995]    + additional namespaces needed: [n=0] 
[15:32:40.995]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:40.995]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:40.996]  - seeds: <none>
[15:32:40.996]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:40.996] getGlobalsAndPackages() ...
[15:32:40.997] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:40.997] Resolving globals: FALSE
[15:32:40.997] Tweak future expression to call with '...' arguments ...
[15:32:40.998] {
[15:32:40.998]     do.call(function(...) {
[15:32:40.998]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:40.998]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:40.998]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:40.998]             on.exit(options(oopts), add = TRUE)
[15:32:40.998]         }
[15:32:40.998]         {
[15:32:40.998]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:40.998]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:40.998]                 ...future.FUN(...future.X_jj, ...)
[15:32:40.998]             })
[15:32:40.998]         }
[15:32:40.998]     }, args = future.call.arguments)
[15:32:40.998] }
[15:32:40.999] Tweak future expression to call with '...' arguments ... DONE
[15:32:40.999] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:41.000] 
[15:32:41.000] getGlobalsAndPackages() ... DONE
[15:32:41.001] run() for 'Future' ...
[15:32:41.001] - state: 'created'
[15:32:41.002] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:41.021] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:41.022] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:41.022]   - Field: 'node'
[15:32:41.022]   - Field: 'label'
[15:32:41.023]   - Field: 'local'
[15:32:41.023]   - Field: 'owner'
[15:32:41.023]   - Field: 'envir'
[15:32:41.024]   - Field: 'workers'
[15:32:41.024]   - Field: 'packages'
[15:32:41.024]   - Field: 'gc'
[15:32:41.025]   - Field: 'conditions'
[15:32:41.025]   - Field: 'persistent'
[15:32:41.025]   - Field: 'expr'
[15:32:41.026]   - Field: 'uuid'
[15:32:41.026]   - Field: 'seed'
[15:32:41.026]   - Field: 'version'
[15:32:41.026]   - Field: 'result'
[15:32:41.027]   - Field: 'asynchronous'
[15:32:41.027]   - Field: 'calls'
[15:32:41.027]   - Field: 'globals'
[15:32:41.028]   - Field: 'stdout'
[15:32:41.028]   - Field: 'earlySignal'
[15:32:41.028]   - Field: 'lazy'
[15:32:41.028]   - Field: 'state'
[15:32:41.029] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:41.029] - Launch lazy future ...
[15:32:41.030] Packages needed by the future expression (n = 0): <none>
[15:32:41.030] Packages needed by future strategies (n = 0): <none>
[15:32:41.031] {
[15:32:41.031]     {
[15:32:41.031]         {
[15:32:41.031]             ...future.startTime <- base::Sys.time()
[15:32:41.031]             {
[15:32:41.031]                 {
[15:32:41.031]                   {
[15:32:41.031]                     {
[15:32:41.031]                       base::local({
[15:32:41.031]                         has_future <- base::requireNamespace("future", 
[15:32:41.031]                           quietly = TRUE)
[15:32:41.031]                         if (has_future) {
[15:32:41.031]                           ns <- base::getNamespace("future")
[15:32:41.031]                           version <- ns[[".package"]][["version"]]
[15:32:41.031]                           if (is.null(version)) 
[15:32:41.031]                             version <- utils::packageVersion("future")
[15:32:41.031]                         }
[15:32:41.031]                         else {
[15:32:41.031]                           version <- NULL
[15:32:41.031]                         }
[15:32:41.031]                         if (!has_future || version < "1.8.0") {
[15:32:41.031]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:41.031]                             "", base::R.version$version.string), 
[15:32:41.031]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:41.031]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:41.031]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:41.031]                               "release", "version")], collapse = " "), 
[15:32:41.031]                             hostname = base::Sys.info()[["nodename"]])
[15:32:41.031]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:41.031]                             info)
[15:32:41.031]                           info <- base::paste(info, collapse = "; ")
[15:32:41.031]                           if (!has_future) {
[15:32:41.031]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:41.031]                               info)
[15:32:41.031]                           }
[15:32:41.031]                           else {
[15:32:41.031]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:41.031]                               info, version)
[15:32:41.031]                           }
[15:32:41.031]                           base::stop(msg)
[15:32:41.031]                         }
[15:32:41.031]                       })
[15:32:41.031]                     }
[15:32:41.031]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:41.031]                     base::options(mc.cores = 1L)
[15:32:41.031]                   }
[15:32:41.031]                   ...future.strategy.old <- future::plan("list")
[15:32:41.031]                   options(future.plan = NULL)
[15:32:41.031]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:41.031]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:41.031]                 }
[15:32:41.031]                 ...future.workdir <- getwd()
[15:32:41.031]             }
[15:32:41.031]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:41.031]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:41.031]         }
[15:32:41.031]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:41.031]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:41.031]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:41.031]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:41.031]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:41.031]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:41.031]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:41.031]             base::names(...future.oldOptions))
[15:32:41.031]     }
[15:32:41.031]     if (FALSE) {
[15:32:41.031]     }
[15:32:41.031]     else {
[15:32:41.031]         if (TRUE) {
[15:32:41.031]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:41.031]                 open = "w")
[15:32:41.031]         }
[15:32:41.031]         else {
[15:32:41.031]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:41.031]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:41.031]         }
[15:32:41.031]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:41.031]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:41.031]             base::sink(type = "output", split = FALSE)
[15:32:41.031]             base::close(...future.stdout)
[15:32:41.031]         }, add = TRUE)
[15:32:41.031]     }
[15:32:41.031]     ...future.frame <- base::sys.nframe()
[15:32:41.031]     ...future.conditions <- base::list()
[15:32:41.031]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:41.031]     if (FALSE) {
[15:32:41.031]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:41.031]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:41.031]     }
[15:32:41.031]     ...future.result <- base::tryCatch({
[15:32:41.031]         base::withCallingHandlers({
[15:32:41.031]             ...future.value <- base::withVisible(base::local({
[15:32:41.031]                 ...future.makeSendCondition <- base::local({
[15:32:41.031]                   sendCondition <- NULL
[15:32:41.031]                   function(frame = 1L) {
[15:32:41.031]                     if (is.function(sendCondition)) 
[15:32:41.031]                       return(sendCondition)
[15:32:41.031]                     ns <- getNamespace("parallel")
[15:32:41.031]                     if (exists("sendData", mode = "function", 
[15:32:41.031]                       envir = ns)) {
[15:32:41.031]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:41.031]                         envir = ns)
[15:32:41.031]                       envir <- sys.frame(frame)
[15:32:41.031]                       master <- NULL
[15:32:41.031]                       while (!identical(envir, .GlobalEnv) && 
[15:32:41.031]                         !identical(envir, emptyenv())) {
[15:32:41.031]                         if (exists("master", mode = "list", envir = envir, 
[15:32:41.031]                           inherits = FALSE)) {
[15:32:41.031]                           master <- get("master", mode = "list", 
[15:32:41.031]                             envir = envir, inherits = FALSE)
[15:32:41.031]                           if (inherits(master, c("SOCKnode", 
[15:32:41.031]                             "SOCK0node"))) {
[15:32:41.031]                             sendCondition <<- function(cond) {
[15:32:41.031]                               data <- list(type = "VALUE", value = cond, 
[15:32:41.031]                                 success = TRUE)
[15:32:41.031]                               parallel_sendData(master, data)
[15:32:41.031]                             }
[15:32:41.031]                             return(sendCondition)
[15:32:41.031]                           }
[15:32:41.031]                         }
[15:32:41.031]                         frame <- frame + 1L
[15:32:41.031]                         envir <- sys.frame(frame)
[15:32:41.031]                       }
[15:32:41.031]                     }
[15:32:41.031]                     sendCondition <<- function(cond) NULL
[15:32:41.031]                   }
[15:32:41.031]                 })
[15:32:41.031]                 withCallingHandlers({
[15:32:41.031]                   {
[15:32:41.031]                     do.call(function(...) {
[15:32:41.031]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:41.031]                       if (!identical(...future.globals.maxSize.org, 
[15:32:41.031]                         ...future.globals.maxSize)) {
[15:32:41.031]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:41.031]                         on.exit(options(oopts), add = TRUE)
[15:32:41.031]                       }
[15:32:41.031]                       {
[15:32:41.031]                         lapply(seq_along(...future.elements_ii), 
[15:32:41.031]                           FUN = function(jj) {
[15:32:41.031]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:41.031]                             ...future.FUN(...future.X_jj, ...)
[15:32:41.031]                           })
[15:32:41.031]                       }
[15:32:41.031]                     }, args = future.call.arguments)
[15:32:41.031]                   }
[15:32:41.031]                 }, immediateCondition = function(cond) {
[15:32:41.031]                   sendCondition <- ...future.makeSendCondition()
[15:32:41.031]                   sendCondition(cond)
[15:32:41.031]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:41.031]                   {
[15:32:41.031]                     inherits <- base::inherits
[15:32:41.031]                     invokeRestart <- base::invokeRestart
[15:32:41.031]                     is.null <- base::is.null
[15:32:41.031]                     muffled <- FALSE
[15:32:41.031]                     if (inherits(cond, "message")) {
[15:32:41.031]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:41.031]                       if (muffled) 
[15:32:41.031]                         invokeRestart("muffleMessage")
[15:32:41.031]                     }
[15:32:41.031]                     else if (inherits(cond, "warning")) {
[15:32:41.031]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:41.031]                       if (muffled) 
[15:32:41.031]                         invokeRestart("muffleWarning")
[15:32:41.031]                     }
[15:32:41.031]                     else if (inherits(cond, "condition")) {
[15:32:41.031]                       if (!is.null(pattern)) {
[15:32:41.031]                         computeRestarts <- base::computeRestarts
[15:32:41.031]                         grepl <- base::grepl
[15:32:41.031]                         restarts <- computeRestarts(cond)
[15:32:41.031]                         for (restart in restarts) {
[15:32:41.031]                           name <- restart$name
[15:32:41.031]                           if (is.null(name)) 
[15:32:41.031]                             next
[15:32:41.031]                           if (!grepl(pattern, name)) 
[15:32:41.031]                             next
[15:32:41.031]                           invokeRestart(restart)
[15:32:41.031]                           muffled <- TRUE
[15:32:41.031]                           break
[15:32:41.031]                         }
[15:32:41.031]                       }
[15:32:41.031]                     }
[15:32:41.031]                     invisible(muffled)
[15:32:41.031]                   }
[15:32:41.031]                   muffleCondition(cond)
[15:32:41.031]                 })
[15:32:41.031]             }))
[15:32:41.031]             future::FutureResult(value = ...future.value$value, 
[15:32:41.031]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:41.031]                   ...future.rng), globalenv = if (FALSE) 
[15:32:41.031]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:41.031]                     ...future.globalenv.names))
[15:32:41.031]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:41.031]         }, condition = base::local({
[15:32:41.031]             c <- base::c
[15:32:41.031]             inherits <- base::inherits
[15:32:41.031]             invokeRestart <- base::invokeRestart
[15:32:41.031]             length <- base::length
[15:32:41.031]             list <- base::list
[15:32:41.031]             seq.int <- base::seq.int
[15:32:41.031]             signalCondition <- base::signalCondition
[15:32:41.031]             sys.calls <- base::sys.calls
[15:32:41.031]             `[[` <- base::`[[`
[15:32:41.031]             `+` <- base::`+`
[15:32:41.031]             `<<-` <- base::`<<-`
[15:32:41.031]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:41.031]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:41.031]                   3L)]
[15:32:41.031]             }
[15:32:41.031]             function(cond) {
[15:32:41.031]                 is_error <- inherits(cond, "error")
[15:32:41.031]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:41.031]                   NULL)
[15:32:41.031]                 if (is_error) {
[15:32:41.031]                   sessionInformation <- function() {
[15:32:41.031]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:41.031]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:41.031]                       search = base::search(), system = base::Sys.info())
[15:32:41.031]                   }
[15:32:41.031]                   ...future.conditions[[length(...future.conditions) + 
[15:32:41.031]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:41.031]                     cond$call), session = sessionInformation(), 
[15:32:41.031]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:41.031]                   signalCondition(cond)
[15:32:41.031]                 }
[15:32:41.031]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:41.031]                 "immediateCondition"))) {
[15:32:41.031]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:41.031]                   ...future.conditions[[length(...future.conditions) + 
[15:32:41.031]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:41.031]                   if (TRUE && !signal) {
[15:32:41.031]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:41.031]                     {
[15:32:41.031]                       inherits <- base::inherits
[15:32:41.031]                       invokeRestart <- base::invokeRestart
[15:32:41.031]                       is.null <- base::is.null
[15:32:41.031]                       muffled <- FALSE
[15:32:41.031]                       if (inherits(cond, "message")) {
[15:32:41.031]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:41.031]                         if (muffled) 
[15:32:41.031]                           invokeRestart("muffleMessage")
[15:32:41.031]                       }
[15:32:41.031]                       else if (inherits(cond, "warning")) {
[15:32:41.031]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:41.031]                         if (muffled) 
[15:32:41.031]                           invokeRestart("muffleWarning")
[15:32:41.031]                       }
[15:32:41.031]                       else if (inherits(cond, "condition")) {
[15:32:41.031]                         if (!is.null(pattern)) {
[15:32:41.031]                           computeRestarts <- base::computeRestarts
[15:32:41.031]                           grepl <- base::grepl
[15:32:41.031]                           restarts <- computeRestarts(cond)
[15:32:41.031]                           for (restart in restarts) {
[15:32:41.031]                             name <- restart$name
[15:32:41.031]                             if (is.null(name)) 
[15:32:41.031]                               next
[15:32:41.031]                             if (!grepl(pattern, name)) 
[15:32:41.031]                               next
[15:32:41.031]                             invokeRestart(restart)
[15:32:41.031]                             muffled <- TRUE
[15:32:41.031]                             break
[15:32:41.031]                           }
[15:32:41.031]                         }
[15:32:41.031]                       }
[15:32:41.031]                       invisible(muffled)
[15:32:41.031]                     }
[15:32:41.031]                     muffleCondition(cond, pattern = "^muffle")
[15:32:41.031]                   }
[15:32:41.031]                 }
[15:32:41.031]                 else {
[15:32:41.031]                   if (TRUE) {
[15:32:41.031]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:41.031]                     {
[15:32:41.031]                       inherits <- base::inherits
[15:32:41.031]                       invokeRestart <- base::invokeRestart
[15:32:41.031]                       is.null <- base::is.null
[15:32:41.031]                       muffled <- FALSE
[15:32:41.031]                       if (inherits(cond, "message")) {
[15:32:41.031]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:41.031]                         if (muffled) 
[15:32:41.031]                           invokeRestart("muffleMessage")
[15:32:41.031]                       }
[15:32:41.031]                       else if (inherits(cond, "warning")) {
[15:32:41.031]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:41.031]                         if (muffled) 
[15:32:41.031]                           invokeRestart("muffleWarning")
[15:32:41.031]                       }
[15:32:41.031]                       else if (inherits(cond, "condition")) {
[15:32:41.031]                         if (!is.null(pattern)) {
[15:32:41.031]                           computeRestarts <- base::computeRestarts
[15:32:41.031]                           grepl <- base::grepl
[15:32:41.031]                           restarts <- computeRestarts(cond)
[15:32:41.031]                           for (restart in restarts) {
[15:32:41.031]                             name <- restart$name
[15:32:41.031]                             if (is.null(name)) 
[15:32:41.031]                               next
[15:32:41.031]                             if (!grepl(pattern, name)) 
[15:32:41.031]                               next
[15:32:41.031]                             invokeRestart(restart)
[15:32:41.031]                             muffled <- TRUE
[15:32:41.031]                             break
[15:32:41.031]                           }
[15:32:41.031]                         }
[15:32:41.031]                       }
[15:32:41.031]                       invisible(muffled)
[15:32:41.031]                     }
[15:32:41.031]                     muffleCondition(cond, pattern = "^muffle")
[15:32:41.031]                   }
[15:32:41.031]                 }
[15:32:41.031]             }
[15:32:41.031]         }))
[15:32:41.031]     }, error = function(ex) {
[15:32:41.031]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:41.031]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:41.031]                 ...future.rng), started = ...future.startTime, 
[15:32:41.031]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:41.031]             version = "1.8"), class = "FutureResult")
[15:32:41.031]     }, finally = {
[15:32:41.031]         if (!identical(...future.workdir, getwd())) 
[15:32:41.031]             setwd(...future.workdir)
[15:32:41.031]         {
[15:32:41.031]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:41.031]                 ...future.oldOptions$nwarnings <- NULL
[15:32:41.031]             }
[15:32:41.031]             base::options(...future.oldOptions)
[15:32:41.031]             if (.Platform$OS.type == "windows") {
[15:32:41.031]                 old_names <- names(...future.oldEnvVars)
[15:32:41.031]                 envs <- base::Sys.getenv()
[15:32:41.031]                 names <- names(envs)
[15:32:41.031]                 common <- intersect(names, old_names)
[15:32:41.031]                 added <- setdiff(names, old_names)
[15:32:41.031]                 removed <- setdiff(old_names, names)
[15:32:41.031]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:41.031]                   envs[common]]
[15:32:41.031]                 NAMES <- toupper(changed)
[15:32:41.031]                 args <- list()
[15:32:41.031]                 for (kk in seq_along(NAMES)) {
[15:32:41.031]                   name <- changed[[kk]]
[15:32:41.031]                   NAME <- NAMES[[kk]]
[15:32:41.031]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:41.031]                     next
[15:32:41.031]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:41.031]                 }
[15:32:41.031]                 NAMES <- toupper(added)
[15:32:41.031]                 for (kk in seq_along(NAMES)) {
[15:32:41.031]                   name <- added[[kk]]
[15:32:41.031]                   NAME <- NAMES[[kk]]
[15:32:41.031]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:41.031]                     next
[15:32:41.031]                   args[[name]] <- ""
[15:32:41.031]                 }
[15:32:41.031]                 NAMES <- toupper(removed)
[15:32:41.031]                 for (kk in seq_along(NAMES)) {
[15:32:41.031]                   name <- removed[[kk]]
[15:32:41.031]                   NAME <- NAMES[[kk]]
[15:32:41.031]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:41.031]                     next
[15:32:41.031]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:41.031]                 }
[15:32:41.031]                 if (length(args) > 0) 
[15:32:41.031]                   base::do.call(base::Sys.setenv, args = args)
[15:32:41.031]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:41.031]             }
[15:32:41.031]             else {
[15:32:41.031]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:41.031]             }
[15:32:41.031]             {
[15:32:41.031]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:41.031]                   0L) {
[15:32:41.031]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:41.031]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:41.031]                   base::options(opts)
[15:32:41.031]                 }
[15:32:41.031]                 {
[15:32:41.031]                   {
[15:32:41.031]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:41.031]                     NULL
[15:32:41.031]                   }
[15:32:41.031]                   options(future.plan = NULL)
[15:32:41.031]                   if (is.na(NA_character_)) 
[15:32:41.031]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:41.031]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:41.031]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:41.031]                     .init = FALSE)
[15:32:41.031]                 }
[15:32:41.031]             }
[15:32:41.031]         }
[15:32:41.031]     })
[15:32:41.031]     if (TRUE) {
[15:32:41.031]         base::sink(type = "output", split = FALSE)
[15:32:41.031]         if (TRUE) {
[15:32:41.031]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:41.031]         }
[15:32:41.031]         else {
[15:32:41.031]             ...future.result["stdout"] <- base::list(NULL)
[15:32:41.031]         }
[15:32:41.031]         base::close(...future.stdout)
[15:32:41.031]         ...future.stdout <- NULL
[15:32:41.031]     }
[15:32:41.031]     ...future.result$conditions <- ...future.conditions
[15:32:41.031]     ...future.result$finished <- base::Sys.time()
[15:32:41.031]     ...future.result
[15:32:41.031] }
[15:32:41.041] Exporting 5 global objects (4.62 KiB) to cluster node #1 ...
[15:32:41.041] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ...
[15:32:41.042] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ... DONE
[15:32:41.042] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:41.043] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:41.043] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:41.044] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:41.044] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:41.045] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:41.046] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:41.046] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:41.047] Exporting 5 global objects (4.62 KiB) to cluster node #1 ... DONE
[15:32:41.048] MultisessionFuture started
[15:32:41.048] - Launch lazy future ... done
[15:32:41.048] run() for 'MultisessionFuture' ... done
[15:32:41.049] Created future:
[15:32:41.069] receiveMessageFromWorker() for ClusterFuture ...
[15:32:41.069] - Validating connection of MultisessionFuture
[15:32:41.070] - received message: FutureResult
[15:32:41.070] - Received FutureResult
[15:32:41.070] - Erased future from FutureRegistry
[15:32:41.071] result() for ClusterFuture ...
[15:32:41.071] - result already collected: FutureResult
[15:32:41.071] result() for ClusterFuture ... done
[15:32:41.071] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:41.049] MultisessionFuture:
[15:32:41.049] Label: 'future_sapply-2'
[15:32:41.049] Expression:
[15:32:41.049] {
[15:32:41.049]     do.call(function(...) {
[15:32:41.049]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:41.049]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:41.049]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:41.049]             on.exit(options(oopts), add = TRUE)
[15:32:41.049]         }
[15:32:41.049]         {
[15:32:41.049]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:41.049]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:41.049]                 ...future.FUN(...future.X_jj, ...)
[15:32:41.049]             })
[15:32:41.049]         }
[15:32:41.049]     }, args = future.call.arguments)
[15:32:41.049] }
[15:32:41.049] Lazy evaluation: FALSE
[15:32:41.049] Asynchronous evaluation: TRUE
[15:32:41.049] Local evaluation: TRUE
[15:32:41.049] Environment: R_GlobalEnv
[15:32:41.049] Capture standard output: TRUE
[15:32:41.049] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:41.049] Globals: 5 objects totaling 4.73 KiB (function '...future.FUN' of 4.62 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)
[15:32:41.049] Packages: <none>
[15:32:41.049] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:41.049] Resolved: TRUE
[15:32:41.049] Value: <not collected>
[15:32:41.049] Conditions captured: <none>
[15:32:41.049] Early signaling: FALSE
[15:32:41.049] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:41.049] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:41.072] Chunk #2 of 2 ... DONE
[15:32:41.072] Launching 2 futures (chunks) ... DONE
[15:32:41.072] Resolving 2 futures (chunks) ...
[15:32:41.073] resolve() on list ...
[15:32:41.073]  recursive: 0
[15:32:41.073]  length: 2
[15:32:41.073] 
[15:32:41.074] Future #1
[15:32:41.074] result() for ClusterFuture ...
[15:32:41.074] - result already collected: FutureResult
[15:32:41.074] result() for ClusterFuture ... done
[15:32:41.080] result() for ClusterFuture ...
[15:32:41.080] - result already collected: FutureResult
[15:32:41.081] result() for ClusterFuture ... done
[15:32:41.081] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:41.082] - nx: 2
[15:32:41.082] - relay: TRUE
[15:32:41.082] - stdout: TRUE
[15:32:41.082] - signal: TRUE
[15:32:41.083] - resignal: FALSE
[15:32:41.083] - force: TRUE
[15:32:41.083] - relayed: [n=2] FALSE, FALSE
[15:32:41.084] - queued futures: [n=2] FALSE, FALSE
[15:32:41.084]  - until=1
[15:32:41.084]  - relaying element #1
[15:32:41.085] result() for ClusterFuture ...
[15:32:41.085] - result already collected: FutureResult
[15:32:41.085] result() for ClusterFuture ... done
[15:32:41.086] result() for ClusterFuture ...
[15:32:41.086] - result already collected: FutureResult
[15:32:41.086] result() for ClusterFuture ... done
[15:32:41.086] result() for ClusterFuture ...
[15:32:41.087] - result already collected: FutureResult
[15:32:41.087] result() for ClusterFuture ... done
[15:32:41.087] result() for ClusterFuture ...
[15:32:41.088] - result already collected: FutureResult
[15:32:41.088] result() for ClusterFuture ... done
[15:32:41.088] - relayed: [n=2] TRUE, FALSE
[15:32:41.088] - queued futures: [n=2] TRUE, FALSE
[15:32:41.089] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:41.089]  length: 1 (resolved future 1)
[15:32:41.089] Future #2
[15:32:41.090] result() for ClusterFuture ...
[15:32:41.090] - result already collected: FutureResult
[15:32:41.090] result() for ClusterFuture ... done
[15:32:41.091] result() for ClusterFuture ...
[15:32:41.091] - result already collected: FutureResult
[15:32:41.091] result() for ClusterFuture ... done
[15:32:41.091] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:41.092] - nx: 2
[15:32:41.092] - relay: TRUE
[15:32:41.092] - stdout: TRUE
[15:32:41.093] - signal: TRUE
[15:32:41.093] - resignal: FALSE
[15:32:41.093] - force: TRUE
[15:32:41.093] - relayed: [n=2] TRUE, FALSE
[15:32:41.094] - queued futures: [n=2] TRUE, FALSE
[15:32:41.094]  - until=2
[15:32:41.094]  - relaying element #2
[15:32:41.095] result() for ClusterFuture ...
[15:32:41.095] - result already collected: FutureResult
[15:32:41.095] result() for ClusterFuture ... done
[15:32:41.095] result() for ClusterFuture ...
[15:32:41.096] - result already collected: FutureResult
[15:32:41.096] result() for ClusterFuture ... done
[15:32:41.096] result() for ClusterFuture ...
[15:32:41.097] - result already collected: FutureResult
[15:32:41.097] result() for ClusterFuture ... done
[15:32:41.097] result() for ClusterFuture ...
[15:32:41.097] - result already collected: FutureResult
[15:32:41.098] result() for ClusterFuture ... done
[15:32:41.098] - relayed: [n=2] TRUE, TRUE
[15:32:41.098] - queued futures: [n=2] TRUE, TRUE
[15:32:41.098] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:41.099]  length: 0 (resolved future 2)
[15:32:41.099] Relaying remaining futures
[15:32:41.099] signalConditionsASAP(NULL, pos=0) ...
[15:32:41.099] - nx: 2
[15:32:41.100] - relay: TRUE
[15:32:41.100] - stdout: TRUE
[15:32:41.100] - signal: TRUE
[15:32:41.100] - resignal: FALSE
[15:32:41.101] - force: TRUE
[15:32:41.101] - relayed: [n=2] TRUE, TRUE
[15:32:41.101] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:41.101] - relayed: [n=2] TRUE, TRUE
[15:32:41.102] - queued futures: [n=2] TRUE, TRUE
[15:32:41.102] signalConditionsASAP(NULL, pos=0) ... done
[15:32:41.102] resolve() on list ... DONE
[15:32:41.102] result() for ClusterFuture ...
[15:32:41.102] - result already collected: FutureResult
[15:32:41.103] result() for ClusterFuture ... done
[15:32:41.103] result() for ClusterFuture ...
[15:32:41.103] - result already collected: FutureResult
[15:32:41.103] result() for ClusterFuture ... done
[15:32:41.104] result() for ClusterFuture ...
[15:32:41.104] - result already collected: FutureResult
[15:32:41.104] result() for ClusterFuture ... done
[15:32:41.104] result() for ClusterFuture ...
[15:32:41.105] - result already collected: FutureResult
[15:32:41.105] result() for ClusterFuture ... done
[15:32:41.105]  - Number of value chunks collected: 2
[15:32:41.105] Resolving 2 futures (chunks) ... DONE
[15:32:41.105] Reducing values from 2 chunks ...
[15:32:41.106]  - Number of values collected after concatenation: 4
[15:32:41.106]  - Number of values expected: 4
[15:32:41.106] Reducing values from 2 chunks ... DONE
[15:32:41.106] future_lapply() ... DONE
List of 2
 $ y0: num [1:15, 1:4] 100 100 100 200 200 200 300 300 300 400 ...
  ..- attr(*, "dimnames")=List of 2
  .. ..$ : NULL
  .. ..$ : chr [1:4] "A" "B" "C" "D"
 $ y1: num [1:15, 1:4] 100 100 100 200 200 200 300 300 300 400 ...
  ..- attr(*, "dimnames")=List of 2
  .. ..$ : NULL
  .. ..$ : chr [1:4] "A" "B" "C" "D"
[15:32:41.111] future_lapply() ...
[15:32:41.115] Number of chunks: 2
[15:32:41.115] getGlobalsAndPackagesXApply() ...
[15:32:41.116]  - future.globals: TRUE
[15:32:41.116] getGlobalsAndPackages() ...
[15:32:41.116] Searching for globals...
[15:32:41.118] - globals found: [1] 'FUN'
[15:32:41.118] Searching for globals ... DONE
[15:32:41.118] Resolving globals: FALSE
[15:32:41.119] The total size of the 1 globals is 848 bytes (848 bytes)
[15:32:41.119] The total size of the 1 globals exported for future expression ('FUN()') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:32:41.120] - globals: [1] 'FUN'
[15:32:41.120] 
[15:32:41.120] getGlobalsAndPackages() ... DONE
[15:32:41.120]  - globals found/used: [n=1] 'FUN'
[15:32:41.121]  - needed namespaces: [n=0] 
[15:32:41.121] Finding globals ... DONE
[15:32:41.121]  - use_args: TRUE
[15:32:41.121]  - Getting '...' globals ...
[15:32:41.122] resolve() on list ...
[15:32:41.122]  recursive: 0
[15:32:41.122]  length: 1
[15:32:41.123]  elements: '...'
[15:32:41.123]  length: 0 (resolved future 1)
[15:32:41.123] resolve() on list ... DONE
[15:32:41.123]    - '...' content: [n=0] 
[15:32:41.124] List of 1
[15:32:41.124]  $ ...: list()
[15:32:41.124]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:41.124]  - attr(*, "where")=List of 1
[15:32:41.124]   ..$ ...:<environment: 0x00000276e1ea2ca8> 
[15:32:41.124]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:41.124]  - attr(*, "resolved")= logi TRUE
[15:32:41.124]  - attr(*, "total_size")= num NA
[15:32:41.128]  - Getting '...' globals ... DONE
[15:32:41.128] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:41.128] List of 2
[15:32:41.128]  $ ...future.FUN:function (x)  
[15:32:41.128]  $ ...          : list()
[15:32:41.128]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:41.128]  - attr(*, "where")=List of 2
[15:32:41.128]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:41.128]   ..$ ...          :<environment: 0x00000276e1ea2ca8> 
[15:32:41.128]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:41.128]  - attr(*, "resolved")= logi FALSE
[15:32:41.128]  - attr(*, "total_size")= num 848
[15:32:41.133] Packages to be attached in all futures: [n=0] 
[15:32:41.133] getGlobalsAndPackagesXApply() ... DONE
[15:32:41.133] Number of futures (= number of chunks): 2
[15:32:41.134] Launching 2 futures (chunks) ...
[15:32:41.134] Chunk #1 of 2 ...
[15:32:41.134]  - Finding globals in 'X' for chunk #1 ...
[15:32:41.134] getGlobalsAndPackages() ...
[15:32:41.135] Searching for globals...
[15:32:41.135] 
[15:32:41.135] Searching for globals ... DONE
[15:32:41.136] - globals: [0] <none>
[15:32:41.136] getGlobalsAndPackages() ... DONE
[15:32:41.136]    + additional globals found: [n=0] 
[15:32:41.136]    + additional namespaces needed: [n=0] 
[15:32:41.137]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:41.137]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:41.137]  - seeds: <none>
[15:32:41.137]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:41.138] getGlobalsAndPackages() ...
[15:32:41.138] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:41.138] Resolving globals: FALSE
[15:32:41.138] Tweak future expression to call with '...' arguments ...
[15:32:41.139] {
[15:32:41.139]     do.call(function(...) {
[15:32:41.139]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:41.139]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:41.139]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:41.139]             on.exit(options(oopts), add = TRUE)
[15:32:41.139]         }
[15:32:41.139]         {
[15:32:41.139]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:41.139]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:41.139]                 ...future.FUN(...future.X_jj, ...)
[15:32:41.139]             })
[15:32:41.139]         }
[15:32:41.139]     }, args = future.call.arguments)
[15:32:41.139] }
[15:32:41.139] Tweak future expression to call with '...' arguments ... DONE
[15:32:41.140] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:41.140] 
[15:32:41.140] getGlobalsAndPackages() ... DONE
[15:32:41.141] run() for 'Future' ...
[15:32:41.141] - state: 'created'
[15:32:41.142] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:41.158] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:41.159] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:41.159]   - Field: 'node'
[15:32:41.159]   - Field: 'label'
[15:32:41.159]   - Field: 'local'
[15:32:41.159]   - Field: 'owner'
[15:32:41.160]   - Field: 'envir'
[15:32:41.160]   - Field: 'workers'
[15:32:41.160]   - Field: 'packages'
[15:32:41.160]   - Field: 'gc'
[15:32:41.160]   - Field: 'conditions'
[15:32:41.160]   - Field: 'persistent'
[15:32:41.161]   - Field: 'expr'
[15:32:41.161]   - Field: 'uuid'
[15:32:41.161]   - Field: 'seed'
[15:32:41.162]   - Field: 'version'
[15:32:41.162]   - Field: 'result'
[15:32:41.162]   - Field: 'asynchronous'
[15:32:41.162]   - Field: 'calls'
[15:32:41.163]   - Field: 'globals'
[15:32:41.163]   - Field: 'stdout'
[15:32:41.163]   - Field: 'earlySignal'
[15:32:41.163]   - Field: 'lazy'
[15:32:41.163]   - Field: 'state'
[15:32:41.163] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:41.164] - Launch lazy future ...
[15:32:41.164] Packages needed by the future expression (n = 0): <none>
[15:32:41.164] Packages needed by future strategies (n = 0): <none>
[15:32:41.165] {
[15:32:41.165]     {
[15:32:41.165]         {
[15:32:41.165]             ...future.startTime <- base::Sys.time()
[15:32:41.165]             {
[15:32:41.165]                 {
[15:32:41.165]                   {
[15:32:41.165]                     {
[15:32:41.165]                       base::local({
[15:32:41.165]                         has_future <- base::requireNamespace("future", 
[15:32:41.165]                           quietly = TRUE)
[15:32:41.165]                         if (has_future) {
[15:32:41.165]                           ns <- base::getNamespace("future")
[15:32:41.165]                           version <- ns[[".package"]][["version"]]
[15:32:41.165]                           if (is.null(version)) 
[15:32:41.165]                             version <- utils::packageVersion("future")
[15:32:41.165]                         }
[15:32:41.165]                         else {
[15:32:41.165]                           version <- NULL
[15:32:41.165]                         }
[15:32:41.165]                         if (!has_future || version < "1.8.0") {
[15:32:41.165]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:41.165]                             "", base::R.version$version.string), 
[15:32:41.165]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:41.165]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:41.165]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:41.165]                               "release", "version")], collapse = " "), 
[15:32:41.165]                             hostname = base::Sys.info()[["nodename"]])
[15:32:41.165]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:41.165]                             info)
[15:32:41.165]                           info <- base::paste(info, collapse = "; ")
[15:32:41.165]                           if (!has_future) {
[15:32:41.165]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:41.165]                               info)
[15:32:41.165]                           }
[15:32:41.165]                           else {
[15:32:41.165]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:41.165]                               info, version)
[15:32:41.165]                           }
[15:32:41.165]                           base::stop(msg)
[15:32:41.165]                         }
[15:32:41.165]                       })
[15:32:41.165]                     }
[15:32:41.165]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:41.165]                     base::options(mc.cores = 1L)
[15:32:41.165]                   }
[15:32:41.165]                   ...future.strategy.old <- future::plan("list")
[15:32:41.165]                   options(future.plan = NULL)
[15:32:41.165]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:41.165]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:41.165]                 }
[15:32:41.165]                 ...future.workdir <- getwd()
[15:32:41.165]             }
[15:32:41.165]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:41.165]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:41.165]         }
[15:32:41.165]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:41.165]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:41.165]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:41.165]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:41.165]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:41.165]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:41.165]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:41.165]             base::names(...future.oldOptions))
[15:32:41.165]     }
[15:32:41.165]     if (FALSE) {
[15:32:41.165]     }
[15:32:41.165]     else {
[15:32:41.165]         if (TRUE) {
[15:32:41.165]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:41.165]                 open = "w")
[15:32:41.165]         }
[15:32:41.165]         else {
[15:32:41.165]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:41.165]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:41.165]         }
[15:32:41.165]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:41.165]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:41.165]             base::sink(type = "output", split = FALSE)
[15:32:41.165]             base::close(...future.stdout)
[15:32:41.165]         }, add = TRUE)
[15:32:41.165]     }
[15:32:41.165]     ...future.frame <- base::sys.nframe()
[15:32:41.165]     ...future.conditions <- base::list()
[15:32:41.165]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:41.165]     if (FALSE) {
[15:32:41.165]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:41.165]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:41.165]     }
[15:32:41.165]     ...future.result <- base::tryCatch({
[15:32:41.165]         base::withCallingHandlers({
[15:32:41.165]             ...future.value <- base::withVisible(base::local({
[15:32:41.165]                 ...future.makeSendCondition <- base::local({
[15:32:41.165]                   sendCondition <- NULL
[15:32:41.165]                   function(frame = 1L) {
[15:32:41.165]                     if (is.function(sendCondition)) 
[15:32:41.165]                       return(sendCondition)
[15:32:41.165]                     ns <- getNamespace("parallel")
[15:32:41.165]                     if (exists("sendData", mode = "function", 
[15:32:41.165]                       envir = ns)) {
[15:32:41.165]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:41.165]                         envir = ns)
[15:32:41.165]                       envir <- sys.frame(frame)
[15:32:41.165]                       master <- NULL
[15:32:41.165]                       while (!identical(envir, .GlobalEnv) && 
[15:32:41.165]                         !identical(envir, emptyenv())) {
[15:32:41.165]                         if (exists("master", mode = "list", envir = envir, 
[15:32:41.165]                           inherits = FALSE)) {
[15:32:41.165]                           master <- get("master", mode = "list", 
[15:32:41.165]                             envir = envir, inherits = FALSE)
[15:32:41.165]                           if (inherits(master, c("SOCKnode", 
[15:32:41.165]                             "SOCK0node"))) {
[15:32:41.165]                             sendCondition <<- function(cond) {
[15:32:41.165]                               data <- list(type = "VALUE", value = cond, 
[15:32:41.165]                                 success = TRUE)
[15:32:41.165]                               parallel_sendData(master, data)
[15:32:41.165]                             }
[15:32:41.165]                             return(sendCondition)
[15:32:41.165]                           }
[15:32:41.165]                         }
[15:32:41.165]                         frame <- frame + 1L
[15:32:41.165]                         envir <- sys.frame(frame)
[15:32:41.165]                       }
[15:32:41.165]                     }
[15:32:41.165]                     sendCondition <<- function(cond) NULL
[15:32:41.165]                   }
[15:32:41.165]                 })
[15:32:41.165]                 withCallingHandlers({
[15:32:41.165]                   {
[15:32:41.165]                     do.call(function(...) {
[15:32:41.165]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:41.165]                       if (!identical(...future.globals.maxSize.org, 
[15:32:41.165]                         ...future.globals.maxSize)) {
[15:32:41.165]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:41.165]                         on.exit(options(oopts), add = TRUE)
[15:32:41.165]                       }
[15:32:41.165]                       {
[15:32:41.165]                         lapply(seq_along(...future.elements_ii), 
[15:32:41.165]                           FUN = function(jj) {
[15:32:41.165]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:41.165]                             ...future.FUN(...future.X_jj, ...)
[15:32:41.165]                           })
[15:32:41.165]                       }
[15:32:41.165]                     }, args = future.call.arguments)
[15:32:41.165]                   }
[15:32:41.165]                 }, immediateCondition = function(cond) {
[15:32:41.165]                   sendCondition <- ...future.makeSendCondition()
[15:32:41.165]                   sendCondition(cond)
[15:32:41.165]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:41.165]                   {
[15:32:41.165]                     inherits <- base::inherits
[15:32:41.165]                     invokeRestart <- base::invokeRestart
[15:32:41.165]                     is.null <- base::is.null
[15:32:41.165]                     muffled <- FALSE
[15:32:41.165]                     if (inherits(cond, "message")) {
[15:32:41.165]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:41.165]                       if (muffled) 
[15:32:41.165]                         invokeRestart("muffleMessage")
[15:32:41.165]                     }
[15:32:41.165]                     else if (inherits(cond, "warning")) {
[15:32:41.165]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:41.165]                       if (muffled) 
[15:32:41.165]                         invokeRestart("muffleWarning")
[15:32:41.165]                     }
[15:32:41.165]                     else if (inherits(cond, "condition")) {
[15:32:41.165]                       if (!is.null(pattern)) {
[15:32:41.165]                         computeRestarts <- base::computeRestarts
[15:32:41.165]                         grepl <- base::grepl
[15:32:41.165]                         restarts <- computeRestarts(cond)
[15:32:41.165]                         for (restart in restarts) {
[15:32:41.165]                           name <- restart$name
[15:32:41.165]                           if (is.null(name)) 
[15:32:41.165]                             next
[15:32:41.165]                           if (!grepl(pattern, name)) 
[15:32:41.165]                             next
[15:32:41.165]                           invokeRestart(restart)
[15:32:41.165]                           muffled <- TRUE
[15:32:41.165]                           break
[15:32:41.165]                         }
[15:32:41.165]                       }
[15:32:41.165]                     }
[15:32:41.165]                     invisible(muffled)
[15:32:41.165]                   }
[15:32:41.165]                   muffleCondition(cond)
[15:32:41.165]                 })
[15:32:41.165]             }))
[15:32:41.165]             future::FutureResult(value = ...future.value$value, 
[15:32:41.165]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:41.165]                   ...future.rng), globalenv = if (FALSE) 
[15:32:41.165]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:41.165]                     ...future.globalenv.names))
[15:32:41.165]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:41.165]         }, condition = base::local({
[15:32:41.165]             c <- base::c
[15:32:41.165]             inherits <- base::inherits
[15:32:41.165]             invokeRestart <- base::invokeRestart
[15:32:41.165]             length <- base::length
[15:32:41.165]             list <- base::list
[15:32:41.165]             seq.int <- base::seq.int
[15:32:41.165]             signalCondition <- base::signalCondition
[15:32:41.165]             sys.calls <- base::sys.calls
[15:32:41.165]             `[[` <- base::`[[`
[15:32:41.165]             `+` <- base::`+`
[15:32:41.165]             `<<-` <- base::`<<-`
[15:32:41.165]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:41.165]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:41.165]                   3L)]
[15:32:41.165]             }
[15:32:41.165]             function(cond) {
[15:32:41.165]                 is_error <- inherits(cond, "error")
[15:32:41.165]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:41.165]                   NULL)
[15:32:41.165]                 if (is_error) {
[15:32:41.165]                   sessionInformation <- function() {
[15:32:41.165]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:41.165]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:41.165]                       search = base::search(), system = base::Sys.info())
[15:32:41.165]                   }
[15:32:41.165]                   ...future.conditions[[length(...future.conditions) + 
[15:32:41.165]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:41.165]                     cond$call), session = sessionInformation(), 
[15:32:41.165]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:41.165]                   signalCondition(cond)
[15:32:41.165]                 }
[15:32:41.165]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:41.165]                 "immediateCondition"))) {
[15:32:41.165]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:41.165]                   ...future.conditions[[length(...future.conditions) + 
[15:32:41.165]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:41.165]                   if (TRUE && !signal) {
[15:32:41.165]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:41.165]                     {
[15:32:41.165]                       inherits <- base::inherits
[15:32:41.165]                       invokeRestart <- base::invokeRestart
[15:32:41.165]                       is.null <- base::is.null
[15:32:41.165]                       muffled <- FALSE
[15:32:41.165]                       if (inherits(cond, "message")) {
[15:32:41.165]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:41.165]                         if (muffled) 
[15:32:41.165]                           invokeRestart("muffleMessage")
[15:32:41.165]                       }
[15:32:41.165]                       else if (inherits(cond, "warning")) {
[15:32:41.165]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:41.165]                         if (muffled) 
[15:32:41.165]                           invokeRestart("muffleWarning")
[15:32:41.165]                       }
[15:32:41.165]                       else if (inherits(cond, "condition")) {
[15:32:41.165]                         if (!is.null(pattern)) {
[15:32:41.165]                           computeRestarts <- base::computeRestarts
[15:32:41.165]                           grepl <- base::grepl
[15:32:41.165]                           restarts <- computeRestarts(cond)
[15:32:41.165]                           for (restart in restarts) {
[15:32:41.165]                             name <- restart$name
[15:32:41.165]                             if (is.null(name)) 
[15:32:41.165]                               next
[15:32:41.165]                             if (!grepl(pattern, name)) 
[15:32:41.165]                               next
[15:32:41.165]                             invokeRestart(restart)
[15:32:41.165]                             muffled <- TRUE
[15:32:41.165]                             break
[15:32:41.165]                           }
[15:32:41.165]                         }
[15:32:41.165]                       }
[15:32:41.165]                       invisible(muffled)
[15:32:41.165]                     }
[15:32:41.165]                     muffleCondition(cond, pattern = "^muffle")
[15:32:41.165]                   }
[15:32:41.165]                 }
[15:32:41.165]                 else {
[15:32:41.165]                   if (TRUE) {
[15:32:41.165]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:41.165]                     {
[15:32:41.165]                       inherits <- base::inherits
[15:32:41.165]                       invokeRestart <- base::invokeRestart
[15:32:41.165]                       is.null <- base::is.null
[15:32:41.165]                       muffled <- FALSE
[15:32:41.165]                       if (inherits(cond, "message")) {
[15:32:41.165]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:41.165]                         if (muffled) 
[15:32:41.165]                           invokeRestart("muffleMessage")
[15:32:41.165]                       }
[15:32:41.165]                       else if (inherits(cond, "warning")) {
[15:32:41.165]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:41.165]                         if (muffled) 
[15:32:41.165]                           invokeRestart("muffleWarning")
[15:32:41.165]                       }
[15:32:41.165]                       else if (inherits(cond, "condition")) {
[15:32:41.165]                         if (!is.null(pattern)) {
[15:32:41.165]                           computeRestarts <- base::computeRestarts
[15:32:41.165]                           grepl <- base::grepl
[15:32:41.165]                           restarts <- computeRestarts(cond)
[15:32:41.165]                           for (restart in restarts) {
[15:32:41.165]                             name <- restart$name
[15:32:41.165]                             if (is.null(name)) 
[15:32:41.165]                               next
[15:32:41.165]                             if (!grepl(pattern, name)) 
[15:32:41.165]                               next
[15:32:41.165]                             invokeRestart(restart)
[15:32:41.165]                             muffled <- TRUE
[15:32:41.165]                             break
[15:32:41.165]                           }
[15:32:41.165]                         }
[15:32:41.165]                       }
[15:32:41.165]                       invisible(muffled)
[15:32:41.165]                     }
[15:32:41.165]                     muffleCondition(cond, pattern = "^muffle")
[15:32:41.165]                   }
[15:32:41.165]                 }
[15:32:41.165]             }
[15:32:41.165]         }))
[15:32:41.165]     }, error = function(ex) {
[15:32:41.165]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:41.165]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:41.165]                 ...future.rng), started = ...future.startTime, 
[15:32:41.165]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:41.165]             version = "1.8"), class = "FutureResult")
[15:32:41.165]     }, finally = {
[15:32:41.165]         if (!identical(...future.workdir, getwd())) 
[15:32:41.165]             setwd(...future.workdir)
[15:32:41.165]         {
[15:32:41.165]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:41.165]                 ...future.oldOptions$nwarnings <- NULL
[15:32:41.165]             }
[15:32:41.165]             base::options(...future.oldOptions)
[15:32:41.165]             if (.Platform$OS.type == "windows") {
[15:32:41.165]                 old_names <- names(...future.oldEnvVars)
[15:32:41.165]                 envs <- base::Sys.getenv()
[15:32:41.165]                 names <- names(envs)
[15:32:41.165]                 common <- intersect(names, old_names)
[15:32:41.165]                 added <- setdiff(names, old_names)
[15:32:41.165]                 removed <- setdiff(old_names, names)
[15:32:41.165]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:41.165]                   envs[common]]
[15:32:41.165]                 NAMES <- toupper(changed)
[15:32:41.165]                 args <- list()
[15:32:41.165]                 for (kk in seq_along(NAMES)) {
[15:32:41.165]                   name <- changed[[kk]]
[15:32:41.165]                   NAME <- NAMES[[kk]]
[15:32:41.165]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:41.165]                     next
[15:32:41.165]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:41.165]                 }
[15:32:41.165]                 NAMES <- toupper(added)
[15:32:41.165]                 for (kk in seq_along(NAMES)) {
[15:32:41.165]                   name <- added[[kk]]
[15:32:41.165]                   NAME <- NAMES[[kk]]
[15:32:41.165]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:41.165]                     next
[15:32:41.165]                   args[[name]] <- ""
[15:32:41.165]                 }
[15:32:41.165]                 NAMES <- toupper(removed)
[15:32:41.165]                 for (kk in seq_along(NAMES)) {
[15:32:41.165]                   name <- removed[[kk]]
[15:32:41.165]                   NAME <- NAMES[[kk]]
[15:32:41.165]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:41.165]                     next
[15:32:41.165]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:41.165]                 }
[15:32:41.165]                 if (length(args) > 0) 
[15:32:41.165]                   base::do.call(base::Sys.setenv, args = args)
[15:32:41.165]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:41.165]             }
[15:32:41.165]             else {
[15:32:41.165]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:41.165]             }
[15:32:41.165]             {
[15:32:41.165]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:41.165]                   0L) {
[15:32:41.165]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:41.165]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:41.165]                   base::options(opts)
[15:32:41.165]                 }
[15:32:41.165]                 {
[15:32:41.165]                   {
[15:32:41.165]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:41.165]                     NULL
[15:32:41.165]                   }
[15:32:41.165]                   options(future.plan = NULL)
[15:32:41.165]                   if (is.na(NA_character_)) 
[15:32:41.165]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:41.165]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:41.165]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:41.165]                     .init = FALSE)
[15:32:41.165]                 }
[15:32:41.165]             }
[15:32:41.165]         }
[15:32:41.165]     })
[15:32:41.165]     if (TRUE) {
[15:32:41.165]         base::sink(type = "output", split = FALSE)
[15:32:41.165]         if (TRUE) {
[15:32:41.165]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:41.165]         }
[15:32:41.165]         else {
[15:32:41.165]             ...future.result["stdout"] <- base::list(NULL)
[15:32:41.165]         }
[15:32:41.165]         base::close(...future.stdout)
[15:32:41.165]         ...future.stdout <- NULL
[15:32:41.165]     }
[15:32:41.165]     ...future.result$conditions <- ...future.conditions
[15:32:41.165]     ...future.result$finished <- base::Sys.time()
[15:32:41.165]     ...future.result
[15:32:41.165] }
[15:32:41.172] Exporting 5 global objects (848 bytes) to cluster node #1 ...
[15:32:41.172] Exporting '...future.FUN' (848 bytes) to cluster node #1 ...
[15:32:41.173] Exporting '...future.FUN' (848 bytes) to cluster node #1 ... DONE
[15:32:41.174] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:41.175] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:41.176] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:41.176] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:41.177] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:41.177] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:41.178] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:41.178] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:41.179] Exporting 5 global objects (848 bytes) to cluster node #1 ... DONE
[15:32:41.180] MultisessionFuture started
[15:32:41.180] - Launch lazy future ... done
[15:32:41.180] run() for 'MultisessionFuture' ... done
[15:32:41.181] Created future:
[15:32:41.213] receiveMessageFromWorker() for ClusterFuture ...
[15:32:41.213] - Validating connection of MultisessionFuture
[15:32:41.214] - received message: FutureResult
[15:32:41.214] - Received FutureResult
[15:32:41.214] - Erased future from FutureRegistry
[15:32:41.214] result() for ClusterFuture ...
[15:32:41.214] - result already collected: FutureResult
[15:32:41.215] result() for ClusterFuture ... done
[15:32:41.215] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:41.181] MultisessionFuture:
[15:32:41.181] Label: 'future_sapply-1'
[15:32:41.181] Expression:
[15:32:41.181] {
[15:32:41.181]     do.call(function(...) {
[15:32:41.181]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:41.181]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:41.181]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:41.181]             on.exit(options(oopts), add = TRUE)
[15:32:41.181]         }
[15:32:41.181]         {
[15:32:41.181]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:41.181]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:41.181]                 ...future.FUN(...future.X_jj, ...)
[15:32:41.181]             })
[15:32:41.181]         }
[15:32:41.181]     }, args = future.call.arguments)
[15:32:41.181] }
[15:32:41.181] Lazy evaluation: FALSE
[15:32:41.181] Asynchronous evaluation: TRUE
[15:32:41.181] Local evaluation: TRUE
[15:32:41.181] Environment: R_GlobalEnv
[15:32:41.181] Capture standard output: TRUE
[15:32:41.181] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:41.181] Globals: 5 objects totaling 960 bytes (function '...future.FUN' of 848 bytes, 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)
[15:32:41.181] Packages: <none>
[15:32:41.181] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:41.181] Resolved: TRUE
[15:32:41.181] Value: <not collected>
[15:32:41.181] Conditions captured: <none>
[15:32:41.181] Early signaling: FALSE
[15:32:41.181] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:41.181] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:41.216] Chunk #1 of 2 ... DONE
[15:32:41.216] Chunk #2 of 2 ...
[15:32:41.216]  - Finding globals in 'X' for chunk #2 ...
[15:32:41.217] getGlobalsAndPackages() ...
[15:32:41.217] Searching for globals...
[15:32:41.217] 
[15:32:41.218] Searching for globals ... DONE
[15:32:41.218] - globals: [0] <none>
[15:32:41.218] getGlobalsAndPackages() ... DONE
[15:32:41.219]    + additional globals found: [n=0] 
[15:32:41.219]    + additional namespaces needed: [n=0] 
[15:32:41.219]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:41.219]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:41.220]  - seeds: <none>
[15:32:41.220]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:41.220] getGlobalsAndPackages() ...
[15:32:41.220] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:41.221] Resolving globals: FALSE
[15:32:41.221] Tweak future expression to call with '...' arguments ...
[15:32:41.221] {
[15:32:41.221]     do.call(function(...) {
[15:32:41.221]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:41.221]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:41.221]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:41.221]             on.exit(options(oopts), add = TRUE)
[15:32:41.221]         }
[15:32:41.221]         {
[15:32:41.221]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:41.221]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:41.221]                 ...future.FUN(...future.X_jj, ...)
[15:32:41.221]             })
[15:32:41.221]         }
[15:32:41.221]     }, args = future.call.arguments)
[15:32:41.221] }
[15:32:41.222] Tweak future expression to call with '...' arguments ... DONE
[15:32:41.223] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:41.223] 
[15:32:41.223] getGlobalsAndPackages() ... DONE
[15:32:41.224] run() for 'Future' ...
[15:32:41.224] - state: 'created'
[15:32:41.224] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:41.241] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:41.242] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:41.242]   - Field: 'node'
[15:32:41.242]   - Field: 'label'
[15:32:41.243]   - Field: 'local'
[15:32:41.243]   - Field: 'owner'
[15:32:41.243]   - Field: 'envir'
[15:32:41.243]   - Field: 'workers'
[15:32:41.244]   - Field: 'packages'
[15:32:41.244]   - Field: 'gc'
[15:32:41.244]   - Field: 'conditions'
[15:32:41.244]   - Field: 'persistent'
[15:32:41.245]   - Field: 'expr'
[15:32:41.245]   - Field: 'uuid'
[15:32:41.245]   - Field: 'seed'
[15:32:41.245]   - Field: 'version'
[15:32:41.246]   - Field: 'result'
[15:32:41.246]   - Field: 'asynchronous'
[15:32:41.246]   - Field: 'calls'
[15:32:41.246]   - Field: 'globals'
[15:32:41.247]   - Field: 'stdout'
[15:32:41.247]   - Field: 'earlySignal'
[15:32:41.247]   - Field: 'lazy'
[15:32:41.248]   - Field: 'state'
[15:32:41.248] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:41.248] - Launch lazy future ...
[15:32:41.249] Packages needed by the future expression (n = 0): <none>
[15:32:41.249] Packages needed by future strategies (n = 0): <none>
[15:32:41.250] {
[15:32:41.250]     {
[15:32:41.250]         {
[15:32:41.250]             ...future.startTime <- base::Sys.time()
[15:32:41.250]             {
[15:32:41.250]                 {
[15:32:41.250]                   {
[15:32:41.250]                     {
[15:32:41.250]                       base::local({
[15:32:41.250]                         has_future <- base::requireNamespace("future", 
[15:32:41.250]                           quietly = TRUE)
[15:32:41.250]                         if (has_future) {
[15:32:41.250]                           ns <- base::getNamespace("future")
[15:32:41.250]                           version <- ns[[".package"]][["version"]]
[15:32:41.250]                           if (is.null(version)) 
[15:32:41.250]                             version <- utils::packageVersion("future")
[15:32:41.250]                         }
[15:32:41.250]                         else {
[15:32:41.250]                           version <- NULL
[15:32:41.250]                         }
[15:32:41.250]                         if (!has_future || version < "1.8.0") {
[15:32:41.250]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:41.250]                             "", base::R.version$version.string), 
[15:32:41.250]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:41.250]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:41.250]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:41.250]                               "release", "version")], collapse = " "), 
[15:32:41.250]                             hostname = base::Sys.info()[["nodename"]])
[15:32:41.250]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:41.250]                             info)
[15:32:41.250]                           info <- base::paste(info, collapse = "; ")
[15:32:41.250]                           if (!has_future) {
[15:32:41.250]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:41.250]                               info)
[15:32:41.250]                           }
[15:32:41.250]                           else {
[15:32:41.250]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:41.250]                               info, version)
[15:32:41.250]                           }
[15:32:41.250]                           base::stop(msg)
[15:32:41.250]                         }
[15:32:41.250]                       })
[15:32:41.250]                     }
[15:32:41.250]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:41.250]                     base::options(mc.cores = 1L)
[15:32:41.250]                   }
[15:32:41.250]                   ...future.strategy.old <- future::plan("list")
[15:32:41.250]                   options(future.plan = NULL)
[15:32:41.250]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:41.250]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:41.250]                 }
[15:32:41.250]                 ...future.workdir <- getwd()
[15:32:41.250]             }
[15:32:41.250]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:41.250]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:41.250]         }
[15:32:41.250]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:41.250]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:41.250]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:41.250]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:41.250]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:41.250]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:41.250]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:41.250]             base::names(...future.oldOptions))
[15:32:41.250]     }
[15:32:41.250]     if (FALSE) {
[15:32:41.250]     }
[15:32:41.250]     else {
[15:32:41.250]         if (TRUE) {
[15:32:41.250]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:41.250]                 open = "w")
[15:32:41.250]         }
[15:32:41.250]         else {
[15:32:41.250]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:41.250]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:41.250]         }
[15:32:41.250]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:41.250]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:41.250]             base::sink(type = "output", split = FALSE)
[15:32:41.250]             base::close(...future.stdout)
[15:32:41.250]         }, add = TRUE)
[15:32:41.250]     }
[15:32:41.250]     ...future.frame <- base::sys.nframe()
[15:32:41.250]     ...future.conditions <- base::list()
[15:32:41.250]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:41.250]     if (FALSE) {
[15:32:41.250]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:41.250]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:41.250]     }
[15:32:41.250]     ...future.result <- base::tryCatch({
[15:32:41.250]         base::withCallingHandlers({
[15:32:41.250]             ...future.value <- base::withVisible(base::local({
[15:32:41.250]                 ...future.makeSendCondition <- base::local({
[15:32:41.250]                   sendCondition <- NULL
[15:32:41.250]                   function(frame = 1L) {
[15:32:41.250]                     if (is.function(sendCondition)) 
[15:32:41.250]                       return(sendCondition)
[15:32:41.250]                     ns <- getNamespace("parallel")
[15:32:41.250]                     if (exists("sendData", mode = "function", 
[15:32:41.250]                       envir = ns)) {
[15:32:41.250]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:41.250]                         envir = ns)
[15:32:41.250]                       envir <- sys.frame(frame)
[15:32:41.250]                       master <- NULL
[15:32:41.250]                       while (!identical(envir, .GlobalEnv) && 
[15:32:41.250]                         !identical(envir, emptyenv())) {
[15:32:41.250]                         if (exists("master", mode = "list", envir = envir, 
[15:32:41.250]                           inherits = FALSE)) {
[15:32:41.250]                           master <- get("master", mode = "list", 
[15:32:41.250]                             envir = envir, inherits = FALSE)
[15:32:41.250]                           if (inherits(master, c("SOCKnode", 
[15:32:41.250]                             "SOCK0node"))) {
[15:32:41.250]                             sendCondition <<- function(cond) {
[15:32:41.250]                               data <- list(type = "VALUE", value = cond, 
[15:32:41.250]                                 success = TRUE)
[15:32:41.250]                               parallel_sendData(master, data)
[15:32:41.250]                             }
[15:32:41.250]                             return(sendCondition)
[15:32:41.250]                           }
[15:32:41.250]                         }
[15:32:41.250]                         frame <- frame + 1L
[15:32:41.250]                         envir <- sys.frame(frame)
[15:32:41.250]                       }
[15:32:41.250]                     }
[15:32:41.250]                     sendCondition <<- function(cond) NULL
[15:32:41.250]                   }
[15:32:41.250]                 })
[15:32:41.250]                 withCallingHandlers({
[15:32:41.250]                   {
[15:32:41.250]                     do.call(function(...) {
[15:32:41.250]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:41.250]                       if (!identical(...future.globals.maxSize.org, 
[15:32:41.250]                         ...future.globals.maxSize)) {
[15:32:41.250]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:41.250]                         on.exit(options(oopts), add = TRUE)
[15:32:41.250]                       }
[15:32:41.250]                       {
[15:32:41.250]                         lapply(seq_along(...future.elements_ii), 
[15:32:41.250]                           FUN = function(jj) {
[15:32:41.250]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:41.250]                             ...future.FUN(...future.X_jj, ...)
[15:32:41.250]                           })
[15:32:41.250]                       }
[15:32:41.250]                     }, args = future.call.arguments)
[15:32:41.250]                   }
[15:32:41.250]                 }, immediateCondition = function(cond) {
[15:32:41.250]                   sendCondition <- ...future.makeSendCondition()
[15:32:41.250]                   sendCondition(cond)
[15:32:41.250]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:41.250]                   {
[15:32:41.250]                     inherits <- base::inherits
[15:32:41.250]                     invokeRestart <- base::invokeRestart
[15:32:41.250]                     is.null <- base::is.null
[15:32:41.250]                     muffled <- FALSE
[15:32:41.250]                     if (inherits(cond, "message")) {
[15:32:41.250]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:41.250]                       if (muffled) 
[15:32:41.250]                         invokeRestart("muffleMessage")
[15:32:41.250]                     }
[15:32:41.250]                     else if (inherits(cond, "warning")) {
[15:32:41.250]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:41.250]                       if (muffled) 
[15:32:41.250]                         invokeRestart("muffleWarning")
[15:32:41.250]                     }
[15:32:41.250]                     else if (inherits(cond, "condition")) {
[15:32:41.250]                       if (!is.null(pattern)) {
[15:32:41.250]                         computeRestarts <- base::computeRestarts
[15:32:41.250]                         grepl <- base::grepl
[15:32:41.250]                         restarts <- computeRestarts(cond)
[15:32:41.250]                         for (restart in restarts) {
[15:32:41.250]                           name <- restart$name
[15:32:41.250]                           if (is.null(name)) 
[15:32:41.250]                             next
[15:32:41.250]                           if (!grepl(pattern, name)) 
[15:32:41.250]                             next
[15:32:41.250]                           invokeRestart(restart)
[15:32:41.250]                           muffled <- TRUE
[15:32:41.250]                           break
[15:32:41.250]                         }
[15:32:41.250]                       }
[15:32:41.250]                     }
[15:32:41.250]                     invisible(muffled)
[15:32:41.250]                   }
[15:32:41.250]                   muffleCondition(cond)
[15:32:41.250]                 })
[15:32:41.250]             }))
[15:32:41.250]             future::FutureResult(value = ...future.value$value, 
[15:32:41.250]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:41.250]                   ...future.rng), globalenv = if (FALSE) 
[15:32:41.250]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:41.250]                     ...future.globalenv.names))
[15:32:41.250]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:41.250]         }, condition = base::local({
[15:32:41.250]             c <- base::c
[15:32:41.250]             inherits <- base::inherits
[15:32:41.250]             invokeRestart <- base::invokeRestart
[15:32:41.250]             length <- base::length
[15:32:41.250]             list <- base::list
[15:32:41.250]             seq.int <- base::seq.int
[15:32:41.250]             signalCondition <- base::signalCondition
[15:32:41.250]             sys.calls <- base::sys.calls
[15:32:41.250]             `[[` <- base::`[[`
[15:32:41.250]             `+` <- base::`+`
[15:32:41.250]             `<<-` <- base::`<<-`
[15:32:41.250]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:41.250]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:41.250]                   3L)]
[15:32:41.250]             }
[15:32:41.250]             function(cond) {
[15:32:41.250]                 is_error <- inherits(cond, "error")
[15:32:41.250]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:41.250]                   NULL)
[15:32:41.250]                 if (is_error) {
[15:32:41.250]                   sessionInformation <- function() {
[15:32:41.250]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:41.250]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:41.250]                       search = base::search(), system = base::Sys.info())
[15:32:41.250]                   }
[15:32:41.250]                   ...future.conditions[[length(...future.conditions) + 
[15:32:41.250]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:41.250]                     cond$call), session = sessionInformation(), 
[15:32:41.250]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:41.250]                   signalCondition(cond)
[15:32:41.250]                 }
[15:32:41.250]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:41.250]                 "immediateCondition"))) {
[15:32:41.250]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:41.250]                   ...future.conditions[[length(...future.conditions) + 
[15:32:41.250]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:41.250]                   if (TRUE && !signal) {
[15:32:41.250]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:41.250]                     {
[15:32:41.250]                       inherits <- base::inherits
[15:32:41.250]                       invokeRestart <- base::invokeRestart
[15:32:41.250]                       is.null <- base::is.null
[15:32:41.250]                       muffled <- FALSE
[15:32:41.250]                       if (inherits(cond, "message")) {
[15:32:41.250]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:41.250]                         if (muffled) 
[15:32:41.250]                           invokeRestart("muffleMessage")
[15:32:41.250]                       }
[15:32:41.250]                       else if (inherits(cond, "warning")) {
[15:32:41.250]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:41.250]                         if (muffled) 
[15:32:41.250]                           invokeRestart("muffleWarning")
[15:32:41.250]                       }
[15:32:41.250]                       else if (inherits(cond, "condition")) {
[15:32:41.250]                         if (!is.null(pattern)) {
[15:32:41.250]                           computeRestarts <- base::computeRestarts
[15:32:41.250]                           grepl <- base::grepl
[15:32:41.250]                           restarts <- computeRestarts(cond)
[15:32:41.250]                           for (restart in restarts) {
[15:32:41.250]                             name <- restart$name
[15:32:41.250]                             if (is.null(name)) 
[15:32:41.250]                               next
[15:32:41.250]                             if (!grepl(pattern, name)) 
[15:32:41.250]                               next
[15:32:41.250]                             invokeRestart(restart)
[15:32:41.250]                             muffled <- TRUE
[15:32:41.250]                             break
[15:32:41.250]                           }
[15:32:41.250]                         }
[15:32:41.250]                       }
[15:32:41.250]                       invisible(muffled)
[15:32:41.250]                     }
[15:32:41.250]                     muffleCondition(cond, pattern = "^muffle")
[15:32:41.250]                   }
[15:32:41.250]                 }
[15:32:41.250]                 else {
[15:32:41.250]                   if (TRUE) {
[15:32:41.250]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:41.250]                     {
[15:32:41.250]                       inherits <- base::inherits
[15:32:41.250]                       invokeRestart <- base::invokeRestart
[15:32:41.250]                       is.null <- base::is.null
[15:32:41.250]                       muffled <- FALSE
[15:32:41.250]                       if (inherits(cond, "message")) {
[15:32:41.250]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:41.250]                         if (muffled) 
[15:32:41.250]                           invokeRestart("muffleMessage")
[15:32:41.250]                       }
[15:32:41.250]                       else if (inherits(cond, "warning")) {
[15:32:41.250]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:41.250]                         if (muffled) 
[15:32:41.250]                           invokeRestart("muffleWarning")
[15:32:41.250]                       }
[15:32:41.250]                       else if (inherits(cond, "condition")) {
[15:32:41.250]                         if (!is.null(pattern)) {
[15:32:41.250]                           computeRestarts <- base::computeRestarts
[15:32:41.250]                           grepl <- base::grepl
[15:32:41.250]                           restarts <- computeRestarts(cond)
[15:32:41.250]                           for (restart in restarts) {
[15:32:41.250]                             name <- restart$name
[15:32:41.250]                             if (is.null(name)) 
[15:32:41.250]                               next
[15:32:41.250]                             if (!grepl(pattern, name)) 
[15:32:41.250]                               next
[15:32:41.250]                             invokeRestart(restart)
[15:32:41.250]                             muffled <- TRUE
[15:32:41.250]                             break
[15:32:41.250]                           }
[15:32:41.250]                         }
[15:32:41.250]                       }
[15:32:41.250]                       invisible(muffled)
[15:32:41.250]                     }
[15:32:41.250]                     muffleCondition(cond, pattern = "^muffle")
[15:32:41.250]                   }
[15:32:41.250]                 }
[15:32:41.250]             }
[15:32:41.250]         }))
[15:32:41.250]     }, error = function(ex) {
[15:32:41.250]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:41.250]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:41.250]                 ...future.rng), started = ...future.startTime, 
[15:32:41.250]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:41.250]             version = "1.8"), class = "FutureResult")
[15:32:41.250]     }, finally = {
[15:32:41.250]         if (!identical(...future.workdir, getwd())) 
[15:32:41.250]             setwd(...future.workdir)
[15:32:41.250]         {
[15:32:41.250]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:41.250]                 ...future.oldOptions$nwarnings <- NULL
[15:32:41.250]             }
[15:32:41.250]             base::options(...future.oldOptions)
[15:32:41.250]             if (.Platform$OS.type == "windows") {
[15:32:41.250]                 old_names <- names(...future.oldEnvVars)
[15:32:41.250]                 envs <- base::Sys.getenv()
[15:32:41.250]                 names <- names(envs)
[15:32:41.250]                 common <- intersect(names, old_names)
[15:32:41.250]                 added <- setdiff(names, old_names)
[15:32:41.250]                 removed <- setdiff(old_names, names)
[15:32:41.250]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:41.250]                   envs[common]]
[15:32:41.250]                 NAMES <- toupper(changed)
[15:32:41.250]                 args <- list()
[15:32:41.250]                 for (kk in seq_along(NAMES)) {
[15:32:41.250]                   name <- changed[[kk]]
[15:32:41.250]                   NAME <- NAMES[[kk]]
[15:32:41.250]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:41.250]                     next
[15:32:41.250]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:41.250]                 }
[15:32:41.250]                 NAMES <- toupper(added)
[15:32:41.250]                 for (kk in seq_along(NAMES)) {
[15:32:41.250]                   name <- added[[kk]]
[15:32:41.250]                   NAME <- NAMES[[kk]]
[15:32:41.250]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:41.250]                     next
[15:32:41.250]                   args[[name]] <- ""
[15:32:41.250]                 }
[15:32:41.250]                 NAMES <- toupper(removed)
[15:32:41.250]                 for (kk in seq_along(NAMES)) {
[15:32:41.250]                   name <- removed[[kk]]
[15:32:41.250]                   NAME <- NAMES[[kk]]
[15:32:41.250]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:41.250]                     next
[15:32:41.250]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:41.250]                 }
[15:32:41.250]                 if (length(args) > 0) 
[15:32:41.250]                   base::do.call(base::Sys.setenv, args = args)
[15:32:41.250]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:41.250]             }
[15:32:41.250]             else {
[15:32:41.250]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:41.250]             }
[15:32:41.250]             {
[15:32:41.250]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:41.250]                   0L) {
[15:32:41.250]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:41.250]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:41.250]                   base::options(opts)
[15:32:41.250]                 }
[15:32:41.250]                 {
[15:32:41.250]                   {
[15:32:41.250]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:41.250]                     NULL
[15:32:41.250]                   }
[15:32:41.250]                   options(future.plan = NULL)
[15:32:41.250]                   if (is.na(NA_character_)) 
[15:32:41.250]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:41.250]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:41.250]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:41.250]                     .init = FALSE)
[15:32:41.250]                 }
[15:32:41.250]             }
[15:32:41.250]         }
[15:32:41.250]     })
[15:32:41.250]     if (TRUE) {
[15:32:41.250]         base::sink(type = "output", split = FALSE)
[15:32:41.250]         if (TRUE) {
[15:32:41.250]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:41.250]         }
[15:32:41.250]         else {
[15:32:41.250]             ...future.result["stdout"] <- base::list(NULL)
[15:32:41.250]         }
[15:32:41.250]         base::close(...future.stdout)
[15:32:41.250]         ...future.stdout <- NULL
[15:32:41.250]     }
[15:32:41.250]     ...future.result$conditions <- ...future.conditions
[15:32:41.250]     ...future.result$finished <- base::Sys.time()
[15:32:41.250]     ...future.result
[15:32:41.250] }
[15:32:41.259] Exporting 5 global objects (848 bytes) to cluster node #1 ...
[15:32:41.259] Exporting '...future.FUN' (848 bytes) to cluster node #1 ...
[15:32:41.260] Exporting '...future.FUN' (848 bytes) to cluster node #1 ... DONE
[15:32:41.260] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:41.261] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:41.261] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:41.262] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:41.262] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:41.262] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:41.263] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:41.263] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:41.264] Exporting 5 global objects (848 bytes) to cluster node #1 ... DONE
[15:32:41.264] MultisessionFuture started
[15:32:41.265] - Launch lazy future ... done
[15:32:41.265] run() for 'MultisessionFuture' ... done
[15:32:41.265] Created future:
[15:32:41.298] receiveMessageFromWorker() for ClusterFuture ...
[15:32:41.298] - Validating connection of MultisessionFuture
[15:32:41.299] - received message: FutureResult
[15:32:41.299] - Received FutureResult
[15:32:41.300] - Erased future from FutureRegistry
[15:32:41.300] result() for ClusterFuture ...
[15:32:41.300] - result already collected: FutureResult
[15:32:41.301] result() for ClusterFuture ... done
[15:32:41.301] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:41.265] MultisessionFuture:
[15:32:41.265] Label: 'future_sapply-2'
[15:32:41.265] Expression:
[15:32:41.265] {
[15:32:41.265]     do.call(function(...) {
[15:32:41.265]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:41.265]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:41.265]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:41.265]             on.exit(options(oopts), add = TRUE)
[15:32:41.265]         }
[15:32:41.265]         {
[15:32:41.265]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:41.265]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:41.265]                 ...future.FUN(...future.X_jj, ...)
[15:32:41.265]             })
[15:32:41.265]         }
[15:32:41.265]     }, args = future.call.arguments)
[15:32:41.265] }
[15:32:41.265] Lazy evaluation: FALSE
[15:32:41.265] Asynchronous evaluation: TRUE
[15:32:41.265] Local evaluation: TRUE
[15:32:41.265] Environment: R_GlobalEnv
[15:32:41.265] Capture standard output: TRUE
[15:32:41.265] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:41.265] Globals: 5 objects totaling 960 bytes (function '...future.FUN' of 848 bytes, 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)
[15:32:41.265] Packages: <none>
[15:32:41.265] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:41.265] Resolved: TRUE
[15:32:41.265] Value: <not collected>
[15:32:41.265] Conditions captured: <none>
[15:32:41.265] Early signaling: FALSE
[15:32:41.265] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:41.265] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:41.302] Chunk #2 of 2 ... DONE
[15:32:41.302] Launching 2 futures (chunks) ... DONE
[15:32:41.302] Resolving 2 futures (chunks) ...
[15:32:41.303] resolve() on list ...
[15:32:41.303]  recursive: 0
[15:32:41.303]  length: 2
[15:32:41.303] 
[15:32:41.303] Future #1
[15:32:41.304] result() for ClusterFuture ...
[15:32:41.304] - result already collected: FutureResult
[15:32:41.304] result() for ClusterFuture ... done
[15:32:41.304] result() for ClusterFuture ...
[15:32:41.304] - result already collected: FutureResult
[15:32:41.304] result() for ClusterFuture ... done
[15:32:41.304] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:41.305] - nx: 2
[15:32:41.305] - relay: TRUE
[15:32:41.305] - stdout: TRUE
[15:32:41.305] - signal: TRUE
[15:32:41.305] - resignal: FALSE
[15:32:41.305] - force: TRUE
[15:32:41.306] - relayed: [n=2] FALSE, FALSE
[15:32:41.306] - queued futures: [n=2] FALSE, FALSE
[15:32:41.306]  - until=1
[15:32:41.306]  - relaying element #1
[15:32:41.306] result() for ClusterFuture ...
[15:32:41.306] - result already collected: FutureResult
[15:32:41.306] result() for ClusterFuture ... done
[15:32:41.307] result() for ClusterFuture ...
[15:32:41.307] - result already collected: FutureResult
[15:32:41.307] result() for ClusterFuture ... done
[15:32:41.307] result() for ClusterFuture ...
[15:32:41.307] - result already collected: FutureResult
[15:32:41.308] result() for ClusterFuture ... done
[15:32:41.308] result() for ClusterFuture ...
[15:32:41.308] - result already collected: FutureResult
[15:32:41.308] result() for ClusterFuture ... done
[15:32:41.308] - relayed: [n=2] TRUE, FALSE
[15:32:41.308] - queued futures: [n=2] TRUE, FALSE
[15:32:41.308] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:41.309]  length: 1 (resolved future 1)
[15:32:41.309] Future #2
[15:32:41.315] result() for ClusterFuture ...
[15:32:41.315] - result already collected: FutureResult
[15:32:41.316] result() for ClusterFuture ... done
[15:32:41.316] result() for ClusterFuture ...
[15:32:41.316] - result already collected: FutureResult
[15:32:41.317] result() for ClusterFuture ... done
[15:32:41.317] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:41.317] - nx: 2
[15:32:41.317] - relay: TRUE
[15:32:41.318] - stdout: TRUE
[15:32:41.318] - signal: TRUE
[15:32:41.318] - resignal: FALSE
[15:32:41.319] - force: TRUE
[15:32:41.319] - relayed: [n=2] TRUE, FALSE
[15:32:41.319] - queued futures: [n=2] TRUE, FALSE
[15:32:41.319]  - until=2
[15:32:41.320]  - relaying element #2
[15:32:41.320] result() for ClusterFuture ...
[15:32:41.320] - result already collected: FutureResult
[15:32:41.320] result() for ClusterFuture ... done
[15:32:41.321] result() for ClusterFuture ...
[15:32:41.321] - result already collected: FutureResult
[15:32:41.321] result() for ClusterFuture ... done
[15:32:41.321] result() for ClusterFuture ...
[15:32:41.322] - result already collected: FutureResult
[15:32:41.322] result() for ClusterFuture ... done
[15:32:41.322] result() for ClusterFuture ...
[15:32:41.322] - result already collected: FutureResult
[15:32:41.323] result() for ClusterFuture ... done
[15:32:41.323] - relayed: [n=2] TRUE, TRUE
[15:32:41.323] - queued futures: [n=2] TRUE, TRUE
[15:32:41.323] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:41.324]  length: 0 (resolved future 2)
[15:32:41.324] Relaying remaining futures
[15:32:41.324] signalConditionsASAP(NULL, pos=0) ...
[15:32:41.324] - nx: 2
[15:32:41.325] - relay: TRUE
[15:32:41.325] - stdout: TRUE
[15:32:41.325] - signal: TRUE
[15:32:41.325] - resignal: FALSE
[15:32:41.325] - force: TRUE
[15:32:41.326] - relayed: [n=2] TRUE, TRUE
[15:32:41.326] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:41.326] - relayed: [n=2] TRUE, TRUE
[15:32:41.326] - queued futures: [n=2] TRUE, TRUE
[15:32:41.326] signalConditionsASAP(NULL, pos=0) ... done
[15:32:41.327] resolve() on list ... DONE
[15:32:41.327] result() for ClusterFuture ...
[15:32:41.327] - result already collected: FutureResult
[15:32:41.327] result() for ClusterFuture ... done
[15:32:41.327] result() for ClusterFuture ...
[15:32:41.328] - result already collected: FutureResult
[15:32:41.328] result() for ClusterFuture ... done
[15:32:41.328] result() for ClusterFuture ...
[15:32:41.328] - result already collected: FutureResult
[15:32:41.328] result() for ClusterFuture ... done
[15:32:41.328] result() for ClusterFuture ...
[15:32:41.328] - result already collected: FutureResult
[15:32:41.329] result() for ClusterFuture ... done
[15:32:41.329]  - Number of value chunks collected: 2
[15:32:41.329] Resolving 2 futures (chunks) ... DONE
[15:32:41.329] Reducing values from 2 chunks ...
[15:32:41.329]  - Number of values collected after concatenation: 4
[15:32:41.330]  - Number of values expected: 4
[15:32:41.330] Reducing values from 2 chunks ... DONE
[15:32:41.330] future_lapply() ... DONE
List of 2
 $ y0: Named num [1:4] 50 60 70 80
  ..- attr(*, "names")= chr [1:4] "A" "B" "C" "D"
 $ y1: Named num [1:4] 50 60 70 80
  ..- attr(*, "names")= chr [1:4] "A" "B" "C" "D"
[15:32:41.332] future_lapply() ...
[15:32:41.337] Number of chunks: 2
[15:32:41.338] getGlobalsAndPackagesXApply() ...
[15:32:41.338]  - future.globals: TRUE
[15:32:41.338] getGlobalsAndPackages() ...
[15:32:41.339] Searching for globals...
[15:32:41.341] - globals found: [2] 'FUN', 'UseMethod'
[15:32:41.341] Searching for globals ... DONE
[15:32:41.341] Resolving globals: FALSE
[15:32:41.342] The total size of the 1 globals is 1.22 KiB (1248 bytes)
[15:32:41.343] The total size of the 1 globals exported for future expression ('FUN()') is 1.22 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.22 KiB of class 'function')
[15:32:41.343] - globals: [1] 'FUN'
[15:32:41.344] 
[15:32:41.344] getGlobalsAndPackages() ... DONE
[15:32:41.344]  - globals found/used: [n=1] 'FUN'
[15:32:41.344]  - needed namespaces: [n=0] 
[15:32:41.345] Finding globals ... DONE
[15:32:41.345]  - use_args: TRUE
[15:32:41.345]  - Getting '...' globals ...
[15:32:41.346] resolve() on list ...
[15:32:41.346]  recursive: 0
[15:32:41.346]  length: 1
[15:32:41.347]  elements: '...'
[15:32:41.347]  length: 0 (resolved future 1)
[15:32:41.347] resolve() on list ... DONE
[15:32:41.348]    - '...' content: [n=0] 
[15:32:41.348] List of 1
[15:32:41.348]  $ ...: list()
[15:32:41.348]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:41.348]  - attr(*, "where")=List of 1
[15:32:41.348]   ..$ ...:<environment: 0x00000276e26a1e60> 
[15:32:41.348]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:41.348]  - attr(*, "resolved")= logi TRUE
[15:32:41.348]  - attr(*, "total_size")= num NA
[15:32:41.353]  - Getting '...' globals ... DONE
[15:32:41.353] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:41.354] List of 2
[15:32:41.354]  $ ...future.FUN:function (x, ...)  
[15:32:41.354]  $ ...          : list()
[15:32:41.354]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:41.354]  - attr(*, "where")=List of 2
[15:32:41.354]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:41.354]   ..$ ...          :<environment: 0x00000276e26a1e60> 
[15:32:41.354]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:41.354]  - attr(*, "resolved")= logi FALSE
[15:32:41.354]  - attr(*, "total_size")= num 1248
[15:32:41.359] Packages to be attached in all futures: [n=0] 
[15:32:41.359] getGlobalsAndPackagesXApply() ... DONE
[15:32:41.360] Number of futures (= number of chunks): 2
[15:32:41.360] Launching 2 futures (chunks) ...
[15:32:41.360] Chunk #1 of 2 ...
[15:32:41.361]  - Finding globals in 'X' for chunk #1 ...
[15:32:41.361] getGlobalsAndPackages() ...
[15:32:41.361] Searching for globals...
[15:32:41.362] 
[15:32:41.362] Searching for globals ... DONE
[15:32:41.362] - globals: [0] <none>
[15:32:41.363] getGlobalsAndPackages() ... DONE
[15:32:41.363]    + additional globals found: [n=0] 
[15:32:41.363]    + additional namespaces needed: [n=0] 
[15:32:41.364]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:41.364]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:41.364]  - seeds: <none>
[15:32:41.364]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:41.365] getGlobalsAndPackages() ...
[15:32:41.365] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:41.365] Resolving globals: FALSE
[15:32:41.366] Tweak future expression to call with '...' arguments ...
[15:32:41.366] {
[15:32:41.366]     do.call(function(...) {
[15:32:41.366]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:41.366]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:41.366]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:41.366]             on.exit(options(oopts), add = TRUE)
[15:32:41.366]         }
[15:32:41.366]         {
[15:32:41.366]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:41.366]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:41.366]                 ...future.FUN(...future.X_jj, ...)
[15:32:41.366]             })
[15:32:41.366]         }
[15:32:41.366]     }, args = future.call.arguments)
[15:32:41.366] }
[15:32:41.367] Tweak future expression to call with '...' arguments ... DONE
[15:32:41.368] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:41.368] 
[15:32:41.368] getGlobalsAndPackages() ... DONE
[15:32:41.369] run() for 'Future' ...
[15:32:41.369] - state: 'created'
[15:32:41.369] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:41.387] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:41.387] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:41.387]   - Field: 'node'
[15:32:41.388]   - Field: 'label'
[15:32:41.388]   - Field: 'local'
[15:32:41.388]   - Field: 'owner'
[15:32:41.388]   - Field: 'envir'
[15:32:41.389]   - Field: 'workers'
[15:32:41.389]   - Field: 'packages'
[15:32:41.389]   - Field: 'gc'
[15:32:41.389]   - Field: 'conditions'
[15:32:41.389]   - Field: 'persistent'
[15:32:41.390]   - Field: 'expr'
[15:32:41.390]   - Field: 'uuid'
[15:32:41.390]   - Field: 'seed'
[15:32:41.390]   - Field: 'version'
[15:32:41.391]   - Field: 'result'
[15:32:41.391]   - Field: 'asynchronous'
[15:32:41.391]   - Field: 'calls'
[15:32:41.392]   - Field: 'globals'
[15:32:41.392]   - Field: 'stdout'
[15:32:41.392]   - Field: 'earlySignal'
[15:32:41.392]   - Field: 'lazy'
[15:32:41.393]   - Field: 'state'
[15:32:41.393] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:41.393] - Launch lazy future ...
[15:32:41.394] Packages needed by the future expression (n = 0): <none>
[15:32:41.395] Packages needed by future strategies (n = 0): <none>
[15:32:41.396] {
[15:32:41.396]     {
[15:32:41.396]         {
[15:32:41.396]             ...future.startTime <- base::Sys.time()
[15:32:41.396]             {
[15:32:41.396]                 {
[15:32:41.396]                   {
[15:32:41.396]                     {
[15:32:41.396]                       base::local({
[15:32:41.396]                         has_future <- base::requireNamespace("future", 
[15:32:41.396]                           quietly = TRUE)
[15:32:41.396]                         if (has_future) {
[15:32:41.396]                           ns <- base::getNamespace("future")
[15:32:41.396]                           version <- ns[[".package"]][["version"]]
[15:32:41.396]                           if (is.null(version)) 
[15:32:41.396]                             version <- utils::packageVersion("future")
[15:32:41.396]                         }
[15:32:41.396]                         else {
[15:32:41.396]                           version <- NULL
[15:32:41.396]                         }
[15:32:41.396]                         if (!has_future || version < "1.8.0") {
[15:32:41.396]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:41.396]                             "", base::R.version$version.string), 
[15:32:41.396]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:41.396]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:41.396]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:41.396]                               "release", "version")], collapse = " "), 
[15:32:41.396]                             hostname = base::Sys.info()[["nodename"]])
[15:32:41.396]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:41.396]                             info)
[15:32:41.396]                           info <- base::paste(info, collapse = "; ")
[15:32:41.396]                           if (!has_future) {
[15:32:41.396]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:41.396]                               info)
[15:32:41.396]                           }
[15:32:41.396]                           else {
[15:32:41.396]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:41.396]                               info, version)
[15:32:41.396]                           }
[15:32:41.396]                           base::stop(msg)
[15:32:41.396]                         }
[15:32:41.396]                       })
[15:32:41.396]                     }
[15:32:41.396]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:41.396]                     base::options(mc.cores = 1L)
[15:32:41.396]                   }
[15:32:41.396]                   ...future.strategy.old <- future::plan("list")
[15:32:41.396]                   options(future.plan = NULL)
[15:32:41.396]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:41.396]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:41.396]                 }
[15:32:41.396]                 ...future.workdir <- getwd()
[15:32:41.396]             }
[15:32:41.396]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:41.396]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:41.396]         }
[15:32:41.396]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:41.396]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:41.396]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:41.396]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:41.396]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:41.396]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:41.396]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:41.396]             base::names(...future.oldOptions))
[15:32:41.396]     }
[15:32:41.396]     if (FALSE) {
[15:32:41.396]     }
[15:32:41.396]     else {
[15:32:41.396]         if (TRUE) {
[15:32:41.396]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:41.396]                 open = "w")
[15:32:41.396]         }
[15:32:41.396]         else {
[15:32:41.396]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:41.396]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:41.396]         }
[15:32:41.396]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:41.396]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:41.396]             base::sink(type = "output", split = FALSE)
[15:32:41.396]             base::close(...future.stdout)
[15:32:41.396]         }, add = TRUE)
[15:32:41.396]     }
[15:32:41.396]     ...future.frame <- base::sys.nframe()
[15:32:41.396]     ...future.conditions <- base::list()
[15:32:41.396]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:41.396]     if (FALSE) {
[15:32:41.396]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:41.396]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:41.396]     }
[15:32:41.396]     ...future.result <- base::tryCatch({
[15:32:41.396]         base::withCallingHandlers({
[15:32:41.396]             ...future.value <- base::withVisible(base::local({
[15:32:41.396]                 ...future.makeSendCondition <- base::local({
[15:32:41.396]                   sendCondition <- NULL
[15:32:41.396]                   function(frame = 1L) {
[15:32:41.396]                     if (is.function(sendCondition)) 
[15:32:41.396]                       return(sendCondition)
[15:32:41.396]                     ns <- getNamespace("parallel")
[15:32:41.396]                     if (exists("sendData", mode = "function", 
[15:32:41.396]                       envir = ns)) {
[15:32:41.396]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:41.396]                         envir = ns)
[15:32:41.396]                       envir <- sys.frame(frame)
[15:32:41.396]                       master <- NULL
[15:32:41.396]                       while (!identical(envir, .GlobalEnv) && 
[15:32:41.396]                         !identical(envir, emptyenv())) {
[15:32:41.396]                         if (exists("master", mode = "list", envir = envir, 
[15:32:41.396]                           inherits = FALSE)) {
[15:32:41.396]                           master <- get("master", mode = "list", 
[15:32:41.396]                             envir = envir, inherits = FALSE)
[15:32:41.396]                           if (inherits(master, c("SOCKnode", 
[15:32:41.396]                             "SOCK0node"))) {
[15:32:41.396]                             sendCondition <<- function(cond) {
[15:32:41.396]                               data <- list(type = "VALUE", value = cond, 
[15:32:41.396]                                 success = TRUE)
[15:32:41.396]                               parallel_sendData(master, data)
[15:32:41.396]                             }
[15:32:41.396]                             return(sendCondition)
[15:32:41.396]                           }
[15:32:41.396]                         }
[15:32:41.396]                         frame <- frame + 1L
[15:32:41.396]                         envir <- sys.frame(frame)
[15:32:41.396]                       }
[15:32:41.396]                     }
[15:32:41.396]                     sendCondition <<- function(cond) NULL
[15:32:41.396]                   }
[15:32:41.396]                 })
[15:32:41.396]                 withCallingHandlers({
[15:32:41.396]                   {
[15:32:41.396]                     do.call(function(...) {
[15:32:41.396]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:41.396]                       if (!identical(...future.globals.maxSize.org, 
[15:32:41.396]                         ...future.globals.maxSize)) {
[15:32:41.396]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:41.396]                         on.exit(options(oopts), add = TRUE)
[15:32:41.396]                       }
[15:32:41.396]                       {
[15:32:41.396]                         lapply(seq_along(...future.elements_ii), 
[15:32:41.396]                           FUN = function(jj) {
[15:32:41.396]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:41.396]                             ...future.FUN(...future.X_jj, ...)
[15:32:41.396]                           })
[15:32:41.396]                       }
[15:32:41.396]                     }, args = future.call.arguments)
[15:32:41.396]                   }
[15:32:41.396]                 }, immediateCondition = function(cond) {
[15:32:41.396]                   sendCondition <- ...future.makeSendCondition()
[15:32:41.396]                   sendCondition(cond)
[15:32:41.396]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:41.396]                   {
[15:32:41.396]                     inherits <- base::inherits
[15:32:41.396]                     invokeRestart <- base::invokeRestart
[15:32:41.396]                     is.null <- base::is.null
[15:32:41.396]                     muffled <- FALSE
[15:32:41.396]                     if (inherits(cond, "message")) {
[15:32:41.396]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:41.396]                       if (muffled) 
[15:32:41.396]                         invokeRestart("muffleMessage")
[15:32:41.396]                     }
[15:32:41.396]                     else if (inherits(cond, "warning")) {
[15:32:41.396]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:41.396]                       if (muffled) 
[15:32:41.396]                         invokeRestart("muffleWarning")
[15:32:41.396]                     }
[15:32:41.396]                     else if (inherits(cond, "condition")) {
[15:32:41.396]                       if (!is.null(pattern)) {
[15:32:41.396]                         computeRestarts <- base::computeRestarts
[15:32:41.396]                         grepl <- base::grepl
[15:32:41.396]                         restarts <- computeRestarts(cond)
[15:32:41.396]                         for (restart in restarts) {
[15:32:41.396]                           name <- restart$name
[15:32:41.396]                           if (is.null(name)) 
[15:32:41.396]                             next
[15:32:41.396]                           if (!grepl(pattern, name)) 
[15:32:41.396]                             next
[15:32:41.396]                           invokeRestart(restart)
[15:32:41.396]                           muffled <- TRUE
[15:32:41.396]                           break
[15:32:41.396]                         }
[15:32:41.396]                       }
[15:32:41.396]                     }
[15:32:41.396]                     invisible(muffled)
[15:32:41.396]                   }
[15:32:41.396]                   muffleCondition(cond)
[15:32:41.396]                 })
[15:32:41.396]             }))
[15:32:41.396]             future::FutureResult(value = ...future.value$value, 
[15:32:41.396]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:41.396]                   ...future.rng), globalenv = if (FALSE) 
[15:32:41.396]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:41.396]                     ...future.globalenv.names))
[15:32:41.396]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:41.396]         }, condition = base::local({
[15:32:41.396]             c <- base::c
[15:32:41.396]             inherits <- base::inherits
[15:32:41.396]             invokeRestart <- base::invokeRestart
[15:32:41.396]             length <- base::length
[15:32:41.396]             list <- base::list
[15:32:41.396]             seq.int <- base::seq.int
[15:32:41.396]             signalCondition <- base::signalCondition
[15:32:41.396]             sys.calls <- base::sys.calls
[15:32:41.396]             `[[` <- base::`[[`
[15:32:41.396]             `+` <- base::`+`
[15:32:41.396]             `<<-` <- base::`<<-`
[15:32:41.396]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:41.396]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:41.396]                   3L)]
[15:32:41.396]             }
[15:32:41.396]             function(cond) {
[15:32:41.396]                 is_error <- inherits(cond, "error")
[15:32:41.396]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:41.396]                   NULL)
[15:32:41.396]                 if (is_error) {
[15:32:41.396]                   sessionInformation <- function() {
[15:32:41.396]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:41.396]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:41.396]                       search = base::search(), system = base::Sys.info())
[15:32:41.396]                   }
[15:32:41.396]                   ...future.conditions[[length(...future.conditions) + 
[15:32:41.396]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:41.396]                     cond$call), session = sessionInformation(), 
[15:32:41.396]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:41.396]                   signalCondition(cond)
[15:32:41.396]                 }
[15:32:41.396]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:41.396]                 "immediateCondition"))) {
[15:32:41.396]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:41.396]                   ...future.conditions[[length(...future.conditions) + 
[15:32:41.396]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:41.396]                   if (TRUE && !signal) {
[15:32:41.396]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:41.396]                     {
[15:32:41.396]                       inherits <- base::inherits
[15:32:41.396]                       invokeRestart <- base::invokeRestart
[15:32:41.396]                       is.null <- base::is.null
[15:32:41.396]                       muffled <- FALSE
[15:32:41.396]                       if (inherits(cond, "message")) {
[15:32:41.396]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:41.396]                         if (muffled) 
[15:32:41.396]                           invokeRestart("muffleMessage")
[15:32:41.396]                       }
[15:32:41.396]                       else if (inherits(cond, "warning")) {
[15:32:41.396]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:41.396]                         if (muffled) 
[15:32:41.396]                           invokeRestart("muffleWarning")
[15:32:41.396]                       }
[15:32:41.396]                       else if (inherits(cond, "condition")) {
[15:32:41.396]                         if (!is.null(pattern)) {
[15:32:41.396]                           computeRestarts <- base::computeRestarts
[15:32:41.396]                           grepl <- base::grepl
[15:32:41.396]                           restarts <- computeRestarts(cond)
[15:32:41.396]                           for (restart in restarts) {
[15:32:41.396]                             name <- restart$name
[15:32:41.396]                             if (is.null(name)) 
[15:32:41.396]                               next
[15:32:41.396]                             if (!grepl(pattern, name)) 
[15:32:41.396]                               next
[15:32:41.396]                             invokeRestart(restart)
[15:32:41.396]                             muffled <- TRUE
[15:32:41.396]                             break
[15:32:41.396]                           }
[15:32:41.396]                         }
[15:32:41.396]                       }
[15:32:41.396]                       invisible(muffled)
[15:32:41.396]                     }
[15:32:41.396]                     muffleCondition(cond, pattern = "^muffle")
[15:32:41.396]                   }
[15:32:41.396]                 }
[15:32:41.396]                 else {
[15:32:41.396]                   if (TRUE) {
[15:32:41.396]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:41.396]                     {
[15:32:41.396]                       inherits <- base::inherits
[15:32:41.396]                       invokeRestart <- base::invokeRestart
[15:32:41.396]                       is.null <- base::is.null
[15:32:41.396]                       muffled <- FALSE
[15:32:41.396]                       if (inherits(cond, "message")) {
[15:32:41.396]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:41.396]                         if (muffled) 
[15:32:41.396]                           invokeRestart("muffleMessage")
[15:32:41.396]                       }
[15:32:41.396]                       else if (inherits(cond, "warning")) {
[15:32:41.396]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:41.396]                         if (muffled) 
[15:32:41.396]                           invokeRestart("muffleWarning")
[15:32:41.396]                       }
[15:32:41.396]                       else if (inherits(cond, "condition")) {
[15:32:41.396]                         if (!is.null(pattern)) {
[15:32:41.396]                           computeRestarts <- base::computeRestarts
[15:32:41.396]                           grepl <- base::grepl
[15:32:41.396]                           restarts <- computeRestarts(cond)
[15:32:41.396]                           for (restart in restarts) {
[15:32:41.396]                             name <- restart$name
[15:32:41.396]                             if (is.null(name)) 
[15:32:41.396]                               next
[15:32:41.396]                             if (!grepl(pattern, name)) 
[15:32:41.396]                               next
[15:32:41.396]                             invokeRestart(restart)
[15:32:41.396]                             muffled <- TRUE
[15:32:41.396]                             break
[15:32:41.396]                           }
[15:32:41.396]                         }
[15:32:41.396]                       }
[15:32:41.396]                       invisible(muffled)
[15:32:41.396]                     }
[15:32:41.396]                     muffleCondition(cond, pattern = "^muffle")
[15:32:41.396]                   }
[15:32:41.396]                 }
[15:32:41.396]             }
[15:32:41.396]         }))
[15:32:41.396]     }, error = function(ex) {
[15:32:41.396]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:41.396]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:41.396]                 ...future.rng), started = ...future.startTime, 
[15:32:41.396]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:41.396]             version = "1.8"), class = "FutureResult")
[15:32:41.396]     }, finally = {
[15:32:41.396]         if (!identical(...future.workdir, getwd())) 
[15:32:41.396]             setwd(...future.workdir)
[15:32:41.396]         {
[15:32:41.396]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:41.396]                 ...future.oldOptions$nwarnings <- NULL
[15:32:41.396]             }
[15:32:41.396]             base::options(...future.oldOptions)
[15:32:41.396]             if (.Platform$OS.type == "windows") {
[15:32:41.396]                 old_names <- names(...future.oldEnvVars)
[15:32:41.396]                 envs <- base::Sys.getenv()
[15:32:41.396]                 names <- names(envs)
[15:32:41.396]                 common <- intersect(names, old_names)
[15:32:41.396]                 added <- setdiff(names, old_names)
[15:32:41.396]                 removed <- setdiff(old_names, names)
[15:32:41.396]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:41.396]                   envs[common]]
[15:32:41.396]                 NAMES <- toupper(changed)
[15:32:41.396]                 args <- list()
[15:32:41.396]                 for (kk in seq_along(NAMES)) {
[15:32:41.396]                   name <- changed[[kk]]
[15:32:41.396]                   NAME <- NAMES[[kk]]
[15:32:41.396]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:41.396]                     next
[15:32:41.396]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:41.396]                 }
[15:32:41.396]                 NAMES <- toupper(added)
[15:32:41.396]                 for (kk in seq_along(NAMES)) {
[15:32:41.396]                   name <- added[[kk]]
[15:32:41.396]                   NAME <- NAMES[[kk]]
[15:32:41.396]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:41.396]                     next
[15:32:41.396]                   args[[name]] <- ""
[15:32:41.396]                 }
[15:32:41.396]                 NAMES <- toupper(removed)
[15:32:41.396]                 for (kk in seq_along(NAMES)) {
[15:32:41.396]                   name <- removed[[kk]]
[15:32:41.396]                   NAME <- NAMES[[kk]]
[15:32:41.396]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:41.396]                     next
[15:32:41.396]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:41.396]                 }
[15:32:41.396]                 if (length(args) > 0) 
[15:32:41.396]                   base::do.call(base::Sys.setenv, args = args)
[15:32:41.396]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:41.396]             }
[15:32:41.396]             else {
[15:32:41.396]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:41.396]             }
[15:32:41.396]             {
[15:32:41.396]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:41.396]                   0L) {
[15:32:41.396]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:41.396]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:41.396]                   base::options(opts)
[15:32:41.396]                 }
[15:32:41.396]                 {
[15:32:41.396]                   {
[15:32:41.396]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:41.396]                     NULL
[15:32:41.396]                   }
[15:32:41.396]                   options(future.plan = NULL)
[15:32:41.396]                   if (is.na(NA_character_)) 
[15:32:41.396]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:41.396]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:41.396]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:41.396]                     .init = FALSE)
[15:32:41.396]                 }
[15:32:41.396]             }
[15:32:41.396]         }
[15:32:41.396]     })
[15:32:41.396]     if (TRUE) {
[15:32:41.396]         base::sink(type = "output", split = FALSE)
[15:32:41.396]         if (TRUE) {
[15:32:41.396]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:41.396]         }
[15:32:41.396]         else {
[15:32:41.396]             ...future.result["stdout"] <- base::list(NULL)
[15:32:41.396]         }
[15:32:41.396]         base::close(...future.stdout)
[15:32:41.396]         ...future.stdout <- NULL
[15:32:41.396]     }
[15:32:41.396]     ...future.result$conditions <- ...future.conditions
[15:32:41.396]     ...future.result$finished <- base::Sys.time()
[15:32:41.396]     ...future.result
[15:32:41.396] }
[15:32:41.405] Exporting 5 global objects (1.22 KiB) to cluster node #1 ...
[15:32:41.406] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ...
[15:32:41.407] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ... DONE
[15:32:41.407] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:41.408] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:41.408] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:41.409] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:41.409] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:41.409] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:41.410] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:41.410] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:41.410] Exporting 5 global objects (1.22 KiB) to cluster node #1 ... DONE
[15:32:41.411] MultisessionFuture started
[15:32:41.411] - Launch lazy future ... done
[15:32:41.412] run() for 'MultisessionFuture' ... done
[15:32:41.412] Created future:
[15:32:41.438] receiveMessageFromWorker() for ClusterFuture ...
[15:32:41.439] - Validating connection of MultisessionFuture
[15:32:41.439] - received message: FutureResult
[15:32:41.439] - Received FutureResult
[15:32:41.439] - Erased future from FutureRegistry
[15:32:41.440] result() for ClusterFuture ...
[15:32:41.440] - result already collected: FutureResult
[15:32:41.440] result() for ClusterFuture ... done
[15:32:41.440] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:41.412] MultisessionFuture:
[15:32:41.412] Label: 'future_sapply-1'
[15:32:41.412] Expression:
[15:32:41.412] {
[15:32:41.412]     do.call(function(...) {
[15:32:41.412]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:41.412]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:41.412]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:41.412]             on.exit(options(oopts), add = TRUE)
[15:32:41.412]         }
[15:32:41.412]         {
[15:32:41.412]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:41.412]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:41.412]                 ...future.FUN(...future.X_jj, ...)
[15:32:41.412]             })
[15:32:41.412]         }
[15:32:41.412]     }, args = future.call.arguments)
[15:32:41.412] }
[15:32:41.412] Lazy evaluation: FALSE
[15:32:41.412] Asynchronous evaluation: TRUE
[15:32:41.412] Local evaluation: TRUE
[15:32:41.412] Environment: R_GlobalEnv
[15:32:41.412] Capture standard output: TRUE
[15:32:41.412] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:41.412] Globals: 5 objects totaling 1.33 KiB (function '...future.FUN' of 1.22 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)
[15:32:41.412] Packages: <none>
[15:32:41.412] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:41.412] Resolved: TRUE
[15:32:41.412] Value: <not collected>
[15:32:41.412] Conditions captured: <none>
[15:32:41.412] Early signaling: FALSE
[15:32:41.412] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:41.412] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:41.441] Chunk #1 of 2 ... DONE
[15:32:41.441] Chunk #2 of 2 ...
[15:32:41.441]  - Finding globals in 'X' for chunk #2 ...
[15:32:41.441] getGlobalsAndPackages() ...
[15:32:41.442] Searching for globals...
[15:32:41.442] 
[15:32:41.442] Searching for globals ... DONE
[15:32:41.442] - globals: [0] <none>
[15:32:41.443] getGlobalsAndPackages() ... DONE
[15:32:41.443]    + additional globals found: [n=0] 
[15:32:41.443]    + additional namespaces needed: [n=0] 
[15:32:41.443]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:41.443]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:41.443]  - seeds: <none>
[15:32:41.443]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:41.444] getGlobalsAndPackages() ...
[15:32:41.444] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:41.444] Resolving globals: FALSE
[15:32:41.444] Tweak future expression to call with '...' arguments ...
[15:32:41.444] {
[15:32:41.444]     do.call(function(...) {
[15:32:41.444]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:41.444]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:41.444]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:41.444]             on.exit(options(oopts), add = TRUE)
[15:32:41.444]         }
[15:32:41.444]         {
[15:32:41.444]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:41.444]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:41.444]                 ...future.FUN(...future.X_jj, ...)
[15:32:41.444]             })
[15:32:41.444]         }
[15:32:41.444]     }, args = future.call.arguments)
[15:32:41.444] }
[15:32:41.445] Tweak future expression to call with '...' arguments ... DONE
[15:32:41.445] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:41.446] 
[15:32:41.446] getGlobalsAndPackages() ... DONE
[15:32:41.446] run() for 'Future' ...
[15:32:41.446] - state: 'created'
[15:32:41.447] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:41.464] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:41.465] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:41.465]   - Field: 'node'
[15:32:41.465]   - Field: 'label'
[15:32:41.466]   - Field: 'local'
[15:32:41.466]   - Field: 'owner'
[15:32:41.467]   - Field: 'envir'
[15:32:41.467]   - Field: 'workers'
[15:32:41.467]   - Field: 'packages'
[15:32:41.468]   - Field: 'gc'
[15:32:41.468]   - Field: 'conditions'
[15:32:41.469]   - Field: 'persistent'
[15:32:41.469]   - Field: 'expr'
[15:32:41.469]   - Field: 'uuid'
[15:32:41.470]   - Field: 'seed'
[15:32:41.470]   - Field: 'version'
[15:32:41.471]   - Field: 'result'
[15:32:41.471]   - Field: 'asynchronous'
[15:32:41.471]   - Field: 'calls'
[15:32:41.472]   - Field: 'globals'
[15:32:41.472]   - Field: 'stdout'
[15:32:41.473]   - Field: 'earlySignal'
[15:32:41.473]   - Field: 'lazy'
[15:32:41.473]   - Field: 'state'
[15:32:41.474] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:41.474] - Launch lazy future ...
[15:32:41.475] Packages needed by the future expression (n = 0): <none>
[15:32:41.475] Packages needed by future strategies (n = 0): <none>
[15:32:41.476] {
[15:32:41.476]     {
[15:32:41.476]         {
[15:32:41.476]             ...future.startTime <- base::Sys.time()
[15:32:41.476]             {
[15:32:41.476]                 {
[15:32:41.476]                   {
[15:32:41.476]                     {
[15:32:41.476]                       base::local({
[15:32:41.476]                         has_future <- base::requireNamespace("future", 
[15:32:41.476]                           quietly = TRUE)
[15:32:41.476]                         if (has_future) {
[15:32:41.476]                           ns <- base::getNamespace("future")
[15:32:41.476]                           version <- ns[[".package"]][["version"]]
[15:32:41.476]                           if (is.null(version)) 
[15:32:41.476]                             version <- utils::packageVersion("future")
[15:32:41.476]                         }
[15:32:41.476]                         else {
[15:32:41.476]                           version <- NULL
[15:32:41.476]                         }
[15:32:41.476]                         if (!has_future || version < "1.8.0") {
[15:32:41.476]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:41.476]                             "", base::R.version$version.string), 
[15:32:41.476]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:41.476]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:41.476]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:41.476]                               "release", "version")], collapse = " "), 
[15:32:41.476]                             hostname = base::Sys.info()[["nodename"]])
[15:32:41.476]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:41.476]                             info)
[15:32:41.476]                           info <- base::paste(info, collapse = "; ")
[15:32:41.476]                           if (!has_future) {
[15:32:41.476]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:41.476]                               info)
[15:32:41.476]                           }
[15:32:41.476]                           else {
[15:32:41.476]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:41.476]                               info, version)
[15:32:41.476]                           }
[15:32:41.476]                           base::stop(msg)
[15:32:41.476]                         }
[15:32:41.476]                       })
[15:32:41.476]                     }
[15:32:41.476]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:41.476]                     base::options(mc.cores = 1L)
[15:32:41.476]                   }
[15:32:41.476]                   ...future.strategy.old <- future::plan("list")
[15:32:41.476]                   options(future.plan = NULL)
[15:32:41.476]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:41.476]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:41.476]                 }
[15:32:41.476]                 ...future.workdir <- getwd()
[15:32:41.476]             }
[15:32:41.476]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:41.476]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:41.476]         }
[15:32:41.476]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:41.476]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:41.476]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:41.476]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:41.476]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:41.476]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:41.476]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:41.476]             base::names(...future.oldOptions))
[15:32:41.476]     }
[15:32:41.476]     if (FALSE) {
[15:32:41.476]     }
[15:32:41.476]     else {
[15:32:41.476]         if (TRUE) {
[15:32:41.476]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:41.476]                 open = "w")
[15:32:41.476]         }
[15:32:41.476]         else {
[15:32:41.476]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:41.476]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:41.476]         }
[15:32:41.476]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:41.476]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:41.476]             base::sink(type = "output", split = FALSE)
[15:32:41.476]             base::close(...future.stdout)
[15:32:41.476]         }, add = TRUE)
[15:32:41.476]     }
[15:32:41.476]     ...future.frame <- base::sys.nframe()
[15:32:41.476]     ...future.conditions <- base::list()
[15:32:41.476]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:41.476]     if (FALSE) {
[15:32:41.476]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:41.476]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:41.476]     }
[15:32:41.476]     ...future.result <- base::tryCatch({
[15:32:41.476]         base::withCallingHandlers({
[15:32:41.476]             ...future.value <- base::withVisible(base::local({
[15:32:41.476]                 ...future.makeSendCondition <- base::local({
[15:32:41.476]                   sendCondition <- NULL
[15:32:41.476]                   function(frame = 1L) {
[15:32:41.476]                     if (is.function(sendCondition)) 
[15:32:41.476]                       return(sendCondition)
[15:32:41.476]                     ns <- getNamespace("parallel")
[15:32:41.476]                     if (exists("sendData", mode = "function", 
[15:32:41.476]                       envir = ns)) {
[15:32:41.476]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:41.476]                         envir = ns)
[15:32:41.476]                       envir <- sys.frame(frame)
[15:32:41.476]                       master <- NULL
[15:32:41.476]                       while (!identical(envir, .GlobalEnv) && 
[15:32:41.476]                         !identical(envir, emptyenv())) {
[15:32:41.476]                         if (exists("master", mode = "list", envir = envir, 
[15:32:41.476]                           inherits = FALSE)) {
[15:32:41.476]                           master <- get("master", mode = "list", 
[15:32:41.476]                             envir = envir, inherits = FALSE)
[15:32:41.476]                           if (inherits(master, c("SOCKnode", 
[15:32:41.476]                             "SOCK0node"))) {
[15:32:41.476]                             sendCondition <<- function(cond) {
[15:32:41.476]                               data <- list(type = "VALUE", value = cond, 
[15:32:41.476]                                 success = TRUE)
[15:32:41.476]                               parallel_sendData(master, data)
[15:32:41.476]                             }
[15:32:41.476]                             return(sendCondition)
[15:32:41.476]                           }
[15:32:41.476]                         }
[15:32:41.476]                         frame <- frame + 1L
[15:32:41.476]                         envir <- sys.frame(frame)
[15:32:41.476]                       }
[15:32:41.476]                     }
[15:32:41.476]                     sendCondition <<- function(cond) NULL
[15:32:41.476]                   }
[15:32:41.476]                 })
[15:32:41.476]                 withCallingHandlers({
[15:32:41.476]                   {
[15:32:41.476]                     do.call(function(...) {
[15:32:41.476]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:41.476]                       if (!identical(...future.globals.maxSize.org, 
[15:32:41.476]                         ...future.globals.maxSize)) {
[15:32:41.476]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:41.476]                         on.exit(options(oopts), add = TRUE)
[15:32:41.476]                       }
[15:32:41.476]                       {
[15:32:41.476]                         lapply(seq_along(...future.elements_ii), 
[15:32:41.476]                           FUN = function(jj) {
[15:32:41.476]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:41.476]                             ...future.FUN(...future.X_jj, ...)
[15:32:41.476]                           })
[15:32:41.476]                       }
[15:32:41.476]                     }, args = future.call.arguments)
[15:32:41.476]                   }
[15:32:41.476]                 }, immediateCondition = function(cond) {
[15:32:41.476]                   sendCondition <- ...future.makeSendCondition()
[15:32:41.476]                   sendCondition(cond)
[15:32:41.476]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:41.476]                   {
[15:32:41.476]                     inherits <- base::inherits
[15:32:41.476]                     invokeRestart <- base::invokeRestart
[15:32:41.476]                     is.null <- base::is.null
[15:32:41.476]                     muffled <- FALSE
[15:32:41.476]                     if (inherits(cond, "message")) {
[15:32:41.476]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:41.476]                       if (muffled) 
[15:32:41.476]                         invokeRestart("muffleMessage")
[15:32:41.476]                     }
[15:32:41.476]                     else if (inherits(cond, "warning")) {
[15:32:41.476]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:41.476]                       if (muffled) 
[15:32:41.476]                         invokeRestart("muffleWarning")
[15:32:41.476]                     }
[15:32:41.476]                     else if (inherits(cond, "condition")) {
[15:32:41.476]                       if (!is.null(pattern)) {
[15:32:41.476]                         computeRestarts <- base::computeRestarts
[15:32:41.476]                         grepl <- base::grepl
[15:32:41.476]                         restarts <- computeRestarts(cond)
[15:32:41.476]                         for (restart in restarts) {
[15:32:41.476]                           name <- restart$name
[15:32:41.476]                           if (is.null(name)) 
[15:32:41.476]                             next
[15:32:41.476]                           if (!grepl(pattern, name)) 
[15:32:41.476]                             next
[15:32:41.476]                           invokeRestart(restart)
[15:32:41.476]                           muffled <- TRUE
[15:32:41.476]                           break
[15:32:41.476]                         }
[15:32:41.476]                       }
[15:32:41.476]                     }
[15:32:41.476]                     invisible(muffled)
[15:32:41.476]                   }
[15:32:41.476]                   muffleCondition(cond)
[15:32:41.476]                 })
[15:32:41.476]             }))
[15:32:41.476]             future::FutureResult(value = ...future.value$value, 
[15:32:41.476]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:41.476]                   ...future.rng), globalenv = if (FALSE) 
[15:32:41.476]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:41.476]                     ...future.globalenv.names))
[15:32:41.476]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:41.476]         }, condition = base::local({
[15:32:41.476]             c <- base::c
[15:32:41.476]             inherits <- base::inherits
[15:32:41.476]             invokeRestart <- base::invokeRestart
[15:32:41.476]             length <- base::length
[15:32:41.476]             list <- base::list
[15:32:41.476]             seq.int <- base::seq.int
[15:32:41.476]             signalCondition <- base::signalCondition
[15:32:41.476]             sys.calls <- base::sys.calls
[15:32:41.476]             `[[` <- base::`[[`
[15:32:41.476]             `+` <- base::`+`
[15:32:41.476]             `<<-` <- base::`<<-`
[15:32:41.476]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:41.476]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:41.476]                   3L)]
[15:32:41.476]             }
[15:32:41.476]             function(cond) {
[15:32:41.476]                 is_error <- inherits(cond, "error")
[15:32:41.476]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:41.476]                   NULL)
[15:32:41.476]                 if (is_error) {
[15:32:41.476]                   sessionInformation <- function() {
[15:32:41.476]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:41.476]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:41.476]                       search = base::search(), system = base::Sys.info())
[15:32:41.476]                   }
[15:32:41.476]                   ...future.conditions[[length(...future.conditions) + 
[15:32:41.476]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:41.476]                     cond$call), session = sessionInformation(), 
[15:32:41.476]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:41.476]                   signalCondition(cond)
[15:32:41.476]                 }
[15:32:41.476]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:41.476]                 "immediateCondition"))) {
[15:32:41.476]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:41.476]                   ...future.conditions[[length(...future.conditions) + 
[15:32:41.476]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:41.476]                   if (TRUE && !signal) {
[15:32:41.476]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:41.476]                     {
[15:32:41.476]                       inherits <- base::inherits
[15:32:41.476]                       invokeRestart <- base::invokeRestart
[15:32:41.476]                       is.null <- base::is.null
[15:32:41.476]                       muffled <- FALSE
[15:32:41.476]                       if (inherits(cond, "message")) {
[15:32:41.476]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:41.476]                         if (muffled) 
[15:32:41.476]                           invokeRestart("muffleMessage")
[15:32:41.476]                       }
[15:32:41.476]                       else if (inherits(cond, "warning")) {
[15:32:41.476]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:41.476]                         if (muffled) 
[15:32:41.476]                           invokeRestart("muffleWarning")
[15:32:41.476]                       }
[15:32:41.476]                       else if (inherits(cond, "condition")) {
[15:32:41.476]                         if (!is.null(pattern)) {
[15:32:41.476]                           computeRestarts <- base::computeRestarts
[15:32:41.476]                           grepl <- base::grepl
[15:32:41.476]                           restarts <- computeRestarts(cond)
[15:32:41.476]                           for (restart in restarts) {
[15:32:41.476]                             name <- restart$name
[15:32:41.476]                             if (is.null(name)) 
[15:32:41.476]                               next
[15:32:41.476]                             if (!grepl(pattern, name)) 
[15:32:41.476]                               next
[15:32:41.476]                             invokeRestart(restart)
[15:32:41.476]                             muffled <- TRUE
[15:32:41.476]                             break
[15:32:41.476]                           }
[15:32:41.476]                         }
[15:32:41.476]                       }
[15:32:41.476]                       invisible(muffled)
[15:32:41.476]                     }
[15:32:41.476]                     muffleCondition(cond, pattern = "^muffle")
[15:32:41.476]                   }
[15:32:41.476]                 }
[15:32:41.476]                 else {
[15:32:41.476]                   if (TRUE) {
[15:32:41.476]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:41.476]                     {
[15:32:41.476]                       inherits <- base::inherits
[15:32:41.476]                       invokeRestart <- base::invokeRestart
[15:32:41.476]                       is.null <- base::is.null
[15:32:41.476]                       muffled <- FALSE
[15:32:41.476]                       if (inherits(cond, "message")) {
[15:32:41.476]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:41.476]                         if (muffled) 
[15:32:41.476]                           invokeRestart("muffleMessage")
[15:32:41.476]                       }
[15:32:41.476]                       else if (inherits(cond, "warning")) {
[15:32:41.476]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:41.476]                         if (muffled) 
[15:32:41.476]                           invokeRestart("muffleWarning")
[15:32:41.476]                       }
[15:32:41.476]                       else if (inherits(cond, "condition")) {
[15:32:41.476]                         if (!is.null(pattern)) {
[15:32:41.476]                           computeRestarts <- base::computeRestarts
[15:32:41.476]                           grepl <- base::grepl
[15:32:41.476]                           restarts <- computeRestarts(cond)
[15:32:41.476]                           for (restart in restarts) {
[15:32:41.476]                             name <- restart$name
[15:32:41.476]                             if (is.null(name)) 
[15:32:41.476]                               next
[15:32:41.476]                             if (!grepl(pattern, name)) 
[15:32:41.476]                               next
[15:32:41.476]                             invokeRestart(restart)
[15:32:41.476]                             muffled <- TRUE
[15:32:41.476]                             break
[15:32:41.476]                           }
[15:32:41.476]                         }
[15:32:41.476]                       }
[15:32:41.476]                       invisible(muffled)
[15:32:41.476]                     }
[15:32:41.476]                     muffleCondition(cond, pattern = "^muffle")
[15:32:41.476]                   }
[15:32:41.476]                 }
[15:32:41.476]             }
[15:32:41.476]         }))
[15:32:41.476]     }, error = function(ex) {
[15:32:41.476]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:41.476]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:41.476]                 ...future.rng), started = ...future.startTime, 
[15:32:41.476]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:41.476]             version = "1.8"), class = "FutureResult")
[15:32:41.476]     }, finally = {
[15:32:41.476]         if (!identical(...future.workdir, getwd())) 
[15:32:41.476]             setwd(...future.workdir)
[15:32:41.476]         {
[15:32:41.476]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:41.476]                 ...future.oldOptions$nwarnings <- NULL
[15:32:41.476]             }
[15:32:41.476]             base::options(...future.oldOptions)
[15:32:41.476]             if (.Platform$OS.type == "windows") {
[15:32:41.476]                 old_names <- names(...future.oldEnvVars)
[15:32:41.476]                 envs <- base::Sys.getenv()
[15:32:41.476]                 names <- names(envs)
[15:32:41.476]                 common <- intersect(names, old_names)
[15:32:41.476]                 added <- setdiff(names, old_names)
[15:32:41.476]                 removed <- setdiff(old_names, names)
[15:32:41.476]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:41.476]                   envs[common]]
[15:32:41.476]                 NAMES <- toupper(changed)
[15:32:41.476]                 args <- list()
[15:32:41.476]                 for (kk in seq_along(NAMES)) {
[15:32:41.476]                   name <- changed[[kk]]
[15:32:41.476]                   NAME <- NAMES[[kk]]
[15:32:41.476]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:41.476]                     next
[15:32:41.476]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:41.476]                 }
[15:32:41.476]                 NAMES <- toupper(added)
[15:32:41.476]                 for (kk in seq_along(NAMES)) {
[15:32:41.476]                   name <- added[[kk]]
[15:32:41.476]                   NAME <- NAMES[[kk]]
[15:32:41.476]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:41.476]                     next
[15:32:41.476]                   args[[name]] <- ""
[15:32:41.476]                 }
[15:32:41.476]                 NAMES <- toupper(removed)
[15:32:41.476]                 for (kk in seq_along(NAMES)) {
[15:32:41.476]                   name <- removed[[kk]]
[15:32:41.476]                   NAME <- NAMES[[kk]]
[15:32:41.476]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:41.476]                     next
[15:32:41.476]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:41.476]                 }
[15:32:41.476]                 if (length(args) > 0) 
[15:32:41.476]                   base::do.call(base::Sys.setenv, args = args)
[15:32:41.476]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:41.476]             }
[15:32:41.476]             else {
[15:32:41.476]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:41.476]             }
[15:32:41.476]             {
[15:32:41.476]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:41.476]                   0L) {
[15:32:41.476]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:41.476]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:41.476]                   base::options(opts)
[15:32:41.476]                 }
[15:32:41.476]                 {
[15:32:41.476]                   {
[15:32:41.476]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:41.476]                     NULL
[15:32:41.476]                   }
[15:32:41.476]                   options(future.plan = NULL)
[15:32:41.476]                   if (is.na(NA_character_)) 
[15:32:41.476]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:41.476]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:41.476]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:41.476]                     .init = FALSE)
[15:32:41.476]                 }
[15:32:41.476]             }
[15:32:41.476]         }
[15:32:41.476]     })
[15:32:41.476]     if (TRUE) {
[15:32:41.476]         base::sink(type = "output", split = FALSE)
[15:32:41.476]         if (TRUE) {
[15:32:41.476]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:41.476]         }
[15:32:41.476]         else {
[15:32:41.476]             ...future.result["stdout"] <- base::list(NULL)
[15:32:41.476]         }
[15:32:41.476]         base::close(...future.stdout)
[15:32:41.476]         ...future.stdout <- NULL
[15:32:41.476]     }
[15:32:41.476]     ...future.result$conditions <- ...future.conditions
[15:32:41.476]     ...future.result$finished <- base::Sys.time()
[15:32:41.476]     ...future.result
[15:32:41.476] }
[15:32:41.488] Exporting 5 global objects (1.22 KiB) to cluster node #1 ...
[15:32:41.489] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ...
[15:32:41.490] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ... DONE
[15:32:41.490] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:41.491] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:41.491] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:41.492] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:41.492] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:41.493] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:41.493] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:41.494] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:41.495] Exporting 5 global objects (1.22 KiB) to cluster node #1 ... DONE
[15:32:41.496] MultisessionFuture started
[15:32:41.496] - Launch lazy future ... done
[15:32:41.496] run() for 'MultisessionFuture' ... done
[15:32:41.497] Created future:
[15:32:41.530] receiveMessageFromWorker() for ClusterFuture ...
[15:32:41.531] - Validating connection of MultisessionFuture
[15:32:41.531] - received message: FutureResult
[15:32:41.532] - Received FutureResult
[15:32:41.532] - Erased future from FutureRegistry
[15:32:41.533] result() for ClusterFuture ...
[15:32:41.533] - result already collected: FutureResult
[15:32:41.533] result() for ClusterFuture ... done
[15:32:41.534] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:41.497] MultisessionFuture:
[15:32:41.497] Label: 'future_sapply-2'
[15:32:41.497] Expression:
[15:32:41.497] {
[15:32:41.497]     do.call(function(...) {
[15:32:41.497]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:41.497]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:41.497]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:41.497]             on.exit(options(oopts), add = TRUE)
[15:32:41.497]         }
[15:32:41.497]         {
[15:32:41.497]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:41.497]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:41.497]                 ...future.FUN(...future.X_jj, ...)
[15:32:41.497]             })
[15:32:41.497]         }
[15:32:41.497]     }, args = future.call.arguments)
[15:32:41.497] }
[15:32:41.497] Lazy evaluation: FALSE
[15:32:41.497] Asynchronous evaluation: TRUE
[15:32:41.497] Local evaluation: TRUE
[15:32:41.497] Environment: R_GlobalEnv
[15:32:41.497] Capture standard output: TRUE
[15:32:41.497] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:41.497] Globals: 5 objects totaling 1.33 KiB (function '...future.FUN' of 1.22 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)
[15:32:41.497] Packages: <none>
[15:32:41.497] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:41.497] Resolved: TRUE
[15:32:41.497] Value: <not collected>
[15:32:41.497] Conditions captured: <none>
[15:32:41.497] Early signaling: FALSE
[15:32:41.497] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:41.497] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:41.535] Chunk #2 of 2 ... DONE
[15:32:41.535] Launching 2 futures (chunks) ... DONE
[15:32:41.535] Resolving 2 futures (chunks) ...
[15:32:41.536] resolve() on list ...
[15:32:41.536]  recursive: 0
[15:32:41.536]  length: 2
[15:32:41.537] 
[15:32:41.537] Future #1
[15:32:41.538] result() for ClusterFuture ...
[15:32:41.538] - result already collected: FutureResult
[15:32:41.538] result() for ClusterFuture ... done
[15:32:41.539] result() for ClusterFuture ...
[15:32:41.539] - result already collected: FutureResult
[15:32:41.539] result() for ClusterFuture ... done
[15:32:41.540] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:41.540] - nx: 2
[15:32:41.540] - relay: TRUE
[15:32:41.541] - stdout: TRUE
[15:32:41.541] - signal: TRUE
[15:32:41.541] - resignal: FALSE
[15:32:41.542] - force: TRUE
[15:32:41.542] - relayed: [n=2] FALSE, FALSE
[15:32:41.542] - queued futures: [n=2] FALSE, FALSE
[15:32:41.543]  - until=1
[15:32:41.543]  - relaying element #1
[15:32:41.543] result() for ClusterFuture ...
[15:32:41.544] - result already collected: FutureResult
[15:32:41.544] result() for ClusterFuture ... done
[15:32:41.544] result() for ClusterFuture ...
[15:32:41.545] - result already collected: FutureResult
[15:32:41.545] result() for ClusterFuture ... done
[15:32:41.546] result() for ClusterFuture ...
[15:32:41.546] - result already collected: FutureResult
[15:32:41.546] result() for ClusterFuture ... done
[15:32:41.547] result() for ClusterFuture ...
[15:32:41.547] - result already collected: FutureResult
[15:32:41.547] result() for ClusterFuture ... done
[15:32:41.548] - relayed: [n=2] TRUE, FALSE
[15:32:41.548] - queued futures: [n=2] TRUE, FALSE
[15:32:41.548] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:41.549]  length: 1 (resolved future 1)
[15:32:41.549] Future #2
[15:32:41.549] result() for ClusterFuture ...
[15:32:41.550] - result already collected: FutureResult
[15:32:41.550] result() for ClusterFuture ... done
[15:32:41.550] result() for ClusterFuture ...
[15:32:41.551] - result already collected: FutureResult
[15:32:41.551] result() for ClusterFuture ... done
[15:32:41.551] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:41.552] - nx: 2
[15:32:41.552] - relay: TRUE
[15:32:41.552] - stdout: TRUE
[15:32:41.553] - signal: TRUE
[15:32:41.553] - resignal: FALSE
[15:32:41.553] - force: TRUE
[15:32:41.554] - relayed: [n=2] TRUE, FALSE
[15:32:41.554] - queued futures: [n=2] TRUE, FALSE
[15:32:41.555]  - until=2
[15:32:41.555]  - relaying element #2
[15:32:41.555] result() for ClusterFuture ...
[15:32:41.556] - result already collected: FutureResult
[15:32:41.556] result() for ClusterFuture ... done
[15:32:41.556] result() for ClusterFuture ...
[15:32:41.557] - result already collected: FutureResult
[15:32:41.557] result() for ClusterFuture ... done
[15:32:41.557] result() for ClusterFuture ...
[15:32:41.558] - result already collected: FutureResult
[15:32:41.558] result() for ClusterFuture ... done
[15:32:41.558] result() for ClusterFuture ...
[15:32:41.559] - result already collected: FutureResult
[15:32:41.559] result() for ClusterFuture ... done
[15:32:41.559] - relayed: [n=2] TRUE, TRUE
[15:32:41.560] - queued futures: [n=2] TRUE, TRUE
[15:32:41.560] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:41.560]  length: 0 (resolved future 2)
[15:32:41.561] Relaying remaining futures
[15:32:41.561] signalConditionsASAP(NULL, pos=0) ...
[15:32:41.561] - nx: 2
[15:32:41.562] - relay: TRUE
[15:32:41.567] - stdout: TRUE
[15:32:41.568] - signal: TRUE
[15:32:41.568] - resignal: FALSE
[15:32:41.569] - force: TRUE
[15:32:41.569] - relayed: [n=2] TRUE, TRUE
[15:32:41.569] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:41.570] - relayed: [n=2] TRUE, TRUE
[15:32:41.570] - queued futures: [n=2] TRUE, TRUE
[15:32:41.570] signalConditionsASAP(NULL, pos=0) ... done
[15:32:41.570] resolve() on list ... DONE
[15:32:41.571] result() for ClusterFuture ...
[15:32:41.571] - result already collected: FutureResult
[15:32:41.571] result() for ClusterFuture ... done
[15:32:41.571] result() for ClusterFuture ...
[15:32:41.572] - result already collected: FutureResult
[15:32:41.572] result() for ClusterFuture ... done
[15:32:41.572] result() for ClusterFuture ...
[15:32:41.573] - result already collected: FutureResult
[15:32:41.573] result() for ClusterFuture ... done
[15:32:41.573] result() for ClusterFuture ...
[15:32:41.574] - result already collected: FutureResult
[15:32:41.574] result() for ClusterFuture ... done
[15:32:41.574]  - Number of value chunks collected: 2
[15:32:41.575] Resolving 2 futures (chunks) ... DONE
[15:32:41.575] Reducing values from 2 chunks ...
[15:32:41.575]  - Number of values collected after concatenation: 4
[15:32:41.575]  - Number of values expected: 4
[15:32:41.575] Reducing values from 2 chunks ... DONE
[15:32:41.576] future_lapply() ... DONE
List of 2
 $ y0: Named num [1:4] 50 60 70 80
  ..- attr(*, "names")= chr [1:4] "A" "B" "C" "D"
 $ y1: Named num [1:4] 50 60 70 80
  ..- attr(*, "names")= chr [1:4] "A" "B" "C" "D"
[15:32:41.579] future_lapply() ...
[15:32:41.586] Number of chunks: 2
[15:32:41.586] getGlobalsAndPackagesXApply() ...
[15:32:41.586]  - future.globals: TRUE
[15:32:41.587] getGlobalsAndPackages() ...
[15:32:41.587] Searching for globals...
[15:32:41.591] - globals found: [5] 'FUN', '*', ':', 'outer', 'rep'
[15:32:41.591] Searching for globals ... DONE
[15:32:41.591] Resolving globals: FALSE
[15:32:41.592] The total size of the 1 globals is 4.62 KiB (4728 bytes)
[15:32:41.593] The total size of the 1 globals exported for future expression ('FUN()') is 4.62 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.62 KiB of class 'function')
[15:32:41.594] - globals: [1] 'FUN'
[15:32:41.594] 
[15:32:41.594] getGlobalsAndPackages() ... DONE
[15:32:41.595]  - globals found/used: [n=1] 'FUN'
[15:32:41.595]  - needed namespaces: [n=0] 
[15:32:41.595] Finding globals ... DONE
[15:32:41.596]  - use_args: TRUE
[15:32:41.596]  - Getting '...' globals ...
[15:32:41.597] resolve() on list ...
[15:32:41.597]  recursive: 0
[15:32:41.598]  length: 1
[15:32:41.598]  elements: '...'
[15:32:41.598]  length: 0 (resolved future 1)
[15:32:41.599] resolve() on list ... DONE
[15:32:41.599]    - '...' content: [n=0] 
[15:32:41.599] List of 1
[15:32:41.599]  $ ...: list()
[15:32:41.599]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:41.599]  - attr(*, "where")=List of 1
[15:32:41.599]   ..$ ...:<environment: 0x00000276e2abf4f8> 
[15:32:41.599]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:41.599]  - attr(*, "resolved")= logi TRUE
[15:32:41.599]  - attr(*, "total_size")= num NA
[15:32:41.605]  - Getting '...' globals ... DONE
[15:32:41.606] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:41.606] List of 2
[15:32:41.606]  $ ...future.FUN:function (x, y = 2 * 1:5)  
[15:32:41.606]  $ ...          : list()
[15:32:41.606]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:41.606]  - attr(*, "where")=List of 2
[15:32:41.606]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:41.606]   ..$ ...          :<environment: 0x00000276e2abf4f8> 
[15:32:41.606]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:41.606]  - attr(*, "resolved")= logi FALSE
[15:32:41.606]  - attr(*, "total_size")= num 4728
[15:32:41.612] Packages to be attached in all futures: [n=0] 
[15:32:41.612] getGlobalsAndPackagesXApply() ... DONE
[15:32:41.612] Number of futures (= number of chunks): 2
[15:32:41.613] Launching 2 futures (chunks) ...
[15:32:41.613] Chunk #1 of 2 ...
[15:32:41.613]  - Finding globals in 'X' for chunk #1 ...
[15:32:41.614] getGlobalsAndPackages() ...
[15:32:41.614] Searching for globals...
[15:32:41.614] 
[15:32:41.615] Searching for globals ... DONE
[15:32:41.615] - globals: [0] <none>
[15:32:41.615] getGlobalsAndPackages() ... DONE
[15:32:41.615]    + additional globals found: [n=0] 
[15:32:41.616]    + additional namespaces needed: [n=0] 
[15:32:41.616]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:41.616]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:41.616]  - seeds: <none>
[15:32:41.617]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:41.617] getGlobalsAndPackages() ...
[15:32:41.617] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:41.618] Resolving globals: FALSE
[15:32:41.618] Tweak future expression to call with '...' arguments ...
[15:32:41.618] {
[15:32:41.618]     do.call(function(...) {
[15:32:41.618]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:41.618]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:41.618]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:41.618]             on.exit(options(oopts), add = TRUE)
[15:32:41.618]         }
[15:32:41.618]         {
[15:32:41.618]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:41.618]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:41.618]                 ...future.FUN(...future.X_jj, ...)
[15:32:41.618]             })
[15:32:41.618]         }
[15:32:41.618]     }, args = future.call.arguments)
[15:32:41.618] }
[15:32:41.619] Tweak future expression to call with '...' arguments ... DONE
[15:32:41.620] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:41.620] 
[15:32:41.620] getGlobalsAndPackages() ... DONE
[15:32:41.621] run() for 'Future' ...
[15:32:41.621] - state: 'created'
[15:32:41.622] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:41.643] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:41.643] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:41.644]   - Field: 'node'
[15:32:41.644]   - Field: 'label'
[15:32:41.644]   - Field: 'local'
[15:32:41.645]   - Field: 'owner'
[15:32:41.645]   - Field: 'envir'
[15:32:41.645]   - Field: 'workers'
[15:32:41.645]   - Field: 'packages'
[15:32:41.646]   - Field: 'gc'
[15:32:41.646]   - Field: 'conditions'
[15:32:41.646]   - Field: 'persistent'
[15:32:41.647]   - Field: 'expr'
[15:32:41.647]   - Field: 'uuid'
[15:32:41.647]   - Field: 'seed'
[15:32:41.647]   - Field: 'version'
[15:32:41.648]   - Field: 'result'
[15:32:41.648]   - Field: 'asynchronous'
[15:32:41.648]   - Field: 'calls'
[15:32:41.649]   - Field: 'globals'
[15:32:41.649]   - Field: 'stdout'
[15:32:41.649]   - Field: 'earlySignal'
[15:32:41.649]   - Field: 'lazy'
[15:32:41.650]   - Field: 'state'
[15:32:41.650] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:41.650] - Launch lazy future ...
[15:32:41.651] Packages needed by the future expression (n = 0): <none>
[15:32:41.651] Packages needed by future strategies (n = 0): <none>
[15:32:41.652] {
[15:32:41.652]     {
[15:32:41.652]         {
[15:32:41.652]             ...future.startTime <- base::Sys.time()
[15:32:41.652]             {
[15:32:41.652]                 {
[15:32:41.652]                   {
[15:32:41.652]                     {
[15:32:41.652]                       base::local({
[15:32:41.652]                         has_future <- base::requireNamespace("future", 
[15:32:41.652]                           quietly = TRUE)
[15:32:41.652]                         if (has_future) {
[15:32:41.652]                           ns <- base::getNamespace("future")
[15:32:41.652]                           version <- ns[[".package"]][["version"]]
[15:32:41.652]                           if (is.null(version)) 
[15:32:41.652]                             version <- utils::packageVersion("future")
[15:32:41.652]                         }
[15:32:41.652]                         else {
[15:32:41.652]                           version <- NULL
[15:32:41.652]                         }
[15:32:41.652]                         if (!has_future || version < "1.8.0") {
[15:32:41.652]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:41.652]                             "", base::R.version$version.string), 
[15:32:41.652]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:41.652]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:41.652]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:41.652]                               "release", "version")], collapse = " "), 
[15:32:41.652]                             hostname = base::Sys.info()[["nodename"]])
[15:32:41.652]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:41.652]                             info)
[15:32:41.652]                           info <- base::paste(info, collapse = "; ")
[15:32:41.652]                           if (!has_future) {
[15:32:41.652]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:41.652]                               info)
[15:32:41.652]                           }
[15:32:41.652]                           else {
[15:32:41.652]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:41.652]                               info, version)
[15:32:41.652]                           }
[15:32:41.652]                           base::stop(msg)
[15:32:41.652]                         }
[15:32:41.652]                       })
[15:32:41.652]                     }
[15:32:41.652]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:41.652]                     base::options(mc.cores = 1L)
[15:32:41.652]                   }
[15:32:41.652]                   ...future.strategy.old <- future::plan("list")
[15:32:41.652]                   options(future.plan = NULL)
[15:32:41.652]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:41.652]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:41.652]                 }
[15:32:41.652]                 ...future.workdir <- getwd()
[15:32:41.652]             }
[15:32:41.652]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:41.652]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:41.652]         }
[15:32:41.652]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:41.652]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:41.652]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:41.652]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:41.652]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:41.652]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:41.652]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:41.652]             base::names(...future.oldOptions))
[15:32:41.652]     }
[15:32:41.652]     if (FALSE) {
[15:32:41.652]     }
[15:32:41.652]     else {
[15:32:41.652]         if (TRUE) {
[15:32:41.652]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:41.652]                 open = "w")
[15:32:41.652]         }
[15:32:41.652]         else {
[15:32:41.652]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:41.652]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:41.652]         }
[15:32:41.652]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:41.652]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:41.652]             base::sink(type = "output", split = FALSE)
[15:32:41.652]             base::close(...future.stdout)
[15:32:41.652]         }, add = TRUE)
[15:32:41.652]     }
[15:32:41.652]     ...future.frame <- base::sys.nframe()
[15:32:41.652]     ...future.conditions <- base::list()
[15:32:41.652]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:41.652]     if (FALSE) {
[15:32:41.652]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:41.652]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:41.652]     }
[15:32:41.652]     ...future.result <- base::tryCatch({
[15:32:41.652]         base::withCallingHandlers({
[15:32:41.652]             ...future.value <- base::withVisible(base::local({
[15:32:41.652]                 ...future.makeSendCondition <- base::local({
[15:32:41.652]                   sendCondition <- NULL
[15:32:41.652]                   function(frame = 1L) {
[15:32:41.652]                     if (is.function(sendCondition)) 
[15:32:41.652]                       return(sendCondition)
[15:32:41.652]                     ns <- getNamespace("parallel")
[15:32:41.652]                     if (exists("sendData", mode = "function", 
[15:32:41.652]                       envir = ns)) {
[15:32:41.652]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:41.652]                         envir = ns)
[15:32:41.652]                       envir <- sys.frame(frame)
[15:32:41.652]                       master <- NULL
[15:32:41.652]                       while (!identical(envir, .GlobalEnv) && 
[15:32:41.652]                         !identical(envir, emptyenv())) {
[15:32:41.652]                         if (exists("master", mode = "list", envir = envir, 
[15:32:41.652]                           inherits = FALSE)) {
[15:32:41.652]                           master <- get("master", mode = "list", 
[15:32:41.652]                             envir = envir, inherits = FALSE)
[15:32:41.652]                           if (inherits(master, c("SOCKnode", 
[15:32:41.652]                             "SOCK0node"))) {
[15:32:41.652]                             sendCondition <<- function(cond) {
[15:32:41.652]                               data <- list(type = "VALUE", value = cond, 
[15:32:41.652]                                 success = TRUE)
[15:32:41.652]                               parallel_sendData(master, data)
[15:32:41.652]                             }
[15:32:41.652]                             return(sendCondition)
[15:32:41.652]                           }
[15:32:41.652]                         }
[15:32:41.652]                         frame <- frame + 1L
[15:32:41.652]                         envir <- sys.frame(frame)
[15:32:41.652]                       }
[15:32:41.652]                     }
[15:32:41.652]                     sendCondition <<- function(cond) NULL
[15:32:41.652]                   }
[15:32:41.652]                 })
[15:32:41.652]                 withCallingHandlers({
[15:32:41.652]                   {
[15:32:41.652]                     do.call(function(...) {
[15:32:41.652]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:41.652]                       if (!identical(...future.globals.maxSize.org, 
[15:32:41.652]                         ...future.globals.maxSize)) {
[15:32:41.652]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:41.652]                         on.exit(options(oopts), add = TRUE)
[15:32:41.652]                       }
[15:32:41.652]                       {
[15:32:41.652]                         lapply(seq_along(...future.elements_ii), 
[15:32:41.652]                           FUN = function(jj) {
[15:32:41.652]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:41.652]                             ...future.FUN(...future.X_jj, ...)
[15:32:41.652]                           })
[15:32:41.652]                       }
[15:32:41.652]                     }, args = future.call.arguments)
[15:32:41.652]                   }
[15:32:41.652]                 }, immediateCondition = function(cond) {
[15:32:41.652]                   sendCondition <- ...future.makeSendCondition()
[15:32:41.652]                   sendCondition(cond)
[15:32:41.652]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:41.652]                   {
[15:32:41.652]                     inherits <- base::inherits
[15:32:41.652]                     invokeRestart <- base::invokeRestart
[15:32:41.652]                     is.null <- base::is.null
[15:32:41.652]                     muffled <- FALSE
[15:32:41.652]                     if (inherits(cond, "message")) {
[15:32:41.652]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:41.652]                       if (muffled) 
[15:32:41.652]                         invokeRestart("muffleMessage")
[15:32:41.652]                     }
[15:32:41.652]                     else if (inherits(cond, "warning")) {
[15:32:41.652]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:41.652]                       if (muffled) 
[15:32:41.652]                         invokeRestart("muffleWarning")
[15:32:41.652]                     }
[15:32:41.652]                     else if (inherits(cond, "condition")) {
[15:32:41.652]                       if (!is.null(pattern)) {
[15:32:41.652]                         computeRestarts <- base::computeRestarts
[15:32:41.652]                         grepl <- base::grepl
[15:32:41.652]                         restarts <- computeRestarts(cond)
[15:32:41.652]                         for (restart in restarts) {
[15:32:41.652]                           name <- restart$name
[15:32:41.652]                           if (is.null(name)) 
[15:32:41.652]                             next
[15:32:41.652]                           if (!grepl(pattern, name)) 
[15:32:41.652]                             next
[15:32:41.652]                           invokeRestart(restart)
[15:32:41.652]                           muffled <- TRUE
[15:32:41.652]                           break
[15:32:41.652]                         }
[15:32:41.652]                       }
[15:32:41.652]                     }
[15:32:41.652]                     invisible(muffled)
[15:32:41.652]                   }
[15:32:41.652]                   muffleCondition(cond)
[15:32:41.652]                 })
[15:32:41.652]             }))
[15:32:41.652]             future::FutureResult(value = ...future.value$value, 
[15:32:41.652]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:41.652]                   ...future.rng), globalenv = if (FALSE) 
[15:32:41.652]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:41.652]                     ...future.globalenv.names))
[15:32:41.652]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:41.652]         }, condition = base::local({
[15:32:41.652]             c <- base::c
[15:32:41.652]             inherits <- base::inherits
[15:32:41.652]             invokeRestart <- base::invokeRestart
[15:32:41.652]             length <- base::length
[15:32:41.652]             list <- base::list
[15:32:41.652]             seq.int <- base::seq.int
[15:32:41.652]             signalCondition <- base::signalCondition
[15:32:41.652]             sys.calls <- base::sys.calls
[15:32:41.652]             `[[` <- base::`[[`
[15:32:41.652]             `+` <- base::`+`
[15:32:41.652]             `<<-` <- base::`<<-`
[15:32:41.652]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:41.652]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:41.652]                   3L)]
[15:32:41.652]             }
[15:32:41.652]             function(cond) {
[15:32:41.652]                 is_error <- inherits(cond, "error")
[15:32:41.652]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:41.652]                   NULL)
[15:32:41.652]                 if (is_error) {
[15:32:41.652]                   sessionInformation <- function() {
[15:32:41.652]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:41.652]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:41.652]                       search = base::search(), system = base::Sys.info())
[15:32:41.652]                   }
[15:32:41.652]                   ...future.conditions[[length(...future.conditions) + 
[15:32:41.652]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:41.652]                     cond$call), session = sessionInformation(), 
[15:32:41.652]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:41.652]                   signalCondition(cond)
[15:32:41.652]                 }
[15:32:41.652]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:41.652]                 "immediateCondition"))) {
[15:32:41.652]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:41.652]                   ...future.conditions[[length(...future.conditions) + 
[15:32:41.652]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:41.652]                   if (TRUE && !signal) {
[15:32:41.652]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:41.652]                     {
[15:32:41.652]                       inherits <- base::inherits
[15:32:41.652]                       invokeRestart <- base::invokeRestart
[15:32:41.652]                       is.null <- base::is.null
[15:32:41.652]                       muffled <- FALSE
[15:32:41.652]                       if (inherits(cond, "message")) {
[15:32:41.652]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:41.652]                         if (muffled) 
[15:32:41.652]                           invokeRestart("muffleMessage")
[15:32:41.652]                       }
[15:32:41.652]                       else if (inherits(cond, "warning")) {
[15:32:41.652]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:41.652]                         if (muffled) 
[15:32:41.652]                           invokeRestart("muffleWarning")
[15:32:41.652]                       }
[15:32:41.652]                       else if (inherits(cond, "condition")) {
[15:32:41.652]                         if (!is.null(pattern)) {
[15:32:41.652]                           computeRestarts <- base::computeRestarts
[15:32:41.652]                           grepl <- base::grepl
[15:32:41.652]                           restarts <- computeRestarts(cond)
[15:32:41.652]                           for (restart in restarts) {
[15:32:41.652]                             name <- restart$name
[15:32:41.652]                             if (is.null(name)) 
[15:32:41.652]                               next
[15:32:41.652]                             if (!grepl(pattern, name)) 
[15:32:41.652]                               next
[15:32:41.652]                             invokeRestart(restart)
[15:32:41.652]                             muffled <- TRUE
[15:32:41.652]                             break
[15:32:41.652]                           }
[15:32:41.652]                         }
[15:32:41.652]                       }
[15:32:41.652]                       invisible(muffled)
[15:32:41.652]                     }
[15:32:41.652]                     muffleCondition(cond, pattern = "^muffle")
[15:32:41.652]                   }
[15:32:41.652]                 }
[15:32:41.652]                 else {
[15:32:41.652]                   if (TRUE) {
[15:32:41.652]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:41.652]                     {
[15:32:41.652]                       inherits <- base::inherits
[15:32:41.652]                       invokeRestart <- base::invokeRestart
[15:32:41.652]                       is.null <- base::is.null
[15:32:41.652]                       muffled <- FALSE
[15:32:41.652]                       if (inherits(cond, "message")) {
[15:32:41.652]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:41.652]                         if (muffled) 
[15:32:41.652]                           invokeRestart("muffleMessage")
[15:32:41.652]                       }
[15:32:41.652]                       else if (inherits(cond, "warning")) {
[15:32:41.652]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:41.652]                         if (muffled) 
[15:32:41.652]                           invokeRestart("muffleWarning")
[15:32:41.652]                       }
[15:32:41.652]                       else if (inherits(cond, "condition")) {
[15:32:41.652]                         if (!is.null(pattern)) {
[15:32:41.652]                           computeRestarts <- base::computeRestarts
[15:32:41.652]                           grepl <- base::grepl
[15:32:41.652]                           restarts <- computeRestarts(cond)
[15:32:41.652]                           for (restart in restarts) {
[15:32:41.652]                             name <- restart$name
[15:32:41.652]                             if (is.null(name)) 
[15:32:41.652]                               next
[15:32:41.652]                             if (!grepl(pattern, name)) 
[15:32:41.652]                               next
[15:32:41.652]                             invokeRestart(restart)
[15:32:41.652]                             muffled <- TRUE
[15:32:41.652]                             break
[15:32:41.652]                           }
[15:32:41.652]                         }
[15:32:41.652]                       }
[15:32:41.652]                       invisible(muffled)
[15:32:41.652]                     }
[15:32:41.652]                     muffleCondition(cond, pattern = "^muffle")
[15:32:41.652]                   }
[15:32:41.652]                 }
[15:32:41.652]             }
[15:32:41.652]         }))
[15:32:41.652]     }, error = function(ex) {
[15:32:41.652]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:41.652]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:41.652]                 ...future.rng), started = ...future.startTime, 
[15:32:41.652]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:41.652]             version = "1.8"), class = "FutureResult")
[15:32:41.652]     }, finally = {
[15:32:41.652]         if (!identical(...future.workdir, getwd())) 
[15:32:41.652]             setwd(...future.workdir)
[15:32:41.652]         {
[15:32:41.652]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:41.652]                 ...future.oldOptions$nwarnings <- NULL
[15:32:41.652]             }
[15:32:41.652]             base::options(...future.oldOptions)
[15:32:41.652]             if (.Platform$OS.type == "windows") {
[15:32:41.652]                 old_names <- names(...future.oldEnvVars)
[15:32:41.652]                 envs <- base::Sys.getenv()
[15:32:41.652]                 names <- names(envs)
[15:32:41.652]                 common <- intersect(names, old_names)
[15:32:41.652]                 added <- setdiff(names, old_names)
[15:32:41.652]                 removed <- setdiff(old_names, names)
[15:32:41.652]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:41.652]                   envs[common]]
[15:32:41.652]                 NAMES <- toupper(changed)
[15:32:41.652]                 args <- list()
[15:32:41.652]                 for (kk in seq_along(NAMES)) {
[15:32:41.652]                   name <- changed[[kk]]
[15:32:41.652]                   NAME <- NAMES[[kk]]
[15:32:41.652]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:41.652]                     next
[15:32:41.652]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:41.652]                 }
[15:32:41.652]                 NAMES <- toupper(added)
[15:32:41.652]                 for (kk in seq_along(NAMES)) {
[15:32:41.652]                   name <- added[[kk]]
[15:32:41.652]                   NAME <- NAMES[[kk]]
[15:32:41.652]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:41.652]                     next
[15:32:41.652]                   args[[name]] <- ""
[15:32:41.652]                 }
[15:32:41.652]                 NAMES <- toupper(removed)
[15:32:41.652]                 for (kk in seq_along(NAMES)) {
[15:32:41.652]                   name <- removed[[kk]]
[15:32:41.652]                   NAME <- NAMES[[kk]]
[15:32:41.652]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:41.652]                     next
[15:32:41.652]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:41.652]                 }
[15:32:41.652]                 if (length(args) > 0) 
[15:32:41.652]                   base::do.call(base::Sys.setenv, args = args)
[15:32:41.652]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:41.652]             }
[15:32:41.652]             else {
[15:32:41.652]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:41.652]             }
[15:32:41.652]             {
[15:32:41.652]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:41.652]                   0L) {
[15:32:41.652]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:41.652]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:41.652]                   base::options(opts)
[15:32:41.652]                 }
[15:32:41.652]                 {
[15:32:41.652]                   {
[15:32:41.652]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:41.652]                     NULL
[15:32:41.652]                   }
[15:32:41.652]                   options(future.plan = NULL)
[15:32:41.652]                   if (is.na(NA_character_)) 
[15:32:41.652]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:41.652]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:41.652]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:41.652]                     .init = FALSE)
[15:32:41.652]                 }
[15:32:41.652]             }
[15:32:41.652]         }
[15:32:41.652]     })
[15:32:41.652]     if (TRUE) {
[15:32:41.652]         base::sink(type = "output", split = FALSE)
[15:32:41.652]         if (TRUE) {
[15:32:41.652]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:41.652]         }
[15:32:41.652]         else {
[15:32:41.652]             ...future.result["stdout"] <- base::list(NULL)
[15:32:41.652]         }
[15:32:41.652]         base::close(...future.stdout)
[15:32:41.652]         ...future.stdout <- NULL
[15:32:41.652]     }
[15:32:41.652]     ...future.result$conditions <- ...future.conditions
[15:32:41.652]     ...future.result$finished <- base::Sys.time()
[15:32:41.652]     ...future.result
[15:32:41.652] }
[15:32:41.662] Exporting 5 global objects (4.62 KiB) to cluster node #1 ...
[15:32:41.662] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ...
[15:32:41.663] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ... DONE
[15:32:41.664] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:41.665] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:41.665] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:41.666] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:41.666] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:41.667] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:41.667] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:41.668] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:41.668] Exporting 5 global objects (4.62 KiB) to cluster node #1 ... DONE
[15:32:41.670] MultisessionFuture started
[15:32:41.670] - Launch lazy future ... done
[15:32:41.670] run() for 'MultisessionFuture' ... done
[15:32:41.671] Created future:
[15:32:41.699] receiveMessageFromWorker() for ClusterFuture ...
[15:32:41.699] - Validating connection of MultisessionFuture
[15:32:41.700] - received message: FutureResult
[15:32:41.700] - Received FutureResult
[15:32:41.700] - Erased future from FutureRegistry
[15:32:41.701] result() for ClusterFuture ...
[15:32:41.701] - result already collected: FutureResult
[15:32:41.701] result() for ClusterFuture ... done
[15:32:41.702] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:41.671] MultisessionFuture:
[15:32:41.671] Label: 'future_sapply-1'
[15:32:41.671] Expression:
[15:32:41.671] {
[15:32:41.671]     do.call(function(...) {
[15:32:41.671]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:41.671]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:41.671]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:41.671]             on.exit(options(oopts), add = TRUE)
[15:32:41.671]         }
[15:32:41.671]         {
[15:32:41.671]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:41.671]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:41.671]                 ...future.FUN(...future.X_jj, ...)
[15:32:41.671]             })
[15:32:41.671]         }
[15:32:41.671]     }, args = future.call.arguments)
[15:32:41.671] }
[15:32:41.671] Lazy evaluation: FALSE
[15:32:41.671] Asynchronous evaluation: TRUE
[15:32:41.671] Local evaluation: TRUE
[15:32:41.671] Environment: R_GlobalEnv
[15:32:41.671] Capture standard output: TRUE
[15:32:41.671] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:41.671] Globals: 5 objects totaling 4.73 KiB (function '...future.FUN' of 4.62 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)
[15:32:41.671] Packages: <none>
[15:32:41.671] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:41.671] Resolved: TRUE
[15:32:41.671] Value: <not collected>
[15:32:41.671] Conditions captured: <none>
[15:32:41.671] Early signaling: FALSE
[15:32:41.671] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:41.671] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:41.702] Chunk #1 of 2 ... DONE
[15:32:41.703] Chunk #2 of 2 ...
[15:32:41.703]  - Finding globals in 'X' for chunk #2 ...
[15:32:41.703] getGlobalsAndPackages() ...
[15:32:41.704] Searching for globals...
[15:32:41.704] 
[15:32:41.705] Searching for globals ... DONE
[15:32:41.705] - globals: [0] <none>
[15:32:41.705] getGlobalsAndPackages() ... DONE
[15:32:41.705]    + additional globals found: [n=0] 
[15:32:41.706]    + additional namespaces needed: [n=0] 
[15:32:41.706]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:41.706]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:41.706]  - seeds: <none>
[15:32:41.707]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:41.707] getGlobalsAndPackages() ...
[15:32:41.707] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:41.708] Resolving globals: FALSE
[15:32:41.708] Tweak future expression to call with '...' arguments ...
[15:32:41.708] {
[15:32:41.708]     do.call(function(...) {
[15:32:41.708]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:41.708]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:41.708]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:41.708]             on.exit(options(oopts), add = TRUE)
[15:32:41.708]         }
[15:32:41.708]         {
[15:32:41.708]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:41.708]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:41.708]                 ...future.FUN(...future.X_jj, ...)
[15:32:41.708]             })
[15:32:41.708]         }
[15:32:41.708]     }, args = future.call.arguments)
[15:32:41.708] }
[15:32:41.709] Tweak future expression to call with '...' arguments ... DONE
[15:32:41.710] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:41.710] 
[15:32:41.710] getGlobalsAndPackages() ... DONE
[15:32:41.711] run() for 'Future' ...
[15:32:41.711] - state: 'created'
[15:32:41.712] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:41.730] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:41.730] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:41.730]   - Field: 'node'
[15:32:41.730]   - Field: 'label'
[15:32:41.731]   - Field: 'local'
[15:32:41.731]   - Field: 'owner'
[15:32:41.731]   - Field: 'envir'
[15:32:41.731]   - Field: 'workers'
[15:32:41.731]   - Field: 'packages'
[15:32:41.732]   - Field: 'gc'
[15:32:41.732]   - Field: 'conditions'
[15:32:41.732]   - Field: 'persistent'
[15:32:41.732]   - Field: 'expr'
[15:32:41.732]   - Field: 'uuid'
[15:32:41.732]   - Field: 'seed'
[15:32:41.733]   - Field: 'version'
[15:32:41.733]   - Field: 'result'
[15:32:41.733]   - Field: 'asynchronous'
[15:32:41.733]   - Field: 'calls'
[15:32:41.733]   - Field: 'globals'
[15:32:41.733]   - Field: 'stdout'
[15:32:41.734]   - Field: 'earlySignal'
[15:32:41.734]   - Field: 'lazy'
[15:32:41.734]   - Field: 'state'
[15:32:41.735] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:41.735] - Launch lazy future ...
[15:32:41.735] Packages needed by the future expression (n = 0): <none>
[15:32:41.736] Packages needed by future strategies (n = 0): <none>
[15:32:41.737] {
[15:32:41.737]     {
[15:32:41.737]         {
[15:32:41.737]             ...future.startTime <- base::Sys.time()
[15:32:41.737]             {
[15:32:41.737]                 {
[15:32:41.737]                   {
[15:32:41.737]                     {
[15:32:41.737]                       base::local({
[15:32:41.737]                         has_future <- base::requireNamespace("future", 
[15:32:41.737]                           quietly = TRUE)
[15:32:41.737]                         if (has_future) {
[15:32:41.737]                           ns <- base::getNamespace("future")
[15:32:41.737]                           version <- ns[[".package"]][["version"]]
[15:32:41.737]                           if (is.null(version)) 
[15:32:41.737]                             version <- utils::packageVersion("future")
[15:32:41.737]                         }
[15:32:41.737]                         else {
[15:32:41.737]                           version <- NULL
[15:32:41.737]                         }
[15:32:41.737]                         if (!has_future || version < "1.8.0") {
[15:32:41.737]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:41.737]                             "", base::R.version$version.string), 
[15:32:41.737]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:41.737]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:41.737]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:41.737]                               "release", "version")], collapse = " "), 
[15:32:41.737]                             hostname = base::Sys.info()[["nodename"]])
[15:32:41.737]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:41.737]                             info)
[15:32:41.737]                           info <- base::paste(info, collapse = "; ")
[15:32:41.737]                           if (!has_future) {
[15:32:41.737]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:41.737]                               info)
[15:32:41.737]                           }
[15:32:41.737]                           else {
[15:32:41.737]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:41.737]                               info, version)
[15:32:41.737]                           }
[15:32:41.737]                           base::stop(msg)
[15:32:41.737]                         }
[15:32:41.737]                       })
[15:32:41.737]                     }
[15:32:41.737]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:41.737]                     base::options(mc.cores = 1L)
[15:32:41.737]                   }
[15:32:41.737]                   ...future.strategy.old <- future::plan("list")
[15:32:41.737]                   options(future.plan = NULL)
[15:32:41.737]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:41.737]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:41.737]                 }
[15:32:41.737]                 ...future.workdir <- getwd()
[15:32:41.737]             }
[15:32:41.737]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:41.737]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:41.737]         }
[15:32:41.737]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:41.737]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:41.737]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:41.737]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:41.737]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:41.737]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:41.737]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:41.737]             base::names(...future.oldOptions))
[15:32:41.737]     }
[15:32:41.737]     if (FALSE) {
[15:32:41.737]     }
[15:32:41.737]     else {
[15:32:41.737]         if (TRUE) {
[15:32:41.737]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:41.737]                 open = "w")
[15:32:41.737]         }
[15:32:41.737]         else {
[15:32:41.737]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:41.737]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:41.737]         }
[15:32:41.737]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:41.737]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:41.737]             base::sink(type = "output", split = FALSE)
[15:32:41.737]             base::close(...future.stdout)
[15:32:41.737]         }, add = TRUE)
[15:32:41.737]     }
[15:32:41.737]     ...future.frame <- base::sys.nframe()
[15:32:41.737]     ...future.conditions <- base::list()
[15:32:41.737]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:41.737]     if (FALSE) {
[15:32:41.737]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:41.737]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:41.737]     }
[15:32:41.737]     ...future.result <- base::tryCatch({
[15:32:41.737]         base::withCallingHandlers({
[15:32:41.737]             ...future.value <- base::withVisible(base::local({
[15:32:41.737]                 ...future.makeSendCondition <- base::local({
[15:32:41.737]                   sendCondition <- NULL
[15:32:41.737]                   function(frame = 1L) {
[15:32:41.737]                     if (is.function(sendCondition)) 
[15:32:41.737]                       return(sendCondition)
[15:32:41.737]                     ns <- getNamespace("parallel")
[15:32:41.737]                     if (exists("sendData", mode = "function", 
[15:32:41.737]                       envir = ns)) {
[15:32:41.737]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:41.737]                         envir = ns)
[15:32:41.737]                       envir <- sys.frame(frame)
[15:32:41.737]                       master <- NULL
[15:32:41.737]                       while (!identical(envir, .GlobalEnv) && 
[15:32:41.737]                         !identical(envir, emptyenv())) {
[15:32:41.737]                         if (exists("master", mode = "list", envir = envir, 
[15:32:41.737]                           inherits = FALSE)) {
[15:32:41.737]                           master <- get("master", mode = "list", 
[15:32:41.737]                             envir = envir, inherits = FALSE)
[15:32:41.737]                           if (inherits(master, c("SOCKnode", 
[15:32:41.737]                             "SOCK0node"))) {
[15:32:41.737]                             sendCondition <<- function(cond) {
[15:32:41.737]                               data <- list(type = "VALUE", value = cond, 
[15:32:41.737]                                 success = TRUE)
[15:32:41.737]                               parallel_sendData(master, data)
[15:32:41.737]                             }
[15:32:41.737]                             return(sendCondition)
[15:32:41.737]                           }
[15:32:41.737]                         }
[15:32:41.737]                         frame <- frame + 1L
[15:32:41.737]                         envir <- sys.frame(frame)
[15:32:41.737]                       }
[15:32:41.737]                     }
[15:32:41.737]                     sendCondition <<- function(cond) NULL
[15:32:41.737]                   }
[15:32:41.737]                 })
[15:32:41.737]                 withCallingHandlers({
[15:32:41.737]                   {
[15:32:41.737]                     do.call(function(...) {
[15:32:41.737]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:41.737]                       if (!identical(...future.globals.maxSize.org, 
[15:32:41.737]                         ...future.globals.maxSize)) {
[15:32:41.737]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:41.737]                         on.exit(options(oopts), add = TRUE)
[15:32:41.737]                       }
[15:32:41.737]                       {
[15:32:41.737]                         lapply(seq_along(...future.elements_ii), 
[15:32:41.737]                           FUN = function(jj) {
[15:32:41.737]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:41.737]                             ...future.FUN(...future.X_jj, ...)
[15:32:41.737]                           })
[15:32:41.737]                       }
[15:32:41.737]                     }, args = future.call.arguments)
[15:32:41.737]                   }
[15:32:41.737]                 }, immediateCondition = function(cond) {
[15:32:41.737]                   sendCondition <- ...future.makeSendCondition()
[15:32:41.737]                   sendCondition(cond)
[15:32:41.737]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:41.737]                   {
[15:32:41.737]                     inherits <- base::inherits
[15:32:41.737]                     invokeRestart <- base::invokeRestart
[15:32:41.737]                     is.null <- base::is.null
[15:32:41.737]                     muffled <- FALSE
[15:32:41.737]                     if (inherits(cond, "message")) {
[15:32:41.737]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:41.737]                       if (muffled) 
[15:32:41.737]                         invokeRestart("muffleMessage")
[15:32:41.737]                     }
[15:32:41.737]                     else if (inherits(cond, "warning")) {
[15:32:41.737]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:41.737]                       if (muffled) 
[15:32:41.737]                         invokeRestart("muffleWarning")
[15:32:41.737]                     }
[15:32:41.737]                     else if (inherits(cond, "condition")) {
[15:32:41.737]                       if (!is.null(pattern)) {
[15:32:41.737]                         computeRestarts <- base::computeRestarts
[15:32:41.737]                         grepl <- base::grepl
[15:32:41.737]                         restarts <- computeRestarts(cond)
[15:32:41.737]                         for (restart in restarts) {
[15:32:41.737]                           name <- restart$name
[15:32:41.737]                           if (is.null(name)) 
[15:32:41.737]                             next
[15:32:41.737]                           if (!grepl(pattern, name)) 
[15:32:41.737]                             next
[15:32:41.737]                           invokeRestart(restart)
[15:32:41.737]                           muffled <- TRUE
[15:32:41.737]                           break
[15:32:41.737]                         }
[15:32:41.737]                       }
[15:32:41.737]                     }
[15:32:41.737]                     invisible(muffled)
[15:32:41.737]                   }
[15:32:41.737]                   muffleCondition(cond)
[15:32:41.737]                 })
[15:32:41.737]             }))
[15:32:41.737]             future::FutureResult(value = ...future.value$value, 
[15:32:41.737]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:41.737]                   ...future.rng), globalenv = if (FALSE) 
[15:32:41.737]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:41.737]                     ...future.globalenv.names))
[15:32:41.737]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:41.737]         }, condition = base::local({
[15:32:41.737]             c <- base::c
[15:32:41.737]             inherits <- base::inherits
[15:32:41.737]             invokeRestart <- base::invokeRestart
[15:32:41.737]             length <- base::length
[15:32:41.737]             list <- base::list
[15:32:41.737]             seq.int <- base::seq.int
[15:32:41.737]             signalCondition <- base::signalCondition
[15:32:41.737]             sys.calls <- base::sys.calls
[15:32:41.737]             `[[` <- base::`[[`
[15:32:41.737]             `+` <- base::`+`
[15:32:41.737]             `<<-` <- base::`<<-`
[15:32:41.737]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:41.737]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:41.737]                   3L)]
[15:32:41.737]             }
[15:32:41.737]             function(cond) {
[15:32:41.737]                 is_error <- inherits(cond, "error")
[15:32:41.737]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:41.737]                   NULL)
[15:32:41.737]                 if (is_error) {
[15:32:41.737]                   sessionInformation <- function() {
[15:32:41.737]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:41.737]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:41.737]                       search = base::search(), system = base::Sys.info())
[15:32:41.737]                   }
[15:32:41.737]                   ...future.conditions[[length(...future.conditions) + 
[15:32:41.737]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:41.737]                     cond$call), session = sessionInformation(), 
[15:32:41.737]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:41.737]                   signalCondition(cond)
[15:32:41.737]                 }
[15:32:41.737]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:41.737]                 "immediateCondition"))) {
[15:32:41.737]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:41.737]                   ...future.conditions[[length(...future.conditions) + 
[15:32:41.737]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:41.737]                   if (TRUE && !signal) {
[15:32:41.737]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:41.737]                     {
[15:32:41.737]                       inherits <- base::inherits
[15:32:41.737]                       invokeRestart <- base::invokeRestart
[15:32:41.737]                       is.null <- base::is.null
[15:32:41.737]                       muffled <- FALSE
[15:32:41.737]                       if (inherits(cond, "message")) {
[15:32:41.737]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:41.737]                         if (muffled) 
[15:32:41.737]                           invokeRestart("muffleMessage")
[15:32:41.737]                       }
[15:32:41.737]                       else if (inherits(cond, "warning")) {
[15:32:41.737]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:41.737]                         if (muffled) 
[15:32:41.737]                           invokeRestart("muffleWarning")
[15:32:41.737]                       }
[15:32:41.737]                       else if (inherits(cond, "condition")) {
[15:32:41.737]                         if (!is.null(pattern)) {
[15:32:41.737]                           computeRestarts <- base::computeRestarts
[15:32:41.737]                           grepl <- base::grepl
[15:32:41.737]                           restarts <- computeRestarts(cond)
[15:32:41.737]                           for (restart in restarts) {
[15:32:41.737]                             name <- restart$name
[15:32:41.737]                             if (is.null(name)) 
[15:32:41.737]                               next
[15:32:41.737]                             if (!grepl(pattern, name)) 
[15:32:41.737]                               next
[15:32:41.737]                             invokeRestart(restart)
[15:32:41.737]                             muffled <- TRUE
[15:32:41.737]                             break
[15:32:41.737]                           }
[15:32:41.737]                         }
[15:32:41.737]                       }
[15:32:41.737]                       invisible(muffled)
[15:32:41.737]                     }
[15:32:41.737]                     muffleCondition(cond, pattern = "^muffle")
[15:32:41.737]                   }
[15:32:41.737]                 }
[15:32:41.737]                 else {
[15:32:41.737]                   if (TRUE) {
[15:32:41.737]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:41.737]                     {
[15:32:41.737]                       inherits <- base::inherits
[15:32:41.737]                       invokeRestart <- base::invokeRestart
[15:32:41.737]                       is.null <- base::is.null
[15:32:41.737]                       muffled <- FALSE
[15:32:41.737]                       if (inherits(cond, "message")) {
[15:32:41.737]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:41.737]                         if (muffled) 
[15:32:41.737]                           invokeRestart("muffleMessage")
[15:32:41.737]                       }
[15:32:41.737]                       else if (inherits(cond, "warning")) {
[15:32:41.737]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:41.737]                         if (muffled) 
[15:32:41.737]                           invokeRestart("muffleWarning")
[15:32:41.737]                       }
[15:32:41.737]                       else if (inherits(cond, "condition")) {
[15:32:41.737]                         if (!is.null(pattern)) {
[15:32:41.737]                           computeRestarts <- base::computeRestarts
[15:32:41.737]                           grepl <- base::grepl
[15:32:41.737]                           restarts <- computeRestarts(cond)
[15:32:41.737]                           for (restart in restarts) {
[15:32:41.737]                             name <- restart$name
[15:32:41.737]                             if (is.null(name)) 
[15:32:41.737]                               next
[15:32:41.737]                             if (!grepl(pattern, name)) 
[15:32:41.737]                               next
[15:32:41.737]                             invokeRestart(restart)
[15:32:41.737]                             muffled <- TRUE
[15:32:41.737]                             break
[15:32:41.737]                           }
[15:32:41.737]                         }
[15:32:41.737]                       }
[15:32:41.737]                       invisible(muffled)
[15:32:41.737]                     }
[15:32:41.737]                     muffleCondition(cond, pattern = "^muffle")
[15:32:41.737]                   }
[15:32:41.737]                 }
[15:32:41.737]             }
[15:32:41.737]         }))
[15:32:41.737]     }, error = function(ex) {
[15:32:41.737]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:41.737]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:41.737]                 ...future.rng), started = ...future.startTime, 
[15:32:41.737]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:41.737]             version = "1.8"), class = "FutureResult")
[15:32:41.737]     }, finally = {
[15:32:41.737]         if (!identical(...future.workdir, getwd())) 
[15:32:41.737]             setwd(...future.workdir)
[15:32:41.737]         {
[15:32:41.737]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:41.737]                 ...future.oldOptions$nwarnings <- NULL
[15:32:41.737]             }
[15:32:41.737]             base::options(...future.oldOptions)
[15:32:41.737]             if (.Platform$OS.type == "windows") {
[15:32:41.737]                 old_names <- names(...future.oldEnvVars)
[15:32:41.737]                 envs <- base::Sys.getenv()
[15:32:41.737]                 names <- names(envs)
[15:32:41.737]                 common <- intersect(names, old_names)
[15:32:41.737]                 added <- setdiff(names, old_names)
[15:32:41.737]                 removed <- setdiff(old_names, names)
[15:32:41.737]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:41.737]                   envs[common]]
[15:32:41.737]                 NAMES <- toupper(changed)
[15:32:41.737]                 args <- list()
[15:32:41.737]                 for (kk in seq_along(NAMES)) {
[15:32:41.737]                   name <- changed[[kk]]
[15:32:41.737]                   NAME <- NAMES[[kk]]
[15:32:41.737]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:41.737]                     next
[15:32:41.737]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:41.737]                 }
[15:32:41.737]                 NAMES <- toupper(added)
[15:32:41.737]                 for (kk in seq_along(NAMES)) {
[15:32:41.737]                   name <- added[[kk]]
[15:32:41.737]                   NAME <- NAMES[[kk]]
[15:32:41.737]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:41.737]                     next
[15:32:41.737]                   args[[name]] <- ""
[15:32:41.737]                 }
[15:32:41.737]                 NAMES <- toupper(removed)
[15:32:41.737]                 for (kk in seq_along(NAMES)) {
[15:32:41.737]                   name <- removed[[kk]]
[15:32:41.737]                   NAME <- NAMES[[kk]]
[15:32:41.737]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:41.737]                     next
[15:32:41.737]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:41.737]                 }
[15:32:41.737]                 if (length(args) > 0) 
[15:32:41.737]                   base::do.call(base::Sys.setenv, args = args)
[15:32:41.737]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:41.737]             }
[15:32:41.737]             else {
[15:32:41.737]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:41.737]             }
[15:32:41.737]             {
[15:32:41.737]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:41.737]                   0L) {
[15:32:41.737]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:41.737]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:41.737]                   base::options(opts)
[15:32:41.737]                 }
[15:32:41.737]                 {
[15:32:41.737]                   {
[15:32:41.737]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:41.737]                     NULL
[15:32:41.737]                   }
[15:32:41.737]                   options(future.plan = NULL)
[15:32:41.737]                   if (is.na(NA_character_)) 
[15:32:41.737]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:41.737]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:41.737]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:41.737]                     .init = FALSE)
[15:32:41.737]                 }
[15:32:41.737]             }
[15:32:41.737]         }
[15:32:41.737]     })
[15:32:41.737]     if (TRUE) {
[15:32:41.737]         base::sink(type = "output", split = FALSE)
[15:32:41.737]         if (TRUE) {
[15:32:41.737]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:41.737]         }
[15:32:41.737]         else {
[15:32:41.737]             ...future.result["stdout"] <- base::list(NULL)
[15:32:41.737]         }
[15:32:41.737]         base::close(...future.stdout)
[15:32:41.737]         ...future.stdout <- NULL
[15:32:41.737]     }
[15:32:41.737]     ...future.result$conditions <- ...future.conditions
[15:32:41.737]     ...future.result$finished <- base::Sys.time()
[15:32:41.737]     ...future.result
[15:32:41.737] }
[15:32:41.746] Exporting 5 global objects (4.62 KiB) to cluster node #1 ...
[15:32:41.747] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ...
[15:32:41.748] Exporting '...future.FUN' (4.62 KiB) to cluster node #1 ... DONE
[15:32:41.748] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:41.749] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:41.749] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:41.750] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:41.750] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:41.751] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:41.753] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:41.755] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:41.755] Exporting 5 global objects (4.62 KiB) to cluster node #1 ... DONE
[15:32:41.756] MultisessionFuture started
[15:32:41.756] - Launch lazy future ... done
[15:32:41.757] run() for 'MultisessionFuture' ... done
[15:32:41.757] Created future:
[15:32:41.786] receiveMessageFromWorker() for ClusterFuture ...
[15:32:41.787] - Validating connection of MultisessionFuture
[15:32:41.788] - received message: FutureResult
[15:32:41.788] - Received FutureResult
[15:32:41.788] - Erased future from FutureRegistry
[15:32:41.788] result() for ClusterFuture ...
[15:32:41.789] - result already collected: FutureResult
[15:32:41.789] result() for ClusterFuture ... done
[15:32:41.789] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:41.757] MultisessionFuture:
[15:32:41.757] Label: 'future_sapply-2'
[15:32:41.757] Expression:
[15:32:41.757] {
[15:32:41.757]     do.call(function(...) {
[15:32:41.757]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:41.757]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:41.757]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:41.757]             on.exit(options(oopts), add = TRUE)
[15:32:41.757]         }
[15:32:41.757]         {
[15:32:41.757]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:41.757]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:41.757]                 ...future.FUN(...future.X_jj, ...)
[15:32:41.757]             })
[15:32:41.757]         }
[15:32:41.757]     }, args = future.call.arguments)
[15:32:41.757] }
[15:32:41.757] Lazy evaluation: FALSE
[15:32:41.757] Asynchronous evaluation: TRUE
[15:32:41.757] Local evaluation: TRUE
[15:32:41.757] Environment: R_GlobalEnv
[15:32:41.757] Capture standard output: TRUE
[15:32:41.757] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:41.757] Globals: 5 objects totaling 4.73 KiB (function '...future.FUN' of 4.62 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)
[15:32:41.757] Packages: <none>
[15:32:41.757] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:41.757] Resolved: TRUE
[15:32:41.757] Value: <not collected>
[15:32:41.757] Conditions captured: <none>
[15:32:41.757] Early signaling: FALSE
[15:32:41.757] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:41.757] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:41.790] Chunk #2 of 2 ... DONE
[15:32:41.790] Launching 2 futures (chunks) ... DONE
[15:32:41.791] Resolving 2 futures (chunks) ...
[15:32:41.791] resolve() on list ...
[15:32:41.791]  recursive: 0
[15:32:41.791]  length: 2
[15:32:41.792] 
[15:32:41.792] Future #1
[15:32:41.792] result() for ClusterFuture ...
[15:32:41.793] - result already collected: FutureResult
[15:32:41.793] result() for ClusterFuture ... done
[15:32:41.793] result() for ClusterFuture ...
[15:32:41.793] - result already collected: FutureResult
[15:32:41.794] result() for ClusterFuture ... done
[15:32:41.794] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:41.794] - nx: 2
[15:32:41.794] - relay: TRUE
[15:32:41.795] - stdout: TRUE
[15:32:41.795] - signal: TRUE
[15:32:41.795] - resignal: FALSE
[15:32:41.795] - force: TRUE
[15:32:41.796] - relayed: [n=2] FALSE, FALSE
[15:32:41.796] - queued futures: [n=2] FALSE, FALSE
[15:32:41.796]  - until=1
[15:32:41.796]  - relaying element #1
[15:32:41.797] result() for ClusterFuture ...
[15:32:41.797] - result already collected: FutureResult
[15:32:41.797] result() for ClusterFuture ... done
[15:32:41.798] result() for ClusterFuture ...
[15:32:41.798] - result already collected: FutureResult
[15:32:41.798] result() for ClusterFuture ... done
[15:32:41.798] result() for ClusterFuture ...
[15:32:41.799] - result already collected: FutureResult
[15:32:41.799] result() for ClusterFuture ... done
[15:32:41.799] result() for ClusterFuture ...
[15:32:41.799] - result already collected: FutureResult
[15:32:41.800] result() for ClusterFuture ... done
[15:32:41.800] - relayed: [n=2] TRUE, FALSE
[15:32:41.800] - queued futures: [n=2] TRUE, FALSE
[15:32:41.800] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:41.801]  length: 1 (resolved future 1)
[15:32:41.801] Future #2
[15:32:41.801] result() for ClusterFuture ...
[15:32:41.802] - result already collected: FutureResult
[15:32:41.802] result() for ClusterFuture ... done
[15:32:41.802] result() for ClusterFuture ...
[15:32:41.802] - result already collected: FutureResult
[15:32:41.803] result() for ClusterFuture ... done
[15:32:41.803] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:41.803] - nx: 2
[15:32:41.803] - relay: TRUE
[15:32:41.804] - stdout: TRUE
[15:32:41.804] - signal: TRUE
[15:32:41.804] - resignal: FALSE
[15:32:41.804] - force: TRUE
[15:32:41.805] - relayed: [n=2] TRUE, FALSE
[15:32:41.805] - queued futures: [n=2] TRUE, FALSE
[15:32:41.805]  - until=2
[15:32:41.806]  - relaying element #2
[15:32:41.806] result() for ClusterFuture ...
[15:32:41.806] - result already collected: FutureResult
[15:32:41.806] result() for ClusterFuture ... done
[15:32:41.807] result() for ClusterFuture ...
[15:32:41.807] - result already collected: FutureResult
[15:32:41.807] result() for ClusterFuture ... done
[15:32:41.807] result() for ClusterFuture ...
[15:32:41.808] - result already collected: FutureResult
[15:32:41.808] result() for ClusterFuture ... done
[15:32:41.808] result() for ClusterFuture ...
[15:32:41.808] - result already collected: FutureResult
[15:32:41.809] result() for ClusterFuture ... done
[15:32:41.809] - relayed: [n=2] TRUE, TRUE
[15:32:41.809] - queued futures: [n=2] TRUE, TRUE
[15:32:41.810] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:41.810]  length: 0 (resolved future 2)
[15:32:41.810] Relaying remaining futures
[15:32:41.810] signalConditionsASAP(NULL, pos=0) ...
[15:32:41.811] - nx: 2
[15:32:41.811] - relay: TRUE
[15:32:41.811] - stdout: TRUE
[15:32:41.811] - signal: TRUE
[15:32:41.812] - resignal: FALSE
[15:32:41.812] - force: TRUE
[15:32:41.812] - relayed: [n=2] TRUE, TRUE
[15:32:41.812] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:41.813] - relayed: [n=2] TRUE, TRUE
[15:32:41.813] - queued futures: [n=2] TRUE, TRUE
[15:32:41.813] signalConditionsASAP(NULL, pos=0) ... done
[15:32:41.814] resolve() on list ... DONE
[15:32:41.814] result() for ClusterFuture ...
[15:32:41.814] - result already collected: FutureResult
[15:32:41.814] result() for ClusterFuture ... done
[15:32:41.815] result() for ClusterFuture ...
[15:32:41.815] - result already collected: FutureResult
[15:32:41.815] result() for ClusterFuture ... done
[15:32:41.816] result() for ClusterFuture ...
[15:32:41.816] - result already collected: FutureResult
[15:32:41.816] result() for ClusterFuture ... done
[15:32:41.816] result() for ClusterFuture ...
[15:32:41.817] - result already collected: FutureResult
[15:32:41.817] result() for ClusterFuture ... done
[15:32:41.817]  - Number of value chunks collected: 2
[15:32:41.824] Resolving 2 futures (chunks) ... DONE
[15:32:41.824] Reducing values from 2 chunks ...
[15:32:41.825]  - Number of values collected after concatenation: 4
[15:32:41.825]  - Number of values expected: 4
[15:32:41.825] Reducing values from 2 chunks ... DONE
[15:32:41.826] future_lapply() ... DONE
List of 2
 $ y0: num [1:3, 1:5, 1:4] 100 100 100 200 200 200 300 300 300 400 ...
  ..- attr(*, "dimnames")=List of 3
  .. ..$ : NULL
  .. ..$ : NULL
  .. ..$ : chr [1:4] "A" "B" "C" "D"
 $ y1: num [1:3, 1:5, 1:4] 100 100 100 200 200 200 300 300 300 400 ...
  ..- attr(*, "dimnames")=List of 3
  .. ..$ : NULL
  .. ..$ : NULL
  .. ..$ : chr [1:4] "A" "B" "C" "D"
[15:32:41.832] future_lapply() ...
[15:32:41.836] Number of chunks: 2
[15:32:41.836] getGlobalsAndPackagesXApply() ...
[15:32:41.836]  - future.globals: TRUE
[15:32:41.837] getGlobalsAndPackages() ...
[15:32:41.837] Searching for globals...
[15:32:41.838] - globals found: [1] 'FUN'
[15:32:41.839] Searching for globals ... DONE
[15:32:41.839] Resolving globals: FALSE
[15:32:41.839] The total size of the 1 globals is 56 bytes (56 bytes)
[15:32:41.840] The total size of the 1 globals exported for future expression ('FUN()') is 56 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (56 bytes of class 'function')
[15:32:41.840] - globals: [1] 'FUN'
[15:32:41.841] 
[15:32:41.841] getGlobalsAndPackages() ... DONE
[15:32:41.841]  - globals found/used: [n=1] 'FUN'
[15:32:41.842]  - needed namespaces: [n=0] 
[15:32:41.842] Finding globals ... DONE
[15:32:41.842]  - use_args: TRUE
[15:32:41.842]  - Getting '...' globals ...
[15:32:41.843] resolve() on list ...
[15:32:41.843]  recursive: 0
[15:32:41.844]  length: 1
[15:32:41.844]  elements: '...'
[15:32:41.844]  length: 0 (resolved future 1)
[15:32:41.845] resolve() on list ... DONE
[15:32:41.845]    - '...' content: [n=0] 
[15:32:41.845] List of 1
[15:32:41.845]  $ ...: list()
[15:32:41.845]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:41.845]  - attr(*, "where")=List of 1
[15:32:41.845]   ..$ ...:<environment: 0x00000276e4074680> 
[15:32:41.845]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:41.845]  - attr(*, "resolved")= logi TRUE
[15:32:41.845]  - attr(*, "total_size")= num NA
[15:32:41.849]  - Getting '...' globals ... DONE
[15:32:41.850] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:41.850] List of 2
[15:32:41.850]  $ ...future.FUN:function (x)  
[15:32:41.850]  $ ...          : list()
[15:32:41.850]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:41.850]  - attr(*, "where")=List of 2
[15:32:41.850]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:41.850]   ..$ ...          :<environment: 0x00000276e4074680> 
[15:32:41.850]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:41.850]  - attr(*, "resolved")= logi FALSE
[15:32:41.850]  - attr(*, "total_size")= num 56
[15:32:41.855] Packages to be attached in all futures: [n=0] 
[15:32:41.855] getGlobalsAndPackagesXApply() ... DONE
[15:32:41.856] Number of futures (= number of chunks): 2
[15:32:41.856] Launching 2 futures (chunks) ...
[15:32:41.856] Chunk #1 of 2 ...
[15:32:41.857]  - Finding globals in 'X' for chunk #1 ...
[15:32:41.857] getGlobalsAndPackages() ...
[15:32:41.857] Searching for globals...
[15:32:41.858] 
[15:32:41.858] Searching for globals ... DONE
[15:32:41.858] - globals: [0] <none>
[15:32:41.859] getGlobalsAndPackages() ... DONE
[15:32:41.859]    + additional globals found: [n=0] 
[15:32:41.859]    + additional namespaces needed: [n=0] 
[15:32:41.859]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:41.860]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:41.860]  - seeds: <none>
[15:32:41.860]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:41.860] getGlobalsAndPackages() ...
[15:32:41.861] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:41.861] Resolving globals: FALSE
[15:32:41.861] Tweak future expression to call with '...' arguments ...
[15:32:41.862] {
[15:32:41.862]     do.call(function(...) {
[15:32:41.862]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:41.862]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:41.862]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:41.862]             on.exit(options(oopts), add = TRUE)
[15:32:41.862]         }
[15:32:41.862]         {
[15:32:41.862]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:41.862]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:41.862]                 ...future.FUN(...future.X_jj, ...)
[15:32:41.862]             })
[15:32:41.862]         }
[15:32:41.862]     }, args = future.call.arguments)
[15:32:41.862] }
[15:32:41.862] Tweak future expression to call with '...' arguments ... DONE
[15:32:41.863] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:41.863] 
[15:32:41.864] getGlobalsAndPackages() ... DONE
[15:32:41.864] run() for 'Future' ...
[15:32:41.865] - state: 'created'
[15:32:41.865] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:41.884] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:41.884] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:41.885]   - Field: 'node'
[15:32:41.885]   - Field: 'label'
[15:32:41.885]   - Field: 'local'
[15:32:41.886]   - Field: 'owner'
[15:32:41.886]   - Field: 'envir'
[15:32:41.886]   - Field: 'workers'
[15:32:41.887]   - Field: 'packages'
[15:32:41.887]   - Field: 'gc'
[15:32:41.887]   - Field: 'conditions'
[15:32:41.887]   - Field: 'persistent'
[15:32:41.888]   - Field: 'expr'
[15:32:41.888]   - Field: 'uuid'
[15:32:41.888]   - Field: 'seed'
[15:32:41.889]   - Field: 'version'
[15:32:41.889]   - Field: 'result'
[15:32:41.889]   - Field: 'asynchronous'
[15:32:41.890]   - Field: 'calls'
[15:32:41.890]   - Field: 'globals'
[15:32:41.890]   - Field: 'stdout'
[15:32:41.890]   - Field: 'earlySignal'
[15:32:41.891]   - Field: 'lazy'
[15:32:41.891]   - Field: 'state'
[15:32:41.891] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:41.892] - Launch lazy future ...
[15:32:41.892] Packages needed by the future expression (n = 0): <none>
[15:32:41.893] Packages needed by future strategies (n = 0): <none>
[15:32:41.894] {
[15:32:41.894]     {
[15:32:41.894]         {
[15:32:41.894]             ...future.startTime <- base::Sys.time()
[15:32:41.894]             {
[15:32:41.894]                 {
[15:32:41.894]                   {
[15:32:41.894]                     {
[15:32:41.894]                       base::local({
[15:32:41.894]                         has_future <- base::requireNamespace("future", 
[15:32:41.894]                           quietly = TRUE)
[15:32:41.894]                         if (has_future) {
[15:32:41.894]                           ns <- base::getNamespace("future")
[15:32:41.894]                           version <- ns[[".package"]][["version"]]
[15:32:41.894]                           if (is.null(version)) 
[15:32:41.894]                             version <- utils::packageVersion("future")
[15:32:41.894]                         }
[15:32:41.894]                         else {
[15:32:41.894]                           version <- NULL
[15:32:41.894]                         }
[15:32:41.894]                         if (!has_future || version < "1.8.0") {
[15:32:41.894]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:41.894]                             "", base::R.version$version.string), 
[15:32:41.894]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:41.894]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:41.894]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:41.894]                               "release", "version")], collapse = " "), 
[15:32:41.894]                             hostname = base::Sys.info()[["nodename"]])
[15:32:41.894]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:41.894]                             info)
[15:32:41.894]                           info <- base::paste(info, collapse = "; ")
[15:32:41.894]                           if (!has_future) {
[15:32:41.894]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:41.894]                               info)
[15:32:41.894]                           }
[15:32:41.894]                           else {
[15:32:41.894]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:41.894]                               info, version)
[15:32:41.894]                           }
[15:32:41.894]                           base::stop(msg)
[15:32:41.894]                         }
[15:32:41.894]                       })
[15:32:41.894]                     }
[15:32:41.894]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:41.894]                     base::options(mc.cores = 1L)
[15:32:41.894]                   }
[15:32:41.894]                   ...future.strategy.old <- future::plan("list")
[15:32:41.894]                   options(future.plan = NULL)
[15:32:41.894]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:41.894]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:41.894]                 }
[15:32:41.894]                 ...future.workdir <- getwd()
[15:32:41.894]             }
[15:32:41.894]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:41.894]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:41.894]         }
[15:32:41.894]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:41.894]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:41.894]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:41.894]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:41.894]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:41.894]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:41.894]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:41.894]             base::names(...future.oldOptions))
[15:32:41.894]     }
[15:32:41.894]     if (FALSE) {
[15:32:41.894]     }
[15:32:41.894]     else {
[15:32:41.894]         if (TRUE) {
[15:32:41.894]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:41.894]                 open = "w")
[15:32:41.894]         }
[15:32:41.894]         else {
[15:32:41.894]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:41.894]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:41.894]         }
[15:32:41.894]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:41.894]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:41.894]             base::sink(type = "output", split = FALSE)
[15:32:41.894]             base::close(...future.stdout)
[15:32:41.894]         }, add = TRUE)
[15:32:41.894]     }
[15:32:41.894]     ...future.frame <- base::sys.nframe()
[15:32:41.894]     ...future.conditions <- base::list()
[15:32:41.894]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:41.894]     if (FALSE) {
[15:32:41.894]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:41.894]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:41.894]     }
[15:32:41.894]     ...future.result <- base::tryCatch({
[15:32:41.894]         base::withCallingHandlers({
[15:32:41.894]             ...future.value <- base::withVisible(base::local({
[15:32:41.894]                 ...future.makeSendCondition <- base::local({
[15:32:41.894]                   sendCondition <- NULL
[15:32:41.894]                   function(frame = 1L) {
[15:32:41.894]                     if (is.function(sendCondition)) 
[15:32:41.894]                       return(sendCondition)
[15:32:41.894]                     ns <- getNamespace("parallel")
[15:32:41.894]                     if (exists("sendData", mode = "function", 
[15:32:41.894]                       envir = ns)) {
[15:32:41.894]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:41.894]                         envir = ns)
[15:32:41.894]                       envir <- sys.frame(frame)
[15:32:41.894]                       master <- NULL
[15:32:41.894]                       while (!identical(envir, .GlobalEnv) && 
[15:32:41.894]                         !identical(envir, emptyenv())) {
[15:32:41.894]                         if (exists("master", mode = "list", envir = envir, 
[15:32:41.894]                           inherits = FALSE)) {
[15:32:41.894]                           master <- get("master", mode = "list", 
[15:32:41.894]                             envir = envir, inherits = FALSE)
[15:32:41.894]                           if (inherits(master, c("SOCKnode", 
[15:32:41.894]                             "SOCK0node"))) {
[15:32:41.894]                             sendCondition <<- function(cond) {
[15:32:41.894]                               data <- list(type = "VALUE", value = cond, 
[15:32:41.894]                                 success = TRUE)
[15:32:41.894]                               parallel_sendData(master, data)
[15:32:41.894]                             }
[15:32:41.894]                             return(sendCondition)
[15:32:41.894]                           }
[15:32:41.894]                         }
[15:32:41.894]                         frame <- frame + 1L
[15:32:41.894]                         envir <- sys.frame(frame)
[15:32:41.894]                       }
[15:32:41.894]                     }
[15:32:41.894]                     sendCondition <<- function(cond) NULL
[15:32:41.894]                   }
[15:32:41.894]                 })
[15:32:41.894]                 withCallingHandlers({
[15:32:41.894]                   {
[15:32:41.894]                     do.call(function(...) {
[15:32:41.894]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:41.894]                       if (!identical(...future.globals.maxSize.org, 
[15:32:41.894]                         ...future.globals.maxSize)) {
[15:32:41.894]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:41.894]                         on.exit(options(oopts), add = TRUE)
[15:32:41.894]                       }
[15:32:41.894]                       {
[15:32:41.894]                         lapply(seq_along(...future.elements_ii), 
[15:32:41.894]                           FUN = function(jj) {
[15:32:41.894]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:41.894]                             ...future.FUN(...future.X_jj, ...)
[15:32:41.894]                           })
[15:32:41.894]                       }
[15:32:41.894]                     }, args = future.call.arguments)
[15:32:41.894]                   }
[15:32:41.894]                 }, immediateCondition = function(cond) {
[15:32:41.894]                   sendCondition <- ...future.makeSendCondition()
[15:32:41.894]                   sendCondition(cond)
[15:32:41.894]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:41.894]                   {
[15:32:41.894]                     inherits <- base::inherits
[15:32:41.894]                     invokeRestart <- base::invokeRestart
[15:32:41.894]                     is.null <- base::is.null
[15:32:41.894]                     muffled <- FALSE
[15:32:41.894]                     if (inherits(cond, "message")) {
[15:32:41.894]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:41.894]                       if (muffled) 
[15:32:41.894]                         invokeRestart("muffleMessage")
[15:32:41.894]                     }
[15:32:41.894]                     else if (inherits(cond, "warning")) {
[15:32:41.894]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:41.894]                       if (muffled) 
[15:32:41.894]                         invokeRestart("muffleWarning")
[15:32:41.894]                     }
[15:32:41.894]                     else if (inherits(cond, "condition")) {
[15:32:41.894]                       if (!is.null(pattern)) {
[15:32:41.894]                         computeRestarts <- base::computeRestarts
[15:32:41.894]                         grepl <- base::grepl
[15:32:41.894]                         restarts <- computeRestarts(cond)
[15:32:41.894]                         for (restart in restarts) {
[15:32:41.894]                           name <- restart$name
[15:32:41.894]                           if (is.null(name)) 
[15:32:41.894]                             next
[15:32:41.894]                           if (!grepl(pattern, name)) 
[15:32:41.894]                             next
[15:32:41.894]                           invokeRestart(restart)
[15:32:41.894]                           muffled <- TRUE
[15:32:41.894]                           break
[15:32:41.894]                         }
[15:32:41.894]                       }
[15:32:41.894]                     }
[15:32:41.894]                     invisible(muffled)
[15:32:41.894]                   }
[15:32:41.894]                   muffleCondition(cond)
[15:32:41.894]                 })
[15:32:41.894]             }))
[15:32:41.894]             future::FutureResult(value = ...future.value$value, 
[15:32:41.894]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:41.894]                   ...future.rng), globalenv = if (FALSE) 
[15:32:41.894]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:41.894]                     ...future.globalenv.names))
[15:32:41.894]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:41.894]         }, condition = base::local({
[15:32:41.894]             c <- base::c
[15:32:41.894]             inherits <- base::inherits
[15:32:41.894]             invokeRestart <- base::invokeRestart
[15:32:41.894]             length <- base::length
[15:32:41.894]             list <- base::list
[15:32:41.894]             seq.int <- base::seq.int
[15:32:41.894]             signalCondition <- base::signalCondition
[15:32:41.894]             sys.calls <- base::sys.calls
[15:32:41.894]             `[[` <- base::`[[`
[15:32:41.894]             `+` <- base::`+`
[15:32:41.894]             `<<-` <- base::`<<-`
[15:32:41.894]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:41.894]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:41.894]                   3L)]
[15:32:41.894]             }
[15:32:41.894]             function(cond) {
[15:32:41.894]                 is_error <- inherits(cond, "error")
[15:32:41.894]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:41.894]                   NULL)
[15:32:41.894]                 if (is_error) {
[15:32:41.894]                   sessionInformation <- function() {
[15:32:41.894]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:41.894]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:41.894]                       search = base::search(), system = base::Sys.info())
[15:32:41.894]                   }
[15:32:41.894]                   ...future.conditions[[length(...future.conditions) + 
[15:32:41.894]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:41.894]                     cond$call), session = sessionInformation(), 
[15:32:41.894]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:41.894]                   signalCondition(cond)
[15:32:41.894]                 }
[15:32:41.894]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:41.894]                 "immediateCondition"))) {
[15:32:41.894]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:41.894]                   ...future.conditions[[length(...future.conditions) + 
[15:32:41.894]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:41.894]                   if (TRUE && !signal) {
[15:32:41.894]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:41.894]                     {
[15:32:41.894]                       inherits <- base::inherits
[15:32:41.894]                       invokeRestart <- base::invokeRestart
[15:32:41.894]                       is.null <- base::is.null
[15:32:41.894]                       muffled <- FALSE
[15:32:41.894]                       if (inherits(cond, "message")) {
[15:32:41.894]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:41.894]                         if (muffled) 
[15:32:41.894]                           invokeRestart("muffleMessage")
[15:32:41.894]                       }
[15:32:41.894]                       else if (inherits(cond, "warning")) {
[15:32:41.894]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:41.894]                         if (muffled) 
[15:32:41.894]                           invokeRestart("muffleWarning")
[15:32:41.894]                       }
[15:32:41.894]                       else if (inherits(cond, "condition")) {
[15:32:41.894]                         if (!is.null(pattern)) {
[15:32:41.894]                           computeRestarts <- base::computeRestarts
[15:32:41.894]                           grepl <- base::grepl
[15:32:41.894]                           restarts <- computeRestarts(cond)
[15:32:41.894]                           for (restart in restarts) {
[15:32:41.894]                             name <- restart$name
[15:32:41.894]                             if (is.null(name)) 
[15:32:41.894]                               next
[15:32:41.894]                             if (!grepl(pattern, name)) 
[15:32:41.894]                               next
[15:32:41.894]                             invokeRestart(restart)
[15:32:41.894]                             muffled <- TRUE
[15:32:41.894]                             break
[15:32:41.894]                           }
[15:32:41.894]                         }
[15:32:41.894]                       }
[15:32:41.894]                       invisible(muffled)
[15:32:41.894]                     }
[15:32:41.894]                     muffleCondition(cond, pattern = "^muffle")
[15:32:41.894]                   }
[15:32:41.894]                 }
[15:32:41.894]                 else {
[15:32:41.894]                   if (TRUE) {
[15:32:41.894]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:41.894]                     {
[15:32:41.894]                       inherits <- base::inherits
[15:32:41.894]                       invokeRestart <- base::invokeRestart
[15:32:41.894]                       is.null <- base::is.null
[15:32:41.894]                       muffled <- FALSE
[15:32:41.894]                       if (inherits(cond, "message")) {
[15:32:41.894]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:41.894]                         if (muffled) 
[15:32:41.894]                           invokeRestart("muffleMessage")
[15:32:41.894]                       }
[15:32:41.894]                       else if (inherits(cond, "warning")) {
[15:32:41.894]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:41.894]                         if (muffled) 
[15:32:41.894]                           invokeRestart("muffleWarning")
[15:32:41.894]                       }
[15:32:41.894]                       else if (inherits(cond, "condition")) {
[15:32:41.894]                         if (!is.null(pattern)) {
[15:32:41.894]                           computeRestarts <- base::computeRestarts
[15:32:41.894]                           grepl <- base::grepl
[15:32:41.894]                           restarts <- computeRestarts(cond)
[15:32:41.894]                           for (restart in restarts) {
[15:32:41.894]                             name <- restart$name
[15:32:41.894]                             if (is.null(name)) 
[15:32:41.894]                               next
[15:32:41.894]                             if (!grepl(pattern, name)) 
[15:32:41.894]                               next
[15:32:41.894]                             invokeRestart(restart)
[15:32:41.894]                             muffled <- TRUE
[15:32:41.894]                             break
[15:32:41.894]                           }
[15:32:41.894]                         }
[15:32:41.894]                       }
[15:32:41.894]                       invisible(muffled)
[15:32:41.894]                     }
[15:32:41.894]                     muffleCondition(cond, pattern = "^muffle")
[15:32:41.894]                   }
[15:32:41.894]                 }
[15:32:41.894]             }
[15:32:41.894]         }))
[15:32:41.894]     }, error = function(ex) {
[15:32:41.894]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:41.894]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:41.894]                 ...future.rng), started = ...future.startTime, 
[15:32:41.894]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:41.894]             version = "1.8"), class = "FutureResult")
[15:32:41.894]     }, finally = {
[15:32:41.894]         if (!identical(...future.workdir, getwd())) 
[15:32:41.894]             setwd(...future.workdir)
[15:32:41.894]         {
[15:32:41.894]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:41.894]                 ...future.oldOptions$nwarnings <- NULL
[15:32:41.894]             }
[15:32:41.894]             base::options(...future.oldOptions)
[15:32:41.894]             if (.Platform$OS.type == "windows") {
[15:32:41.894]                 old_names <- names(...future.oldEnvVars)
[15:32:41.894]                 envs <- base::Sys.getenv()
[15:32:41.894]                 names <- names(envs)
[15:32:41.894]                 common <- intersect(names, old_names)
[15:32:41.894]                 added <- setdiff(names, old_names)
[15:32:41.894]                 removed <- setdiff(old_names, names)
[15:32:41.894]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:41.894]                   envs[common]]
[15:32:41.894]                 NAMES <- toupper(changed)
[15:32:41.894]                 args <- list()
[15:32:41.894]                 for (kk in seq_along(NAMES)) {
[15:32:41.894]                   name <- changed[[kk]]
[15:32:41.894]                   NAME <- NAMES[[kk]]
[15:32:41.894]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:41.894]                     next
[15:32:41.894]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:41.894]                 }
[15:32:41.894]                 NAMES <- toupper(added)
[15:32:41.894]                 for (kk in seq_along(NAMES)) {
[15:32:41.894]                   name <- added[[kk]]
[15:32:41.894]                   NAME <- NAMES[[kk]]
[15:32:41.894]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:41.894]                     next
[15:32:41.894]                   args[[name]] <- ""
[15:32:41.894]                 }
[15:32:41.894]                 NAMES <- toupper(removed)
[15:32:41.894]                 for (kk in seq_along(NAMES)) {
[15:32:41.894]                   name <- removed[[kk]]
[15:32:41.894]                   NAME <- NAMES[[kk]]
[15:32:41.894]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:41.894]                     next
[15:32:41.894]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:41.894]                 }
[15:32:41.894]                 if (length(args) > 0) 
[15:32:41.894]                   base::do.call(base::Sys.setenv, args = args)
[15:32:41.894]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:41.894]             }
[15:32:41.894]             else {
[15:32:41.894]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:41.894]             }
[15:32:41.894]             {
[15:32:41.894]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:41.894]                   0L) {
[15:32:41.894]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:41.894]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:41.894]                   base::options(opts)
[15:32:41.894]                 }
[15:32:41.894]                 {
[15:32:41.894]                   {
[15:32:41.894]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:41.894]                     NULL
[15:32:41.894]                   }
[15:32:41.894]                   options(future.plan = NULL)
[15:32:41.894]                   if (is.na(NA_character_)) 
[15:32:41.894]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:41.894]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:41.894]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:41.894]                     .init = FALSE)
[15:32:41.894]                 }
[15:32:41.894]             }
[15:32:41.894]         }
[15:32:41.894]     })
[15:32:41.894]     if (TRUE) {
[15:32:41.894]         base::sink(type = "output", split = FALSE)
[15:32:41.894]         if (TRUE) {
[15:32:41.894]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:41.894]         }
[15:32:41.894]         else {
[15:32:41.894]             ...future.result["stdout"] <- base::list(NULL)
[15:32:41.894]         }
[15:32:41.894]         base::close(...future.stdout)
[15:32:41.894]         ...future.stdout <- NULL
[15:32:41.894]     }
[15:32:41.894]     ...future.result$conditions <- ...future.conditions
[15:32:41.894]     ...future.result$finished <- base::Sys.time()
[15:32:41.894]     ...future.result
[15:32:41.894] }
[15:32:41.903] Exporting 5 global objects (56 bytes) to cluster node #1 ...
[15:32:41.903] Exporting '...future.FUN' (56 bytes) to cluster node #1 ...
[15:32:41.904] Exporting '...future.FUN' (56 bytes) to cluster node #1 ... DONE
[15:32:41.905] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:41.905] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:41.906] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ...
[15:32:41.906] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ... DONE
[15:32:41.907] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:41.907] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:41.908] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:41.908] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:41.909] Exporting 5 global objects (56 bytes) to cluster node #1 ... DONE
[15:32:41.910] MultisessionFuture started
[15:32:41.910] - Launch lazy future ... done
[15:32:41.910] run() for 'MultisessionFuture' ... done
[15:32:41.910] Created future:
[15:32:41.941] receiveMessageFromWorker() for ClusterFuture ...
[15:32:41.942] - Validating connection of MultisessionFuture
[15:32:41.942] - received message: FutureResult
[15:32:41.943] - Received FutureResult
[15:32:41.943] - Erased future from FutureRegistry
[15:32:41.944] result() for ClusterFuture ...
[15:32:41.944] - result already collected: FutureResult
[15:32:41.944] result() for ClusterFuture ... done
[15:32:41.945] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:41.911] MultisessionFuture:
[15:32:41.911] Label: 'future_sapply-1'
[15:32:41.911] Expression:
[15:32:41.911] {
[15:32:41.911]     do.call(function(...) {
[15:32:41.911]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:41.911]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:41.911]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:41.911]             on.exit(options(oopts), add = TRUE)
[15:32:41.911]         }
[15:32:41.911]         {
[15:32:41.911]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:41.911]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:41.911]                 ...future.FUN(...future.X_jj, ...)
[15:32:41.911]             })
[15:32:41.911]         }
[15:32:41.911]     }, args = future.call.arguments)
[15:32:41.911] }
[15:32:41.911] Lazy evaluation: FALSE
[15:32:41.911] Asynchronous evaluation: TRUE
[15:32:41.911] Local evaluation: TRUE
[15:32:41.911] Environment: R_GlobalEnv
[15:32:41.911] Capture standard output: TRUE
[15:32:41.911] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:41.911] Globals: 5 objects totaling 112 bytes (function '...future.FUN' of 56 bytes, 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)
[15:32:41.911] Packages: <none>
[15:32:41.911] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:41.911] Resolved: TRUE
[15:32:41.911] Value: <not collected>
[15:32:41.911] Conditions captured: <none>
[15:32:41.911] Early signaling: FALSE
[15:32:41.911] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:41.911] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:41.945] Chunk #1 of 2 ... DONE
[15:32:41.946] Chunk #2 of 2 ...
[15:32:41.946]  - Finding globals in 'X' for chunk #2 ...
[15:32:41.946] getGlobalsAndPackages() ...
[15:32:41.947] Searching for globals...
[15:32:41.948] 
[15:32:41.948] Searching for globals ... DONE
[15:32:41.948] - globals: [0] <none>
[15:32:41.948] getGlobalsAndPackages() ... DONE
[15:32:41.949]    + additional globals found: [n=0] 
[15:32:41.949]    + additional namespaces needed: [n=0] 
[15:32:41.949]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:41.950]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:41.950]  - seeds: <none>
[15:32:41.950]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:41.951] getGlobalsAndPackages() ...
[15:32:41.951] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:41.951] Resolving globals: FALSE
[15:32:41.952] Tweak future expression to call with '...' arguments ...
[15:32:41.952] {
[15:32:41.952]     do.call(function(...) {
[15:32:41.952]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:41.952]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:41.952]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:41.952]             on.exit(options(oopts), add = TRUE)
[15:32:41.952]         }
[15:32:41.952]         {
[15:32:41.952]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:41.952]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:41.952]                 ...future.FUN(...future.X_jj, ...)
[15:32:41.952]             })
[15:32:41.952]         }
[15:32:41.952]     }, args = future.call.arguments)
[15:32:41.952] }
[15:32:41.953] Tweak future expression to call with '...' arguments ... DONE
[15:32:41.954] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:41.954] 
[15:32:41.954] getGlobalsAndPackages() ... DONE
[15:32:41.955] run() for 'Future' ...
[15:32:41.956] - state: 'created'
[15:32:41.956] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:41.975] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:41.976] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:41.976]   - Field: 'node'
[15:32:41.976]   - Field: 'label'
[15:32:41.977]   - Field: 'local'
[15:32:41.977]   - Field: 'owner'
[15:32:41.977]   - Field: 'envir'
[15:32:41.978]   - Field: 'workers'
[15:32:41.978]   - Field: 'packages'
[15:32:41.978]   - Field: 'gc'
[15:32:41.979]   - Field: 'conditions'
[15:32:41.979]   - Field: 'persistent'
[15:32:41.979]   - Field: 'expr'
[15:32:41.980]   - Field: 'uuid'
[15:32:41.980]   - Field: 'seed'
[15:32:41.980]   - Field: 'version'
[15:32:41.981]   - Field: 'result'
[15:32:41.981]   - Field: 'asynchronous'
[15:32:41.981]   - Field: 'calls'
[15:32:41.982]   - Field: 'globals'
[15:32:41.982]   - Field: 'stdout'
[15:32:41.982]   - Field: 'earlySignal'
[15:32:41.983]   - Field: 'lazy'
[15:32:41.983]   - Field: 'state'
[15:32:41.983] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:41.984] - Launch lazy future ...
[15:32:41.984] Packages needed by the future expression (n = 0): <none>
[15:32:41.985] Packages needed by future strategies (n = 0): <none>
[15:32:41.986] {
[15:32:41.986]     {
[15:32:41.986]         {
[15:32:41.986]             ...future.startTime <- base::Sys.time()
[15:32:41.986]             {
[15:32:41.986]                 {
[15:32:41.986]                   {
[15:32:41.986]                     {
[15:32:41.986]                       base::local({
[15:32:41.986]                         has_future <- base::requireNamespace("future", 
[15:32:41.986]                           quietly = TRUE)
[15:32:41.986]                         if (has_future) {
[15:32:41.986]                           ns <- base::getNamespace("future")
[15:32:41.986]                           version <- ns[[".package"]][["version"]]
[15:32:41.986]                           if (is.null(version)) 
[15:32:41.986]                             version <- utils::packageVersion("future")
[15:32:41.986]                         }
[15:32:41.986]                         else {
[15:32:41.986]                           version <- NULL
[15:32:41.986]                         }
[15:32:41.986]                         if (!has_future || version < "1.8.0") {
[15:32:41.986]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:41.986]                             "", base::R.version$version.string), 
[15:32:41.986]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:41.986]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:41.986]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:41.986]                               "release", "version")], collapse = " "), 
[15:32:41.986]                             hostname = base::Sys.info()[["nodename"]])
[15:32:41.986]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:41.986]                             info)
[15:32:41.986]                           info <- base::paste(info, collapse = "; ")
[15:32:41.986]                           if (!has_future) {
[15:32:41.986]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:41.986]                               info)
[15:32:41.986]                           }
[15:32:41.986]                           else {
[15:32:41.986]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:41.986]                               info, version)
[15:32:41.986]                           }
[15:32:41.986]                           base::stop(msg)
[15:32:41.986]                         }
[15:32:41.986]                       })
[15:32:41.986]                     }
[15:32:41.986]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:41.986]                     base::options(mc.cores = 1L)
[15:32:41.986]                   }
[15:32:41.986]                   ...future.strategy.old <- future::plan("list")
[15:32:41.986]                   options(future.plan = NULL)
[15:32:41.986]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:41.986]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:41.986]                 }
[15:32:41.986]                 ...future.workdir <- getwd()
[15:32:41.986]             }
[15:32:41.986]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:41.986]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:41.986]         }
[15:32:41.986]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:41.986]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:41.986]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:41.986]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:41.986]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:41.986]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:41.986]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:41.986]             base::names(...future.oldOptions))
[15:32:41.986]     }
[15:32:41.986]     if (FALSE) {
[15:32:41.986]     }
[15:32:41.986]     else {
[15:32:41.986]         if (TRUE) {
[15:32:41.986]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:41.986]                 open = "w")
[15:32:41.986]         }
[15:32:41.986]         else {
[15:32:41.986]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:41.986]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:41.986]         }
[15:32:41.986]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:41.986]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:41.986]             base::sink(type = "output", split = FALSE)
[15:32:41.986]             base::close(...future.stdout)
[15:32:41.986]         }, add = TRUE)
[15:32:41.986]     }
[15:32:41.986]     ...future.frame <- base::sys.nframe()
[15:32:41.986]     ...future.conditions <- base::list()
[15:32:41.986]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:41.986]     if (FALSE) {
[15:32:41.986]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:41.986]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:41.986]     }
[15:32:41.986]     ...future.result <- base::tryCatch({
[15:32:41.986]         base::withCallingHandlers({
[15:32:41.986]             ...future.value <- base::withVisible(base::local({
[15:32:41.986]                 ...future.makeSendCondition <- base::local({
[15:32:41.986]                   sendCondition <- NULL
[15:32:41.986]                   function(frame = 1L) {
[15:32:41.986]                     if (is.function(sendCondition)) 
[15:32:41.986]                       return(sendCondition)
[15:32:41.986]                     ns <- getNamespace("parallel")
[15:32:41.986]                     if (exists("sendData", mode = "function", 
[15:32:41.986]                       envir = ns)) {
[15:32:41.986]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:41.986]                         envir = ns)
[15:32:41.986]                       envir <- sys.frame(frame)
[15:32:41.986]                       master <- NULL
[15:32:41.986]                       while (!identical(envir, .GlobalEnv) && 
[15:32:41.986]                         !identical(envir, emptyenv())) {
[15:32:41.986]                         if (exists("master", mode = "list", envir = envir, 
[15:32:41.986]                           inherits = FALSE)) {
[15:32:41.986]                           master <- get("master", mode = "list", 
[15:32:41.986]                             envir = envir, inherits = FALSE)
[15:32:41.986]                           if (inherits(master, c("SOCKnode", 
[15:32:41.986]                             "SOCK0node"))) {
[15:32:41.986]                             sendCondition <<- function(cond) {
[15:32:41.986]                               data <- list(type = "VALUE", value = cond, 
[15:32:41.986]                                 success = TRUE)
[15:32:41.986]                               parallel_sendData(master, data)
[15:32:41.986]                             }
[15:32:41.986]                             return(sendCondition)
[15:32:41.986]                           }
[15:32:41.986]                         }
[15:32:41.986]                         frame <- frame + 1L
[15:32:41.986]                         envir <- sys.frame(frame)
[15:32:41.986]                       }
[15:32:41.986]                     }
[15:32:41.986]                     sendCondition <<- function(cond) NULL
[15:32:41.986]                   }
[15:32:41.986]                 })
[15:32:41.986]                 withCallingHandlers({
[15:32:41.986]                   {
[15:32:41.986]                     do.call(function(...) {
[15:32:41.986]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:41.986]                       if (!identical(...future.globals.maxSize.org, 
[15:32:41.986]                         ...future.globals.maxSize)) {
[15:32:41.986]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:41.986]                         on.exit(options(oopts), add = TRUE)
[15:32:41.986]                       }
[15:32:41.986]                       {
[15:32:41.986]                         lapply(seq_along(...future.elements_ii), 
[15:32:41.986]                           FUN = function(jj) {
[15:32:41.986]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:41.986]                             ...future.FUN(...future.X_jj, ...)
[15:32:41.986]                           })
[15:32:41.986]                       }
[15:32:41.986]                     }, args = future.call.arguments)
[15:32:41.986]                   }
[15:32:41.986]                 }, immediateCondition = function(cond) {
[15:32:41.986]                   sendCondition <- ...future.makeSendCondition()
[15:32:41.986]                   sendCondition(cond)
[15:32:41.986]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:41.986]                   {
[15:32:41.986]                     inherits <- base::inherits
[15:32:41.986]                     invokeRestart <- base::invokeRestart
[15:32:41.986]                     is.null <- base::is.null
[15:32:41.986]                     muffled <- FALSE
[15:32:41.986]                     if (inherits(cond, "message")) {
[15:32:41.986]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:41.986]                       if (muffled) 
[15:32:41.986]                         invokeRestart("muffleMessage")
[15:32:41.986]                     }
[15:32:41.986]                     else if (inherits(cond, "warning")) {
[15:32:41.986]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:41.986]                       if (muffled) 
[15:32:41.986]                         invokeRestart("muffleWarning")
[15:32:41.986]                     }
[15:32:41.986]                     else if (inherits(cond, "condition")) {
[15:32:41.986]                       if (!is.null(pattern)) {
[15:32:41.986]                         computeRestarts <- base::computeRestarts
[15:32:41.986]                         grepl <- base::grepl
[15:32:41.986]                         restarts <- computeRestarts(cond)
[15:32:41.986]                         for (restart in restarts) {
[15:32:41.986]                           name <- restart$name
[15:32:41.986]                           if (is.null(name)) 
[15:32:41.986]                             next
[15:32:41.986]                           if (!grepl(pattern, name)) 
[15:32:41.986]                             next
[15:32:41.986]                           invokeRestart(restart)
[15:32:41.986]                           muffled <- TRUE
[15:32:41.986]                           break
[15:32:41.986]                         }
[15:32:41.986]                       }
[15:32:41.986]                     }
[15:32:41.986]                     invisible(muffled)
[15:32:41.986]                   }
[15:32:41.986]                   muffleCondition(cond)
[15:32:41.986]                 })
[15:32:41.986]             }))
[15:32:41.986]             future::FutureResult(value = ...future.value$value, 
[15:32:41.986]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:41.986]                   ...future.rng), globalenv = if (FALSE) 
[15:32:41.986]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:41.986]                     ...future.globalenv.names))
[15:32:41.986]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:41.986]         }, condition = base::local({
[15:32:41.986]             c <- base::c
[15:32:41.986]             inherits <- base::inherits
[15:32:41.986]             invokeRestart <- base::invokeRestart
[15:32:41.986]             length <- base::length
[15:32:41.986]             list <- base::list
[15:32:41.986]             seq.int <- base::seq.int
[15:32:41.986]             signalCondition <- base::signalCondition
[15:32:41.986]             sys.calls <- base::sys.calls
[15:32:41.986]             `[[` <- base::`[[`
[15:32:41.986]             `+` <- base::`+`
[15:32:41.986]             `<<-` <- base::`<<-`
[15:32:41.986]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:41.986]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:41.986]                   3L)]
[15:32:41.986]             }
[15:32:41.986]             function(cond) {
[15:32:41.986]                 is_error <- inherits(cond, "error")
[15:32:41.986]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:41.986]                   NULL)
[15:32:41.986]                 if (is_error) {
[15:32:41.986]                   sessionInformation <- function() {
[15:32:41.986]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:41.986]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:41.986]                       search = base::search(), system = base::Sys.info())
[15:32:41.986]                   }
[15:32:41.986]                   ...future.conditions[[length(...future.conditions) + 
[15:32:41.986]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:41.986]                     cond$call), session = sessionInformation(), 
[15:32:41.986]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:41.986]                   signalCondition(cond)
[15:32:41.986]                 }
[15:32:41.986]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:41.986]                 "immediateCondition"))) {
[15:32:41.986]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:41.986]                   ...future.conditions[[length(...future.conditions) + 
[15:32:41.986]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:41.986]                   if (TRUE && !signal) {
[15:32:41.986]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:41.986]                     {
[15:32:41.986]                       inherits <- base::inherits
[15:32:41.986]                       invokeRestart <- base::invokeRestart
[15:32:41.986]                       is.null <- base::is.null
[15:32:41.986]                       muffled <- FALSE
[15:32:41.986]                       if (inherits(cond, "message")) {
[15:32:41.986]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:41.986]                         if (muffled) 
[15:32:41.986]                           invokeRestart("muffleMessage")
[15:32:41.986]                       }
[15:32:41.986]                       else if (inherits(cond, "warning")) {
[15:32:41.986]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:41.986]                         if (muffled) 
[15:32:41.986]                           invokeRestart("muffleWarning")
[15:32:41.986]                       }
[15:32:41.986]                       else if (inherits(cond, "condition")) {
[15:32:41.986]                         if (!is.null(pattern)) {
[15:32:41.986]                           computeRestarts <- base::computeRestarts
[15:32:41.986]                           grepl <- base::grepl
[15:32:41.986]                           restarts <- computeRestarts(cond)
[15:32:41.986]                           for (restart in restarts) {
[15:32:41.986]                             name <- restart$name
[15:32:41.986]                             if (is.null(name)) 
[15:32:41.986]                               next
[15:32:41.986]                             if (!grepl(pattern, name)) 
[15:32:41.986]                               next
[15:32:41.986]                             invokeRestart(restart)
[15:32:41.986]                             muffled <- TRUE
[15:32:41.986]                             break
[15:32:41.986]                           }
[15:32:41.986]                         }
[15:32:41.986]                       }
[15:32:41.986]                       invisible(muffled)
[15:32:41.986]                     }
[15:32:41.986]                     muffleCondition(cond, pattern = "^muffle")
[15:32:41.986]                   }
[15:32:41.986]                 }
[15:32:41.986]                 else {
[15:32:41.986]                   if (TRUE) {
[15:32:41.986]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:41.986]                     {
[15:32:41.986]                       inherits <- base::inherits
[15:32:41.986]                       invokeRestart <- base::invokeRestart
[15:32:41.986]                       is.null <- base::is.null
[15:32:41.986]                       muffled <- FALSE
[15:32:41.986]                       if (inherits(cond, "message")) {
[15:32:41.986]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:41.986]                         if (muffled) 
[15:32:41.986]                           invokeRestart("muffleMessage")
[15:32:41.986]                       }
[15:32:41.986]                       else if (inherits(cond, "warning")) {
[15:32:41.986]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:41.986]                         if (muffled) 
[15:32:41.986]                           invokeRestart("muffleWarning")
[15:32:41.986]                       }
[15:32:41.986]                       else if (inherits(cond, "condition")) {
[15:32:41.986]                         if (!is.null(pattern)) {
[15:32:41.986]                           computeRestarts <- base::computeRestarts
[15:32:41.986]                           grepl <- base::grepl
[15:32:41.986]                           restarts <- computeRestarts(cond)
[15:32:41.986]                           for (restart in restarts) {
[15:32:41.986]                             name <- restart$name
[15:32:41.986]                             if (is.null(name)) 
[15:32:41.986]                               next
[15:32:41.986]                             if (!grepl(pattern, name)) 
[15:32:41.986]                               next
[15:32:41.986]                             invokeRestart(restart)
[15:32:41.986]                             muffled <- TRUE
[15:32:41.986]                             break
[15:32:41.986]                           }
[15:32:41.986]                         }
[15:32:41.986]                       }
[15:32:41.986]                       invisible(muffled)
[15:32:41.986]                     }
[15:32:41.986]                     muffleCondition(cond, pattern = "^muffle")
[15:32:41.986]                   }
[15:32:41.986]                 }
[15:32:41.986]             }
[15:32:41.986]         }))
[15:32:41.986]     }, error = function(ex) {
[15:32:41.986]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:41.986]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:41.986]                 ...future.rng), started = ...future.startTime, 
[15:32:41.986]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:41.986]             version = "1.8"), class = "FutureResult")
[15:32:41.986]     }, finally = {
[15:32:41.986]         if (!identical(...future.workdir, getwd())) 
[15:32:41.986]             setwd(...future.workdir)
[15:32:41.986]         {
[15:32:41.986]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:41.986]                 ...future.oldOptions$nwarnings <- NULL
[15:32:41.986]             }
[15:32:41.986]             base::options(...future.oldOptions)
[15:32:41.986]             if (.Platform$OS.type == "windows") {
[15:32:41.986]                 old_names <- names(...future.oldEnvVars)
[15:32:41.986]                 envs <- base::Sys.getenv()
[15:32:41.986]                 names <- names(envs)
[15:32:41.986]                 common <- intersect(names, old_names)
[15:32:41.986]                 added <- setdiff(names, old_names)
[15:32:41.986]                 removed <- setdiff(old_names, names)
[15:32:41.986]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:41.986]                   envs[common]]
[15:32:41.986]                 NAMES <- toupper(changed)
[15:32:41.986]                 args <- list()
[15:32:41.986]                 for (kk in seq_along(NAMES)) {
[15:32:41.986]                   name <- changed[[kk]]
[15:32:41.986]                   NAME <- NAMES[[kk]]
[15:32:41.986]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:41.986]                     next
[15:32:41.986]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:41.986]                 }
[15:32:41.986]                 NAMES <- toupper(added)
[15:32:41.986]                 for (kk in seq_along(NAMES)) {
[15:32:41.986]                   name <- added[[kk]]
[15:32:41.986]                   NAME <- NAMES[[kk]]
[15:32:41.986]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:41.986]                     next
[15:32:41.986]                   args[[name]] <- ""
[15:32:41.986]                 }
[15:32:41.986]                 NAMES <- toupper(removed)
[15:32:41.986]                 for (kk in seq_along(NAMES)) {
[15:32:41.986]                   name <- removed[[kk]]
[15:32:41.986]                   NAME <- NAMES[[kk]]
[15:32:41.986]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:41.986]                     next
[15:32:41.986]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:41.986]                 }
[15:32:41.986]                 if (length(args) > 0) 
[15:32:41.986]                   base::do.call(base::Sys.setenv, args = args)
[15:32:41.986]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:41.986]             }
[15:32:41.986]             else {
[15:32:41.986]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:41.986]             }
[15:32:41.986]             {
[15:32:41.986]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:41.986]                   0L) {
[15:32:41.986]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:41.986]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:41.986]                   base::options(opts)
[15:32:41.986]                 }
[15:32:41.986]                 {
[15:32:41.986]                   {
[15:32:41.986]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:41.986]                     NULL
[15:32:41.986]                   }
[15:32:41.986]                   options(future.plan = NULL)
[15:32:41.986]                   if (is.na(NA_character_)) 
[15:32:41.986]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:41.986]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:41.986]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:41.986]                     .init = FALSE)
[15:32:41.986]                 }
[15:32:41.986]             }
[15:32:41.986]         }
[15:32:41.986]     })
[15:32:41.986]     if (TRUE) {
[15:32:41.986]         base::sink(type = "output", split = FALSE)
[15:32:41.986]         if (TRUE) {
[15:32:41.986]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:41.986]         }
[15:32:41.986]         else {
[15:32:41.986]             ...future.result["stdout"] <- base::list(NULL)
[15:32:41.986]         }
[15:32:41.986]         base::close(...future.stdout)
[15:32:41.986]         ...future.stdout <- NULL
[15:32:41.986]     }
[15:32:41.986]     ...future.result$conditions <- ...future.conditions
[15:32:41.986]     ...future.result$finished <- base::Sys.time()
[15:32:41.986]     ...future.result
[15:32:41.986] }
[15:32:41.995] Exporting 5 global objects (56 bytes) to cluster node #1 ...
[15:32:41.996] Exporting '...future.FUN' (56 bytes) to cluster node #1 ...
[15:32:41.997] Exporting '...future.FUN' (56 bytes) to cluster node #1 ... DONE
[15:32:41.997] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:41.998] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:41.998] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:41.999] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:41.999] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:42.000] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:42.001] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:42.001] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:42.002] Exporting 5 global objects (56 bytes) to cluster node #1 ... DONE
[15:32:42.003] MultisessionFuture started
[15:32:42.003] - Launch lazy future ... done
[15:32:42.003] run() for 'MultisessionFuture' ... done
[15:32:42.004] Created future:
[15:32:42.029] receiveMessageFromWorker() for ClusterFuture ...
[15:32:42.030] - Validating connection of MultisessionFuture
[15:32:42.031] - received message: FutureResult
[15:32:42.031] - Received FutureResult
[15:32:42.031] - Erased future from FutureRegistry
[15:32:42.032] result() for ClusterFuture ...
[15:32:42.032] - result already collected: FutureResult
[15:32:42.032] result() for ClusterFuture ... done
[15:32:42.033] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:42.004] MultisessionFuture:
[15:32:42.004] Label: 'future_sapply-2'
[15:32:42.004] Expression:
[15:32:42.004] {
[15:32:42.004]     do.call(function(...) {
[15:32:42.004]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:42.004]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:42.004]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:42.004]             on.exit(options(oopts), add = TRUE)
[15:32:42.004]         }
[15:32:42.004]         {
[15:32:42.004]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:42.004]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:42.004]                 ...future.FUN(...future.X_jj, ...)
[15:32:42.004]             })
[15:32:42.004]         }
[15:32:42.004]     }, args = future.call.arguments)
[15:32:42.004] }
[15:32:42.004] Lazy evaluation: FALSE
[15:32:42.004] Asynchronous evaluation: TRUE
[15:32:42.004] Local evaluation: TRUE
[15:32:42.004] Environment: R_GlobalEnv
[15:32:42.004] Capture standard output: TRUE
[15:32:42.004] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:42.004] Globals: 5 objects totaling 168 bytes (function '...future.FUN' of 56 bytes, 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)
[15:32:42.004] Packages: <none>
[15:32:42.004] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:42.004] Resolved: TRUE
[15:32:42.004] Value: <not collected>
[15:32:42.004] Conditions captured: <none>
[15:32:42.004] Early signaling: FALSE
[15:32:42.004] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:42.004] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:42.033] Chunk #2 of 2 ... DONE
[15:32:42.034] Launching 2 futures (chunks) ... DONE
[15:32:42.034] Resolving 2 futures (chunks) ...
[15:32:42.034] resolve() on list ...
[15:32:42.035]  recursive: 0
[15:32:42.035]  length: 2
[15:32:42.035] 
[15:32:42.035] Future #1
[15:32:42.036] result() for ClusterFuture ...
[15:32:42.036] - result already collected: FutureResult
[15:32:42.036] result() for ClusterFuture ... done
[15:32:42.037] result() for ClusterFuture ...
[15:32:42.037] - result already collected: FutureResult
[15:32:42.037] result() for ClusterFuture ... done
[15:32:42.038] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:42.038] - nx: 2
[15:32:42.038] - relay: TRUE
[15:32:42.038] - stdout: TRUE
[15:32:42.039] - signal: TRUE
[15:32:42.039] - resignal: FALSE
[15:32:42.039] - force: TRUE
[15:32:42.040] - relayed: [n=2] FALSE, FALSE
[15:32:42.040] - queued futures: [n=2] FALSE, FALSE
[15:32:42.040]  - until=1
[15:32:42.040]  - relaying element #1
[15:32:42.041] result() for ClusterFuture ...
[15:32:42.041] - result already collected: FutureResult
[15:32:42.041] result() for ClusterFuture ... done
[15:32:42.042] result() for ClusterFuture ...
[15:32:42.042] - result already collected: FutureResult
[15:32:42.042] result() for ClusterFuture ... done
[15:32:42.043] result() for ClusterFuture ...
[15:32:42.043] - result already collected: FutureResult
[15:32:42.043] result() for ClusterFuture ... done
[15:32:42.043] result() for ClusterFuture ...
[15:32:42.044] - result already collected: FutureResult
[15:32:42.044] result() for ClusterFuture ... done
[15:32:42.044] - relayed: [n=2] TRUE, FALSE
[15:32:42.045] - queued futures: [n=2] TRUE, FALSE
[15:32:42.045] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:42.045]  length: 1 (resolved future 1)
[15:32:42.046] Future #2
[15:32:42.046] result() for ClusterFuture ...
[15:32:42.046] - result already collected: FutureResult
[15:32:42.047] result() for ClusterFuture ... done
[15:32:42.047] result() for ClusterFuture ...
[15:32:42.047] - result already collected: FutureResult
[15:32:42.047] result() for ClusterFuture ... done
[15:32:42.048] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:42.048] - nx: 2
[15:32:42.048] - relay: TRUE
[15:32:42.049] - stdout: TRUE
[15:32:42.049] - signal: TRUE
[15:32:42.049] - resignal: FALSE
[15:32:42.049] - force: TRUE
[15:32:42.050] - relayed: [n=2] TRUE, FALSE
[15:32:42.050] - queued futures: [n=2] TRUE, FALSE
[15:32:42.050]  - until=2
[15:32:42.051]  - relaying element #2
[15:32:42.051] result() for ClusterFuture ...
[15:32:42.051] - result already collected: FutureResult
[15:32:42.051] result() for ClusterFuture ... done
[15:32:42.052] result() for ClusterFuture ...
[15:32:42.052] - result already collected: FutureResult
[15:32:42.052] result() for ClusterFuture ... done
[15:32:42.053] result() for ClusterFuture ...
[15:32:42.053] - result already collected: FutureResult
[15:32:42.053] result() for ClusterFuture ... done
[15:32:42.054] result() for ClusterFuture ...
[15:32:42.054] - result already collected: FutureResult
[15:32:42.054] result() for ClusterFuture ... done
[15:32:42.054] - relayed: [n=2] TRUE, TRUE
[15:32:42.055] - queued futures: [n=2] TRUE, TRUE
[15:32:42.055] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:42.055]  length: 0 (resolved future 2)
[15:32:42.056] Relaying remaining futures
[15:32:42.056] signalConditionsASAP(NULL, pos=0) ...
[15:32:42.056] - nx: 2
[15:32:42.056] - relay: TRUE
[15:32:42.057] - stdout: TRUE
[15:32:42.057] - signal: TRUE
[15:32:42.057] - resignal: FALSE
[15:32:42.057] - force: TRUE
[15:32:42.058] - relayed: [n=2] TRUE, TRUE
[15:32:42.058] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:42.058] - relayed: [n=2] TRUE, TRUE
[15:32:42.059] - queued futures: [n=2] TRUE, TRUE
[15:32:42.059] signalConditionsASAP(NULL, pos=0) ... done
[15:32:42.059] resolve() on list ... DONE
[15:32:42.059] result() for ClusterFuture ...
[15:32:42.059] - result already collected: FutureResult
[15:32:42.060] result() for ClusterFuture ... done
[15:32:42.060] result() for ClusterFuture ...
[15:32:42.060] - result already collected: FutureResult
[15:32:42.060] result() for ClusterFuture ... done
[15:32:42.061] result() for ClusterFuture ...
[15:32:42.061] - result already collected: FutureResult
[15:32:42.061] result() for ClusterFuture ... done
[15:32:42.061] result() for ClusterFuture ...
[15:32:42.062] - result already collected: FutureResult
[15:32:42.062] result() for ClusterFuture ... done
[15:32:42.062]  - Number of value chunks collected: 2
[15:32:42.063] Resolving 2 futures (chunks) ... DONE
[15:32:42.063] Reducing values from 2 chunks ...
[15:32:42.063]  - Number of values collected after concatenation: 3
[15:32:42.063]  - Number of values expected: 3
[15:32:42.064] Reducing values from 2 chunks ... DONE
[15:32:42.064] future_lapply() ... DONE
[15:32:42.064] future_lapply() ...
[15:32:42.071] Number of chunks: 2
[15:32:42.077] getGlobalsAndPackagesXApply() ...
[15:32:42.077]  - future.globals: TRUE
[15:32:42.078] getGlobalsAndPackages() ...
[15:32:42.078] Searching for globals...
[15:32:42.082] - globals found: [4] 'FUN', 'compute', '...', '+'
[15:32:42.083] Searching for globals ... DONE
[15:32:42.083] Resolving globals: FALSE
[15:32:42.083] Tweak future expression to call with '...' arguments ...
[15:32:42.084] {
[15:32:42.084]     do.call(function(...) FUN(), args = future.call.arguments)
[15:32:42.084] }
[15:32:42.084] Tweak future expression to call with '...' arguments ... DONE
[15:32:42.085] The total size of the 3 globals is 3.92 KiB (4016 bytes)
[15:32:42.086] The total size of the 3 globals exported for future expression ('FUN()') is 3.92 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are three globals: 'FUN' (2.43 KiB of class 'function'), 'compute' (1.44 KiB of class 'function') and 'future.call.arguments' (56 bytes of class 'list')
[15:32:42.086] - globals: [3] 'FUN', 'compute', 'future.call.arguments'
[15:32:42.087] 
[15:32:42.087] getGlobalsAndPackages() ... DONE
[15:32:42.087]  - globals found/used: [n=3] 'FUN', 'compute', 'future.call.arguments'
[15:32:42.088]  - needed namespaces: [n=0] 
[15:32:42.088] Finding globals ... DONE
[15:32:42.088]  - use_args: TRUE
[15:32:42.088]  - Getting '...' globals ...
[15:32:42.089] resolve() on list ...
[15:32:42.089]  recursive: 0
[15:32:42.090]  length: 1
[15:32:42.090]  elements: '...'
[15:32:42.090]  length: 0 (resolved future 1)
[15:32:42.091] resolve() on list ... DONE
[15:32:42.091]    - '...' content: [n=0] 
[15:32:42.091] List of 1
[15:32:42.091]  $ ...: list()
[15:32:42.091]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:42.091]  - attr(*, "where")=List of 1
[15:32:42.091]   ..$ ...:<environment: 0x00000276e52a2420> 
[15:32:42.091]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:42.091]  - attr(*, "resolved")= logi TRUE
[15:32:42.091]  - attr(*, "total_size")= num NA
[15:32:42.096]  - Getting '...' globals ... DONE
[15:32:42.097] Globals to be used in all futures (chunks): [n=4] '...future.FUN', 'compute', 'future.call.arguments', '...'
[15:32:42.097] List of 4
[15:32:42.097]  $ ...future.FUN        :function (x)  
[15:32:42.097]  $ compute              :function (a, x_vec)  
[15:32:42.097]  $ future.call.arguments:List of 1
[15:32:42.097]   ..$ : int 0
[15:32:42.097]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:42.097]  $ ...                  : list()
[15:32:42.097]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:42.097]  - attr(*, "where")=List of 4
[15:32:42.097]   ..$ ...future.FUN        :<environment: R_EmptyEnv> 
[15:32:42.097]   ..$ compute              :<environment: R_EmptyEnv> 
[15:32:42.097]   ..$ future.call.arguments:<environment: R_EmptyEnv> 
[15:32:42.097]   ..$ ...                  :<environment: 0x00000276e52a2420> 
[15:32:42.097]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:42.097]  - attr(*, "resolved")= logi FALSE
[15:32:42.097]  - attr(*, "total_size")= num 4016
[15:32:42.106] Packages to be attached in all futures: [n=0] 
[15:32:42.106] getGlobalsAndPackagesXApply() ... DONE
[15:32:42.106] Number of futures (= number of chunks): 2
[15:32:42.107] Launching 2 futures (chunks) ...
[15:32:42.107] Chunk #1 of 2 ...
[15:32:42.107]  - Finding globals in 'X' for chunk #1 ...
[15:32:42.108] getGlobalsAndPackages() ...
[15:32:42.108] Searching for globals...
[15:32:42.109] 
[15:32:42.109] Searching for globals ... DONE
[15:32:42.109] - globals: [0] <none>
[15:32:42.109] getGlobalsAndPackages() ... DONE
[15:32:42.110]    + additional globals found: [n=0] 
[15:32:42.110]    + additional namespaces needed: [n=0] 
[15:32:42.110]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:42.111]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:42.111]  - seeds: <none>
[15:32:42.111]  - All globals exported: [n=7] '...future.FUN', 'compute', 'future.call.arguments', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:42.111] getGlobalsAndPackages() ...
[15:32:42.112] - globals passed as-is: [7] '...future.FUN', 'compute', 'future.call.arguments', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:42.112] Resolving globals: FALSE
[15:32:42.112] Tweak future expression to call with '...' arguments ...
[15:32:42.113] - Detected 2 'future.call.arguments' global entries:
[15:32:42.113] List of 2
[15:32:42.113]  $ future.call.arguments:List of 1
[15:32:42.113]   ..$ : int 0
[15:32:42.113]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:42.113]  $ future.call.arguments: list()
[15:32:42.113]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:42.113]  - attr(*, "where")=List of 2
[15:32:42.113]   ..$ future.call.arguments:<environment: R_EmptyEnv> 
[15:32:42.113]   ..$ future.call.arguments:<environment: 0x00000276e52a2420> 
[15:32:42.113]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:42.113]  - attr(*, "resolved")= logi FALSE
[15:32:42.113]  - attr(*, "total_size")= num 4016
[15:32:42.120] future.call.arguments future.call.arguments 
[15:32:42.120]                     1                     0 
[15:32:42.120] - 'future.call.arguments' global entries:
[15:32:42.121] List of 2
[15:32:42.121]  $ future.call.arguments:List of 1
[15:32:42.121]   ..$ : int 0
[15:32:42.121]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:42.121]  $ ...future.elements_ii:List of 1
[15:32:42.121]   ..$ : int 1
[15:32:42.121]  - attr(*, "where")=List of 2
[15:32:42.121]   ..$ future.call.arguments:<environment: R_EmptyEnv> 
[15:32:42.121]   ..$ ...future.elements_ii:<environment: R_EmptyEnv> 
[15:32:42.121]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:42.121]  - attr(*, "resolved")= logi FALSE
[15:32:42.121]  - attr(*, "total_size")= num 4016
[15:32:42.127] {
[15:32:42.127]     do.call(function(...) {
[15:32:42.127]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:42.127]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:42.127]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:42.127]             on.exit(options(oopts), add = TRUE)
[15:32:42.127]         }
[15:32:42.127]         {
[15:32:42.127]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:42.127]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:42.127]                 ...future.FUN(...future.X_jj)
[15:32:42.127]             })
[15:32:42.127]         }
[15:32:42.127]     }, args = future.call.arguments)
[15:32:42.127] }
[15:32:42.127] Tweak future expression to call with '...' arguments ... DONE
[15:32:42.128] - globals: [6] '...future.FUN', 'compute', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:42.128] 
[15:32:42.129] getGlobalsAndPackages() ... DONE
[15:32:42.129] run() for 'Future' ...
[15:32:42.130] - state: 'created'
[15:32:42.130] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:42.148] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:42.149] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:42.149]   - Field: 'node'
[15:32:42.149]   - Field: 'label'
[15:32:42.150]   - Field: 'local'
[15:32:42.150]   - Field: 'owner'
[15:32:42.150]   - Field: 'envir'
[15:32:42.150]   - Field: 'workers'
[15:32:42.151]   - Field: 'packages'
[15:32:42.151]   - Field: 'gc'
[15:32:42.151]   - Field: 'conditions'
[15:32:42.151]   - Field: 'persistent'
[15:32:42.152]   - Field: 'expr'
[15:32:42.152]   - Field: 'uuid'
[15:32:42.152]   - Field: 'seed'
[15:32:42.153]   - Field: 'version'
[15:32:42.153]   - Field: 'result'
[15:32:42.153]   - Field: 'asynchronous'
[15:32:42.153]   - Field: 'calls'
[15:32:42.154]   - Field: 'globals'
[15:32:42.154]   - Field: 'stdout'
[15:32:42.154]   - Field: 'earlySignal'
[15:32:42.155]   - Field: 'lazy'
[15:32:42.155]   - Field: 'state'
[15:32:42.155] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:42.155] - Launch lazy future ...
[15:32:42.156] Packages needed by the future expression (n = 0): <none>
[15:32:42.156] Packages needed by future strategies (n = 0): <none>
[15:32:42.157] {
[15:32:42.157]     {
[15:32:42.157]         {
[15:32:42.157]             ...future.startTime <- base::Sys.time()
[15:32:42.157]             {
[15:32:42.157]                 {
[15:32:42.157]                   {
[15:32:42.157]                     {
[15:32:42.157]                       base::local({
[15:32:42.157]                         has_future <- base::requireNamespace("future", 
[15:32:42.157]                           quietly = TRUE)
[15:32:42.157]                         if (has_future) {
[15:32:42.157]                           ns <- base::getNamespace("future")
[15:32:42.157]                           version <- ns[[".package"]][["version"]]
[15:32:42.157]                           if (is.null(version)) 
[15:32:42.157]                             version <- utils::packageVersion("future")
[15:32:42.157]                         }
[15:32:42.157]                         else {
[15:32:42.157]                           version <- NULL
[15:32:42.157]                         }
[15:32:42.157]                         if (!has_future || version < "1.8.0") {
[15:32:42.157]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:42.157]                             "", base::R.version$version.string), 
[15:32:42.157]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:42.157]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:42.157]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:42.157]                               "release", "version")], collapse = " "), 
[15:32:42.157]                             hostname = base::Sys.info()[["nodename"]])
[15:32:42.157]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:42.157]                             info)
[15:32:42.157]                           info <- base::paste(info, collapse = "; ")
[15:32:42.157]                           if (!has_future) {
[15:32:42.157]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:42.157]                               info)
[15:32:42.157]                           }
[15:32:42.157]                           else {
[15:32:42.157]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:42.157]                               info, version)
[15:32:42.157]                           }
[15:32:42.157]                           base::stop(msg)
[15:32:42.157]                         }
[15:32:42.157]                       })
[15:32:42.157]                     }
[15:32:42.157]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:42.157]                     base::options(mc.cores = 1L)
[15:32:42.157]                   }
[15:32:42.157]                   ...future.strategy.old <- future::plan("list")
[15:32:42.157]                   options(future.plan = NULL)
[15:32:42.157]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:42.157]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:42.157]                 }
[15:32:42.157]                 ...future.workdir <- getwd()
[15:32:42.157]             }
[15:32:42.157]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:42.157]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:42.157]         }
[15:32:42.157]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:42.157]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:42.157]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:42.157]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:42.157]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:42.157]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:42.157]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:42.157]             base::names(...future.oldOptions))
[15:32:42.157]     }
[15:32:42.157]     if (FALSE) {
[15:32:42.157]     }
[15:32:42.157]     else {
[15:32:42.157]         if (TRUE) {
[15:32:42.157]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:42.157]                 open = "w")
[15:32:42.157]         }
[15:32:42.157]         else {
[15:32:42.157]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:42.157]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:42.157]         }
[15:32:42.157]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:42.157]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:42.157]             base::sink(type = "output", split = FALSE)
[15:32:42.157]             base::close(...future.stdout)
[15:32:42.157]         }, add = TRUE)
[15:32:42.157]     }
[15:32:42.157]     ...future.frame <- base::sys.nframe()
[15:32:42.157]     ...future.conditions <- base::list()
[15:32:42.157]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:42.157]     if (FALSE) {
[15:32:42.157]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:42.157]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:42.157]     }
[15:32:42.157]     ...future.result <- base::tryCatch({
[15:32:42.157]         base::withCallingHandlers({
[15:32:42.157]             ...future.value <- base::withVisible(base::local({
[15:32:42.157]                 ...future.makeSendCondition <- base::local({
[15:32:42.157]                   sendCondition <- NULL
[15:32:42.157]                   function(frame = 1L) {
[15:32:42.157]                     if (is.function(sendCondition)) 
[15:32:42.157]                       return(sendCondition)
[15:32:42.157]                     ns <- getNamespace("parallel")
[15:32:42.157]                     if (exists("sendData", mode = "function", 
[15:32:42.157]                       envir = ns)) {
[15:32:42.157]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:42.157]                         envir = ns)
[15:32:42.157]                       envir <- sys.frame(frame)
[15:32:42.157]                       master <- NULL
[15:32:42.157]                       while (!identical(envir, .GlobalEnv) && 
[15:32:42.157]                         !identical(envir, emptyenv())) {
[15:32:42.157]                         if (exists("master", mode = "list", envir = envir, 
[15:32:42.157]                           inherits = FALSE)) {
[15:32:42.157]                           master <- get("master", mode = "list", 
[15:32:42.157]                             envir = envir, inherits = FALSE)
[15:32:42.157]                           if (inherits(master, c("SOCKnode", 
[15:32:42.157]                             "SOCK0node"))) {
[15:32:42.157]                             sendCondition <<- function(cond) {
[15:32:42.157]                               data <- list(type = "VALUE", value = cond, 
[15:32:42.157]                                 success = TRUE)
[15:32:42.157]                               parallel_sendData(master, data)
[15:32:42.157]                             }
[15:32:42.157]                             return(sendCondition)
[15:32:42.157]                           }
[15:32:42.157]                         }
[15:32:42.157]                         frame <- frame + 1L
[15:32:42.157]                         envir <- sys.frame(frame)
[15:32:42.157]                       }
[15:32:42.157]                     }
[15:32:42.157]                     sendCondition <<- function(cond) NULL
[15:32:42.157]                   }
[15:32:42.157]                 })
[15:32:42.157]                 withCallingHandlers({
[15:32:42.157]                   {
[15:32:42.157]                     do.call(function(...) {
[15:32:42.157]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:42.157]                       if (!identical(...future.globals.maxSize.org, 
[15:32:42.157]                         ...future.globals.maxSize)) {
[15:32:42.157]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:42.157]                         on.exit(options(oopts), add = TRUE)
[15:32:42.157]                       }
[15:32:42.157]                       {
[15:32:42.157]                         lapply(seq_along(...future.elements_ii), 
[15:32:42.157]                           FUN = function(jj) {
[15:32:42.157]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:42.157]                             ...future.FUN(...future.X_jj)
[15:32:42.157]                           })
[15:32:42.157]                       }
[15:32:42.157]                     }, args = future.call.arguments)
[15:32:42.157]                   }
[15:32:42.157]                 }, immediateCondition = function(cond) {
[15:32:42.157]                   sendCondition <- ...future.makeSendCondition()
[15:32:42.157]                   sendCondition(cond)
[15:32:42.157]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:42.157]                   {
[15:32:42.157]                     inherits <- base::inherits
[15:32:42.157]                     invokeRestart <- base::invokeRestart
[15:32:42.157]                     is.null <- base::is.null
[15:32:42.157]                     muffled <- FALSE
[15:32:42.157]                     if (inherits(cond, "message")) {
[15:32:42.157]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:42.157]                       if (muffled) 
[15:32:42.157]                         invokeRestart("muffleMessage")
[15:32:42.157]                     }
[15:32:42.157]                     else if (inherits(cond, "warning")) {
[15:32:42.157]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:42.157]                       if (muffled) 
[15:32:42.157]                         invokeRestart("muffleWarning")
[15:32:42.157]                     }
[15:32:42.157]                     else if (inherits(cond, "condition")) {
[15:32:42.157]                       if (!is.null(pattern)) {
[15:32:42.157]                         computeRestarts <- base::computeRestarts
[15:32:42.157]                         grepl <- base::grepl
[15:32:42.157]                         restarts <- computeRestarts(cond)
[15:32:42.157]                         for (restart in restarts) {
[15:32:42.157]                           name <- restart$name
[15:32:42.157]                           if (is.null(name)) 
[15:32:42.157]                             next
[15:32:42.157]                           if (!grepl(pattern, name)) 
[15:32:42.157]                             next
[15:32:42.157]                           invokeRestart(restart)
[15:32:42.157]                           muffled <- TRUE
[15:32:42.157]                           break
[15:32:42.157]                         }
[15:32:42.157]                       }
[15:32:42.157]                     }
[15:32:42.157]                     invisible(muffled)
[15:32:42.157]                   }
[15:32:42.157]                   muffleCondition(cond)
[15:32:42.157]                 })
[15:32:42.157]             }))
[15:32:42.157]             future::FutureResult(value = ...future.value$value, 
[15:32:42.157]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:42.157]                   ...future.rng), globalenv = if (FALSE) 
[15:32:42.157]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:42.157]                     ...future.globalenv.names))
[15:32:42.157]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:42.157]         }, condition = base::local({
[15:32:42.157]             c <- base::c
[15:32:42.157]             inherits <- base::inherits
[15:32:42.157]             invokeRestart <- base::invokeRestart
[15:32:42.157]             length <- base::length
[15:32:42.157]             list <- base::list
[15:32:42.157]             seq.int <- base::seq.int
[15:32:42.157]             signalCondition <- base::signalCondition
[15:32:42.157]             sys.calls <- base::sys.calls
[15:32:42.157]             `[[` <- base::`[[`
[15:32:42.157]             `+` <- base::`+`
[15:32:42.157]             `<<-` <- base::`<<-`
[15:32:42.157]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:42.157]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:42.157]                   3L)]
[15:32:42.157]             }
[15:32:42.157]             function(cond) {
[15:32:42.157]                 is_error <- inherits(cond, "error")
[15:32:42.157]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:42.157]                   NULL)
[15:32:42.157]                 if (is_error) {
[15:32:42.157]                   sessionInformation <- function() {
[15:32:42.157]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:42.157]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:42.157]                       search = base::search(), system = base::Sys.info())
[15:32:42.157]                   }
[15:32:42.157]                   ...future.conditions[[length(...future.conditions) + 
[15:32:42.157]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:42.157]                     cond$call), session = sessionInformation(), 
[15:32:42.157]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:42.157]                   signalCondition(cond)
[15:32:42.157]                 }
[15:32:42.157]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:42.157]                 "immediateCondition"))) {
[15:32:42.157]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:42.157]                   ...future.conditions[[length(...future.conditions) + 
[15:32:42.157]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:42.157]                   if (TRUE && !signal) {
[15:32:42.157]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:42.157]                     {
[15:32:42.157]                       inherits <- base::inherits
[15:32:42.157]                       invokeRestart <- base::invokeRestart
[15:32:42.157]                       is.null <- base::is.null
[15:32:42.157]                       muffled <- FALSE
[15:32:42.157]                       if (inherits(cond, "message")) {
[15:32:42.157]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:42.157]                         if (muffled) 
[15:32:42.157]                           invokeRestart("muffleMessage")
[15:32:42.157]                       }
[15:32:42.157]                       else if (inherits(cond, "warning")) {
[15:32:42.157]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:42.157]                         if (muffled) 
[15:32:42.157]                           invokeRestart("muffleWarning")
[15:32:42.157]                       }
[15:32:42.157]                       else if (inherits(cond, "condition")) {
[15:32:42.157]                         if (!is.null(pattern)) {
[15:32:42.157]                           computeRestarts <- base::computeRestarts
[15:32:42.157]                           grepl <- base::grepl
[15:32:42.157]                           restarts <- computeRestarts(cond)
[15:32:42.157]                           for (restart in restarts) {
[15:32:42.157]                             name <- restart$name
[15:32:42.157]                             if (is.null(name)) 
[15:32:42.157]                               next
[15:32:42.157]                             if (!grepl(pattern, name)) 
[15:32:42.157]                               next
[15:32:42.157]                             invokeRestart(restart)
[15:32:42.157]                             muffled <- TRUE
[15:32:42.157]                             break
[15:32:42.157]                           }
[15:32:42.157]                         }
[15:32:42.157]                       }
[15:32:42.157]                       invisible(muffled)
[15:32:42.157]                     }
[15:32:42.157]                     muffleCondition(cond, pattern = "^muffle")
[15:32:42.157]                   }
[15:32:42.157]                 }
[15:32:42.157]                 else {
[15:32:42.157]                   if (TRUE) {
[15:32:42.157]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:42.157]                     {
[15:32:42.157]                       inherits <- base::inherits
[15:32:42.157]                       invokeRestart <- base::invokeRestart
[15:32:42.157]                       is.null <- base::is.null
[15:32:42.157]                       muffled <- FALSE
[15:32:42.157]                       if (inherits(cond, "message")) {
[15:32:42.157]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:42.157]                         if (muffled) 
[15:32:42.157]                           invokeRestart("muffleMessage")
[15:32:42.157]                       }
[15:32:42.157]                       else if (inherits(cond, "warning")) {
[15:32:42.157]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:42.157]                         if (muffled) 
[15:32:42.157]                           invokeRestart("muffleWarning")
[15:32:42.157]                       }
[15:32:42.157]                       else if (inherits(cond, "condition")) {
[15:32:42.157]                         if (!is.null(pattern)) {
[15:32:42.157]                           computeRestarts <- base::computeRestarts
[15:32:42.157]                           grepl <- base::grepl
[15:32:42.157]                           restarts <- computeRestarts(cond)
[15:32:42.157]                           for (restart in restarts) {
[15:32:42.157]                             name <- restart$name
[15:32:42.157]                             if (is.null(name)) 
[15:32:42.157]                               next
[15:32:42.157]                             if (!grepl(pattern, name)) 
[15:32:42.157]                               next
[15:32:42.157]                             invokeRestart(restart)
[15:32:42.157]                             muffled <- TRUE
[15:32:42.157]                             break
[15:32:42.157]                           }
[15:32:42.157]                         }
[15:32:42.157]                       }
[15:32:42.157]                       invisible(muffled)
[15:32:42.157]                     }
[15:32:42.157]                     muffleCondition(cond, pattern = "^muffle")
[15:32:42.157]                   }
[15:32:42.157]                 }
[15:32:42.157]             }
[15:32:42.157]         }))
[15:32:42.157]     }, error = function(ex) {
[15:32:42.157]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:42.157]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:42.157]                 ...future.rng), started = ...future.startTime, 
[15:32:42.157]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:42.157]             version = "1.8"), class = "FutureResult")
[15:32:42.157]     }, finally = {
[15:32:42.157]         if (!identical(...future.workdir, getwd())) 
[15:32:42.157]             setwd(...future.workdir)
[15:32:42.157]         {
[15:32:42.157]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:42.157]                 ...future.oldOptions$nwarnings <- NULL
[15:32:42.157]             }
[15:32:42.157]             base::options(...future.oldOptions)
[15:32:42.157]             if (.Platform$OS.type == "windows") {
[15:32:42.157]                 old_names <- names(...future.oldEnvVars)
[15:32:42.157]                 envs <- base::Sys.getenv()
[15:32:42.157]                 names <- names(envs)
[15:32:42.157]                 common <- intersect(names, old_names)
[15:32:42.157]                 added <- setdiff(names, old_names)
[15:32:42.157]                 removed <- setdiff(old_names, names)
[15:32:42.157]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:42.157]                   envs[common]]
[15:32:42.157]                 NAMES <- toupper(changed)
[15:32:42.157]                 args <- list()
[15:32:42.157]                 for (kk in seq_along(NAMES)) {
[15:32:42.157]                   name <- changed[[kk]]
[15:32:42.157]                   NAME <- NAMES[[kk]]
[15:32:42.157]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:42.157]                     next
[15:32:42.157]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:42.157]                 }
[15:32:42.157]                 NAMES <- toupper(added)
[15:32:42.157]                 for (kk in seq_along(NAMES)) {
[15:32:42.157]                   name <- added[[kk]]
[15:32:42.157]                   NAME <- NAMES[[kk]]
[15:32:42.157]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:42.157]                     next
[15:32:42.157]                   args[[name]] <- ""
[15:32:42.157]                 }
[15:32:42.157]                 NAMES <- toupper(removed)
[15:32:42.157]                 for (kk in seq_along(NAMES)) {
[15:32:42.157]                   name <- removed[[kk]]
[15:32:42.157]                   NAME <- NAMES[[kk]]
[15:32:42.157]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:42.157]                     next
[15:32:42.157]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:42.157]                 }
[15:32:42.157]                 if (length(args) > 0) 
[15:32:42.157]                   base::do.call(base::Sys.setenv, args = args)
[15:32:42.157]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:42.157]             }
[15:32:42.157]             else {
[15:32:42.157]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:42.157]             }
[15:32:42.157]             {
[15:32:42.157]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:42.157]                   0L) {
[15:32:42.157]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:42.157]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:42.157]                   base::options(opts)
[15:32:42.157]                 }
[15:32:42.157]                 {
[15:32:42.157]                   {
[15:32:42.157]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:42.157]                     NULL
[15:32:42.157]                   }
[15:32:42.157]                   options(future.plan = NULL)
[15:32:42.157]                   if (is.na(NA_character_)) 
[15:32:42.157]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:42.157]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:42.157]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:42.157]                     .init = FALSE)
[15:32:42.157]                 }
[15:32:42.157]             }
[15:32:42.157]         }
[15:32:42.157]     })
[15:32:42.157]     if (TRUE) {
[15:32:42.157]         base::sink(type = "output", split = FALSE)
[15:32:42.157]         if (TRUE) {
[15:32:42.157]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:42.157]         }
[15:32:42.157]         else {
[15:32:42.157]             ...future.result["stdout"] <- base::list(NULL)
[15:32:42.157]         }
[15:32:42.157]         base::close(...future.stdout)
[15:32:42.157]         ...future.stdout <- NULL
[15:32:42.157]     }
[15:32:42.157]     ...future.result$conditions <- ...future.conditions
[15:32:42.157]     ...future.result$finished <- base::Sys.time()
[15:32:42.157]     ...future.result
[15:32:42.157] }
[15:32:42.165] Exporting 6 global objects (3.92 KiB) to cluster node #1 ...
[15:32:42.166] Exporting '...future.FUN' (2.43 KiB) to cluster node #1 ...
[15:32:42.166] Exporting '...future.FUN' (2.43 KiB) to cluster node #1 ... DONE
[15:32:42.167] Exporting 'compute' (1.44 KiB) to cluster node #1 ...
[15:32:42.168] Exporting 'compute' (1.44 KiB) to cluster node #1 ... DONE
[15:32:42.168] Exporting 'future.call.arguments' (56 bytes) to cluster node #1 ...
[15:32:42.169] Exporting 'future.call.arguments' (56 bytes) to cluster node #1 ... DONE
[15:32:42.169] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ...
[15:32:42.170] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ... DONE
[15:32:42.170] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:42.171] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:42.171] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:42.171] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:42.172] Exporting 6 global objects (3.92 KiB) to cluster node #1 ... DONE
[15:32:42.172] MultisessionFuture started
[15:32:42.173] - Launch lazy future ... done
[15:32:42.173] run() for 'MultisessionFuture' ... done
[15:32:42.173] Created future:
[15:32:42.198] receiveMessageFromWorker() for ClusterFuture ...
[15:32:42.199] - Validating connection of MultisessionFuture
[15:32:42.199] - received message: FutureResult
[15:32:42.200] - Received FutureResult
[15:32:42.200] - Erased future from FutureRegistry
[15:32:42.200] result() for ClusterFuture ...
[15:32:42.200] - result already collected: FutureResult
[15:32:42.200] result() for ClusterFuture ... done
[15:32:42.200] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:42.173] MultisessionFuture:
[15:32:42.173] Label: 'future_sapply-1'
[15:32:42.173] Expression:
[15:32:42.173] {
[15:32:42.173]     do.call(function(...) {
[15:32:42.173]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:42.173]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:42.173]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:42.173]             on.exit(options(oopts), add = TRUE)
[15:32:42.173]         }
[15:32:42.173]         {
[15:32:42.173]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:42.173]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:42.173]                 ...future.FUN(...future.X_jj)
[15:32:42.173]             })
[15:32:42.173]         }
[15:32:42.173]     }, args = future.call.arguments)
[15:32:42.173] }
[15:32:42.173] Lazy evaluation: FALSE
[15:32:42.173] Asynchronous evaluation: TRUE
[15:32:42.173] Local evaluation: TRUE
[15:32:42.173] Environment: 0x00000276e52a2e68
[15:32:42.173] Capture standard output: TRUE
[15:32:42.173] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:42.173] Globals: 6 objects totaling 3.98 KiB (function '...future.FUN' of 2.43 KiB, function 'compute' of 1.44 KiB, DotDotDotList 'future.call.arguments' of 56 bytes, list '...future.elements_ii' of 56 bytes, NULL '...future.seeds_ii' of 0 bytes, ...)
[15:32:42.173] Packages: <none>
[15:32:42.173] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:42.173] Resolved: TRUE
[15:32:42.173] Value: <not collected>
[15:32:42.173] Conditions captured: <none>
[15:32:42.173] Early signaling: FALSE
[15:32:42.173] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:42.173] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:42.201] Chunk #1 of 2 ... DONE
[15:32:42.201] Chunk #2 of 2 ...
[15:32:42.201]  - Finding globals in 'X' for chunk #2 ...
[15:32:42.202] getGlobalsAndPackages() ...
[15:32:42.202] Searching for globals...
[15:32:42.202] 
[15:32:42.202] Searching for globals ... DONE
[15:32:42.203] - globals: [0] <none>
[15:32:42.203] getGlobalsAndPackages() ... DONE
[15:32:42.203]    + additional globals found: [n=0] 
[15:32:42.203]    + additional namespaces needed: [n=0] 
[15:32:42.203]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:42.204]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:42.204]  - seeds: <none>
[15:32:42.204]  - All globals exported: [n=7] '...future.FUN', 'compute', 'future.call.arguments', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:42.204] getGlobalsAndPackages() ...
[15:32:42.204] - globals passed as-is: [7] '...future.FUN', 'compute', 'future.call.arguments', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:42.205] Resolving globals: FALSE
[15:32:42.205] Tweak future expression to call with '...' arguments ...
[15:32:42.205] - Detected 2 'future.call.arguments' global entries:
[15:32:42.205] List of 2
[15:32:42.205]  $ future.call.arguments:List of 1
[15:32:42.205]   ..$ : int 0
[15:32:42.205]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:42.205]  $ future.call.arguments: list()
[15:32:42.205]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:42.205]  - attr(*, "where")=List of 2
[15:32:42.205]   ..$ future.call.arguments:<environment: R_EmptyEnv> 
[15:32:42.205]   ..$ future.call.arguments:<environment: 0x00000276e52a2420> 
[15:32:42.205]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:42.205]  - attr(*, "resolved")= logi FALSE
[15:32:42.205]  - attr(*, "total_size")= num 4016
[15:32:42.211] future.call.arguments future.call.arguments 
[15:32:42.211]                     1                     0 
[15:32:42.212] - 'future.call.arguments' global entries:
[15:32:42.212] List of 2
[15:32:42.212]  $ future.call.arguments:List of 1
[15:32:42.212]   ..$ : int 0
[15:32:42.212]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:42.212]  $ ...future.elements_ii:List of 1
[15:32:42.212]   ..$ : int 2
[15:32:42.212]  - attr(*, "where")=List of 2
[15:32:42.212]   ..$ future.call.arguments:<environment: R_EmptyEnv> 
[15:32:42.212]   ..$ ...future.elements_ii:<environment: R_EmptyEnv> 
[15:32:42.212]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:42.212]  - attr(*, "resolved")= logi FALSE
[15:32:42.212]  - attr(*, "total_size")= num 4016
[15:32:42.219] {
[15:32:42.219]     do.call(function(...) {
[15:32:42.219]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:42.219]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:42.219]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:42.219]             on.exit(options(oopts), add = TRUE)
[15:32:42.219]         }
[15:32:42.219]         {
[15:32:42.219]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:42.219]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:42.219]                 ...future.FUN(...future.X_jj)
[15:32:42.219]             })
[15:32:42.219]         }
[15:32:42.219]     }, args = future.call.arguments)
[15:32:42.219] }
[15:32:42.220] Tweak future expression to call with '...' arguments ... DONE
[15:32:42.221] - globals: [6] '...future.FUN', 'compute', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:42.221] 
[15:32:42.221] getGlobalsAndPackages() ... DONE
[15:32:42.222] run() for 'Future' ...
[15:32:42.222] - state: 'created'
[15:32:42.223] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:42.241] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:42.241] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:42.242]   - Field: 'node'
[15:32:42.242]   - Field: 'label'
[15:32:42.242]   - Field: 'local'
[15:32:42.242]   - Field: 'owner'
[15:32:42.243]   - Field: 'envir'
[15:32:42.243]   - Field: 'workers'
[15:32:42.243]   - Field: 'packages'
[15:32:42.244]   - Field: 'gc'
[15:32:42.244]   - Field: 'conditions'
[15:32:42.244]   - Field: 'persistent'
[15:32:42.245]   - Field: 'expr'
[15:32:42.245]   - Field: 'uuid'
[15:32:42.245]   - Field: 'seed'
[15:32:42.245]   - Field: 'version'
[15:32:42.246]   - Field: 'result'
[15:32:42.246]   - Field: 'asynchronous'
[15:32:42.246]   - Field: 'calls'
[15:32:42.247]   - Field: 'globals'
[15:32:42.247]   - Field: 'stdout'
[15:32:42.247]   - Field: 'earlySignal'
[15:32:42.248]   - Field: 'lazy'
[15:32:42.248]   - Field: 'state'
[15:32:42.248] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:42.249] - Launch lazy future ...
[15:32:42.249] Packages needed by the future expression (n = 0): <none>
[15:32:42.250] Packages needed by future strategies (n = 0): <none>
[15:32:42.251] {
[15:32:42.251]     {
[15:32:42.251]         {
[15:32:42.251]             ...future.startTime <- base::Sys.time()
[15:32:42.251]             {
[15:32:42.251]                 {
[15:32:42.251]                   {
[15:32:42.251]                     {
[15:32:42.251]                       base::local({
[15:32:42.251]                         has_future <- base::requireNamespace("future", 
[15:32:42.251]                           quietly = TRUE)
[15:32:42.251]                         if (has_future) {
[15:32:42.251]                           ns <- base::getNamespace("future")
[15:32:42.251]                           version <- ns[[".package"]][["version"]]
[15:32:42.251]                           if (is.null(version)) 
[15:32:42.251]                             version <- utils::packageVersion("future")
[15:32:42.251]                         }
[15:32:42.251]                         else {
[15:32:42.251]                           version <- NULL
[15:32:42.251]                         }
[15:32:42.251]                         if (!has_future || version < "1.8.0") {
[15:32:42.251]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:42.251]                             "", base::R.version$version.string), 
[15:32:42.251]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:42.251]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:42.251]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:42.251]                               "release", "version")], collapse = " "), 
[15:32:42.251]                             hostname = base::Sys.info()[["nodename"]])
[15:32:42.251]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:42.251]                             info)
[15:32:42.251]                           info <- base::paste(info, collapse = "; ")
[15:32:42.251]                           if (!has_future) {
[15:32:42.251]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:42.251]                               info)
[15:32:42.251]                           }
[15:32:42.251]                           else {
[15:32:42.251]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:42.251]                               info, version)
[15:32:42.251]                           }
[15:32:42.251]                           base::stop(msg)
[15:32:42.251]                         }
[15:32:42.251]                       })
[15:32:42.251]                     }
[15:32:42.251]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:42.251]                     base::options(mc.cores = 1L)
[15:32:42.251]                   }
[15:32:42.251]                   ...future.strategy.old <- future::plan("list")
[15:32:42.251]                   options(future.plan = NULL)
[15:32:42.251]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:42.251]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:42.251]                 }
[15:32:42.251]                 ...future.workdir <- getwd()
[15:32:42.251]             }
[15:32:42.251]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:42.251]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:42.251]         }
[15:32:42.251]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:42.251]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:42.251]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:42.251]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:42.251]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:42.251]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:42.251]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:42.251]             base::names(...future.oldOptions))
[15:32:42.251]     }
[15:32:42.251]     if (FALSE) {
[15:32:42.251]     }
[15:32:42.251]     else {
[15:32:42.251]         if (TRUE) {
[15:32:42.251]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:42.251]                 open = "w")
[15:32:42.251]         }
[15:32:42.251]         else {
[15:32:42.251]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:42.251]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:42.251]         }
[15:32:42.251]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:42.251]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:42.251]             base::sink(type = "output", split = FALSE)
[15:32:42.251]             base::close(...future.stdout)
[15:32:42.251]         }, add = TRUE)
[15:32:42.251]     }
[15:32:42.251]     ...future.frame <- base::sys.nframe()
[15:32:42.251]     ...future.conditions <- base::list()
[15:32:42.251]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:42.251]     if (FALSE) {
[15:32:42.251]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:42.251]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:42.251]     }
[15:32:42.251]     ...future.result <- base::tryCatch({
[15:32:42.251]         base::withCallingHandlers({
[15:32:42.251]             ...future.value <- base::withVisible(base::local({
[15:32:42.251]                 ...future.makeSendCondition <- base::local({
[15:32:42.251]                   sendCondition <- NULL
[15:32:42.251]                   function(frame = 1L) {
[15:32:42.251]                     if (is.function(sendCondition)) 
[15:32:42.251]                       return(sendCondition)
[15:32:42.251]                     ns <- getNamespace("parallel")
[15:32:42.251]                     if (exists("sendData", mode = "function", 
[15:32:42.251]                       envir = ns)) {
[15:32:42.251]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:42.251]                         envir = ns)
[15:32:42.251]                       envir <- sys.frame(frame)
[15:32:42.251]                       master <- NULL
[15:32:42.251]                       while (!identical(envir, .GlobalEnv) && 
[15:32:42.251]                         !identical(envir, emptyenv())) {
[15:32:42.251]                         if (exists("master", mode = "list", envir = envir, 
[15:32:42.251]                           inherits = FALSE)) {
[15:32:42.251]                           master <- get("master", mode = "list", 
[15:32:42.251]                             envir = envir, inherits = FALSE)
[15:32:42.251]                           if (inherits(master, c("SOCKnode", 
[15:32:42.251]                             "SOCK0node"))) {
[15:32:42.251]                             sendCondition <<- function(cond) {
[15:32:42.251]                               data <- list(type = "VALUE", value = cond, 
[15:32:42.251]                                 success = TRUE)
[15:32:42.251]                               parallel_sendData(master, data)
[15:32:42.251]                             }
[15:32:42.251]                             return(sendCondition)
[15:32:42.251]                           }
[15:32:42.251]                         }
[15:32:42.251]                         frame <- frame + 1L
[15:32:42.251]                         envir <- sys.frame(frame)
[15:32:42.251]                       }
[15:32:42.251]                     }
[15:32:42.251]                     sendCondition <<- function(cond) NULL
[15:32:42.251]                   }
[15:32:42.251]                 })
[15:32:42.251]                 withCallingHandlers({
[15:32:42.251]                   {
[15:32:42.251]                     do.call(function(...) {
[15:32:42.251]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:42.251]                       if (!identical(...future.globals.maxSize.org, 
[15:32:42.251]                         ...future.globals.maxSize)) {
[15:32:42.251]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:42.251]                         on.exit(options(oopts), add = TRUE)
[15:32:42.251]                       }
[15:32:42.251]                       {
[15:32:42.251]                         lapply(seq_along(...future.elements_ii), 
[15:32:42.251]                           FUN = function(jj) {
[15:32:42.251]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:42.251]                             ...future.FUN(...future.X_jj)
[15:32:42.251]                           })
[15:32:42.251]                       }
[15:32:42.251]                     }, args = future.call.arguments)
[15:32:42.251]                   }
[15:32:42.251]                 }, immediateCondition = function(cond) {
[15:32:42.251]                   sendCondition <- ...future.makeSendCondition()
[15:32:42.251]                   sendCondition(cond)
[15:32:42.251]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:42.251]                   {
[15:32:42.251]                     inherits <- base::inherits
[15:32:42.251]                     invokeRestart <- base::invokeRestart
[15:32:42.251]                     is.null <- base::is.null
[15:32:42.251]                     muffled <- FALSE
[15:32:42.251]                     if (inherits(cond, "message")) {
[15:32:42.251]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:42.251]                       if (muffled) 
[15:32:42.251]                         invokeRestart("muffleMessage")
[15:32:42.251]                     }
[15:32:42.251]                     else if (inherits(cond, "warning")) {
[15:32:42.251]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:42.251]                       if (muffled) 
[15:32:42.251]                         invokeRestart("muffleWarning")
[15:32:42.251]                     }
[15:32:42.251]                     else if (inherits(cond, "condition")) {
[15:32:42.251]                       if (!is.null(pattern)) {
[15:32:42.251]                         computeRestarts <- base::computeRestarts
[15:32:42.251]                         grepl <- base::grepl
[15:32:42.251]                         restarts <- computeRestarts(cond)
[15:32:42.251]                         for (restart in restarts) {
[15:32:42.251]                           name <- restart$name
[15:32:42.251]                           if (is.null(name)) 
[15:32:42.251]                             next
[15:32:42.251]                           if (!grepl(pattern, name)) 
[15:32:42.251]                             next
[15:32:42.251]                           invokeRestart(restart)
[15:32:42.251]                           muffled <- TRUE
[15:32:42.251]                           break
[15:32:42.251]                         }
[15:32:42.251]                       }
[15:32:42.251]                     }
[15:32:42.251]                     invisible(muffled)
[15:32:42.251]                   }
[15:32:42.251]                   muffleCondition(cond)
[15:32:42.251]                 })
[15:32:42.251]             }))
[15:32:42.251]             future::FutureResult(value = ...future.value$value, 
[15:32:42.251]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:42.251]                   ...future.rng), globalenv = if (FALSE) 
[15:32:42.251]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:42.251]                     ...future.globalenv.names))
[15:32:42.251]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:42.251]         }, condition = base::local({
[15:32:42.251]             c <- base::c
[15:32:42.251]             inherits <- base::inherits
[15:32:42.251]             invokeRestart <- base::invokeRestart
[15:32:42.251]             length <- base::length
[15:32:42.251]             list <- base::list
[15:32:42.251]             seq.int <- base::seq.int
[15:32:42.251]             signalCondition <- base::signalCondition
[15:32:42.251]             sys.calls <- base::sys.calls
[15:32:42.251]             `[[` <- base::`[[`
[15:32:42.251]             `+` <- base::`+`
[15:32:42.251]             `<<-` <- base::`<<-`
[15:32:42.251]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:42.251]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:42.251]                   3L)]
[15:32:42.251]             }
[15:32:42.251]             function(cond) {
[15:32:42.251]                 is_error <- inherits(cond, "error")
[15:32:42.251]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:42.251]                   NULL)
[15:32:42.251]                 if (is_error) {
[15:32:42.251]                   sessionInformation <- function() {
[15:32:42.251]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:42.251]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:42.251]                       search = base::search(), system = base::Sys.info())
[15:32:42.251]                   }
[15:32:42.251]                   ...future.conditions[[length(...future.conditions) + 
[15:32:42.251]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:42.251]                     cond$call), session = sessionInformation(), 
[15:32:42.251]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:42.251]                   signalCondition(cond)
[15:32:42.251]                 }
[15:32:42.251]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:42.251]                 "immediateCondition"))) {
[15:32:42.251]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:42.251]                   ...future.conditions[[length(...future.conditions) + 
[15:32:42.251]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:42.251]                   if (TRUE && !signal) {
[15:32:42.251]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:42.251]                     {
[15:32:42.251]                       inherits <- base::inherits
[15:32:42.251]                       invokeRestart <- base::invokeRestart
[15:32:42.251]                       is.null <- base::is.null
[15:32:42.251]                       muffled <- FALSE
[15:32:42.251]                       if (inherits(cond, "message")) {
[15:32:42.251]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:42.251]                         if (muffled) 
[15:32:42.251]                           invokeRestart("muffleMessage")
[15:32:42.251]                       }
[15:32:42.251]                       else if (inherits(cond, "warning")) {
[15:32:42.251]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:42.251]                         if (muffled) 
[15:32:42.251]                           invokeRestart("muffleWarning")
[15:32:42.251]                       }
[15:32:42.251]                       else if (inherits(cond, "condition")) {
[15:32:42.251]                         if (!is.null(pattern)) {
[15:32:42.251]                           computeRestarts <- base::computeRestarts
[15:32:42.251]                           grepl <- base::grepl
[15:32:42.251]                           restarts <- computeRestarts(cond)
[15:32:42.251]                           for (restart in restarts) {
[15:32:42.251]                             name <- restart$name
[15:32:42.251]                             if (is.null(name)) 
[15:32:42.251]                               next
[15:32:42.251]                             if (!grepl(pattern, name)) 
[15:32:42.251]                               next
[15:32:42.251]                             invokeRestart(restart)
[15:32:42.251]                             muffled <- TRUE
[15:32:42.251]                             break
[15:32:42.251]                           }
[15:32:42.251]                         }
[15:32:42.251]                       }
[15:32:42.251]                       invisible(muffled)
[15:32:42.251]                     }
[15:32:42.251]                     muffleCondition(cond, pattern = "^muffle")
[15:32:42.251]                   }
[15:32:42.251]                 }
[15:32:42.251]                 else {
[15:32:42.251]                   if (TRUE) {
[15:32:42.251]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:42.251]                     {
[15:32:42.251]                       inherits <- base::inherits
[15:32:42.251]                       invokeRestart <- base::invokeRestart
[15:32:42.251]                       is.null <- base::is.null
[15:32:42.251]                       muffled <- FALSE
[15:32:42.251]                       if (inherits(cond, "message")) {
[15:32:42.251]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:42.251]                         if (muffled) 
[15:32:42.251]                           invokeRestart("muffleMessage")
[15:32:42.251]                       }
[15:32:42.251]                       else if (inherits(cond, "warning")) {
[15:32:42.251]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:42.251]                         if (muffled) 
[15:32:42.251]                           invokeRestart("muffleWarning")
[15:32:42.251]                       }
[15:32:42.251]                       else if (inherits(cond, "condition")) {
[15:32:42.251]                         if (!is.null(pattern)) {
[15:32:42.251]                           computeRestarts <- base::computeRestarts
[15:32:42.251]                           grepl <- base::grepl
[15:32:42.251]                           restarts <- computeRestarts(cond)
[15:32:42.251]                           for (restart in restarts) {
[15:32:42.251]                             name <- restart$name
[15:32:42.251]                             if (is.null(name)) 
[15:32:42.251]                               next
[15:32:42.251]                             if (!grepl(pattern, name)) 
[15:32:42.251]                               next
[15:32:42.251]                             invokeRestart(restart)
[15:32:42.251]                             muffled <- TRUE
[15:32:42.251]                             break
[15:32:42.251]                           }
[15:32:42.251]                         }
[15:32:42.251]                       }
[15:32:42.251]                       invisible(muffled)
[15:32:42.251]                     }
[15:32:42.251]                     muffleCondition(cond, pattern = "^muffle")
[15:32:42.251]                   }
[15:32:42.251]                 }
[15:32:42.251]             }
[15:32:42.251]         }))
[15:32:42.251]     }, error = function(ex) {
[15:32:42.251]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:42.251]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:42.251]                 ...future.rng), started = ...future.startTime, 
[15:32:42.251]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:42.251]             version = "1.8"), class = "FutureResult")
[15:32:42.251]     }, finally = {
[15:32:42.251]         if (!identical(...future.workdir, getwd())) 
[15:32:42.251]             setwd(...future.workdir)
[15:32:42.251]         {
[15:32:42.251]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:42.251]                 ...future.oldOptions$nwarnings <- NULL
[15:32:42.251]             }
[15:32:42.251]             base::options(...future.oldOptions)
[15:32:42.251]             if (.Platform$OS.type == "windows") {
[15:32:42.251]                 old_names <- names(...future.oldEnvVars)
[15:32:42.251]                 envs <- base::Sys.getenv()
[15:32:42.251]                 names <- names(envs)
[15:32:42.251]                 common <- intersect(names, old_names)
[15:32:42.251]                 added <- setdiff(names, old_names)
[15:32:42.251]                 removed <- setdiff(old_names, names)
[15:32:42.251]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:42.251]                   envs[common]]
[15:32:42.251]                 NAMES <- toupper(changed)
[15:32:42.251]                 args <- list()
[15:32:42.251]                 for (kk in seq_along(NAMES)) {
[15:32:42.251]                   name <- changed[[kk]]
[15:32:42.251]                   NAME <- NAMES[[kk]]
[15:32:42.251]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:42.251]                     next
[15:32:42.251]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:42.251]                 }
[15:32:42.251]                 NAMES <- toupper(added)
[15:32:42.251]                 for (kk in seq_along(NAMES)) {
[15:32:42.251]                   name <- added[[kk]]
[15:32:42.251]                   NAME <- NAMES[[kk]]
[15:32:42.251]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:42.251]                     next
[15:32:42.251]                   args[[name]] <- ""
[15:32:42.251]                 }
[15:32:42.251]                 NAMES <- toupper(removed)
[15:32:42.251]                 for (kk in seq_along(NAMES)) {
[15:32:42.251]                   name <- removed[[kk]]
[15:32:42.251]                   NAME <- NAMES[[kk]]
[15:32:42.251]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:42.251]                     next
[15:32:42.251]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:42.251]                 }
[15:32:42.251]                 if (length(args) > 0) 
[15:32:42.251]                   base::do.call(base::Sys.setenv, args = args)
[15:32:42.251]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:42.251]             }
[15:32:42.251]             else {
[15:32:42.251]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:42.251]             }
[15:32:42.251]             {
[15:32:42.251]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:42.251]                   0L) {
[15:32:42.251]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:42.251]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:42.251]                   base::options(opts)
[15:32:42.251]                 }
[15:32:42.251]                 {
[15:32:42.251]                   {
[15:32:42.251]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:42.251]                     NULL
[15:32:42.251]                   }
[15:32:42.251]                   options(future.plan = NULL)
[15:32:42.251]                   if (is.na(NA_character_)) 
[15:32:42.251]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:42.251]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:42.251]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:42.251]                     .init = FALSE)
[15:32:42.251]                 }
[15:32:42.251]             }
[15:32:42.251]         }
[15:32:42.251]     })
[15:32:42.251]     if (TRUE) {
[15:32:42.251]         base::sink(type = "output", split = FALSE)
[15:32:42.251]         if (TRUE) {
[15:32:42.251]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:42.251]         }
[15:32:42.251]         else {
[15:32:42.251]             ...future.result["stdout"] <- base::list(NULL)
[15:32:42.251]         }
[15:32:42.251]         base::close(...future.stdout)
[15:32:42.251]         ...future.stdout <- NULL
[15:32:42.251]     }
[15:32:42.251]     ...future.result$conditions <- ...future.conditions
[15:32:42.251]     ...future.result$finished <- base::Sys.time()
[15:32:42.251]     ...future.result
[15:32:42.251] }
[15:32:42.260] Exporting 6 global objects (3.92 KiB) to cluster node #1 ...
[15:32:42.260] Exporting '...future.FUN' (2.43 KiB) to cluster node #1 ...
[15:32:42.261] Exporting '...future.FUN' (2.43 KiB) to cluster node #1 ... DONE
[15:32:42.261] Exporting 'compute' (1.44 KiB) to cluster node #1 ...
[15:32:42.262] Exporting 'compute' (1.44 KiB) to cluster node #1 ... DONE
[15:32:42.262] Exporting 'future.call.arguments' (56 bytes) to cluster node #1 ...
[15:32:42.263] Exporting 'future.call.arguments' (56 bytes) to cluster node #1 ... DONE
[15:32:42.263] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ...
[15:32:42.264] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ... DONE
[15:32:42.279] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:42.280] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:42.280] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:42.281] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:42.281] Exporting 6 global objects (3.92 KiB) to cluster node #1 ... DONE
[15:32:42.282] MultisessionFuture started
[15:32:42.282] - Launch lazy future ... done
[15:32:42.283] run() for 'MultisessionFuture' ... done
[15:32:42.283] Created future:
[15:32:42.302] receiveMessageFromWorker() for ClusterFuture ...
[15:32:42.302] - Validating connection of MultisessionFuture
[15:32:42.303] - received message: FutureResult
[15:32:42.303] - Received FutureResult
[15:32:42.303] - Erased future from FutureRegistry
[15:32:42.304] result() for ClusterFuture ...
[15:32:42.304] - result already collected: FutureResult
[15:32:42.304] result() for ClusterFuture ... done
[15:32:42.304] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:42.283] MultisessionFuture:
[15:32:42.283] Label: 'future_sapply-2'
[15:32:42.283] Expression:
[15:32:42.283] {
[15:32:42.283]     do.call(function(...) {
[15:32:42.283]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:42.283]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:42.283]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:42.283]             on.exit(options(oopts), add = TRUE)
[15:32:42.283]         }
[15:32:42.283]         {
[15:32:42.283]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:42.283]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:42.283]                 ...future.FUN(...future.X_jj)
[15:32:42.283]             })
[15:32:42.283]         }
[15:32:42.283]     }, args = future.call.arguments)
[15:32:42.283] }
[15:32:42.283] Lazy evaluation: FALSE
[15:32:42.283] Asynchronous evaluation: TRUE
[15:32:42.283] Local evaluation: TRUE
[15:32:42.283] Environment: 0x00000276e52a2e68
[15:32:42.283] Capture standard output: TRUE
[15:32:42.283] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:42.283] Globals: 6 objects totaling 3.98 KiB (function '...future.FUN' of 2.43 KiB, function 'compute' of 1.44 KiB, DotDotDotList 'future.call.arguments' of 56 bytes, list '...future.elements_ii' of 56 bytes, NULL '...future.seeds_ii' of 0 bytes, ...)
[15:32:42.283] Packages: <none>
[15:32:42.283] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:42.283] Resolved: TRUE
[15:32:42.283] Value: <not collected>
[15:32:42.283] Conditions captured: <none>
[15:32:42.283] Early signaling: FALSE
[15:32:42.283] Owner process: c00ea1ba-6b4f-0bac-0e97-f1b65060498b
[15:32:42.283] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:42.305] Chunk #2 of 2 ... DONE
[15:32:42.305] Launching 2 futures (chunks) ... DONE
[15:32:42.305] Resolving 2 futures (chunks) ...
[15:32:42.306] resolve() on list ...
[15:32:42.306]  recursive: 0
[15:32:42.306]  length: 2
[15:32:42.306] 
[15:32:42.307] Future #1
[15:32:42.307] result() for ClusterFuture ...
[15:32:42.307] - result already collected: FutureResult
[15:32:42.307] result() for ClusterFuture ... done
[15:32:42.307] result() for ClusterFuture ...
[15:32:42.308] - result already collected: FutureResult
[15:32:42.308] result() for ClusterFuture ... done
[15:32:42.308] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:42.308] - nx: 2
[15:32:42.308] - relay: TRUE
[15:32:42.308] - stdout: TRUE
[15:32:42.309] - signal: TRUE
[15:32:42.309] - resignal: FALSE
[15:32:42.309] - force: TRUE
[15:32:42.309] - relayed: [n=2] FALSE, FALSE
[15:32:42.310] - queued futures: [n=2] FALSE, FALSE
[15:32:42.310]  - until=1
[15:32:42.310]  - relaying element #1
[15:32:42.310] result() for ClusterFuture ...
[15:32:42.310] - result already collected: FutureResult
[15:32:42.311] result() for ClusterFuture ... done
[15:32:42.311] result() for ClusterFuture ...
[15:32:42.311] - result already collected: FutureResult
[15:32:42.311] result() for ClusterFuture ... done
[15:32:42.311] result() for ClusterFuture ...
[15:32:42.312] - result already collected: FutureResult
[15:32:42.312] result() for ClusterFuture ... done
[15:32:42.312] result() for ClusterFuture ...
[15:32:42.312] - result already collected: FutureResult
[15:32:42.313] result() for ClusterFuture ... done
[15:32:42.313] - relayed: [n=2] TRUE, FALSE
[15:32:42.313] - queued futures: [n=2] TRUE, FALSE
[15:32:42.314] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:42.314]  length: 1 (resolved future 1)
[15:32:42.315] Future #2
[15:32:42.315] result() for ClusterFuture ...
[15:32:42.315] - result already collected: FutureResult
[15:32:42.316] result() for ClusterFuture ... done
[15:32:42.316] result() for ClusterFuture ...
[15:32:42.316] - result already collected: FutureResult
[15:32:42.317] result() for ClusterFuture ... done
[15:32:42.317] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:42.317] - nx: 2
[15:32:42.318] - relay: TRUE
[15:32:42.318] - stdout: TRUE
[15:32:42.318] - signal: TRUE
[15:32:42.319] - resignal: FALSE
[15:32:42.319] - force: TRUE
[15:32:42.319] - relayed: [n=2] TRUE, FALSE
[15:32:42.320] - queued futures: [n=2] TRUE, FALSE
[15:32:42.320]  - until=2
[15:32:42.320]  - relaying element #2
[15:32:42.321] result() for ClusterFuture ...
[15:32:42.321] - result already collected: FutureResult
[15:32:42.321] result() for ClusterFuture ... done
[15:32:42.322] result() for ClusterFuture ...
[15:32:42.322] - result already collected: FutureResult
[15:32:42.322] result() for ClusterFuture ... done
[15:32:42.323] result() for ClusterFuture ...
[15:32:42.323] - result already collected: FutureResult
[15:32:42.323] result() for ClusterFuture ... done
[15:32:42.324] result() for ClusterFuture ...
[15:32:42.324] - result already collected: FutureResult
[15:32:42.324] result() for ClusterFuture ... done
[15:32:42.325] - relayed: [n=2] TRUE, TRUE
[15:32:42.325] - queued futures: [n=2] TRUE, TRUE
[15:32:42.325] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:42.326]  length: 0 (resolved future 2)
[15:32:42.326] Relaying remaining futures
[15:32:42.326] signalConditionsASAP(NULL, pos=0) ...
[15:32:42.327] - nx: 2
[15:32:42.327] - relay: TRUE
[15:32:42.327] - stdout: TRUE
[15:32:42.328] - signal: TRUE
[15:32:42.328] - resignal: FALSE
[15:32:42.328] - force: TRUE
[15:32:42.329] - relayed: [n=2] TRUE, TRUE
[15:32:42.329] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:42.329] - relayed: [n=2] TRUE, TRUE
[15:32:42.330] - queued futures: [n=2] TRUE, TRUE
[15:32:42.330] signalConditionsASAP(NULL, pos=0) ... done
[15:32:42.330] resolve() on list ... DONE
[15:32:42.331] result() for ClusterFuture ...
[15:32:42.331] - result already collected: FutureResult
[15:32:42.331] result() for ClusterFuture ... done
[15:32:42.331] result() for ClusterFuture ...
[15:32:42.332] - result already collected: FutureResult
[15:32:42.332] result() for ClusterFuture ... done
[15:32:42.332] result() for ClusterFuture ...
[15:32:42.332] - result already collected: FutureResult
[15:32:42.333] result() for ClusterFuture ... done
[15:32:42.333] result() for ClusterFuture ...
[15:32:42.333] - result already collected: FutureResult
[15:32:42.334] result() for ClusterFuture ... done
[15:32:42.334]  - Number of value chunks collected: 2
[15:32:42.334] Resolving 2 futures (chunks) ... DONE
[15:32:42.335] Reducing values from 2 chunks ...
[15:32:42.335]  - Number of values collected after concatenation: 2
[15:32:42.335]  - Number of values expected: 2
[15:32:42.335] Reducing values from 2 chunks ... DONE
[15:32:42.336] future_lapply() ... DONE
[1] 1 2
[15:32:42.336] plan(): Setting new future strategy stack:
[15:32:42.337] List of future strategies:
[15:32:42.337] 1. sequential:
[15:32:42.337]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:42.337]    - tweaked: FALSE
[15:32:42.337]    - call: plan(sequential)
[15:32:42.339] plan(): nbrOfWorkers() = 1
*** strategy = 'multisession' ... done
> 
> message("*** future_sapply() ... DONE")
*** future_sapply() ... DONE
> 
> source("incl/end.R")
[15:32:42.340] plan(): Setting new future strategy stack:
[15:32:42.341] List of future strategies:
[15:32:42.341] 1. FutureStrategy:
[15:32:42.341]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:42.341]    - tweaked: FALSE
[15:32:42.341]    - call: future::plan(oplan)
[15:32:42.342] plan(): nbrOfWorkers() = 1
> 
> proc.time()
   user  system elapsed 
  19.01    0.60   23.78