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:56.863] plan(): Setting new future strategy stack:
[15:32:56.864] List of future strategies:
[15:32:56.864] 1. sequential:
[15:32:56.864]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:56.864]    - tweaked: FALSE
[15:32:56.864]    - call: future::plan("sequential")
[15:32:56.892] plan(): nbrOfWorkers() = 1
> 
> message("*** future_*apply() and 'future.stdout' ...")
*** future_*apply() and 'future.stdout' ...
> 
> options(future.debug = TRUE)
> 
> truth <- list()
> 
> out <- utils::capture.output({
+   y <- lapply(1:0, FUN = function(x) {
+     print(x)
+   })
+ })
> truth[["lapply"]] <- list(value = y, stdout = out)
> 
> out <- utils::capture.output({
+   y <- mapply(1:0, 0:1, FUN = function(x, y) {
+     print(list(x = x, y = y))
+   })
+ })
> truth[["mapply"]] <- list(value = y, stdout = out)
> 
> for (cores in 1:availCores) {
+   message(sprintf("  - Testing with %d cores ...", cores))
+   options(mc.cores = cores)
+   
+   for (strategy in supportedStrategies(cores)) {
+     message(sprintf("* plan('%s') ...", strategy))
+     plan(strategy)
+ 
+     for (fun in names(truth)) {
+       for (stdout in c(FALSE, TRUE, NA)) {
+         message(sprintf("* future_%s(x, ..., future.stdout = %s) ...", fun, stdout))
+   
+         out <- utils::capture.output({
+           if (fun == "lapply") {
+             y <- future_lapply(1:0, FUN = function(x) {
+               Sys.sleep(x / 2)  ## make futures resolve out of order
+ 	      print(x)
+             }, future.stdout = stdout)
+ 	  } else if (fun == "mapply") {
+             y <- future_mapply(1:0, 0:1, FUN = function(x, y) {
+               Sys.sleep(x / 2)  ## make futures resolve out of order
+               print(list(x = x, y = y))
+             }, future.stdout = stdout)
+ 	  }
+         })
+         stopifnot(identical(y, truth[[fun]]$value))
+   
+         if (isTRUE(stdout)) {
+           stopifnot(identical(out, truth[[fun]]$stdout))
+         } else if (is.na(stdout)) {
+         } else {
+           stopifnot(nchar(out) == 0)
+         }
+       
+         message(sprintf("* future_%s(x, ..., future.stdout = %s) ... DONE", fun, stdout))
+       } ## for (stdout ...)
+     } ## for (fun ...)
+     
+     message(sprintf("* plan('%s') ... DONE", strategy))
+   }
+   
+   message(sprintf("  - Testing with %d cores ... DONE", cores))
+ }
  - Testing with 1 cores ...
* plan('sequential') ...
[15:32:56.948] plan(): Setting new future strategy stack:
[15:32:56.949] List of future strategies:
[15:32:56.949] 1. sequential:
[15:32:56.949]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:56.949]    - tweaked: FALSE
[15:32:56.949]    - call: plan(strategy)
[15:32:56.973] plan(): nbrOfWorkers() = 1
* future_lapply(x, ..., future.stdout = FALSE) ...
[15:32:56.974] future_lapply() ...
[15:32:56.980] Number of chunks: 1
[15:32:56.981] getGlobalsAndPackagesXApply() ...
[15:32:56.981]  - future.globals: TRUE
[15:32:56.982] getGlobalsAndPackages() ...
[15:32:56.983] Searching for globals...
[15:32:56.987] - globals found: [5] 'FUN', '{', 'Sys.sleep', '/', 'print'
[15:32:56.987] Searching for globals ... DONE
[15:32:56.987] Resolving globals: FALSE
[15:32:56.989] The total size of the 1 globals is 4.61 KiB (4720 bytes)
[15:32:56.990] The total size of the 1 globals exported for future expression ('FUN()') is 4.61 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.61 KiB of class 'function')
[15:32:56.990] - globals: [1] 'FUN'
[15:32:56.991] 
[15:32:56.991] getGlobalsAndPackages() ... DONE
[15:32:56.991]  - globals found/used: [n=1] 'FUN'
[15:32:56.991]  - needed namespaces: [n=0] 
[15:32:56.992] Finding globals ... DONE
[15:32:56.992]  - use_args: TRUE
[15:32:56.992]  - Getting '...' globals ...
[15:32:56.993] resolve() on list ...
[15:32:56.994]  recursive: 0
[15:32:56.994]  length: 1
[15:32:56.995]  elements: '...'
[15:32:56.995]  length: 0 (resolved future 1)
[15:32:56.995] resolve() on list ... DONE
[15:32:56.995]    - '...' content: [n=0] 
[15:32:56.996] List of 1
[15:32:56.996]  $ ...: list()
[15:32:56.996]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:56.996]  - attr(*, "where")=List of 1
[15:32:56.996]   ..$ ...:<environment: 0x0000027fbc878c30> 
[15:32:56.996]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:56.996]  - attr(*, "resolved")= logi TRUE
[15:32:56.996]  - attr(*, "total_size")= num NA
[15:32:57.005]  - Getting '...' globals ... DONE
[15:32:57.006] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:57.006] List of 2
[15:32:57.006]  $ ...future.FUN:function (x)  
[15:32:57.006]  $ ...          : list()
[15:32:57.006]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:57.006]  - attr(*, "where")=List of 2
[15:32:57.006]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:57.006]   ..$ ...          :<environment: 0x0000027fbc878c30> 
[15:32:57.006]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:57.006]  - attr(*, "resolved")= logi FALSE
[15:32:57.006]  - attr(*, "total_size")= num 4720
[15:32:57.011] Packages to be attached in all futures: [n=0] 
[15:32:57.011] getGlobalsAndPackagesXApply() ... DONE
[15:32:57.012] Number of futures (= number of chunks): 1
[15:32:57.012] Launching 1 futures (chunks) ...
[15:32:57.012] Chunk #1 of 1 ...
[15:32:57.013]  - Finding globals in 'X' for chunk #1 ...
[15:32:57.013] getGlobalsAndPackages() ...
[15:32:57.013] Searching for globals...
[15:32:57.014] 
[15:32:57.014] Searching for globals ... DONE
[15:32:57.015] - globals: [0] <none>
[15:32:57.015] getGlobalsAndPackages() ... DONE
[15:32:57.015]    + additional globals found: [n=0] 
[15:32:57.015]    + additional namespaces needed: [n=0] 
[15:32:57.016]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:57.016]  - seeds: <none>
[15:32:57.016]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:57.017] getGlobalsAndPackages() ...
[15:32:57.017] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:57.017] Resolving globals: FALSE
[15:32:57.018] Tweak future expression to call with '...' arguments ...
[15:32:57.018] {
[15:32:57.018]     do.call(function(...) {
[15:32:57.018]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:57.018]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:57.018]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:57.018]             on.exit(options(oopts), add = TRUE)
[15:32:57.018]         }
[15:32:57.018]         {
[15:32:57.018]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:57.018]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:57.018]                 ...future.FUN(...future.X_jj, ...)
[15:32:57.018]             })
[15:32:57.018]         }
[15:32:57.018]     }, args = future.call.arguments)
[15:32:57.018] }
[15:32:57.019] Tweak future expression to call with '...' arguments ... DONE
[15:32:57.020] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:57.020] 
[15:32:57.020] getGlobalsAndPackages() ... DONE
[15:32:57.026] run() for 'Future' ...
[15:32:57.027] - state: 'created'
[15:32:57.027] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:57.028] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:57.028] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:57.029]   - Field: 'label'
[15:32:57.029]   - Field: 'local'
[15:32:57.029]   - Field: 'owner'
[15:32:57.030]   - Field: 'envir'
[15:32:57.030]   - Field: 'packages'
[15:32:57.030]   - Field: 'gc'
[15:32:57.031]   - Field: 'conditions'
[15:32:57.031]   - Field: 'expr'
[15:32:57.031]   - Field: 'uuid'
[15:32:57.032]   - Field: 'seed'
[15:32:57.032]   - Field: 'version'
[15:32:57.032]   - Field: 'result'
[15:32:57.033]   - Field: 'asynchronous'
[15:32:57.033]   - Field: 'calls'
[15:32:57.033]   - Field: 'globals'
[15:32:57.033]   - Field: 'stdout'
[15:32:57.033]   - Field: 'earlySignal'
[15:32:57.034]   - Field: 'lazy'
[15:32:57.034]   - Field: 'state'
[15:32:57.034] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:57.034] - Launch lazy future ...
[15:32:57.035] Packages needed by the future expression (n = 0): <none>
[15:32:57.035] Packages needed by future strategies (n = 0): <none>
[15:32:57.036] {
[15:32:57.036]     {
[15:32:57.036]         {
[15:32:57.036]             ...future.startTime <- base::Sys.time()
[15:32:57.036]             {
[15:32:57.036]                 {
[15:32:57.036]                   {
[15:32:57.036]                     base::local({
[15:32:57.036]                       has_future <- base::requireNamespace("future", 
[15:32:57.036]                         quietly = TRUE)
[15:32:57.036]                       if (has_future) {
[15:32:57.036]                         ns <- base::getNamespace("future")
[15:32:57.036]                         version <- ns[[".package"]][["version"]]
[15:32:57.036]                         if (is.null(version)) 
[15:32:57.036]                           version <- utils::packageVersion("future")
[15:32:57.036]                       }
[15:32:57.036]                       else {
[15:32:57.036]                         version <- NULL
[15:32:57.036]                       }
[15:32:57.036]                       if (!has_future || version < "1.8.0") {
[15:32:57.036]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:57.036]                           "", base::R.version$version.string), 
[15:32:57.036]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:57.036]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:57.036]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:57.036]                             "release", "version")], collapse = " "), 
[15:32:57.036]                           hostname = base::Sys.info()[["nodename"]])
[15:32:57.036]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:57.036]                           info)
[15:32:57.036]                         info <- base::paste(info, collapse = "; ")
[15:32:57.036]                         if (!has_future) {
[15:32:57.036]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:57.036]                             info)
[15:32:57.036]                         }
[15:32:57.036]                         else {
[15:32:57.036]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:57.036]                             info, version)
[15:32:57.036]                         }
[15:32:57.036]                         base::stop(msg)
[15:32:57.036]                       }
[15:32:57.036]                     })
[15:32:57.036]                   }
[15:32:57.036]                   ...future.strategy.old <- future::plan("list")
[15:32:57.036]                   options(future.plan = NULL)
[15:32:57.036]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:57.036]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:57.036]                 }
[15:32:57.036]                 ...future.workdir <- getwd()
[15:32:57.036]             }
[15:32:57.036]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:57.036]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:57.036]         }
[15:32:57.036]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:57.036]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:57.036]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:57.036]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:57.036]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:57.036]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:57.036]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:57.036]             base::names(...future.oldOptions))
[15:32:57.036]     }
[15:32:57.036]     if (FALSE) {
[15:32:57.036]     }
[15:32:57.036]     else {
[15:32:57.036]         if (FALSE) {
[15:32:57.036]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:57.036]                 open = "w")
[15:32:57.036]         }
[15:32:57.036]         else {
[15:32:57.036]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:57.036]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:57.036]         }
[15:32:57.036]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:57.036]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:57.036]             base::sink(type = "output", split = FALSE)
[15:32:57.036]             base::close(...future.stdout)
[15:32:57.036]         }, add = TRUE)
[15:32:57.036]     }
[15:32:57.036]     ...future.frame <- base::sys.nframe()
[15:32:57.036]     ...future.conditions <- base::list()
[15:32:57.036]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:57.036]     if (FALSE) {
[15:32:57.036]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:57.036]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:57.036]     }
[15:32:57.036]     ...future.result <- base::tryCatch({
[15:32:57.036]         base::withCallingHandlers({
[15:32:57.036]             ...future.value <- base::withVisible(base::local({
[15:32:57.036]                 do.call(function(...) {
[15:32:57.036]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:57.036]                   if (!identical(...future.globals.maxSize.org, 
[15:32:57.036]                     ...future.globals.maxSize)) {
[15:32:57.036]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:57.036]                     on.exit(options(oopts), add = TRUE)
[15:32:57.036]                   }
[15:32:57.036]                   {
[15:32:57.036]                     lapply(seq_along(...future.elements_ii), 
[15:32:57.036]                       FUN = function(jj) {
[15:32:57.036]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:57.036]                         ...future.FUN(...future.X_jj, ...)
[15:32:57.036]                       })
[15:32:57.036]                   }
[15:32:57.036]                 }, args = future.call.arguments)
[15:32:57.036]             }))
[15:32:57.036]             future::FutureResult(value = ...future.value$value, 
[15:32:57.036]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:57.036]                   ...future.rng), globalenv = if (FALSE) 
[15:32:57.036]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:57.036]                     ...future.globalenv.names))
[15:32:57.036]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:57.036]         }, condition = base::local({
[15:32:57.036]             c <- base::c
[15:32:57.036]             inherits <- base::inherits
[15:32:57.036]             invokeRestart <- base::invokeRestart
[15:32:57.036]             length <- base::length
[15:32:57.036]             list <- base::list
[15:32:57.036]             seq.int <- base::seq.int
[15:32:57.036]             signalCondition <- base::signalCondition
[15:32:57.036]             sys.calls <- base::sys.calls
[15:32:57.036]             `[[` <- base::`[[`
[15:32:57.036]             `+` <- base::`+`
[15:32:57.036]             `<<-` <- base::`<<-`
[15:32:57.036]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:57.036]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:57.036]                   3L)]
[15:32:57.036]             }
[15:32:57.036]             function(cond) {
[15:32:57.036]                 is_error <- inherits(cond, "error")
[15:32:57.036]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:57.036]                   NULL)
[15:32:57.036]                 if (is_error) {
[15:32:57.036]                   sessionInformation <- function() {
[15:32:57.036]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:57.036]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:57.036]                       search = base::search(), system = base::Sys.info())
[15:32:57.036]                   }
[15:32:57.036]                   ...future.conditions[[length(...future.conditions) + 
[15:32:57.036]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:57.036]                     cond$call), session = sessionInformation(), 
[15:32:57.036]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:57.036]                   signalCondition(cond)
[15:32:57.036]                 }
[15:32:57.036]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:57.036]                 "immediateCondition"))) {
[15:32:57.036]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:57.036]                   ...future.conditions[[length(...future.conditions) + 
[15:32:57.036]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:57.036]                   if (TRUE && !signal) {
[15:32:57.036]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:57.036]                     {
[15:32:57.036]                       inherits <- base::inherits
[15:32:57.036]                       invokeRestart <- base::invokeRestart
[15:32:57.036]                       is.null <- base::is.null
[15:32:57.036]                       muffled <- FALSE
[15:32:57.036]                       if (inherits(cond, "message")) {
[15:32:57.036]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:57.036]                         if (muffled) 
[15:32:57.036]                           invokeRestart("muffleMessage")
[15:32:57.036]                       }
[15:32:57.036]                       else if (inherits(cond, "warning")) {
[15:32:57.036]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:57.036]                         if (muffled) 
[15:32:57.036]                           invokeRestart("muffleWarning")
[15:32:57.036]                       }
[15:32:57.036]                       else if (inherits(cond, "condition")) {
[15:32:57.036]                         if (!is.null(pattern)) {
[15:32:57.036]                           computeRestarts <- base::computeRestarts
[15:32:57.036]                           grepl <- base::grepl
[15:32:57.036]                           restarts <- computeRestarts(cond)
[15:32:57.036]                           for (restart in restarts) {
[15:32:57.036]                             name <- restart$name
[15:32:57.036]                             if (is.null(name)) 
[15:32:57.036]                               next
[15:32:57.036]                             if (!grepl(pattern, name)) 
[15:32:57.036]                               next
[15:32:57.036]                             invokeRestart(restart)
[15:32:57.036]                             muffled <- TRUE
[15:32:57.036]                             break
[15:32:57.036]                           }
[15:32:57.036]                         }
[15:32:57.036]                       }
[15:32:57.036]                       invisible(muffled)
[15:32:57.036]                     }
[15:32:57.036]                     muffleCondition(cond, pattern = "^muffle")
[15:32:57.036]                   }
[15:32:57.036]                 }
[15:32:57.036]                 else {
[15:32:57.036]                   if (TRUE) {
[15:32:57.036]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:57.036]                     {
[15:32:57.036]                       inherits <- base::inherits
[15:32:57.036]                       invokeRestart <- base::invokeRestart
[15:32:57.036]                       is.null <- base::is.null
[15:32:57.036]                       muffled <- FALSE
[15:32:57.036]                       if (inherits(cond, "message")) {
[15:32:57.036]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:57.036]                         if (muffled) 
[15:32:57.036]                           invokeRestart("muffleMessage")
[15:32:57.036]                       }
[15:32:57.036]                       else if (inherits(cond, "warning")) {
[15:32:57.036]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:57.036]                         if (muffled) 
[15:32:57.036]                           invokeRestart("muffleWarning")
[15:32:57.036]                       }
[15:32:57.036]                       else if (inherits(cond, "condition")) {
[15:32:57.036]                         if (!is.null(pattern)) {
[15:32:57.036]                           computeRestarts <- base::computeRestarts
[15:32:57.036]                           grepl <- base::grepl
[15:32:57.036]                           restarts <- computeRestarts(cond)
[15:32:57.036]                           for (restart in restarts) {
[15:32:57.036]                             name <- restart$name
[15:32:57.036]                             if (is.null(name)) 
[15:32:57.036]                               next
[15:32:57.036]                             if (!grepl(pattern, name)) 
[15:32:57.036]                               next
[15:32:57.036]                             invokeRestart(restart)
[15:32:57.036]                             muffled <- TRUE
[15:32:57.036]                             break
[15:32:57.036]                           }
[15:32:57.036]                         }
[15:32:57.036]                       }
[15:32:57.036]                       invisible(muffled)
[15:32:57.036]                     }
[15:32:57.036]                     muffleCondition(cond, pattern = "^muffle")
[15:32:57.036]                   }
[15:32:57.036]                 }
[15:32:57.036]             }
[15:32:57.036]         }))
[15:32:57.036]     }, error = function(ex) {
[15:32:57.036]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:57.036]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:57.036]                 ...future.rng), started = ...future.startTime, 
[15:32:57.036]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:57.036]             version = "1.8"), class = "FutureResult")
[15:32:57.036]     }, finally = {
[15:32:57.036]         if (!identical(...future.workdir, getwd())) 
[15:32:57.036]             setwd(...future.workdir)
[15:32:57.036]         {
[15:32:57.036]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:57.036]                 ...future.oldOptions$nwarnings <- NULL
[15:32:57.036]             }
[15:32:57.036]             base::options(...future.oldOptions)
[15:32:57.036]             if (.Platform$OS.type == "windows") {
[15:32:57.036]                 old_names <- names(...future.oldEnvVars)
[15:32:57.036]                 envs <- base::Sys.getenv()
[15:32:57.036]                 names <- names(envs)
[15:32:57.036]                 common <- intersect(names, old_names)
[15:32:57.036]                 added <- setdiff(names, old_names)
[15:32:57.036]                 removed <- setdiff(old_names, names)
[15:32:57.036]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:57.036]                   envs[common]]
[15:32:57.036]                 NAMES <- toupper(changed)
[15:32:57.036]                 args <- list()
[15:32:57.036]                 for (kk in seq_along(NAMES)) {
[15:32:57.036]                   name <- changed[[kk]]
[15:32:57.036]                   NAME <- NAMES[[kk]]
[15:32:57.036]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:57.036]                     next
[15:32:57.036]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:57.036]                 }
[15:32:57.036]                 NAMES <- toupper(added)
[15:32:57.036]                 for (kk in seq_along(NAMES)) {
[15:32:57.036]                   name <- added[[kk]]
[15:32:57.036]                   NAME <- NAMES[[kk]]
[15:32:57.036]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:57.036]                     next
[15:32:57.036]                   args[[name]] <- ""
[15:32:57.036]                 }
[15:32:57.036]                 NAMES <- toupper(removed)
[15:32:57.036]                 for (kk in seq_along(NAMES)) {
[15:32:57.036]                   name <- removed[[kk]]
[15:32:57.036]                   NAME <- NAMES[[kk]]
[15:32:57.036]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:57.036]                     next
[15:32:57.036]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:57.036]                 }
[15:32:57.036]                 if (length(args) > 0) 
[15:32:57.036]                   base::do.call(base::Sys.setenv, args = args)
[15:32:57.036]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:57.036]             }
[15:32:57.036]             else {
[15:32:57.036]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:57.036]             }
[15:32:57.036]             {
[15:32:57.036]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:57.036]                   0L) {
[15:32:57.036]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:57.036]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:57.036]                   base::options(opts)
[15:32:57.036]                 }
[15:32:57.036]                 {
[15:32:57.036]                   {
[15:32:57.036]                     NULL
[15:32:57.036]                     RNGkind("Mersenne-Twister")
[15:32:57.036]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:57.036]                       inherits = FALSE)
[15:32:57.036]                   }
[15:32:57.036]                   options(future.plan = NULL)
[15:32:57.036]                   if (is.na(NA_character_)) 
[15:32:57.036]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:57.036]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:57.036]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:57.036]                     .init = FALSE)
[15:32:57.036]                 }
[15:32:57.036]             }
[15:32:57.036]         }
[15:32:57.036]     })
[15:32:57.036]     if (TRUE) {
[15:32:57.036]         base::sink(type = "output", split = FALSE)
[15:32:57.036]         if (FALSE) {
[15:32:57.036]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:57.036]         }
[15:32:57.036]         else {
[15:32:57.036]             ...future.result["stdout"] <- base::list(NULL)
[15:32:57.036]         }
[15:32:57.036]         base::close(...future.stdout)
[15:32:57.036]         ...future.stdout <- NULL
[15:32:57.036]     }
[15:32:57.036]     ...future.result$conditions <- ...future.conditions
[15:32:57.036]     ...future.result$finished <- base::Sys.time()
[15:32:57.036]     ...future.result
[15:32:57.036] }
[15:32:57.041] assign_globals() ...
[15:32:57.041] List of 5
[15:32:57.041]  $ ...future.FUN            :function (x)  
[15:32:57.041]  $ future.call.arguments    : list()
[15:32:57.041]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:57.041]  $ ...future.elements_ii    :List of 2
[15:32:57.041]   ..$ : int 1
[15:32:57.041]   ..$ : int 0
[15:32:57.041]  $ ...future.seeds_ii       : NULL
[15:32:57.041]  $ ...future.globals.maxSize: NULL
[15:32:57.041]  - attr(*, "where")=List of 5
[15:32:57.041]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:57.041]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:57.041]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:57.041]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:57.041]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:57.041]  - attr(*, "resolved")= logi FALSE
[15:32:57.041]  - attr(*, "total_size")= num 4720
[15:32:57.041]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:57.041]  - attr(*, "already-done")= logi TRUE
[15:32:57.051] - reassign environment for '...future.FUN'
[15:32:57.051] - copied '...future.FUN' to environment
[15:32:57.051] - copied 'future.call.arguments' to environment
[15:32:57.052] - copied '...future.elements_ii' to environment
[15:32:57.052] - copied '...future.seeds_ii' to environment
[15:32:57.052] - copied '...future.globals.maxSize' to environment
[15:32:57.052] assign_globals() ... done
[15:32:57.053] plan(): Setting new future strategy stack:
[15:32:57.053] List of future strategies:
[15:32:57.053] 1. sequential:
[15:32:57.053]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:57.053]    - tweaked: FALSE
[15:32:57.053]    - call: NULL
[15:32:57.054] plan(): nbrOfWorkers() = 1
[15:32:57.566] plan(): Setting new future strategy stack:
[15:32:57.566] List of future strategies:
[15:32:57.566] 1. sequential:
[15:32:57.566]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:57.566]    - tweaked: FALSE
[15:32:57.566]    - call: plan(strategy)
[15:32:57.568] plan(): nbrOfWorkers() = 1
[15:32:57.569] SequentialFuture started (and completed)
[15:32:57.570] - Launch lazy future ... done
[15:32:57.570] run() for 'SequentialFuture' ... done
[15:32:57.571] Created future:
[15:32:57.571] SequentialFuture:
[15:32:57.571] Label: 'future_lapply-1'
[15:32:57.571] Expression:
[15:32:57.571] {
[15:32:57.571]     do.call(function(...) {
[15:32:57.571]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:57.571]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:57.571]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:57.571]             on.exit(options(oopts), add = TRUE)
[15:32:57.571]         }
[15:32:57.571]         {
[15:32:57.571]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:57.571]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:57.571]                 ...future.FUN(...future.X_jj, ...)
[15:32:57.571]             })
[15:32:57.571]         }
[15:32:57.571]     }, args = future.call.arguments)
[15:32:57.571] }
[15:32:57.571] Lazy evaluation: FALSE
[15:32:57.571] Asynchronous evaluation: FALSE
[15:32:57.571] Local evaluation: TRUE
[15:32:57.571] Environment: R_GlobalEnv
[15:32:57.571] Capture standard output: FALSE
[15:32:57.571] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:57.571] Globals: 5 objects totaling 4.72 KiB (function '...future.FUN' of 4.61 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 112 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:57.571] Packages: <none>
[15:32:57.571] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:57.571] Resolved: TRUE
[15:32:57.571] Value: 112 bytes of class 'list'
[15:32:57.571] Early signaling: FALSE
[15:32:57.571] Owner process: bdd4bc13-919d-bf34-b2cf-84eb53f6e11f
[15:32:57.571] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:57.576] Chunk #1 of 1 ... DONE
[15:32:57.576] Launching 1 futures (chunks) ... DONE
[15:32:57.577] Resolving 1 futures (chunks) ...
[15:32:57.577] resolve() on list ...
[15:32:57.578]  recursive: 0
[15:32:57.578]  length: 1
[15:32:57.578] 
[15:32:57.579] resolved() for 'SequentialFuture' ...
[15:32:57.579] - state: 'finished'
[15:32:57.580] - run: TRUE
[15:32:57.580] - result: 'FutureResult'
[15:32:57.581] resolved() for 'SequentialFuture' ... done
[15:32:57.581] Future #1
[15:32:57.582] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:57.582] - nx: 1
[15:32:57.583] - relay: TRUE
[15:32:57.583] - stdout: TRUE
[15:32:57.584] - signal: TRUE
[15:32:57.584] - resignal: FALSE
[15:32:57.584] - force: TRUE
[15:32:57.585] - relayed: [n=1] FALSE
[15:32:57.585] - queued futures: [n=1] FALSE
[15:32:57.585]  - until=1
[15:32:57.586]  - relaying element #1
[15:32:57.586] - relayed: [n=1] TRUE
[15:32:57.587] - queued futures: [n=1] TRUE
[15:32:57.587] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:57.588]  length: 0 (resolved future 1)
[15:32:57.588] Relaying remaining futures
[15:32:57.588] signalConditionsASAP(NULL, pos=0) ...
[15:32:57.589] - nx: 1
[15:32:57.589] - relay: TRUE
[15:32:57.589] - stdout: TRUE
[15:32:57.589] - signal: TRUE
[15:32:57.590] - resignal: FALSE
[15:32:57.590] - force: TRUE
[15:32:57.590] - relayed: [n=1] TRUE
[15:32:57.591] - queued futures: [n=1] TRUE
 - flush all
[15:32:57.591] - relayed: [n=1] TRUE
[15:32:57.591] - queued futures: [n=1] TRUE
[15:32:57.592] signalConditionsASAP(NULL, pos=0) ... done
[15:32:57.592] resolve() on list ... DONE
[15:32:57.592]  - Number of value chunks collected: 1
[15:32:57.592] Resolving 1 futures (chunks) ... DONE
[15:32:57.593] Reducing values from 1 chunks ...
[15:32:57.593]  - Number of values collected after concatenation: 2
[15:32:57.593]  - Number of values expected: 2
[15:32:57.594] Reducing values from 1 chunks ... DONE
[15:32:57.594] future_lapply() ... DONE
* future_lapply(x, ..., future.stdout = FALSE) ... DONE
* future_lapply(x, ..., future.stdout = TRUE) ...
[15:32:57.595] future_lapply() ...
[15:32:57.600] Number of chunks: 1
[15:32:57.600] getGlobalsAndPackagesXApply() ...
[15:32:57.601]  - future.globals: TRUE
[15:32:57.601] getGlobalsAndPackages() ...
[15:32:57.601] Searching for globals...
[15:32:57.603] - globals found: [5] 'FUN', '{', 'Sys.sleep', '/', 'print'
[15:32:57.604] Searching for globals ... DONE
[15:32:57.604] Resolving globals: FALSE
[15:32:57.605] The total size of the 1 globals is 4.61 KiB (4720 bytes)
[15:32:57.606] The total size of the 1 globals exported for future expression ('FUN()') is 4.61 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.61 KiB of class 'function')
[15:32:57.607] - globals: [1] 'FUN'
[15:32:57.607] 
[15:32:57.608] getGlobalsAndPackages() ... DONE
[15:32:57.608]  - globals found/used: [n=1] 'FUN'
[15:32:57.608]  - needed namespaces: [n=0] 
[15:32:57.609] Finding globals ... DONE
[15:32:57.609]  - use_args: TRUE
[15:32:57.609]  - Getting '...' globals ...
[15:32:57.610] resolve() on list ...
[15:32:57.611]  recursive: 0
[15:32:57.611]  length: 1
[15:32:57.611]  elements: '...'
[15:32:57.612]  length: 0 (resolved future 1)
[15:32:57.612] resolve() on list ... DONE
[15:32:57.612]    - '...' content: [n=0] 
[15:32:57.612] List of 1
[15:32:57.612]  $ ...: list()
[15:32:57.612]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:57.612]  - attr(*, "where")=List of 1
[15:32:57.612]   ..$ ...:<environment: 0x0000027fc0587e28> 
[15:32:57.612]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:57.612]  - attr(*, "resolved")= logi TRUE
[15:32:57.612]  - attr(*, "total_size")= num NA
[15:32:57.618]  - Getting '...' globals ... DONE
[15:32:57.619] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:57.619] List of 2
[15:32:57.619]  $ ...future.FUN:function (x)  
[15:32:57.619]  $ ...          : list()
[15:32:57.619]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:57.619]  - attr(*, "where")=List of 2
[15:32:57.619]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:57.619]   ..$ ...          :<environment: 0x0000027fc0587e28> 
[15:32:57.619]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:57.619]  - attr(*, "resolved")= logi FALSE
[15:32:57.619]  - attr(*, "total_size")= num 4720
[15:32:57.625] Packages to be attached in all futures: [n=0] 
[15:32:57.626] getGlobalsAndPackagesXApply() ... DONE
[15:32:57.626] Number of futures (= number of chunks): 1
[15:32:57.627] Launching 1 futures (chunks) ...
[15:32:57.627] Chunk #1 of 1 ...
[15:32:57.627]  - Finding globals in 'X' for chunk #1 ...
[15:32:57.628] getGlobalsAndPackages() ...
[15:32:57.628] Searching for globals...
[15:32:57.629] 
[15:32:57.629] Searching for globals ... DONE
[15:32:57.629] - globals: [0] <none>
[15:32:57.630] getGlobalsAndPackages() ... DONE
[15:32:57.630]    + additional globals found: [n=0] 
[15:32:57.630]    + additional namespaces needed: [n=0] 
[15:32:57.630]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:57.631]  - seeds: <none>
[15:32:57.631]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:57.631] getGlobalsAndPackages() ...
[15:32:57.632] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:57.632] Resolving globals: FALSE
[15:32:57.632] Tweak future expression to call with '...' arguments ...
[15:32:57.633] {
[15:32:57.633]     do.call(function(...) {
[15:32:57.633]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:57.633]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:57.633]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:57.633]             on.exit(options(oopts), add = TRUE)
[15:32:57.633]         }
[15:32:57.633]         {
[15:32:57.633]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:57.633]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:57.633]                 ...future.FUN(...future.X_jj, ...)
[15:32:57.633]             })
[15:32:57.633]         }
[15:32:57.633]     }, args = future.call.arguments)
[15:32:57.633] }
[15:32:57.633] Tweak future expression to call with '...' arguments ... DONE
[15:32:57.634] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:57.635] 
[15:32:57.635] getGlobalsAndPackages() ... DONE
[15:32:57.636] run() for 'Future' ...
[15:32:57.636] - state: 'created'
[15:32:57.637] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:57.637] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:57.638] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:57.638]   - Field: 'label'
[15:32:57.638]   - Field: 'local'
[15:32:57.639]   - Field: 'owner'
[15:32:57.639]   - Field: 'envir'
[15:32:57.639]   - Field: 'packages'
[15:32:57.640]   - Field: 'gc'
[15:32:57.640]   - Field: 'conditions'
[15:32:57.640]   - Field: 'expr'
[15:32:57.641]   - Field: 'uuid'
[15:32:57.641]   - Field: 'seed'
[15:32:57.641]   - Field: 'version'
[15:32:57.642]   - Field: 'result'
[15:32:57.642]   - Field: 'asynchronous'
[15:32:57.642]   - Field: 'calls'
[15:32:57.643]   - Field: 'globals'
[15:32:57.643]   - Field: 'stdout'
[15:32:57.643]   - Field: 'earlySignal'
[15:32:57.644]   - Field: 'lazy'
[15:32:57.644]   - Field: 'state'
[15:32:57.644] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:57.645] - Launch lazy future ...
[15:32:57.645] Packages needed by the future expression (n = 0): <none>
[15:32:57.646] Packages needed by future strategies (n = 0): <none>
[15:32:57.647] {
[15:32:57.647]     {
[15:32:57.647]         {
[15:32:57.647]             ...future.startTime <- base::Sys.time()
[15:32:57.647]             {
[15:32:57.647]                 {
[15:32:57.647]                   {
[15:32:57.647]                     base::local({
[15:32:57.647]                       has_future <- base::requireNamespace("future", 
[15:32:57.647]                         quietly = TRUE)
[15:32:57.647]                       if (has_future) {
[15:32:57.647]                         ns <- base::getNamespace("future")
[15:32:57.647]                         version <- ns[[".package"]][["version"]]
[15:32:57.647]                         if (is.null(version)) 
[15:32:57.647]                           version <- utils::packageVersion("future")
[15:32:57.647]                       }
[15:32:57.647]                       else {
[15:32:57.647]                         version <- NULL
[15:32:57.647]                       }
[15:32:57.647]                       if (!has_future || version < "1.8.0") {
[15:32:57.647]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:57.647]                           "", base::R.version$version.string), 
[15:32:57.647]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:57.647]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:57.647]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:57.647]                             "release", "version")], collapse = " "), 
[15:32:57.647]                           hostname = base::Sys.info()[["nodename"]])
[15:32:57.647]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:57.647]                           info)
[15:32:57.647]                         info <- base::paste(info, collapse = "; ")
[15:32:57.647]                         if (!has_future) {
[15:32:57.647]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:57.647]                             info)
[15:32:57.647]                         }
[15:32:57.647]                         else {
[15:32:57.647]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:57.647]                             info, version)
[15:32:57.647]                         }
[15:32:57.647]                         base::stop(msg)
[15:32:57.647]                       }
[15:32:57.647]                     })
[15:32:57.647]                   }
[15:32:57.647]                   ...future.strategy.old <- future::plan("list")
[15:32:57.647]                   options(future.plan = NULL)
[15:32:57.647]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:57.647]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:57.647]                 }
[15:32:57.647]                 ...future.workdir <- getwd()
[15:32:57.647]             }
[15:32:57.647]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:57.647]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:57.647]         }
[15:32:57.647]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:57.647]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:57.647]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:57.647]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:57.647]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:57.647]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:57.647]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:57.647]             base::names(...future.oldOptions))
[15:32:57.647]     }
[15:32:57.647]     if (FALSE) {
[15:32:57.647]     }
[15:32:57.647]     else {
[15:32:57.647]         if (TRUE) {
[15:32:57.647]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:57.647]                 open = "w")
[15:32:57.647]         }
[15:32:57.647]         else {
[15:32:57.647]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:57.647]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:57.647]         }
[15:32:57.647]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:57.647]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:57.647]             base::sink(type = "output", split = FALSE)
[15:32:57.647]             base::close(...future.stdout)
[15:32:57.647]         }, add = TRUE)
[15:32:57.647]     }
[15:32:57.647]     ...future.frame <- base::sys.nframe()
[15:32:57.647]     ...future.conditions <- base::list()
[15:32:57.647]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:57.647]     if (FALSE) {
[15:32:57.647]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:57.647]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:57.647]     }
[15:32:57.647]     ...future.result <- base::tryCatch({
[15:32:57.647]         base::withCallingHandlers({
[15:32:57.647]             ...future.value <- base::withVisible(base::local({
[15:32:57.647]                 do.call(function(...) {
[15:32:57.647]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:57.647]                   if (!identical(...future.globals.maxSize.org, 
[15:32:57.647]                     ...future.globals.maxSize)) {
[15:32:57.647]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:57.647]                     on.exit(options(oopts), add = TRUE)
[15:32:57.647]                   }
[15:32:57.647]                   {
[15:32:57.647]                     lapply(seq_along(...future.elements_ii), 
[15:32:57.647]                       FUN = function(jj) {
[15:32:57.647]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:57.647]                         ...future.FUN(...future.X_jj, ...)
[15:32:57.647]                       })
[15:32:57.647]                   }
[15:32:57.647]                 }, args = future.call.arguments)
[15:32:57.647]             }))
[15:32:57.647]             future::FutureResult(value = ...future.value$value, 
[15:32:57.647]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:57.647]                   ...future.rng), globalenv = if (FALSE) 
[15:32:57.647]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:57.647]                     ...future.globalenv.names))
[15:32:57.647]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:57.647]         }, condition = base::local({
[15:32:57.647]             c <- base::c
[15:32:57.647]             inherits <- base::inherits
[15:32:57.647]             invokeRestart <- base::invokeRestart
[15:32:57.647]             length <- base::length
[15:32:57.647]             list <- base::list
[15:32:57.647]             seq.int <- base::seq.int
[15:32:57.647]             signalCondition <- base::signalCondition
[15:32:57.647]             sys.calls <- base::sys.calls
[15:32:57.647]             `[[` <- base::`[[`
[15:32:57.647]             `+` <- base::`+`
[15:32:57.647]             `<<-` <- base::`<<-`
[15:32:57.647]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:57.647]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:57.647]                   3L)]
[15:32:57.647]             }
[15:32:57.647]             function(cond) {
[15:32:57.647]                 is_error <- inherits(cond, "error")
[15:32:57.647]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:57.647]                   NULL)
[15:32:57.647]                 if (is_error) {
[15:32:57.647]                   sessionInformation <- function() {
[15:32:57.647]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:57.647]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:57.647]                       search = base::search(), system = base::Sys.info())
[15:32:57.647]                   }
[15:32:57.647]                   ...future.conditions[[length(...future.conditions) + 
[15:32:57.647]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:57.647]                     cond$call), session = sessionInformation(), 
[15:32:57.647]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:57.647]                   signalCondition(cond)
[15:32:57.647]                 }
[15:32:57.647]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:57.647]                 "immediateCondition"))) {
[15:32:57.647]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:57.647]                   ...future.conditions[[length(...future.conditions) + 
[15:32:57.647]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:57.647]                   if (TRUE && !signal) {
[15:32:57.647]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:57.647]                     {
[15:32:57.647]                       inherits <- base::inherits
[15:32:57.647]                       invokeRestart <- base::invokeRestart
[15:32:57.647]                       is.null <- base::is.null
[15:32:57.647]                       muffled <- FALSE
[15:32:57.647]                       if (inherits(cond, "message")) {
[15:32:57.647]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:57.647]                         if (muffled) 
[15:32:57.647]                           invokeRestart("muffleMessage")
[15:32:57.647]                       }
[15:32:57.647]                       else if (inherits(cond, "warning")) {
[15:32:57.647]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:57.647]                         if (muffled) 
[15:32:57.647]                           invokeRestart("muffleWarning")
[15:32:57.647]                       }
[15:32:57.647]                       else if (inherits(cond, "condition")) {
[15:32:57.647]                         if (!is.null(pattern)) {
[15:32:57.647]                           computeRestarts <- base::computeRestarts
[15:32:57.647]                           grepl <- base::grepl
[15:32:57.647]                           restarts <- computeRestarts(cond)
[15:32:57.647]                           for (restart in restarts) {
[15:32:57.647]                             name <- restart$name
[15:32:57.647]                             if (is.null(name)) 
[15:32:57.647]                               next
[15:32:57.647]                             if (!grepl(pattern, name)) 
[15:32:57.647]                               next
[15:32:57.647]                             invokeRestart(restart)
[15:32:57.647]                             muffled <- TRUE
[15:32:57.647]                             break
[15:32:57.647]                           }
[15:32:57.647]                         }
[15:32:57.647]                       }
[15:32:57.647]                       invisible(muffled)
[15:32:57.647]                     }
[15:32:57.647]                     muffleCondition(cond, pattern = "^muffle")
[15:32:57.647]                   }
[15:32:57.647]                 }
[15:32:57.647]                 else {
[15:32:57.647]                   if (TRUE) {
[15:32:57.647]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:57.647]                     {
[15:32:57.647]                       inherits <- base::inherits
[15:32:57.647]                       invokeRestart <- base::invokeRestart
[15:32:57.647]                       is.null <- base::is.null
[15:32:57.647]                       muffled <- FALSE
[15:32:57.647]                       if (inherits(cond, "message")) {
[15:32:57.647]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:57.647]                         if (muffled) 
[15:32:57.647]                           invokeRestart("muffleMessage")
[15:32:57.647]                       }
[15:32:57.647]                       else if (inherits(cond, "warning")) {
[15:32:57.647]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:57.647]                         if (muffled) 
[15:32:57.647]                           invokeRestart("muffleWarning")
[15:32:57.647]                       }
[15:32:57.647]                       else if (inherits(cond, "condition")) {
[15:32:57.647]                         if (!is.null(pattern)) {
[15:32:57.647]                           computeRestarts <- base::computeRestarts
[15:32:57.647]                           grepl <- base::grepl
[15:32:57.647]                           restarts <- computeRestarts(cond)
[15:32:57.647]                           for (restart in restarts) {
[15:32:57.647]                             name <- restart$name
[15:32:57.647]                             if (is.null(name)) 
[15:32:57.647]                               next
[15:32:57.647]                             if (!grepl(pattern, name)) 
[15:32:57.647]                               next
[15:32:57.647]                             invokeRestart(restart)
[15:32:57.647]                             muffled <- TRUE
[15:32:57.647]                             break
[15:32:57.647]                           }
[15:32:57.647]                         }
[15:32:57.647]                       }
[15:32:57.647]                       invisible(muffled)
[15:32:57.647]                     }
[15:32:57.647]                     muffleCondition(cond, pattern = "^muffle")
[15:32:57.647]                   }
[15:32:57.647]                 }
[15:32:57.647]             }
[15:32:57.647]         }))
[15:32:57.647]     }, error = function(ex) {
[15:32:57.647]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:57.647]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:57.647]                 ...future.rng), started = ...future.startTime, 
[15:32:57.647]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:57.647]             version = "1.8"), class = "FutureResult")
[15:32:57.647]     }, finally = {
[15:32:57.647]         if (!identical(...future.workdir, getwd())) 
[15:32:57.647]             setwd(...future.workdir)
[15:32:57.647]         {
[15:32:57.647]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:57.647]                 ...future.oldOptions$nwarnings <- NULL
[15:32:57.647]             }
[15:32:57.647]             base::options(...future.oldOptions)
[15:32:57.647]             if (.Platform$OS.type == "windows") {
[15:32:57.647]                 old_names <- names(...future.oldEnvVars)
[15:32:57.647]                 envs <- base::Sys.getenv()
[15:32:57.647]                 names <- names(envs)
[15:32:57.647]                 common <- intersect(names, old_names)
[15:32:57.647]                 added <- setdiff(names, old_names)
[15:32:57.647]                 removed <- setdiff(old_names, names)
[15:32:57.647]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:57.647]                   envs[common]]
[15:32:57.647]                 NAMES <- toupper(changed)
[15:32:57.647]                 args <- list()
[15:32:57.647]                 for (kk in seq_along(NAMES)) {
[15:32:57.647]                   name <- changed[[kk]]
[15:32:57.647]                   NAME <- NAMES[[kk]]
[15:32:57.647]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:57.647]                     next
[15:32:57.647]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:57.647]                 }
[15:32:57.647]                 NAMES <- toupper(added)
[15:32:57.647]                 for (kk in seq_along(NAMES)) {
[15:32:57.647]                   name <- added[[kk]]
[15:32:57.647]                   NAME <- NAMES[[kk]]
[15:32:57.647]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:57.647]                     next
[15:32:57.647]                   args[[name]] <- ""
[15:32:57.647]                 }
[15:32:57.647]                 NAMES <- toupper(removed)
[15:32:57.647]                 for (kk in seq_along(NAMES)) {
[15:32:57.647]                   name <- removed[[kk]]
[15:32:57.647]                   NAME <- NAMES[[kk]]
[15:32:57.647]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:57.647]                     next
[15:32:57.647]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:57.647]                 }
[15:32:57.647]                 if (length(args) > 0) 
[15:32:57.647]                   base::do.call(base::Sys.setenv, args = args)
[15:32:57.647]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:57.647]             }
[15:32:57.647]             else {
[15:32:57.647]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:57.647]             }
[15:32:57.647]             {
[15:32:57.647]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:57.647]                   0L) {
[15:32:57.647]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:57.647]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:57.647]                   base::options(opts)
[15:32:57.647]                 }
[15:32:57.647]                 {
[15:32:57.647]                   {
[15:32:57.647]                     NULL
[15:32:57.647]                     RNGkind("Mersenne-Twister")
[15:32:57.647]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:57.647]                       inherits = FALSE)
[15:32:57.647]                   }
[15:32:57.647]                   options(future.plan = NULL)
[15:32:57.647]                   if (is.na(NA_character_)) 
[15:32:57.647]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:57.647]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:57.647]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:57.647]                     .init = FALSE)
[15:32:57.647]                 }
[15:32:57.647]             }
[15:32:57.647]         }
[15:32:57.647]     })
[15:32:57.647]     if (TRUE) {
[15:32:57.647]         base::sink(type = "output", split = FALSE)
[15:32:57.647]         if (TRUE) {
[15:32:57.647]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:57.647]         }
[15:32:57.647]         else {
[15:32:57.647]             ...future.result["stdout"] <- base::list(NULL)
[15:32:57.647]         }
[15:32:57.647]         base::close(...future.stdout)
[15:32:57.647]         ...future.stdout <- NULL
[15:32:57.647]     }
[15:32:57.647]     ...future.result$conditions <- ...future.conditions
[15:32:57.647]     ...future.result$finished <- base::Sys.time()
[15:32:57.647]     ...future.result
[15:32:57.647] }
[15:32:57.654] assign_globals() ...
[15:32:57.654] List of 5
[15:32:57.654]  $ ...future.FUN            :function (x)  
[15:32:57.654]  $ future.call.arguments    : list()
[15:32:57.654]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:57.654]  $ ...future.elements_ii    :List of 2
[15:32:57.654]   ..$ : int 1
[15:32:57.654]   ..$ : int 0
[15:32:57.654]  $ ...future.seeds_ii       : NULL
[15:32:57.654]  $ ...future.globals.maxSize: NULL
[15:32:57.654]  - attr(*, "where")=List of 5
[15:32:57.654]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:57.654]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:57.654]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:57.654]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:57.654]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:57.654]  - attr(*, "resolved")= logi FALSE
[15:32:57.654]  - attr(*, "total_size")= num 4720
[15:32:57.654]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:57.654]  - attr(*, "already-done")= logi TRUE
[15:32:57.670] - reassign environment for '...future.FUN'
[15:32:57.670] - copied '...future.FUN' to environment
[15:32:57.670] - copied 'future.call.arguments' to environment
[15:32:57.671] - copied '...future.elements_ii' to environment
[15:32:57.671] - copied '...future.seeds_ii' to environment
[15:32:57.671] - copied '...future.globals.maxSize' to environment
[15:32:57.672] assign_globals() ... done
[15:32:57.672] plan(): Setting new future strategy stack:
[15:32:57.673] List of future strategies:
[15:32:57.673] 1. sequential:
[15:32:57.673]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:57.673]    - tweaked: FALSE
[15:32:57.673]    - call: NULL
[15:32:57.674] plan(): nbrOfWorkers() = 1
[15:32:58.188] plan(): Setting new future strategy stack:
[15:32:58.189] List of future strategies:
[15:32:58.189] 1. sequential:
[15:32:58.189]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:58.189]    - tweaked: FALSE
[15:32:58.189]    - call: plan(strategy)
[15:32:58.190] plan(): nbrOfWorkers() = 1
[15:32:58.190] SequentialFuture started (and completed)
[15:32:58.190] - Launch lazy future ... done
[15:32:58.191] run() for 'SequentialFuture' ... done
[15:32:58.191] Created future:
[15:32:58.191] SequentialFuture:
[15:32:58.191] Label: 'future_lapply-1'
[15:32:58.191] Expression:
[15:32:58.191] {
[15:32:58.191]     do.call(function(...) {
[15:32:58.191]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:58.191]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:58.191]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:58.191]             on.exit(options(oopts), add = TRUE)
[15:32:58.191]         }
[15:32:58.191]         {
[15:32:58.191]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:58.191]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:58.191]                 ...future.FUN(...future.X_jj, ...)
[15:32:58.191]             })
[15:32:58.191]         }
[15:32:58.191]     }, args = future.call.arguments)
[15:32:58.191] }
[15:32:58.191] Lazy evaluation: FALSE
[15:32:58.191] Asynchronous evaluation: FALSE
[15:32:58.191] Local evaluation: TRUE
[15:32:58.191] Environment: R_GlobalEnv
[15:32:58.191] Capture standard output: TRUE
[15:32:58.191] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:58.191] Globals: 5 objects totaling 4.72 KiB (function '...future.FUN' of 4.61 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 112 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:58.191] Packages: <none>
[15:32:58.191] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:58.191] Resolved: TRUE
[15:32:58.191] Value: 112 bytes of class 'list'
[15:32:58.191] Early signaling: FALSE
[15:32:58.191] Owner process: bdd4bc13-919d-bf34-b2cf-84eb53f6e11f
[15:32:58.191] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:58.194] Chunk #1 of 1 ... DONE
[15:32:58.194] Launching 1 futures (chunks) ... DONE
[15:32:58.194] Resolving 1 futures (chunks) ...
[15:32:58.195] resolve() on list ...
[15:32:58.195]  recursive: 0
[15:32:58.195]  length: 1
[15:32:58.195] 
[15:32:58.196] resolved() for 'SequentialFuture' ...
[15:32:58.196] - state: 'finished'
[15:32:58.196] - run: TRUE
[15:32:58.197] - result: 'FutureResult'
[15:32:58.197] resolved() for 'SequentialFuture' ... done
[15:32:58.197] Future #1
[15:32:58.198] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:58.198] - nx: 1
[15:32:58.198] - relay: TRUE
[15:32:58.198] - stdout: TRUE
[15:32:58.199] - signal: TRUE
[15:32:58.199] - resignal: FALSE
[15:32:58.199] - force: TRUE
[15:32:58.199] - relayed: [n=1] FALSE
[15:32:58.200] - queued futures: [n=1] FALSE
[15:32:58.200]  - until=1
[15:32:58.200]  - relaying element #1
[15:32:58.201] - relayed: [n=1] TRUE
[15:32:58.201] - queued futures: [n=1] TRUE
[15:32:58.201] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:58.202]  length: 0 (resolved future 1)
[15:32:58.202] Relaying remaining futures
[15:32:58.202] signalConditionsASAP(NULL, pos=0) ...
[15:32:58.202] - nx: 1
[15:32:58.203] - relay: TRUE
[15:32:58.203] - stdout: TRUE
[15:32:58.203] - signal: TRUE
[15:32:58.204] - resignal: FALSE
[15:32:58.204] - force: TRUE
[15:32:58.204] - relayed: [n=1] TRUE
[15:32:58.204] - queued futures: [n=1] TRUE
 - flush all
[15:32:58.205] - relayed: [n=1] TRUE
[15:32:58.205] - queued futures: [n=1] TRUE
[15:32:58.205] signalConditionsASAP(NULL, pos=0) ... done
[15:32:58.206] resolve() on list ... DONE
[15:32:58.206]  - Number of value chunks collected: 1
[15:32:58.206] Resolving 1 futures (chunks) ... DONE
[15:32:58.206] Reducing values from 1 chunks ...
[15:32:58.207]  - Number of values collected after concatenation: 2
[15:32:58.207]  - Number of values expected: 2
[15:32:58.207] Reducing values from 1 chunks ... DONE
[15:32:58.208] future_lapply() ... DONE
* future_lapply(x, ..., future.stdout = TRUE) ... DONE
* future_lapply(x, ..., future.stdout = NA) ...
[15:32:58.208] future_lapply() ...
[15:32:58.210] Number of chunks: 1
[15:32:58.210] getGlobalsAndPackagesXApply() ...
[15:32:58.210]  - future.globals: TRUE
[15:32:58.211] getGlobalsAndPackages() ...
[15:32:58.211] Searching for globals...
[15:32:58.214] - globals found: [5] 'FUN', '{', 'Sys.sleep', '/', 'print'
[15:32:58.214] Searching for globals ... DONE
[15:32:58.214] Resolving globals: FALSE
[15:32:58.215] The total size of the 1 globals is 4.61 KiB (4720 bytes)
[15:32:58.216] The total size of the 1 globals exported for future expression ('FUN()') is 4.61 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.61 KiB of class 'function')
[15:32:58.216] - globals: [1] 'FUN'
[15:32:58.217] 
[15:32:58.217] getGlobalsAndPackages() ... DONE
[15:32:58.217]  - globals found/used: [n=1] 'FUN'
[15:32:58.217]  - needed namespaces: [n=0] 
[15:32:58.218] Finding globals ... DONE
[15:32:58.218]  - use_args: TRUE
[15:32:58.221]  - Getting '...' globals ...
[15:32:58.221] resolve() on list ...
[15:32:58.222]  recursive: 0
[15:32:58.222]  length: 1
[15:32:58.222]  elements: '...'
[15:32:58.222]  length: 0 (resolved future 1)
[15:32:58.223] resolve() on list ... DONE
[15:32:58.223]    - '...' content: [n=0] 
[15:32:58.223] List of 1
[15:32:58.223]  $ ...: list()
[15:32:58.223]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:58.223]  - attr(*, "where")=List of 1
[15:32:58.223]   ..$ ...:<environment: 0x0000027fc026c140> 
[15:32:58.223]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:58.223]  - attr(*, "resolved")= logi TRUE
[15:32:58.223]  - attr(*, "total_size")= num NA
[15:32:58.228]  - Getting '...' globals ... DONE
[15:32:58.229] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:58.229] List of 2
[15:32:58.229]  $ ...future.FUN:function (x)  
[15:32:58.229]  $ ...          : list()
[15:32:58.229]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:58.229]  - attr(*, "where")=List of 2
[15:32:58.229]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:58.229]   ..$ ...          :<environment: 0x0000027fc026c140> 
[15:32:58.229]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:58.229]  - attr(*, "resolved")= logi FALSE
[15:32:58.229]  - attr(*, "total_size")= num 4720
[15:32:58.234] Packages to be attached in all futures: [n=0] 
[15:32:58.235] getGlobalsAndPackagesXApply() ... DONE
[15:32:58.235] Number of futures (= number of chunks): 1
[15:32:58.235] Launching 1 futures (chunks) ...
[15:32:58.236] Chunk #1 of 1 ...
[15:32:58.236]  - Finding globals in 'X' for chunk #1 ...
[15:32:58.236] getGlobalsAndPackages() ...
[15:32:58.236] Searching for globals...
[15:32:58.237] 
[15:32:58.237] Searching for globals ... DONE
[15:32:58.238] - globals: [0] <none>
[15:32:58.238] getGlobalsAndPackages() ... DONE
[15:32:58.238]    + additional globals found: [n=0] 
[15:32:58.238]    + additional namespaces needed: [n=0] 
[15:32:58.239]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:58.239]  - seeds: <none>
[15:32:58.239]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:58.239] getGlobalsAndPackages() ...
[15:32:58.240] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:58.240] Resolving globals: FALSE
[15:32:58.240] Tweak future expression to call with '...' arguments ...
[15:32:58.241] {
[15:32:58.241]     do.call(function(...) {
[15:32:58.241]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:58.241]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:58.241]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:58.241]             on.exit(options(oopts), add = TRUE)
[15:32:58.241]         }
[15:32:58.241]         {
[15:32:58.241]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:58.241]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:58.241]                 ...future.FUN(...future.X_jj, ...)
[15:32:58.241]             })
[15:32:58.241]         }
[15:32:58.241]     }, args = future.call.arguments)
[15:32:58.241] }
[15:32:58.241] Tweak future expression to call with '...' arguments ... DONE
[15:32:58.242] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:58.242] 
[15:32:58.243] getGlobalsAndPackages() ... DONE
[15:32:58.243] run() for 'Future' ...
[15:32:58.244] - state: 'created'
[15:32:58.244] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:58.245] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:58.245] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:58.245]   - Field: 'label'
[15:32:58.246]   - Field: 'local'
[15:32:58.246]   - Field: 'owner'
[15:32:58.246]   - Field: 'envir'
[15:32:58.246]   - Field: 'packages'
[15:32:58.247]   - Field: 'gc'
[15:32:58.247]   - Field: 'conditions'
[15:32:58.247]   - Field: 'expr'
[15:32:58.248]   - Field: 'uuid'
[15:32:58.248]   - Field: 'seed'
[15:32:58.248]   - Field: 'version'
[15:32:58.248]   - Field: 'result'
[15:32:58.249]   - Field: 'asynchronous'
[15:32:58.249]   - Field: 'calls'
[15:32:58.249]   - Field: 'globals'
[15:32:58.250]   - Field: 'stdout'
[15:32:58.250]   - Field: 'earlySignal'
[15:32:58.250]   - Field: 'lazy'
[15:32:58.250]   - Field: 'state'
[15:32:58.251] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:58.251] - Launch lazy future ...
[15:32:58.251] Packages needed by the future expression (n = 0): <none>
[15:32:58.252] Packages needed by future strategies (n = 0): <none>
[15:32:58.253] {
[15:32:58.253]     {
[15:32:58.253]         {
[15:32:58.253]             ...future.startTime <- base::Sys.time()
[15:32:58.253]             {
[15:32:58.253]                 {
[15:32:58.253]                   {
[15:32:58.253]                     base::local({
[15:32:58.253]                       has_future <- base::requireNamespace("future", 
[15:32:58.253]                         quietly = TRUE)
[15:32:58.253]                       if (has_future) {
[15:32:58.253]                         ns <- base::getNamespace("future")
[15:32:58.253]                         version <- ns[[".package"]][["version"]]
[15:32:58.253]                         if (is.null(version)) 
[15:32:58.253]                           version <- utils::packageVersion("future")
[15:32:58.253]                       }
[15:32:58.253]                       else {
[15:32:58.253]                         version <- NULL
[15:32:58.253]                       }
[15:32:58.253]                       if (!has_future || version < "1.8.0") {
[15:32:58.253]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:58.253]                           "", base::R.version$version.string), 
[15:32:58.253]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:58.253]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:58.253]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:58.253]                             "release", "version")], collapse = " "), 
[15:32:58.253]                           hostname = base::Sys.info()[["nodename"]])
[15:32:58.253]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:58.253]                           info)
[15:32:58.253]                         info <- base::paste(info, collapse = "; ")
[15:32:58.253]                         if (!has_future) {
[15:32:58.253]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:58.253]                             info)
[15:32:58.253]                         }
[15:32:58.253]                         else {
[15:32:58.253]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:58.253]                             info, version)
[15:32:58.253]                         }
[15:32:58.253]                         base::stop(msg)
[15:32:58.253]                       }
[15:32:58.253]                     })
[15:32:58.253]                   }
[15:32:58.253]                   ...future.strategy.old <- future::plan("list")
[15:32:58.253]                   options(future.plan = NULL)
[15:32:58.253]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:58.253]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:58.253]                 }
[15:32:58.253]                 ...future.workdir <- getwd()
[15:32:58.253]             }
[15:32:58.253]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:58.253]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:58.253]         }
[15:32:58.253]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:58.253]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:58.253]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:58.253]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:58.253]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:58.253]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:58.253]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:58.253]             base::names(...future.oldOptions))
[15:32:58.253]     }
[15:32:58.253]     if (TRUE) {
[15:32:58.253]     }
[15:32:58.253]     else {
[15:32:58.253]         if (NA) {
[15:32:58.253]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:58.253]                 open = "w")
[15:32:58.253]         }
[15:32:58.253]         else {
[15:32:58.253]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:58.253]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:58.253]         }
[15:32:58.253]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:58.253]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:58.253]             base::sink(type = "output", split = FALSE)
[15:32:58.253]             base::close(...future.stdout)
[15:32:58.253]         }, add = TRUE)
[15:32:58.253]     }
[15:32:58.253]     ...future.frame <- base::sys.nframe()
[15:32:58.253]     ...future.conditions <- base::list()
[15:32:58.253]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:58.253]     if (FALSE) {
[15:32:58.253]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:58.253]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:58.253]     }
[15:32:58.253]     ...future.result <- base::tryCatch({
[15:32:58.253]         base::withCallingHandlers({
[15:32:58.253]             ...future.value <- base::withVisible(base::local({
[15:32:58.253]                 do.call(function(...) {
[15:32:58.253]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:58.253]                   if (!identical(...future.globals.maxSize.org, 
[15:32:58.253]                     ...future.globals.maxSize)) {
[15:32:58.253]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:58.253]                     on.exit(options(oopts), add = TRUE)
[15:32:58.253]                   }
[15:32:58.253]                   {
[15:32:58.253]                     lapply(seq_along(...future.elements_ii), 
[15:32:58.253]                       FUN = function(jj) {
[15:32:58.253]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:58.253]                         ...future.FUN(...future.X_jj, ...)
[15:32:58.253]                       })
[15:32:58.253]                   }
[15:32:58.253]                 }, args = future.call.arguments)
[15:32:58.253]             }))
[15:32:58.253]             future::FutureResult(value = ...future.value$value, 
[15:32:58.253]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:58.253]                   ...future.rng), globalenv = if (FALSE) 
[15:32:58.253]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:58.253]                     ...future.globalenv.names))
[15:32:58.253]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:58.253]         }, condition = base::local({
[15:32:58.253]             c <- base::c
[15:32:58.253]             inherits <- base::inherits
[15:32:58.253]             invokeRestart <- base::invokeRestart
[15:32:58.253]             length <- base::length
[15:32:58.253]             list <- base::list
[15:32:58.253]             seq.int <- base::seq.int
[15:32:58.253]             signalCondition <- base::signalCondition
[15:32:58.253]             sys.calls <- base::sys.calls
[15:32:58.253]             `[[` <- base::`[[`
[15:32:58.253]             `+` <- base::`+`
[15:32:58.253]             `<<-` <- base::`<<-`
[15:32:58.253]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:58.253]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:58.253]                   3L)]
[15:32:58.253]             }
[15:32:58.253]             function(cond) {
[15:32:58.253]                 is_error <- inherits(cond, "error")
[15:32:58.253]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:58.253]                   NULL)
[15:32:58.253]                 if (is_error) {
[15:32:58.253]                   sessionInformation <- function() {
[15:32:58.253]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:58.253]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:58.253]                       search = base::search(), system = base::Sys.info())
[15:32:58.253]                   }
[15:32:58.253]                   ...future.conditions[[length(...future.conditions) + 
[15:32:58.253]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:58.253]                     cond$call), session = sessionInformation(), 
[15:32:58.253]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:58.253]                   signalCondition(cond)
[15:32:58.253]                 }
[15:32:58.253]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:58.253]                 "immediateCondition"))) {
[15:32:58.253]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:58.253]                   ...future.conditions[[length(...future.conditions) + 
[15:32:58.253]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:58.253]                   if (TRUE && !signal) {
[15:32:58.253]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:58.253]                     {
[15:32:58.253]                       inherits <- base::inherits
[15:32:58.253]                       invokeRestart <- base::invokeRestart
[15:32:58.253]                       is.null <- base::is.null
[15:32:58.253]                       muffled <- FALSE
[15:32:58.253]                       if (inherits(cond, "message")) {
[15:32:58.253]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:58.253]                         if (muffled) 
[15:32:58.253]                           invokeRestart("muffleMessage")
[15:32:58.253]                       }
[15:32:58.253]                       else if (inherits(cond, "warning")) {
[15:32:58.253]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:58.253]                         if (muffled) 
[15:32:58.253]                           invokeRestart("muffleWarning")
[15:32:58.253]                       }
[15:32:58.253]                       else if (inherits(cond, "condition")) {
[15:32:58.253]                         if (!is.null(pattern)) {
[15:32:58.253]                           computeRestarts <- base::computeRestarts
[15:32:58.253]                           grepl <- base::grepl
[15:32:58.253]                           restarts <- computeRestarts(cond)
[15:32:58.253]                           for (restart in restarts) {
[15:32:58.253]                             name <- restart$name
[15:32:58.253]                             if (is.null(name)) 
[15:32:58.253]                               next
[15:32:58.253]                             if (!grepl(pattern, name)) 
[15:32:58.253]                               next
[15:32:58.253]                             invokeRestart(restart)
[15:32:58.253]                             muffled <- TRUE
[15:32:58.253]                             break
[15:32:58.253]                           }
[15:32:58.253]                         }
[15:32:58.253]                       }
[15:32:58.253]                       invisible(muffled)
[15:32:58.253]                     }
[15:32:58.253]                     muffleCondition(cond, pattern = "^muffle")
[15:32:58.253]                   }
[15:32:58.253]                 }
[15:32:58.253]                 else {
[15:32:58.253]                   if (TRUE) {
[15:32:58.253]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:58.253]                     {
[15:32:58.253]                       inherits <- base::inherits
[15:32:58.253]                       invokeRestart <- base::invokeRestart
[15:32:58.253]                       is.null <- base::is.null
[15:32:58.253]                       muffled <- FALSE
[15:32:58.253]                       if (inherits(cond, "message")) {
[15:32:58.253]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:58.253]                         if (muffled) 
[15:32:58.253]                           invokeRestart("muffleMessage")
[15:32:58.253]                       }
[15:32:58.253]                       else if (inherits(cond, "warning")) {
[15:32:58.253]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:58.253]                         if (muffled) 
[15:32:58.253]                           invokeRestart("muffleWarning")
[15:32:58.253]                       }
[15:32:58.253]                       else if (inherits(cond, "condition")) {
[15:32:58.253]                         if (!is.null(pattern)) {
[15:32:58.253]                           computeRestarts <- base::computeRestarts
[15:32:58.253]                           grepl <- base::grepl
[15:32:58.253]                           restarts <- computeRestarts(cond)
[15:32:58.253]                           for (restart in restarts) {
[15:32:58.253]                             name <- restart$name
[15:32:58.253]                             if (is.null(name)) 
[15:32:58.253]                               next
[15:32:58.253]                             if (!grepl(pattern, name)) 
[15:32:58.253]                               next
[15:32:58.253]                             invokeRestart(restart)
[15:32:58.253]                             muffled <- TRUE
[15:32:58.253]                             break
[15:32:58.253]                           }
[15:32:58.253]                         }
[15:32:58.253]                       }
[15:32:58.253]                       invisible(muffled)
[15:32:58.253]                     }
[15:32:58.253]                     muffleCondition(cond, pattern = "^muffle")
[15:32:58.253]                   }
[15:32:58.253]                 }
[15:32:58.253]             }
[15:32:58.253]         }))
[15:32:58.253]     }, error = function(ex) {
[15:32:58.253]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:58.253]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:58.253]                 ...future.rng), started = ...future.startTime, 
[15:32:58.253]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:58.253]             version = "1.8"), class = "FutureResult")
[15:32:58.253]     }, finally = {
[15:32:58.253]         if (!identical(...future.workdir, getwd())) 
[15:32:58.253]             setwd(...future.workdir)
[15:32:58.253]         {
[15:32:58.253]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:58.253]                 ...future.oldOptions$nwarnings <- NULL
[15:32:58.253]             }
[15:32:58.253]             base::options(...future.oldOptions)
[15:32:58.253]             if (.Platform$OS.type == "windows") {
[15:32:58.253]                 old_names <- names(...future.oldEnvVars)
[15:32:58.253]                 envs <- base::Sys.getenv()
[15:32:58.253]                 names <- names(envs)
[15:32:58.253]                 common <- intersect(names, old_names)
[15:32:58.253]                 added <- setdiff(names, old_names)
[15:32:58.253]                 removed <- setdiff(old_names, names)
[15:32:58.253]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:58.253]                   envs[common]]
[15:32:58.253]                 NAMES <- toupper(changed)
[15:32:58.253]                 args <- list()
[15:32:58.253]                 for (kk in seq_along(NAMES)) {
[15:32:58.253]                   name <- changed[[kk]]
[15:32:58.253]                   NAME <- NAMES[[kk]]
[15:32:58.253]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:58.253]                     next
[15:32:58.253]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:58.253]                 }
[15:32:58.253]                 NAMES <- toupper(added)
[15:32:58.253]                 for (kk in seq_along(NAMES)) {
[15:32:58.253]                   name <- added[[kk]]
[15:32:58.253]                   NAME <- NAMES[[kk]]
[15:32:58.253]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:58.253]                     next
[15:32:58.253]                   args[[name]] <- ""
[15:32:58.253]                 }
[15:32:58.253]                 NAMES <- toupper(removed)
[15:32:58.253]                 for (kk in seq_along(NAMES)) {
[15:32:58.253]                   name <- removed[[kk]]
[15:32:58.253]                   NAME <- NAMES[[kk]]
[15:32:58.253]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:58.253]                     next
[15:32:58.253]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:58.253]                 }
[15:32:58.253]                 if (length(args) > 0) 
[15:32:58.253]                   base::do.call(base::Sys.setenv, args = args)
[15:32:58.253]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:58.253]             }
[15:32:58.253]             else {
[15:32:58.253]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:58.253]             }
[15:32:58.253]             {
[15:32:58.253]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:58.253]                   0L) {
[15:32:58.253]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:58.253]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:58.253]                   base::options(opts)
[15:32:58.253]                 }
[15:32:58.253]                 {
[15:32:58.253]                   {
[15:32:58.253]                     NULL
[15:32:58.253]                     RNGkind("Mersenne-Twister")
[15:32:58.253]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:58.253]                       inherits = FALSE)
[15:32:58.253]                   }
[15:32:58.253]                   options(future.plan = NULL)
[15:32:58.253]                   if (is.na(NA_character_)) 
[15:32:58.253]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:58.253]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:58.253]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:58.253]                     .init = FALSE)
[15:32:58.253]                 }
[15:32:58.253]             }
[15:32:58.253]         }
[15:32:58.253]     })
[15:32:58.253]     if (FALSE) {
[15:32:58.253]         base::sink(type = "output", split = FALSE)
[15:32:58.253]         if (NA) {
[15:32:58.253]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:58.253]         }
[15:32:58.253]         else {
[15:32:58.253]             ...future.result["stdout"] <- base::list(NULL)
[15:32:58.253]         }
[15:32:58.253]         base::close(...future.stdout)
[15:32:58.253]         ...future.stdout <- NULL
[15:32:58.253]     }
[15:32:58.253]     ...future.result$conditions <- ...future.conditions
[15:32:58.253]     ...future.result$finished <- base::Sys.time()
[15:32:58.253]     ...future.result
[15:32:58.253] }
[15:32:58.259] assign_globals() ...
[15:32:58.260] List of 5
[15:32:58.260]  $ ...future.FUN            :function (x)  
[15:32:58.260]  $ future.call.arguments    : list()
[15:32:58.260]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:58.260]  $ ...future.elements_ii    :List of 2
[15:32:58.260]   ..$ : int 1
[15:32:58.260]   ..$ : int 0
[15:32:58.260]  $ ...future.seeds_ii       : NULL
[15:32:58.260]  $ ...future.globals.maxSize: NULL
[15:32:58.260]  - attr(*, "where")=List of 5
[15:32:58.260]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:58.260]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:58.260]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:58.260]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:58.260]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:58.260]  - attr(*, "resolved")= logi FALSE
[15:32:58.260]  - attr(*, "total_size")= num 4720
[15:32:58.260]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:58.260]  - attr(*, "already-done")= logi TRUE
[15:32:58.272] - reassign environment for '...future.FUN'
[15:32:58.273] - copied '...future.FUN' to environment
[15:32:58.273] - copied 'future.call.arguments' to environment
[15:32:58.273] - copied '...future.elements_ii' to environment
[15:32:58.273] - copied '...future.seeds_ii' to environment
[15:32:58.274] - copied '...future.globals.maxSize' to environment
[15:32:58.274] assign_globals() ... done
[15:32:58.275] plan(): Setting new future strategy stack:
[15:32:58.275] List of future strategies:
[15:32:58.275] 1. sequential:
[15:32:58.275]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:58.275]    - tweaked: FALSE
[15:32:58.275]    - call: NULL
[15:32:58.276] plan(): nbrOfWorkers() = 1
[15:32:58.782] plan(): Setting new future strategy stack:
[15:32:58.782] List of future strategies:
[15:32:58.782] 1. sequential:
[15:32:58.782]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:58.782]    - tweaked: FALSE
[15:32:58.782]    - call: plan(strategy)
[15:32:58.783] plan(): nbrOfWorkers() = 1
[15:32:58.784] SequentialFuture started (and completed)
[15:32:58.784] - Launch lazy future ... done
[15:32:58.784] run() for 'SequentialFuture' ... done
[15:32:58.785] Created future:
[15:32:58.785] SequentialFuture:
[15:32:58.785] Label: 'future_lapply-1'
[15:32:58.785] Expression:
[15:32:58.785] {
[15:32:58.785]     do.call(function(...) {
[15:32:58.785]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:58.785]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:58.785]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:58.785]             on.exit(options(oopts), add = TRUE)
[15:32:58.785]         }
[15:32:58.785]         {
[15:32:58.785]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:58.785]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:58.785]                 ...future.FUN(...future.X_jj, ...)
[15:32:58.785]             })
[15:32:58.785]         }
[15:32:58.785]     }, args = future.call.arguments)
[15:32:58.785] }
[15:32:58.785] Lazy evaluation: FALSE
[15:32:58.785] Asynchronous evaluation: FALSE
[15:32:58.785] Local evaluation: TRUE
[15:32:58.785] Environment: R_GlobalEnv
[15:32:58.785] Capture standard output: NA
[15:32:58.785] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:58.785] Globals: 5 objects totaling 4.72 KiB (function '...future.FUN' of 4.61 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 112 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:58.785] Packages: <none>
[15:32:58.785] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:58.785] Resolved: TRUE
[15:32:58.785] Value: 112 bytes of class 'list'
[15:32:58.785] Early signaling: FALSE
[15:32:58.785] Owner process: bdd4bc13-919d-bf34-b2cf-84eb53f6e11f
[15:32:58.785] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:58.787] Chunk #1 of 1 ... DONE
[15:32:58.787] Launching 1 futures (chunks) ... DONE
[15:32:58.787] Resolving 1 futures (chunks) ...
[15:32:58.787] resolve() on list ...
[15:32:58.788]  recursive: 0
[15:32:58.788]  length: 1
[15:32:58.788] 
[15:32:58.788] resolved() for 'SequentialFuture' ...
[15:32:58.789] - state: 'finished'
[15:32:58.789] - run: TRUE
[15:32:58.789] - result: 'FutureResult'
[15:32:58.789] resolved() for 'SequentialFuture' ... done
[15:32:58.790] Future #1
[15:32:58.790] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:58.790] - nx: 1
[15:32:58.790] - relay: TRUE
[15:32:58.791] - stdout: TRUE
[15:32:58.791] - signal: TRUE
[15:32:58.791] - resignal: FALSE
[15:32:58.791] - force: TRUE
[15:32:58.792] - relayed: [n=1] FALSE
[15:32:58.792] - queued futures: [n=1] FALSE
[15:32:58.792]  - until=1
[15:32:58.792]  - relaying element #1
[15:32:58.793] - relayed: [n=1] TRUE
[15:32:58.793] - queued futures: [n=1] TRUE
[15:32:58.793] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:58.793]  length: 0 (resolved future 1)
[15:32:58.794] Relaying remaining futures
[15:32:58.794] signalConditionsASAP(NULL, pos=0) ...
[15:32:58.794] - nx: 1
[15:32:58.794] - relay: TRUE
[15:32:58.794] - stdout: TRUE
[15:32:58.795] - signal: TRUE
[15:32:58.795] - resignal: FALSE
[15:32:58.795] - force: TRUE
[15:32:58.795] - relayed: [n=1] TRUE
[15:32:58.796] - queued futures: [n=1] TRUE
 - flush all
[15:32:58.796] - relayed: [n=1] TRUE
[15:32:58.796] - queued futures: [n=1] TRUE
[15:32:58.796] signalConditionsASAP(NULL, pos=0) ... done
[15:32:58.797] resolve() on list ... DONE
[15:32:58.797]  - Number of value chunks collected: 1
[15:32:58.797] Resolving 1 futures (chunks) ... DONE
[15:32:58.797] Reducing values from 1 chunks ...
[15:32:58.798]  - Number of values collected after concatenation: 2
[15:32:58.798]  - Number of values expected: 2
[15:32:58.798] Reducing values from 1 chunks ... DONE
[15:32:58.798] future_lapply() ... DONE
* future_lapply(x, ..., future.stdout = NA) ... DONE
* future_mapply(x, ..., future.stdout = FALSE) ...
[15:32:58.799] future_mapply() ...
[15:32:58.799] Number of chunks: 1
[15:32:58.800] getGlobalsAndPackagesXApply() ...
[15:32:58.800]  - future.globals: TRUE
[15:32:58.800] getGlobalsAndPackages() ...
[15:32:58.800] Searching for globals...
[15:32:58.803] - globals found: [6] 'FUN', '{', 'Sys.sleep', '/', 'print', 'list'
[15:32:58.803] Searching for globals ... DONE
[15:32:58.803] Resolving globals: FALSE
[15:32:58.804] The total size of the 1 globals is 6.11 KiB (6256 bytes)
[15:32:58.805] The total size of the 1 globals exported for future expression ('FUN()') is 6.11 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (6.11 KiB of class 'function')
[15:32:58.805] - globals: [1] 'FUN'
[15:32:58.805] 
[15:32:58.805] getGlobalsAndPackages() ... DONE
[15:32:58.806]  - globals found/used: [n=1] 'FUN'
[15:32:58.806]  - needed namespaces: [n=0] 
[15:32:58.806] Finding globals ... DONE
[15:32:58.807] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[15:32:58.807] List of 2
[15:32:58.807]  $ ...future.FUN:function (x, y)  
[15:32:58.807]  $ MoreArgs     : NULL
[15:32:58.807]  - attr(*, "where")=List of 2
[15:32:58.807]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:58.807]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[15:32:58.807]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:58.807]  - attr(*, "resolved")= logi FALSE
[15:32:58.807]  - attr(*, "total_size")= num NA
[15:32:58.811] Packages to be attached in all futures: [n=0] 
[15:32:58.811] getGlobalsAndPackagesXApply() ... DONE
[15:32:58.812] Number of futures (= number of chunks): 1
[15:32:58.812] Launching 1 futures (chunks) ...
[15:32:58.812] Chunk #1 of 1 ...
[15:32:58.812]  - Finding globals in '...' for chunk #1 ...
[15:32:58.813] getGlobalsAndPackages() ...
[15:32:58.813] Searching for globals...
[15:32:58.813] 
[15:32:58.814] Searching for globals ... DONE
[15:32:58.814] - globals: [0] <none>
[15:32:58.816] getGlobalsAndPackages() ... DONE
[15:32:58.816]    + additional globals found: [n=0] 
[15:32:58.817]    + additional namespaces needed: [n=0] 
[15:32:58.817]  - Finding globals in '...' for chunk #1 ... DONE
[15:32:58.817]  - seeds: <none>
[15:32:58.817]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:58.818] getGlobalsAndPackages() ...
[15:32:58.818] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:58.818] Resolving globals: FALSE
[15:32:58.819] The total size of the 5 globals is 6.33 KiB (6480 bytes)
[15:32:58.820] The total size of the 5 globals exported for future expression ('{; ...future.globals.maxSize.org <- getOption("future.globals.maxSize"); if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {; oopts <- options(future.globals.maxSize = ...future.globals.maxSize); on.exit(options(oopts), add = TRUE); }; ...; do.call(mapply, args = args); }; }') is 6.33 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (6.11 KiB of class 'function'), '...future.elements_ii' (224 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[15:32:58.820] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:58.820] 
[15:32:58.821] getGlobalsAndPackages() ... DONE
[15:32:58.821] run() for 'Future' ...
[15:32:58.821] - state: 'created'
[15:32:58.822] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:58.822] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:58.822] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:58.823]   - Field: 'label'
[15:32:58.823]   - Field: 'local'
[15:32:58.823]   - Field: 'owner'
[15:32:58.823]   - Field: 'envir'
[15:32:58.823]   - Field: 'packages'
[15:32:58.824]   - Field: 'gc'
[15:32:58.824]   - Field: 'conditions'
[15:32:58.824]   - Field: 'expr'
[15:32:58.824]   - Field: 'uuid'
[15:32:58.824]   - Field: 'seed'
[15:32:58.824]   - Field: 'version'
[15:32:58.825]   - Field: 'result'
[15:32:58.825]   - Field: 'asynchronous'
[15:32:58.825]   - Field: 'calls'
[15:32:58.825]   - Field: 'globals'
[15:32:58.826]   - Field: 'stdout'
[15:32:58.826]   - Field: 'earlySignal'
[15:32:58.826]   - Field: 'lazy'
[15:32:58.826]   - Field: 'state'
[15:32:58.826] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:58.826] - Launch lazy future ...
[15:32:58.827] Packages needed by the future expression (n = 0): <none>
[15:32:58.827] Packages needed by future strategies (n = 0): <none>
[15:32:58.827] {
[15:32:58.827]     {
[15:32:58.827]         {
[15:32:58.827]             ...future.startTime <- base::Sys.time()
[15:32:58.827]             {
[15:32:58.827]                 {
[15:32:58.827]                   {
[15:32:58.827]                     base::local({
[15:32:58.827]                       has_future <- base::requireNamespace("future", 
[15:32:58.827]                         quietly = TRUE)
[15:32:58.827]                       if (has_future) {
[15:32:58.827]                         ns <- base::getNamespace("future")
[15:32:58.827]                         version <- ns[[".package"]][["version"]]
[15:32:58.827]                         if (is.null(version)) 
[15:32:58.827]                           version <- utils::packageVersion("future")
[15:32:58.827]                       }
[15:32:58.827]                       else {
[15:32:58.827]                         version <- NULL
[15:32:58.827]                       }
[15:32:58.827]                       if (!has_future || version < "1.8.0") {
[15:32:58.827]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:58.827]                           "", base::R.version$version.string), 
[15:32:58.827]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:58.827]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:58.827]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:58.827]                             "release", "version")], collapse = " "), 
[15:32:58.827]                           hostname = base::Sys.info()[["nodename"]])
[15:32:58.827]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:58.827]                           info)
[15:32:58.827]                         info <- base::paste(info, collapse = "; ")
[15:32:58.827]                         if (!has_future) {
[15:32:58.827]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:58.827]                             info)
[15:32:58.827]                         }
[15:32:58.827]                         else {
[15:32:58.827]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:58.827]                             info, version)
[15:32:58.827]                         }
[15:32:58.827]                         base::stop(msg)
[15:32:58.827]                       }
[15:32:58.827]                     })
[15:32:58.827]                   }
[15:32:58.827]                   ...future.strategy.old <- future::plan("list")
[15:32:58.827]                   options(future.plan = NULL)
[15:32:58.827]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:58.827]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:58.827]                 }
[15:32:58.827]                 ...future.workdir <- getwd()
[15:32:58.827]             }
[15:32:58.827]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:58.827]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:58.827]         }
[15:32:58.827]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:58.827]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:58.827]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:58.827]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:58.827]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:58.827]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:58.827]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:58.827]             base::names(...future.oldOptions))
[15:32:58.827]     }
[15:32:58.827]     if (FALSE) {
[15:32:58.827]     }
[15:32:58.827]     else {
[15:32:58.827]         if (FALSE) {
[15:32:58.827]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:58.827]                 open = "w")
[15:32:58.827]         }
[15:32:58.827]         else {
[15:32:58.827]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:58.827]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:58.827]         }
[15:32:58.827]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:58.827]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:58.827]             base::sink(type = "output", split = FALSE)
[15:32:58.827]             base::close(...future.stdout)
[15:32:58.827]         }, add = TRUE)
[15:32:58.827]     }
[15:32:58.827]     ...future.frame <- base::sys.nframe()
[15:32:58.827]     ...future.conditions <- base::list()
[15:32:58.827]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:58.827]     if (FALSE) {
[15:32:58.827]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:58.827]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:58.827]     }
[15:32:58.827]     ...future.result <- base::tryCatch({
[15:32:58.827]         base::withCallingHandlers({
[15:32:58.827]             ...future.value <- base::withVisible(base::local({
[15:32:58.827]                 ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:58.827]                 if (!identical(...future.globals.maxSize.org, 
[15:32:58.827]                   ...future.globals.maxSize)) {
[15:32:58.827]                   oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:58.827]                   on.exit(options(oopts), add = TRUE)
[15:32:58.827]                 }
[15:32:58.827]                 {
[15:32:58.827]                   args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:58.827]                     MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:58.827]                     USE.NAMES = FALSE)
[15:32:58.827]                   do.call(mapply, args = args)
[15:32:58.827]                 }
[15:32:58.827]             }))
[15:32:58.827]             future::FutureResult(value = ...future.value$value, 
[15:32:58.827]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:58.827]                   ...future.rng), globalenv = if (FALSE) 
[15:32:58.827]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:58.827]                     ...future.globalenv.names))
[15:32:58.827]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:58.827]         }, condition = base::local({
[15:32:58.827]             c <- base::c
[15:32:58.827]             inherits <- base::inherits
[15:32:58.827]             invokeRestart <- base::invokeRestart
[15:32:58.827]             length <- base::length
[15:32:58.827]             list <- base::list
[15:32:58.827]             seq.int <- base::seq.int
[15:32:58.827]             signalCondition <- base::signalCondition
[15:32:58.827]             sys.calls <- base::sys.calls
[15:32:58.827]             `[[` <- base::`[[`
[15:32:58.827]             `+` <- base::`+`
[15:32:58.827]             `<<-` <- base::`<<-`
[15:32:58.827]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:58.827]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:58.827]                   3L)]
[15:32:58.827]             }
[15:32:58.827]             function(cond) {
[15:32:58.827]                 is_error <- inherits(cond, "error")
[15:32:58.827]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:58.827]                   NULL)
[15:32:58.827]                 if (is_error) {
[15:32:58.827]                   sessionInformation <- function() {
[15:32:58.827]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:58.827]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:58.827]                       search = base::search(), system = base::Sys.info())
[15:32:58.827]                   }
[15:32:58.827]                   ...future.conditions[[length(...future.conditions) + 
[15:32:58.827]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:58.827]                     cond$call), session = sessionInformation(), 
[15:32:58.827]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:58.827]                   signalCondition(cond)
[15:32:58.827]                 }
[15:32:58.827]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:58.827]                 "immediateCondition"))) {
[15:32:58.827]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:58.827]                   ...future.conditions[[length(...future.conditions) + 
[15:32:58.827]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:58.827]                   if (TRUE && !signal) {
[15:32:58.827]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:58.827]                     {
[15:32:58.827]                       inherits <- base::inherits
[15:32:58.827]                       invokeRestart <- base::invokeRestart
[15:32:58.827]                       is.null <- base::is.null
[15:32:58.827]                       muffled <- FALSE
[15:32:58.827]                       if (inherits(cond, "message")) {
[15:32:58.827]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:58.827]                         if (muffled) 
[15:32:58.827]                           invokeRestart("muffleMessage")
[15:32:58.827]                       }
[15:32:58.827]                       else if (inherits(cond, "warning")) {
[15:32:58.827]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:58.827]                         if (muffled) 
[15:32:58.827]                           invokeRestart("muffleWarning")
[15:32:58.827]                       }
[15:32:58.827]                       else if (inherits(cond, "condition")) {
[15:32:58.827]                         if (!is.null(pattern)) {
[15:32:58.827]                           computeRestarts <- base::computeRestarts
[15:32:58.827]                           grepl <- base::grepl
[15:32:58.827]                           restarts <- computeRestarts(cond)
[15:32:58.827]                           for (restart in restarts) {
[15:32:58.827]                             name <- restart$name
[15:32:58.827]                             if (is.null(name)) 
[15:32:58.827]                               next
[15:32:58.827]                             if (!grepl(pattern, name)) 
[15:32:58.827]                               next
[15:32:58.827]                             invokeRestart(restart)
[15:32:58.827]                             muffled <- TRUE
[15:32:58.827]                             break
[15:32:58.827]                           }
[15:32:58.827]                         }
[15:32:58.827]                       }
[15:32:58.827]                       invisible(muffled)
[15:32:58.827]                     }
[15:32:58.827]                     muffleCondition(cond, pattern = "^muffle")
[15:32:58.827]                   }
[15:32:58.827]                 }
[15:32:58.827]                 else {
[15:32:58.827]                   if (TRUE) {
[15:32:58.827]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:58.827]                     {
[15:32:58.827]                       inherits <- base::inherits
[15:32:58.827]                       invokeRestart <- base::invokeRestart
[15:32:58.827]                       is.null <- base::is.null
[15:32:58.827]                       muffled <- FALSE
[15:32:58.827]                       if (inherits(cond, "message")) {
[15:32:58.827]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:58.827]                         if (muffled) 
[15:32:58.827]                           invokeRestart("muffleMessage")
[15:32:58.827]                       }
[15:32:58.827]                       else if (inherits(cond, "warning")) {
[15:32:58.827]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:58.827]                         if (muffled) 
[15:32:58.827]                           invokeRestart("muffleWarning")
[15:32:58.827]                       }
[15:32:58.827]                       else if (inherits(cond, "condition")) {
[15:32:58.827]                         if (!is.null(pattern)) {
[15:32:58.827]                           computeRestarts <- base::computeRestarts
[15:32:58.827]                           grepl <- base::grepl
[15:32:58.827]                           restarts <- computeRestarts(cond)
[15:32:58.827]                           for (restart in restarts) {
[15:32:58.827]                             name <- restart$name
[15:32:58.827]                             if (is.null(name)) 
[15:32:58.827]                               next
[15:32:58.827]                             if (!grepl(pattern, name)) 
[15:32:58.827]                               next
[15:32:58.827]                             invokeRestart(restart)
[15:32:58.827]                             muffled <- TRUE
[15:32:58.827]                             break
[15:32:58.827]                           }
[15:32:58.827]                         }
[15:32:58.827]                       }
[15:32:58.827]                       invisible(muffled)
[15:32:58.827]                     }
[15:32:58.827]                     muffleCondition(cond, pattern = "^muffle")
[15:32:58.827]                   }
[15:32:58.827]                 }
[15:32:58.827]             }
[15:32:58.827]         }))
[15:32:58.827]     }, error = function(ex) {
[15:32:58.827]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:58.827]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:58.827]                 ...future.rng), started = ...future.startTime, 
[15:32:58.827]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:58.827]             version = "1.8"), class = "FutureResult")
[15:32:58.827]     }, finally = {
[15:32:58.827]         if (!identical(...future.workdir, getwd())) 
[15:32:58.827]             setwd(...future.workdir)
[15:32:58.827]         {
[15:32:58.827]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:58.827]                 ...future.oldOptions$nwarnings <- NULL
[15:32:58.827]             }
[15:32:58.827]             base::options(...future.oldOptions)
[15:32:58.827]             if (.Platform$OS.type == "windows") {
[15:32:58.827]                 old_names <- names(...future.oldEnvVars)
[15:32:58.827]                 envs <- base::Sys.getenv()
[15:32:58.827]                 names <- names(envs)
[15:32:58.827]                 common <- intersect(names, old_names)
[15:32:58.827]                 added <- setdiff(names, old_names)
[15:32:58.827]                 removed <- setdiff(old_names, names)
[15:32:58.827]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:58.827]                   envs[common]]
[15:32:58.827]                 NAMES <- toupper(changed)
[15:32:58.827]                 args <- list()
[15:32:58.827]                 for (kk in seq_along(NAMES)) {
[15:32:58.827]                   name <- changed[[kk]]
[15:32:58.827]                   NAME <- NAMES[[kk]]
[15:32:58.827]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:58.827]                     next
[15:32:58.827]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:58.827]                 }
[15:32:58.827]                 NAMES <- toupper(added)
[15:32:58.827]                 for (kk in seq_along(NAMES)) {
[15:32:58.827]                   name <- added[[kk]]
[15:32:58.827]                   NAME <- NAMES[[kk]]
[15:32:58.827]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:58.827]                     next
[15:32:58.827]                   args[[name]] <- ""
[15:32:58.827]                 }
[15:32:58.827]                 NAMES <- toupper(removed)
[15:32:58.827]                 for (kk in seq_along(NAMES)) {
[15:32:58.827]                   name <- removed[[kk]]
[15:32:58.827]                   NAME <- NAMES[[kk]]
[15:32:58.827]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:58.827]                     next
[15:32:58.827]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:58.827]                 }
[15:32:58.827]                 if (length(args) > 0) 
[15:32:58.827]                   base::do.call(base::Sys.setenv, args = args)
[15:32:58.827]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:58.827]             }
[15:32:58.827]             else {
[15:32:58.827]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:58.827]             }
[15:32:58.827]             {
[15:32:58.827]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:58.827]                   0L) {
[15:32:58.827]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:58.827]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:58.827]                   base::options(opts)
[15:32:58.827]                 }
[15:32:58.827]                 {
[15:32:58.827]                   {
[15:32:58.827]                     NULL
[15:32:58.827]                     RNGkind("Mersenne-Twister")
[15:32:58.827]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:58.827]                       inherits = FALSE)
[15:32:58.827]                   }
[15:32:58.827]                   options(future.plan = NULL)
[15:32:58.827]                   if (is.na(NA_character_)) 
[15:32:58.827]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:58.827]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:58.827]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:58.827]                     .init = FALSE)
[15:32:58.827]                 }
[15:32:58.827]             }
[15:32:58.827]         }
[15:32:58.827]     })
[15:32:58.827]     if (TRUE) {
[15:32:58.827]         base::sink(type = "output", split = FALSE)
[15:32:58.827]         if (FALSE) {
[15:32:58.827]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:58.827]         }
[15:32:58.827]         else {
[15:32:58.827]             ...future.result["stdout"] <- base::list(NULL)
[15:32:58.827]         }
[15:32:58.827]         base::close(...future.stdout)
[15:32:58.827]         ...future.stdout <- NULL
[15:32:58.827]     }
[15:32:58.827]     ...future.result$conditions <- ...future.conditions
[15:32:58.827]     ...future.result$finished <- base::Sys.time()
[15:32:58.827]     ...future.result
[15:32:58.827] }
[15:32:58.831] assign_globals() ...
[15:32:58.832] List of 5
[15:32:58.832]  $ ...future.FUN            :function (x, y)  
[15:32:58.832]  $ MoreArgs                 : NULL
[15:32:58.832]  $ ...future.elements_ii    :List of 2
[15:32:58.832]   ..$ :List of 2
[15:32:58.832]   .. ..$ : int 1
[15:32:58.832]   .. ..$ : int 0
[15:32:58.832]   ..$ :List of 2
[15:32:58.832]   .. ..$ : int 0
[15:32:58.832]   .. ..$ : int 1
[15:32:58.832]  $ ...future.seeds_ii       : NULL
[15:32:58.832]  $ ...future.globals.maxSize: NULL
[15:32:58.832]  - attr(*, "where")=List of 5
[15:32:58.832]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:58.832]   ..$ MoreArgs                 :<environment: R_EmptyEnv> 
[15:32:58.832]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:58.832]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:58.832]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:58.832]  - attr(*, "resolved")= logi FALSE
[15:32:58.832]  - attr(*, "total_size")= num 6480
[15:32:58.832]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:58.832]  - attr(*, "already-done")= logi TRUE
[15:32:58.839] - reassign environment for '...future.FUN'
[15:32:58.839] - copied '...future.FUN' to environment
[15:32:58.839] - copied 'MoreArgs' to environment
[15:32:58.839] - copied '...future.elements_ii' to environment
[15:32:58.839] - copied '...future.seeds_ii' to environment
[15:32:58.840] - copied '...future.globals.maxSize' to environment
[15:32:58.840] assign_globals() ... done
[15:32:58.840] plan(): Setting new future strategy stack:
[15:32:58.840] List of future strategies:
[15:32:58.840] 1. sequential:
[15:32:58.840]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:58.840]    - tweaked: FALSE
[15:32:58.840]    - call: NULL
[15:32:58.841] plan(): nbrOfWorkers() = 1
[15:32:59.345] plan(): Setting new future strategy stack:
[15:32:59.345] List of future strategies:
[15:32:59.345] 1. sequential:
[15:32:59.345]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:59.345]    - tweaked: FALSE
[15:32:59.345]    - call: plan(strategy)
[15:32:59.346] plan(): nbrOfWorkers() = 1
[15:32:59.347] SequentialFuture started (and completed)
[15:32:59.347] - Launch lazy future ... done
[15:32:59.347] run() for 'SequentialFuture' ... done
[15:32:59.348] Created future:
[15:32:59.348] SequentialFuture:
[15:32:59.348] Label: 'future_mapply-1'
[15:32:59.348] Expression:
[15:32:59.348] {
[15:32:59.348]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:59.348]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:59.348]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:59.348]         on.exit(options(oopts), add = TRUE)
[15:32:59.348]     }
[15:32:59.348]     {
[15:32:59.348]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:59.348]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:59.348]         do.call(mapply, args = args)
[15:32:59.348]     }
[15:32:59.348] }
[15:32:59.348] Lazy evaluation: FALSE
[15:32:59.348] Asynchronous evaluation: FALSE
[15:32:59.348] Local evaluation: TRUE
[15:32:59.348] Environment: R_GlobalEnv
[15:32:59.348] Capture standard output: FALSE
[15:32:59.348] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:59.348] Globals: 5 objects totaling 6.33 KiB (function '...future.FUN' of 6.11 KiB, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 224 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:59.348] Packages: <none>
[15:32:59.348] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:59.348] Resolved: TRUE
[15:32:59.348] Value: 224 bytes of class 'list'
[15:32:59.348] Early signaling: FALSE
[15:32:59.348] Owner process: bdd4bc13-919d-bf34-b2cf-84eb53f6e11f
[15:32:59.348] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:59.350] Chunk #1 of 1 ... DONE
[15:32:59.350] Launching 1 futures (chunks) ... DONE
[15:32:59.351] Resolving 1 futures (chunks) ...
[15:32:59.351] resolve() on list ...
[15:32:59.351]  recursive: 0
[15:32:59.351]  length: 1
[15:32:59.352] 
[15:32:59.352] resolved() for 'SequentialFuture' ...
[15:32:59.352] - state: 'finished'
[15:32:59.353] - run: TRUE
[15:32:59.353] - result: 'FutureResult'
[15:32:59.353] resolved() for 'SequentialFuture' ... done
[15:32:59.353] Future #1
[15:32:59.354] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:59.354] - nx: 1
[15:32:59.354] - relay: TRUE
[15:32:59.355] - stdout: TRUE
[15:32:59.355] - signal: TRUE
[15:32:59.355] - resignal: FALSE
[15:32:59.355] - force: TRUE
[15:32:59.359] - relayed: [n=1] FALSE
[15:32:59.359] - queued futures: [n=1] FALSE
[15:32:59.359]  - until=1
[15:32:59.359]  - relaying element #1
[15:32:59.360] - relayed: [n=1] TRUE
[15:32:59.360] - queued futures: [n=1] TRUE
[15:32:59.360] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:59.361]  length: 0 (resolved future 1)
[15:32:59.361] Relaying remaining futures
[15:32:59.361] signalConditionsASAP(NULL, pos=0) ...
[15:32:59.361] - nx: 1
[15:32:59.362] - relay: TRUE
[15:32:59.362] - stdout: TRUE
[15:32:59.362] - signal: TRUE
[15:32:59.362] - resignal: FALSE
[15:32:59.363] - force: TRUE
[15:32:59.363] - relayed: [n=1] TRUE
[15:32:59.363] - queued futures: [n=1] TRUE
 - flush all
[15:32:59.364] - relayed: [n=1] TRUE
[15:32:59.364] - queued futures: [n=1] TRUE
[15:32:59.364] signalConditionsASAP(NULL, pos=0) ... done
[15:32:59.364] resolve() on list ... DONE
[15:32:59.365]  - Number of value chunks collected: 1
[15:32:59.365] Resolving 1 futures (chunks) ... DONE
[15:32:59.365] Reducing values from 1 chunks ...
[15:32:59.365]  - Number of values collected after concatenation: 2
[15:32:59.366]  - Number of values expected: 2
[15:32:59.366] Reducing values from 1 chunks ... DONE
[15:32:59.366] future_mapply() ... DONE
* future_mapply(x, ..., future.stdout = FALSE) ... DONE
* future_mapply(x, ..., future.stdout = TRUE) ...
[15:32:59.367] future_mapply() ...
[15:32:59.368] Number of chunks: 1
[15:32:59.368] getGlobalsAndPackagesXApply() ...
[15:32:59.368]  - future.globals: TRUE
[15:32:59.368] getGlobalsAndPackages() ...
[15:32:59.369] Searching for globals...
[15:32:59.372] - globals found: [6] 'FUN', '{', 'Sys.sleep', '/', 'print', 'list'
[15:32:59.372] Searching for globals ... DONE
[15:32:59.373] Resolving globals: FALSE
[15:32:59.374] The total size of the 1 globals is 6.11 KiB (6256 bytes)
[15:32:59.374] The total size of the 1 globals exported for future expression ('FUN()') is 6.11 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (6.11 KiB of class 'function')
[15:32:59.375] - globals: [1] 'FUN'
[15:32:59.375] 
[15:32:59.375] getGlobalsAndPackages() ... DONE
[15:32:59.376]  - globals found/used: [n=1] 'FUN'
[15:32:59.376]  - needed namespaces: [n=0] 
[15:32:59.376] Finding globals ... DONE
[15:32:59.377] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[15:32:59.377] List of 2
[15:32:59.377]  $ ...future.FUN:function (x, y)  
[15:32:59.377]  $ MoreArgs     : NULL
[15:32:59.377]  - attr(*, "where")=List of 2
[15:32:59.377]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:59.377]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[15:32:59.377]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:59.377]  - attr(*, "resolved")= logi FALSE
[15:32:59.377]  - attr(*, "total_size")= num NA
[15:32:59.382] Packages to be attached in all futures: [n=0] 
[15:32:59.382] getGlobalsAndPackagesXApply() ... DONE
[15:32:59.383] Number of futures (= number of chunks): 1
[15:32:59.383] Launching 1 futures (chunks) ...
[15:32:59.383] Chunk #1 of 1 ...
[15:32:59.384]  - Finding globals in '...' for chunk #1 ...
[15:32:59.384] getGlobalsAndPackages() ...
[15:32:59.384] Searching for globals...
[15:32:59.385] 
[15:32:59.385] Searching for globals ... DONE
[15:32:59.385] - globals: [0] <none>
[15:32:59.386] getGlobalsAndPackages() ... DONE
[15:32:59.386]    + additional globals found: [n=0] 
[15:32:59.386]    + additional namespaces needed: [n=0] 
[15:32:59.386]  - Finding globals in '...' for chunk #1 ... DONE
[15:32:59.387]  - seeds: <none>
[15:32:59.387]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:59.387] getGlobalsAndPackages() ...
[15:32:59.388] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:59.388] Resolving globals: FALSE
[15:32:59.389] The total size of the 5 globals is 6.33 KiB (6480 bytes)
[15:32:59.390] The total size of the 5 globals exported for future expression ('{; ...future.globals.maxSize.org <- getOption("future.globals.maxSize"); if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {; oopts <- options(future.globals.maxSize = ...future.globals.maxSize); on.exit(options(oopts), add = TRUE); }; ...; do.call(mapply, args = args); }; }') is 6.33 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (6.11 KiB of class 'function'), '...future.elements_ii' (224 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[15:32:59.390] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:59.391] 
[15:32:59.391] getGlobalsAndPackages() ... DONE
[15:32:59.392] run() for 'Future' ...
[15:32:59.392] - state: 'created'
[15:32:59.392] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:59.393] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:59.393] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:59.394]   - Field: 'label'
[15:32:59.394]   - Field: 'local'
[15:32:59.394]   - Field: 'owner'
[15:32:59.395]   - Field: 'envir'
[15:32:59.395]   - Field: 'packages'
[15:32:59.395]   - Field: 'gc'
[15:32:59.396]   - Field: 'conditions'
[15:32:59.396]   - Field: 'expr'
[15:32:59.396]   - Field: 'uuid'
[15:32:59.397]   - Field: 'seed'
[15:32:59.397]   - Field: 'version'
[15:32:59.397]   - Field: 'result'
[15:32:59.398]   - Field: 'asynchronous'
[15:32:59.398]   - Field: 'calls'
[15:32:59.398]   - Field: 'globals'
[15:32:59.399]   - Field: 'stdout'
[15:32:59.399]   - Field: 'earlySignal'
[15:32:59.399]   - Field: 'lazy'
[15:32:59.400]   - Field: 'state'
[15:32:59.400] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:59.400] - Launch lazy future ...
[15:32:59.401] Packages needed by the future expression (n = 0): <none>
[15:32:59.401] Packages needed by future strategies (n = 0): <none>
[15:32:59.402] {
[15:32:59.402]     {
[15:32:59.402]         {
[15:32:59.402]             ...future.startTime <- base::Sys.time()
[15:32:59.402]             {
[15:32:59.402]                 {
[15:32:59.402]                   {
[15:32:59.402]                     base::local({
[15:32:59.402]                       has_future <- base::requireNamespace("future", 
[15:32:59.402]                         quietly = TRUE)
[15:32:59.402]                       if (has_future) {
[15:32:59.402]                         ns <- base::getNamespace("future")
[15:32:59.402]                         version <- ns[[".package"]][["version"]]
[15:32:59.402]                         if (is.null(version)) 
[15:32:59.402]                           version <- utils::packageVersion("future")
[15:32:59.402]                       }
[15:32:59.402]                       else {
[15:32:59.402]                         version <- NULL
[15:32:59.402]                       }
[15:32:59.402]                       if (!has_future || version < "1.8.0") {
[15:32:59.402]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:59.402]                           "", base::R.version$version.string), 
[15:32:59.402]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:59.402]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:59.402]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:59.402]                             "release", "version")], collapse = " "), 
[15:32:59.402]                           hostname = base::Sys.info()[["nodename"]])
[15:32:59.402]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:59.402]                           info)
[15:32:59.402]                         info <- base::paste(info, collapse = "; ")
[15:32:59.402]                         if (!has_future) {
[15:32:59.402]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:59.402]                             info)
[15:32:59.402]                         }
[15:32:59.402]                         else {
[15:32:59.402]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:59.402]                             info, version)
[15:32:59.402]                         }
[15:32:59.402]                         base::stop(msg)
[15:32:59.402]                       }
[15:32:59.402]                     })
[15:32:59.402]                   }
[15:32:59.402]                   ...future.strategy.old <- future::plan("list")
[15:32:59.402]                   options(future.plan = NULL)
[15:32:59.402]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:59.402]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:59.402]                 }
[15:32:59.402]                 ...future.workdir <- getwd()
[15:32:59.402]             }
[15:32:59.402]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:59.402]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:59.402]         }
[15:32:59.402]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:59.402]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:59.402]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:59.402]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:59.402]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:59.402]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:59.402]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:59.402]             base::names(...future.oldOptions))
[15:32:59.402]     }
[15:32:59.402]     if (FALSE) {
[15:32:59.402]     }
[15:32:59.402]     else {
[15:32:59.402]         if (TRUE) {
[15:32:59.402]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:59.402]                 open = "w")
[15:32:59.402]         }
[15:32:59.402]         else {
[15:32:59.402]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:59.402]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:59.402]         }
[15:32:59.402]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:59.402]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:59.402]             base::sink(type = "output", split = FALSE)
[15:32:59.402]             base::close(...future.stdout)
[15:32:59.402]         }, add = TRUE)
[15:32:59.402]     }
[15:32:59.402]     ...future.frame <- base::sys.nframe()
[15:32:59.402]     ...future.conditions <- base::list()
[15:32:59.402]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:59.402]     if (FALSE) {
[15:32:59.402]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:59.402]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:59.402]     }
[15:32:59.402]     ...future.result <- base::tryCatch({
[15:32:59.402]         base::withCallingHandlers({
[15:32:59.402]             ...future.value <- base::withVisible(base::local({
[15:32:59.402]                 ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:59.402]                 if (!identical(...future.globals.maxSize.org, 
[15:32:59.402]                   ...future.globals.maxSize)) {
[15:32:59.402]                   oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:59.402]                   on.exit(options(oopts), add = TRUE)
[15:32:59.402]                 }
[15:32:59.402]                 {
[15:32:59.402]                   args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:59.402]                     MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:59.402]                     USE.NAMES = FALSE)
[15:32:59.402]                   do.call(mapply, args = args)
[15:32:59.402]                 }
[15:32:59.402]             }))
[15:32:59.402]             future::FutureResult(value = ...future.value$value, 
[15:32:59.402]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:59.402]                   ...future.rng), globalenv = if (FALSE) 
[15:32:59.402]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:59.402]                     ...future.globalenv.names))
[15:32:59.402]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:59.402]         }, condition = base::local({
[15:32:59.402]             c <- base::c
[15:32:59.402]             inherits <- base::inherits
[15:32:59.402]             invokeRestart <- base::invokeRestart
[15:32:59.402]             length <- base::length
[15:32:59.402]             list <- base::list
[15:32:59.402]             seq.int <- base::seq.int
[15:32:59.402]             signalCondition <- base::signalCondition
[15:32:59.402]             sys.calls <- base::sys.calls
[15:32:59.402]             `[[` <- base::`[[`
[15:32:59.402]             `+` <- base::`+`
[15:32:59.402]             `<<-` <- base::`<<-`
[15:32:59.402]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:59.402]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:59.402]                   3L)]
[15:32:59.402]             }
[15:32:59.402]             function(cond) {
[15:32:59.402]                 is_error <- inherits(cond, "error")
[15:32:59.402]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:59.402]                   NULL)
[15:32:59.402]                 if (is_error) {
[15:32:59.402]                   sessionInformation <- function() {
[15:32:59.402]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:59.402]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:59.402]                       search = base::search(), system = base::Sys.info())
[15:32:59.402]                   }
[15:32:59.402]                   ...future.conditions[[length(...future.conditions) + 
[15:32:59.402]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:59.402]                     cond$call), session = sessionInformation(), 
[15:32:59.402]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:59.402]                   signalCondition(cond)
[15:32:59.402]                 }
[15:32:59.402]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:59.402]                 "immediateCondition"))) {
[15:32:59.402]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:59.402]                   ...future.conditions[[length(...future.conditions) + 
[15:32:59.402]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:59.402]                   if (TRUE && !signal) {
[15:32:59.402]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:59.402]                     {
[15:32:59.402]                       inherits <- base::inherits
[15:32:59.402]                       invokeRestart <- base::invokeRestart
[15:32:59.402]                       is.null <- base::is.null
[15:32:59.402]                       muffled <- FALSE
[15:32:59.402]                       if (inherits(cond, "message")) {
[15:32:59.402]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:59.402]                         if (muffled) 
[15:32:59.402]                           invokeRestart("muffleMessage")
[15:32:59.402]                       }
[15:32:59.402]                       else if (inherits(cond, "warning")) {
[15:32:59.402]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:59.402]                         if (muffled) 
[15:32:59.402]                           invokeRestart("muffleWarning")
[15:32:59.402]                       }
[15:32:59.402]                       else if (inherits(cond, "condition")) {
[15:32:59.402]                         if (!is.null(pattern)) {
[15:32:59.402]                           computeRestarts <- base::computeRestarts
[15:32:59.402]                           grepl <- base::grepl
[15:32:59.402]                           restarts <- computeRestarts(cond)
[15:32:59.402]                           for (restart in restarts) {
[15:32:59.402]                             name <- restart$name
[15:32:59.402]                             if (is.null(name)) 
[15:32:59.402]                               next
[15:32:59.402]                             if (!grepl(pattern, name)) 
[15:32:59.402]                               next
[15:32:59.402]                             invokeRestart(restart)
[15:32:59.402]                             muffled <- TRUE
[15:32:59.402]                             break
[15:32:59.402]                           }
[15:32:59.402]                         }
[15:32:59.402]                       }
[15:32:59.402]                       invisible(muffled)
[15:32:59.402]                     }
[15:32:59.402]                     muffleCondition(cond, pattern = "^muffle")
[15:32:59.402]                   }
[15:32:59.402]                 }
[15:32:59.402]                 else {
[15:32:59.402]                   if (TRUE) {
[15:32:59.402]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:59.402]                     {
[15:32:59.402]                       inherits <- base::inherits
[15:32:59.402]                       invokeRestart <- base::invokeRestart
[15:32:59.402]                       is.null <- base::is.null
[15:32:59.402]                       muffled <- FALSE
[15:32:59.402]                       if (inherits(cond, "message")) {
[15:32:59.402]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:59.402]                         if (muffled) 
[15:32:59.402]                           invokeRestart("muffleMessage")
[15:32:59.402]                       }
[15:32:59.402]                       else if (inherits(cond, "warning")) {
[15:32:59.402]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:59.402]                         if (muffled) 
[15:32:59.402]                           invokeRestart("muffleWarning")
[15:32:59.402]                       }
[15:32:59.402]                       else if (inherits(cond, "condition")) {
[15:32:59.402]                         if (!is.null(pattern)) {
[15:32:59.402]                           computeRestarts <- base::computeRestarts
[15:32:59.402]                           grepl <- base::grepl
[15:32:59.402]                           restarts <- computeRestarts(cond)
[15:32:59.402]                           for (restart in restarts) {
[15:32:59.402]                             name <- restart$name
[15:32:59.402]                             if (is.null(name)) 
[15:32:59.402]                               next
[15:32:59.402]                             if (!grepl(pattern, name)) 
[15:32:59.402]                               next
[15:32:59.402]                             invokeRestart(restart)
[15:32:59.402]                             muffled <- TRUE
[15:32:59.402]                             break
[15:32:59.402]                           }
[15:32:59.402]                         }
[15:32:59.402]                       }
[15:32:59.402]                       invisible(muffled)
[15:32:59.402]                     }
[15:32:59.402]                     muffleCondition(cond, pattern = "^muffle")
[15:32:59.402]                   }
[15:32:59.402]                 }
[15:32:59.402]             }
[15:32:59.402]         }))
[15:32:59.402]     }, error = function(ex) {
[15:32:59.402]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:59.402]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:59.402]                 ...future.rng), started = ...future.startTime, 
[15:32:59.402]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:59.402]             version = "1.8"), class = "FutureResult")
[15:32:59.402]     }, finally = {
[15:32:59.402]         if (!identical(...future.workdir, getwd())) 
[15:32:59.402]             setwd(...future.workdir)
[15:32:59.402]         {
[15:32:59.402]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:59.402]                 ...future.oldOptions$nwarnings <- NULL
[15:32:59.402]             }
[15:32:59.402]             base::options(...future.oldOptions)
[15:32:59.402]             if (.Platform$OS.type == "windows") {
[15:32:59.402]                 old_names <- names(...future.oldEnvVars)
[15:32:59.402]                 envs <- base::Sys.getenv()
[15:32:59.402]                 names <- names(envs)
[15:32:59.402]                 common <- intersect(names, old_names)
[15:32:59.402]                 added <- setdiff(names, old_names)
[15:32:59.402]                 removed <- setdiff(old_names, names)
[15:32:59.402]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:59.402]                   envs[common]]
[15:32:59.402]                 NAMES <- toupper(changed)
[15:32:59.402]                 args <- list()
[15:32:59.402]                 for (kk in seq_along(NAMES)) {
[15:32:59.402]                   name <- changed[[kk]]
[15:32:59.402]                   NAME <- NAMES[[kk]]
[15:32:59.402]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:59.402]                     next
[15:32:59.402]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:59.402]                 }
[15:32:59.402]                 NAMES <- toupper(added)
[15:32:59.402]                 for (kk in seq_along(NAMES)) {
[15:32:59.402]                   name <- added[[kk]]
[15:32:59.402]                   NAME <- NAMES[[kk]]
[15:32:59.402]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:59.402]                     next
[15:32:59.402]                   args[[name]] <- ""
[15:32:59.402]                 }
[15:32:59.402]                 NAMES <- toupper(removed)
[15:32:59.402]                 for (kk in seq_along(NAMES)) {
[15:32:59.402]                   name <- removed[[kk]]
[15:32:59.402]                   NAME <- NAMES[[kk]]
[15:32:59.402]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:59.402]                     next
[15:32:59.402]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:59.402]                 }
[15:32:59.402]                 if (length(args) > 0) 
[15:32:59.402]                   base::do.call(base::Sys.setenv, args = args)
[15:32:59.402]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:59.402]             }
[15:32:59.402]             else {
[15:32:59.402]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:59.402]             }
[15:32:59.402]             {
[15:32:59.402]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:59.402]                   0L) {
[15:32:59.402]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:59.402]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:59.402]                   base::options(opts)
[15:32:59.402]                 }
[15:32:59.402]                 {
[15:32:59.402]                   {
[15:32:59.402]                     NULL
[15:32:59.402]                     RNGkind("Mersenne-Twister")
[15:32:59.402]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:59.402]                       inherits = FALSE)
[15:32:59.402]                   }
[15:32:59.402]                   options(future.plan = NULL)
[15:32:59.402]                   if (is.na(NA_character_)) 
[15:32:59.402]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:59.402]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:59.402]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:59.402]                     .init = FALSE)
[15:32:59.402]                 }
[15:32:59.402]             }
[15:32:59.402]         }
[15:32:59.402]     })
[15:32:59.402]     if (TRUE) {
[15:32:59.402]         base::sink(type = "output", split = FALSE)
[15:32:59.402]         if (TRUE) {
[15:32:59.402]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:59.402]         }
[15:32:59.402]         else {
[15:32:59.402]             ...future.result["stdout"] <- base::list(NULL)
[15:32:59.402]         }
[15:32:59.402]         base::close(...future.stdout)
[15:32:59.402]         ...future.stdout <- NULL
[15:32:59.402]     }
[15:32:59.402]     ...future.result$conditions <- ...future.conditions
[15:32:59.402]     ...future.result$finished <- base::Sys.time()
[15:32:59.402]     ...future.result
[15:32:59.402] }
[15:32:59.409] assign_globals() ...
[15:32:59.410] List of 5
[15:32:59.410]  $ ...future.FUN            :function (x, y)  
[15:32:59.410]  $ MoreArgs                 : NULL
[15:32:59.410]  $ ...future.elements_ii    :List of 2
[15:32:59.410]   ..$ :List of 2
[15:32:59.410]   .. ..$ : int 1
[15:32:59.410]   .. ..$ : int 0
[15:32:59.410]   ..$ :List of 2
[15:32:59.410]   .. ..$ : int 0
[15:32:59.410]   .. ..$ : int 1
[15:32:59.410]  $ ...future.seeds_ii       : NULL
[15:32:59.410]  $ ...future.globals.maxSize: NULL
[15:32:59.410]  - attr(*, "where")=List of 5
[15:32:59.410]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:59.410]   ..$ MoreArgs                 :<environment: R_EmptyEnv> 
[15:32:59.410]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:59.410]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:59.410]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:59.410]  - attr(*, "resolved")= logi FALSE
[15:32:59.410]  - attr(*, "total_size")= num 6480
[15:32:59.410]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:59.410]  - attr(*, "already-done")= logi TRUE
[15:32:59.427] - reassign environment for '...future.FUN'
[15:32:59.428] - copied '...future.FUN' to environment
[15:32:59.428] - copied 'MoreArgs' to environment
[15:32:59.429] - copied '...future.elements_ii' to environment
[15:32:59.429] - copied '...future.seeds_ii' to environment
[15:32:59.429] - copied '...future.globals.maxSize' to environment
[15:32:59.430] assign_globals() ... done
[15:32:59.430] plan(): Setting new future strategy stack:
[15:32:59.431] List of future strategies:
[15:32:59.431] 1. sequential:
[15:32:59.431]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:59.431]    - tweaked: FALSE
[15:32:59.431]    - call: NULL
[15:32:59.432] plan(): nbrOfWorkers() = 1
[15:32:59.938] plan(): Setting new future strategy stack:
[15:32:59.939] List of future strategies:
[15:32:59.939] 1. sequential:
[15:32:59.939]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:59.939]    - tweaked: FALSE
[15:32:59.939]    - call: plan(strategy)
[15:32:59.940] plan(): nbrOfWorkers() = 1
[15:32:59.940] SequentialFuture started (and completed)
[15:32:59.941] - Launch lazy future ... done
[15:32:59.941] run() for 'SequentialFuture' ... done
[15:32:59.941] Created future:
[15:32:59.942] SequentialFuture:
[15:32:59.942] Label: 'future_mapply-1'
[15:32:59.942] Expression:
[15:32:59.942] {
[15:32:59.942]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:59.942]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:59.942]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:59.942]         on.exit(options(oopts), add = TRUE)
[15:32:59.942]     }
[15:32:59.942]     {
[15:32:59.942]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:59.942]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:59.942]         do.call(mapply, args = args)
[15:32:59.942]     }
[15:32:59.942] }
[15:32:59.942] Lazy evaluation: FALSE
[15:32:59.942] Asynchronous evaluation: FALSE
[15:32:59.942] Local evaluation: TRUE
[15:32:59.942] Environment: R_GlobalEnv
[15:32:59.942] Capture standard output: TRUE
[15:32:59.942] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:59.942] Globals: 5 objects totaling 6.33 KiB (function '...future.FUN' of 6.11 KiB, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 224 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:59.942] Packages: <none>
[15:32:59.942] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:59.942] Resolved: TRUE
[15:32:59.942] Value: 224 bytes of class 'list'
[15:32:59.942] Early signaling: FALSE
[15:32:59.942] Owner process: bdd4bc13-919d-bf34-b2cf-84eb53f6e11f
[15:32:59.942] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:59.944] Chunk #1 of 1 ... DONE
[15:32:59.944] Launching 1 futures (chunks) ... DONE
[15:32:59.944] Resolving 1 futures (chunks) ...
[15:32:59.944] resolve() on list ...
[15:32:59.945]  recursive: 0
[15:32:59.945]  length: 1
[15:32:59.945] 
[15:32:59.945] resolved() for 'SequentialFuture' ...
[15:32:59.946] - state: 'finished'
[15:32:59.946] - run: TRUE
[15:32:59.946] - result: 'FutureResult'
[15:32:59.947] resolved() for 'SequentialFuture' ... done
[15:32:59.947] Future #1
[15:32:59.947] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:59.948] - nx: 1
[15:32:59.948] - relay: TRUE
[15:32:59.948] - stdout: TRUE
[15:32:59.948] - signal: TRUE
[15:32:59.949] - resignal: FALSE
[15:32:59.949] - force: TRUE
[15:32:59.949] - relayed: [n=1] FALSE
[15:32:59.949] - queued futures: [n=1] FALSE
[15:32:59.950]  - until=1
[15:32:59.950]  - relaying element #1
[15:32:59.950] - relayed: [n=1] TRUE
[15:32:59.951] - queued futures: [n=1] TRUE
[15:32:59.951] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:59.951]  length: 0 (resolved future 1)
[15:32:59.952] Relaying remaining futures
[15:32:59.952] signalConditionsASAP(NULL, pos=0) ...
[15:32:59.952] - nx: 1
[15:32:59.952] - relay: TRUE
[15:32:59.953] - stdout: TRUE
[15:32:59.953] - signal: TRUE
[15:32:59.953] - resignal: FALSE
[15:32:59.953] - force: TRUE
[15:32:59.954] - relayed: [n=1] TRUE
[15:32:59.954] - queued futures: [n=1] TRUE
 - flush all
[15:32:59.954] - relayed: [n=1] TRUE
[15:32:59.954] - queued futures: [n=1] TRUE
[15:32:59.955] signalConditionsASAP(NULL, pos=0) ... done
[15:32:59.955] resolve() on list ... DONE
[15:32:59.955]  - Number of value chunks collected: 1
[15:32:59.956] Resolving 1 futures (chunks) ... DONE
[15:32:59.956] Reducing values from 1 chunks ...
[15:32:59.956]  - Number of values collected after concatenation: 2
[15:32:59.956]  - Number of values expected: 2
[15:32:59.957] Reducing values from 1 chunks ... DONE
[15:32:59.957] future_mapply() ... DONE
* future_mapply(x, ..., future.stdout = TRUE) ... DONE
* future_mapply(x, ..., future.stdout = NA) ...
[15:32:59.958] future_mapply() ...
[15:32:59.958] Number of chunks: 1
[15:32:59.959] getGlobalsAndPackagesXApply() ...
[15:32:59.959]  - future.globals: TRUE
[15:32:59.959] getGlobalsAndPackages() ...
[15:32:59.959] Searching for globals...
[15:32:59.962] - globals found: [6] 'FUN', '{', 'Sys.sleep', '/', 'print', 'list'
[15:32:59.962] Searching for globals ... DONE
[15:32:59.962] Resolving globals: FALSE
[15:32:59.963] The total size of the 1 globals is 6.11 KiB (6256 bytes)
[15:32:59.966] The total size of the 1 globals exported for future expression ('FUN()') is 6.11 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (6.11 KiB of class 'function')
[15:32:59.966] - globals: [1] 'FUN'
[15:32:59.967] 
[15:32:59.967] getGlobalsAndPackages() ... DONE
[15:32:59.967]  - globals found/used: [n=1] 'FUN'
[15:32:59.967]  - needed namespaces: [n=0] 
[15:32:59.968] Finding globals ... DONE
[15:32:59.968] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[15:32:59.968] List of 2
[15:32:59.968]  $ ...future.FUN:function (x, y)  
[15:32:59.968]  $ MoreArgs     : NULL
[15:32:59.968]  - attr(*, "where")=List of 2
[15:32:59.968]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:59.968]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[15:32:59.968]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:59.968]  - attr(*, "resolved")= logi FALSE
[15:32:59.968]  - attr(*, "total_size")= num NA
[15:32:59.972] Packages to be attached in all futures: [n=0] 
[15:32:59.972] getGlobalsAndPackagesXApply() ... DONE
[15:32:59.972] Number of futures (= number of chunks): 1
[15:32:59.973] Launching 1 futures (chunks) ...
[15:32:59.973] Chunk #1 of 1 ...
[15:32:59.973]  - Finding globals in '...' for chunk #1 ...
[15:32:59.973] getGlobalsAndPackages() ...
[15:32:59.973] Searching for globals...
[15:32:59.974] 
[15:32:59.974] Searching for globals ... DONE
[15:32:59.974] - globals: [0] <none>
[15:32:59.974] getGlobalsAndPackages() ... DONE
[15:32:59.974]    + additional globals found: [n=0] 
[15:32:59.975]    + additional namespaces needed: [n=0] 
[15:32:59.975]  - Finding globals in '...' for chunk #1 ... DONE
[15:32:59.975]  - seeds: <none>
[15:32:59.975]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:59.975] getGlobalsAndPackages() ...
[15:32:59.975] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:59.976] Resolving globals: FALSE
[15:32:59.976] The total size of the 5 globals is 6.33 KiB (6480 bytes)
[15:32:59.977] The total size of the 5 globals exported for future expression ('{; ...future.globals.maxSize.org <- getOption("future.globals.maxSize"); if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {; oopts <- options(future.globals.maxSize = ...future.globals.maxSize); on.exit(options(oopts), add = TRUE); }; ...; do.call(mapply, args = args); }; }') is 6.33 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (6.11 KiB of class 'function'), '...future.elements_ii' (224 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[15:32:59.977] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:59.978] 
[15:32:59.978] getGlobalsAndPackages() ... DONE
[15:32:59.978] run() for 'Future' ...
[15:32:59.978] - state: 'created'
[15:32:59.979] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:59.979] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:59.979] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:59.980]   - Field: 'label'
[15:32:59.980]   - Field: 'local'
[15:32:59.980]   - Field: 'owner'
[15:32:59.980]   - Field: 'envir'
[15:32:59.980]   - Field: 'packages'
[15:32:59.980]   - Field: 'gc'
[15:32:59.981]   - Field: 'conditions'
[15:32:59.981]   - Field: 'expr'
[15:32:59.981]   - Field: 'uuid'
[15:32:59.981]   - Field: 'seed'
[15:32:59.981]   - Field: 'version'
[15:32:59.982]   - Field: 'result'
[15:32:59.982]   - Field: 'asynchronous'
[15:32:59.982]   - Field: 'calls'
[15:32:59.982]   - Field: 'globals'
[15:32:59.982]   - Field: 'stdout'
[15:32:59.983]   - Field: 'earlySignal'
[15:32:59.983]   - Field: 'lazy'
[15:32:59.983]   - Field: 'state'
[15:32:59.984] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:59.984] - Launch lazy future ...
[15:32:59.984] Packages needed by the future expression (n = 0): <none>
[15:32:59.985] Packages needed by future strategies (n = 0): <none>
[15:32:59.986] {
[15:32:59.986]     {
[15:32:59.986]         {
[15:32:59.986]             ...future.startTime <- base::Sys.time()
[15:32:59.986]             {
[15:32:59.986]                 {
[15:32:59.986]                   {
[15:32:59.986]                     base::local({
[15:32:59.986]                       has_future <- base::requireNamespace("future", 
[15:32:59.986]                         quietly = TRUE)
[15:32:59.986]                       if (has_future) {
[15:32:59.986]                         ns <- base::getNamespace("future")
[15:32:59.986]                         version <- ns[[".package"]][["version"]]
[15:32:59.986]                         if (is.null(version)) 
[15:32:59.986]                           version <- utils::packageVersion("future")
[15:32:59.986]                       }
[15:32:59.986]                       else {
[15:32:59.986]                         version <- NULL
[15:32:59.986]                       }
[15:32:59.986]                       if (!has_future || version < "1.8.0") {
[15:32:59.986]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:59.986]                           "", base::R.version$version.string), 
[15:32:59.986]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:59.986]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:59.986]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:59.986]                             "release", "version")], collapse = " "), 
[15:32:59.986]                           hostname = base::Sys.info()[["nodename"]])
[15:32:59.986]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:59.986]                           info)
[15:32:59.986]                         info <- base::paste(info, collapse = "; ")
[15:32:59.986]                         if (!has_future) {
[15:32:59.986]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:59.986]                             info)
[15:32:59.986]                         }
[15:32:59.986]                         else {
[15:32:59.986]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:59.986]                             info, version)
[15:32:59.986]                         }
[15:32:59.986]                         base::stop(msg)
[15:32:59.986]                       }
[15:32:59.986]                     })
[15:32:59.986]                   }
[15:32:59.986]                   ...future.strategy.old <- future::plan("list")
[15:32:59.986]                   options(future.plan = NULL)
[15:32:59.986]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:59.986]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:59.986]                 }
[15:32:59.986]                 ...future.workdir <- getwd()
[15:32:59.986]             }
[15:32:59.986]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:59.986]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:59.986]         }
[15:32:59.986]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:59.986]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:59.986]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:59.986]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:59.986]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:59.986]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:59.986]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:59.986]             base::names(...future.oldOptions))
[15:32:59.986]     }
[15:32:59.986]     if (TRUE) {
[15:32:59.986]     }
[15:32:59.986]     else {
[15:32:59.986]         if (NA) {
[15:32:59.986]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:59.986]                 open = "w")
[15:32:59.986]         }
[15:32:59.986]         else {
[15:32:59.986]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:59.986]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:59.986]         }
[15:32:59.986]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:59.986]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:59.986]             base::sink(type = "output", split = FALSE)
[15:32:59.986]             base::close(...future.stdout)
[15:32:59.986]         }, add = TRUE)
[15:32:59.986]     }
[15:32:59.986]     ...future.frame <- base::sys.nframe()
[15:32:59.986]     ...future.conditions <- base::list()
[15:32:59.986]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:59.986]     if (FALSE) {
[15:32:59.986]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:59.986]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:59.986]     }
[15:32:59.986]     ...future.result <- base::tryCatch({
[15:32:59.986]         base::withCallingHandlers({
[15:32:59.986]             ...future.value <- base::withVisible(base::local({
[15:32:59.986]                 ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:59.986]                 if (!identical(...future.globals.maxSize.org, 
[15:32:59.986]                   ...future.globals.maxSize)) {
[15:32:59.986]                   oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:59.986]                   on.exit(options(oopts), add = TRUE)
[15:32:59.986]                 }
[15:32:59.986]                 {
[15:32:59.986]                   args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:59.986]                     MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:59.986]                     USE.NAMES = FALSE)
[15:32:59.986]                   do.call(mapply, args = args)
[15:32:59.986]                 }
[15:32:59.986]             }))
[15:32:59.986]             future::FutureResult(value = ...future.value$value, 
[15:32:59.986]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:59.986]                   ...future.rng), globalenv = if (FALSE) 
[15:32:59.986]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:59.986]                     ...future.globalenv.names))
[15:32:59.986]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:59.986]         }, condition = base::local({
[15:32:59.986]             c <- base::c
[15:32:59.986]             inherits <- base::inherits
[15:32:59.986]             invokeRestart <- base::invokeRestart
[15:32:59.986]             length <- base::length
[15:32:59.986]             list <- base::list
[15:32:59.986]             seq.int <- base::seq.int
[15:32:59.986]             signalCondition <- base::signalCondition
[15:32:59.986]             sys.calls <- base::sys.calls
[15:32:59.986]             `[[` <- base::`[[`
[15:32:59.986]             `+` <- base::`+`
[15:32:59.986]             `<<-` <- base::`<<-`
[15:32:59.986]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:59.986]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:59.986]                   3L)]
[15:32:59.986]             }
[15:32:59.986]             function(cond) {
[15:32:59.986]                 is_error <- inherits(cond, "error")
[15:32:59.986]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:59.986]                   NULL)
[15:32:59.986]                 if (is_error) {
[15:32:59.986]                   sessionInformation <- function() {
[15:32:59.986]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:59.986]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:59.986]                       search = base::search(), system = base::Sys.info())
[15:32:59.986]                   }
[15:32:59.986]                   ...future.conditions[[length(...future.conditions) + 
[15:32:59.986]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:59.986]                     cond$call), session = sessionInformation(), 
[15:32:59.986]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:59.986]                   signalCondition(cond)
[15:32:59.986]                 }
[15:32:59.986]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:59.986]                 "immediateCondition"))) {
[15:32:59.986]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:59.986]                   ...future.conditions[[length(...future.conditions) + 
[15:32:59.986]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:59.986]                   if (TRUE && !signal) {
[15:32:59.986]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:59.986]                     {
[15:32:59.986]                       inherits <- base::inherits
[15:32:59.986]                       invokeRestart <- base::invokeRestart
[15:32:59.986]                       is.null <- base::is.null
[15:32:59.986]                       muffled <- FALSE
[15:32:59.986]                       if (inherits(cond, "message")) {
[15:32:59.986]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:59.986]                         if (muffled) 
[15:32:59.986]                           invokeRestart("muffleMessage")
[15:32:59.986]                       }
[15:32:59.986]                       else if (inherits(cond, "warning")) {
[15:32:59.986]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:59.986]                         if (muffled) 
[15:32:59.986]                           invokeRestart("muffleWarning")
[15:32:59.986]                       }
[15:32:59.986]                       else if (inherits(cond, "condition")) {
[15:32:59.986]                         if (!is.null(pattern)) {
[15:32:59.986]                           computeRestarts <- base::computeRestarts
[15:32:59.986]                           grepl <- base::grepl
[15:32:59.986]                           restarts <- computeRestarts(cond)
[15:32:59.986]                           for (restart in restarts) {
[15:32:59.986]                             name <- restart$name
[15:32:59.986]                             if (is.null(name)) 
[15:32:59.986]                               next
[15:32:59.986]                             if (!grepl(pattern, name)) 
[15:32:59.986]                               next
[15:32:59.986]                             invokeRestart(restart)
[15:32:59.986]                             muffled <- TRUE
[15:32:59.986]                             break
[15:32:59.986]                           }
[15:32:59.986]                         }
[15:32:59.986]                       }
[15:32:59.986]                       invisible(muffled)
[15:32:59.986]                     }
[15:32:59.986]                     muffleCondition(cond, pattern = "^muffle")
[15:32:59.986]                   }
[15:32:59.986]                 }
[15:32:59.986]                 else {
[15:32:59.986]                   if (TRUE) {
[15:32:59.986]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:59.986]                     {
[15:32:59.986]                       inherits <- base::inherits
[15:32:59.986]                       invokeRestart <- base::invokeRestart
[15:32:59.986]                       is.null <- base::is.null
[15:32:59.986]                       muffled <- FALSE
[15:32:59.986]                       if (inherits(cond, "message")) {
[15:32:59.986]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:59.986]                         if (muffled) 
[15:32:59.986]                           invokeRestart("muffleMessage")
[15:32:59.986]                       }
[15:32:59.986]                       else if (inherits(cond, "warning")) {
[15:32:59.986]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:59.986]                         if (muffled) 
[15:32:59.986]                           invokeRestart("muffleWarning")
[15:32:59.986]                       }
[15:32:59.986]                       else if (inherits(cond, "condition")) {
[15:32:59.986]                         if (!is.null(pattern)) {
[15:32:59.986]                           computeRestarts <- base::computeRestarts
[15:32:59.986]                           grepl <- base::grepl
[15:32:59.986]                           restarts <- computeRestarts(cond)
[15:32:59.986]                           for (restart in restarts) {
[15:32:59.986]                             name <- restart$name
[15:32:59.986]                             if (is.null(name)) 
[15:32:59.986]                               next
[15:32:59.986]                             if (!grepl(pattern, name)) 
[15:32:59.986]                               next
[15:32:59.986]                             invokeRestart(restart)
[15:32:59.986]                             muffled <- TRUE
[15:32:59.986]                             break
[15:32:59.986]                           }
[15:32:59.986]                         }
[15:32:59.986]                       }
[15:32:59.986]                       invisible(muffled)
[15:32:59.986]                     }
[15:32:59.986]                     muffleCondition(cond, pattern = "^muffle")
[15:32:59.986]                   }
[15:32:59.986]                 }
[15:32:59.986]             }
[15:32:59.986]         }))
[15:32:59.986]     }, error = function(ex) {
[15:32:59.986]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:59.986]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:59.986]                 ...future.rng), started = ...future.startTime, 
[15:32:59.986]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:59.986]             version = "1.8"), class = "FutureResult")
[15:32:59.986]     }, finally = {
[15:32:59.986]         if (!identical(...future.workdir, getwd())) 
[15:32:59.986]             setwd(...future.workdir)
[15:32:59.986]         {
[15:32:59.986]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:59.986]                 ...future.oldOptions$nwarnings <- NULL
[15:32:59.986]             }
[15:32:59.986]             base::options(...future.oldOptions)
[15:32:59.986]             if (.Platform$OS.type == "windows") {
[15:32:59.986]                 old_names <- names(...future.oldEnvVars)
[15:32:59.986]                 envs <- base::Sys.getenv()
[15:32:59.986]                 names <- names(envs)
[15:32:59.986]                 common <- intersect(names, old_names)
[15:32:59.986]                 added <- setdiff(names, old_names)
[15:32:59.986]                 removed <- setdiff(old_names, names)
[15:32:59.986]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:59.986]                   envs[common]]
[15:32:59.986]                 NAMES <- toupper(changed)
[15:32:59.986]                 args <- list()
[15:32:59.986]                 for (kk in seq_along(NAMES)) {
[15:32:59.986]                   name <- changed[[kk]]
[15:32:59.986]                   NAME <- NAMES[[kk]]
[15:32:59.986]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:59.986]                     next
[15:32:59.986]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:59.986]                 }
[15:32:59.986]                 NAMES <- toupper(added)
[15:32:59.986]                 for (kk in seq_along(NAMES)) {
[15:32:59.986]                   name <- added[[kk]]
[15:32:59.986]                   NAME <- NAMES[[kk]]
[15:32:59.986]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:59.986]                     next
[15:32:59.986]                   args[[name]] <- ""
[15:32:59.986]                 }
[15:32:59.986]                 NAMES <- toupper(removed)
[15:32:59.986]                 for (kk in seq_along(NAMES)) {
[15:32:59.986]                   name <- removed[[kk]]
[15:32:59.986]                   NAME <- NAMES[[kk]]
[15:32:59.986]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:59.986]                     next
[15:32:59.986]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:59.986]                 }
[15:32:59.986]                 if (length(args) > 0) 
[15:32:59.986]                   base::do.call(base::Sys.setenv, args = args)
[15:32:59.986]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:59.986]             }
[15:32:59.986]             else {
[15:32:59.986]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:59.986]             }
[15:32:59.986]             {
[15:32:59.986]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:59.986]                   0L) {
[15:32:59.986]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:59.986]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:59.986]                   base::options(opts)
[15:32:59.986]                 }
[15:32:59.986]                 {
[15:32:59.986]                   {
[15:32:59.986]                     NULL
[15:32:59.986]                     RNGkind("Mersenne-Twister")
[15:32:59.986]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:59.986]                       inherits = FALSE)
[15:32:59.986]                   }
[15:32:59.986]                   options(future.plan = NULL)
[15:32:59.986]                   if (is.na(NA_character_)) 
[15:32:59.986]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:59.986]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:59.986]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:59.986]                     .init = FALSE)
[15:32:59.986]                 }
[15:32:59.986]             }
[15:32:59.986]         }
[15:32:59.986]     })
[15:32:59.986]     if (FALSE) {
[15:32:59.986]         base::sink(type = "output", split = FALSE)
[15:32:59.986]         if (NA) {
[15:32:59.986]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:59.986]         }
[15:32:59.986]         else {
[15:32:59.986]             ...future.result["stdout"] <- base::list(NULL)
[15:32:59.986]         }
[15:32:59.986]         base::close(...future.stdout)
[15:32:59.986]         ...future.stdout <- NULL
[15:32:59.986]     }
[15:32:59.986]     ...future.result$conditions <- ...future.conditions
[15:32:59.986]     ...future.result$finished <- base::Sys.time()
[15:32:59.986]     ...future.result
[15:32:59.986] }
[15:32:59.992] assign_globals() ...
[15:32:59.993] List of 5
[15:32:59.993]  $ ...future.FUN            :function (x, y)  
[15:32:59.993]  $ MoreArgs                 : NULL
[15:32:59.993]  $ ...future.elements_ii    :List of 2
[15:32:59.993]   ..$ :List of 2
[15:32:59.993]   .. ..$ : int 1
[15:32:59.993]   .. ..$ : int 0
[15:32:59.993]   ..$ :List of 2
[15:32:59.993]   .. ..$ : int 0
[15:32:59.993]   .. ..$ : int 1
[15:32:59.993]  $ ...future.seeds_ii       : NULL
[15:32:59.993]  $ ...future.globals.maxSize: NULL
[15:32:59.993]  - attr(*, "where")=List of 5
[15:32:59.993]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:59.993]   ..$ MoreArgs                 :<environment: R_EmptyEnv> 
[15:32:59.993]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:59.993]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:59.993]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:59.993]  - attr(*, "resolved")= logi FALSE
[15:32:59.993]  - attr(*, "total_size")= num 6480
[15:32:59.993]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:59.993]  - attr(*, "already-done")= logi TRUE
[15:33:00.004] - reassign environment for '...future.FUN'
[15:33:00.005] - copied '...future.FUN' to environment
[15:33:00.008] - copied 'MoreArgs' to environment
[15:33:00.008] - copied '...future.elements_ii' to environment
[15:33:00.009] - copied '...future.seeds_ii' to environment
[15:33:00.009] - copied '...future.globals.maxSize' to environment
[15:33:00.009] assign_globals() ... done
[15:33:00.010] plan(): Setting new future strategy stack:
[15:33:00.010] List of future strategies:
[15:33:00.010] 1. sequential:
[15:33:00.010]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:33:00.010]    - tweaked: FALSE
[15:33:00.010]    - call: NULL
[15:33:00.011] plan(): nbrOfWorkers() = 1
[15:33:00.517] plan(): Setting new future strategy stack:
[15:33:00.517] List of future strategies:
[15:33:00.517] 1. sequential:
[15:33:00.517]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:33:00.517]    - tweaked: FALSE
[15:33:00.517]    - call: plan(strategy)
[15:33:00.518] plan(): nbrOfWorkers() = 1
[15:33:00.519] SequentialFuture started (and completed)
[15:33:00.519] - Launch lazy future ... done
[15:33:00.519] run() for 'SequentialFuture' ... done
[15:33:00.520] Created future:
[15:33:00.520] SequentialFuture:
[15:33:00.520] Label: 'future_mapply-1'
[15:33:00.520] Expression:
[15:33:00.520] {
[15:33:00.520]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:33:00.520]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:33:00.520]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:33:00.520]         on.exit(options(oopts), add = TRUE)
[15:33:00.520]     }
[15:33:00.520]     {
[15:33:00.520]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:33:00.520]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:33:00.520]         do.call(mapply, args = args)
[15:33:00.520]     }
[15:33:00.520] }
[15:33:00.520] Lazy evaluation: FALSE
[15:33:00.520] Asynchronous evaluation: FALSE
[15:33:00.520] Local evaluation: TRUE
[15:33:00.520] Environment: R_GlobalEnv
[15:33:00.520] Capture standard output: NA
[15:33:00.520] Capture condition classes: 'condition' (excluding 'nothing')
[15:33:00.520] Globals: 5 objects totaling 6.33 KiB (function '...future.FUN' of 6.11 KiB, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 224 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:33:00.520] Packages: <none>
[15:33:00.520] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:33:00.520] Resolved: TRUE
[15:33:00.520] Value: 224 bytes of class 'list'
[15:33:00.520] Early signaling: FALSE
[15:33:00.520] Owner process: bdd4bc13-919d-bf34-b2cf-84eb53f6e11f
[15:33:00.520] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:33:00.522] Chunk #1 of 1 ... DONE
[15:33:00.522] Launching 1 futures (chunks) ... DONE
[15:33:00.522] Resolving 1 futures (chunks) ...
[15:33:00.522] resolve() on list ...
[15:33:00.522]  recursive: 0
[15:33:00.523]  length: 1
[15:33:00.523] 
[15:33:00.523] resolved() for 'SequentialFuture' ...
[15:33:00.523] - state: 'finished'
[15:33:00.523] - run: TRUE
[15:33:00.524] - result: 'FutureResult'
[15:33:00.524] resolved() for 'SequentialFuture' ... done
[15:33:00.524] Future #1
[15:33:00.524] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:33:00.524] - nx: 1
[15:33:00.525] - relay: TRUE
[15:33:00.525] - stdout: TRUE
[15:33:00.525] - signal: TRUE
[15:33:00.525] - resignal: FALSE
[15:33:00.525] - force: TRUE
[15:33:00.526] - relayed: [n=1] FALSE
[15:33:00.526] - queued futures: [n=1] FALSE
[15:33:00.526]  - until=1
[15:33:00.526]  - relaying element #1
[15:33:00.526] - relayed: [n=1] TRUE
[15:33:00.527] - queued futures: [n=1] TRUE
[15:33:00.527] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:33:00.527]  length: 0 (resolved future 1)
[15:33:00.527] Relaying remaining futures
[15:33:00.527] signalConditionsASAP(NULL, pos=0) ...
[15:33:00.527] - nx: 1
[15:33:00.528] - relay: TRUE
[15:33:00.528] - stdout: TRUE
[15:33:00.528] - signal: TRUE
[15:33:00.528] - resignal: FALSE
[15:33:00.528] - force: TRUE
[15:33:00.528] - relayed: [n=1] TRUE
[15:33:00.529] - queued futures: [n=1] TRUE
 - flush all
[15:33:00.529] - relayed: [n=1] TRUE
[15:33:00.529] - queued futures: [n=1] TRUE
[15:33:00.529] signalConditionsASAP(NULL, pos=0) ... done
[15:33:00.529] resolve() on list ... DONE
[15:33:00.530]  - Number of value chunks collected: 1
[15:33:00.530] Resolving 1 futures (chunks) ... DONE
[15:33:00.530] Reducing values from 1 chunks ...
[15:33:00.530]  - Number of values collected after concatenation: 2
[15:33:00.530]  - Number of values expected: 2
[15:33:00.530] Reducing values from 1 chunks ... DONE
[15:33:00.531] future_mapply() ... DONE
* future_mapply(x, ..., future.stdout = NA) ... DONE
* plan('sequential') ... DONE
* plan('multisession') ...
[15:33:00.531] plan(): Setting new future strategy stack:
[15:33:00.532] List of future strategies:
[15:33:00.532] 1. multisession:
[15:33:00.532]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[15:33:00.532]    - tweaked: FALSE
[15:33:00.532]    - call: plan(strategy)
[15:33:00.532] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
[15:33:00.533] multisession:
[15:33:00.533] - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[15:33:00.533] - tweaked: FALSE
[15:33:00.533] - call: plan(strategy)
[15:33:00.536] getGlobalsAndPackages() ...
[15:33:00.536] Not searching for globals
[15:33:00.536] - globals: [0] <none>
[15:33:00.536] getGlobalsAndPackages() ... DONE
[15:33:00.537] Packages needed by the future expression (n = 0): <none>
[15:33:00.537] Packages needed by future strategies (n = 0): <none>
[15:33:00.538] {
[15:33:00.538]     {
[15:33:00.538]         {
[15:33:00.538]             ...future.startTime <- base::Sys.time()
[15:33:00.538]             {
[15:33:00.538]                 {
[15:33:00.538]                   {
[15:33:00.538]                     base::local({
[15:33:00.538]                       has_future <- base::requireNamespace("future", 
[15:33:00.538]                         quietly = TRUE)
[15:33:00.538]                       if (has_future) {
[15:33:00.538]                         ns <- base::getNamespace("future")
[15:33:00.538]                         version <- ns[[".package"]][["version"]]
[15:33:00.538]                         if (is.null(version)) 
[15:33:00.538]                           version <- utils::packageVersion("future")
[15:33:00.538]                       }
[15:33:00.538]                       else {
[15:33:00.538]                         version <- NULL
[15:33:00.538]                       }
[15:33:00.538]                       if (!has_future || version < "1.8.0") {
[15:33:00.538]                         info <- base::c(r_version = base::gsub("R version ", 
[15:33:00.538]                           "", base::R.version$version.string), 
[15:33:00.538]                           platform = base::sprintf("%s (%s-bit)", 
[15:33:00.538]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:33:00.538]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:33:00.538]                             "release", "version")], collapse = " "), 
[15:33:00.538]                           hostname = base::Sys.info()[["nodename"]])
[15:33:00.538]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:33:00.538]                           info)
[15:33:00.538]                         info <- base::paste(info, collapse = "; ")
[15:33:00.538]                         if (!has_future) {
[15:33:00.538]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:33:00.538]                             info)
[15:33:00.538]                         }
[15:33:00.538]                         else {
[15:33:00.538]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:33:00.538]                             info, version)
[15:33:00.538]                         }
[15:33:00.538]                         base::stop(msg)
[15:33:00.538]                       }
[15:33:00.538]                     })
[15:33:00.538]                   }
[15:33:00.538]                   ...future.strategy.old <- future::plan("list")
[15:33:00.538]                   options(future.plan = NULL)
[15:33:00.538]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:33:00.538]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:33:00.538]                 }
[15:33:00.538]                 ...future.workdir <- getwd()
[15:33:00.538]             }
[15:33:00.538]             ...future.oldOptions <- base::as.list(base::.Options)
[15:33:00.538]             ...future.oldEnvVars <- base::Sys.getenv()
[15:33:00.538]         }
[15:33:00.538]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:33:00.538]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:33:00.538]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:33:00.538]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:33:00.538]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:33:00.538]             future.stdout.windows.reencode = NULL, width = 80L)
[15:33:00.538]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:33:00.538]             base::names(...future.oldOptions))
[15:33:00.538]     }
[15:33:00.538]     if (FALSE) {
[15:33:00.538]     }
[15:33:00.538]     else {
[15:33:00.538]         if (TRUE) {
[15:33:00.538]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:33:00.538]                 open = "w")
[15:33:00.538]         }
[15:33:00.538]         else {
[15:33:00.538]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:33:00.538]                 windows = "NUL", "/dev/null"), open = "w")
[15:33:00.538]         }
[15:33:00.538]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:33:00.538]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:33:00.538]             base::sink(type = "output", split = FALSE)
[15:33:00.538]             base::close(...future.stdout)
[15:33:00.538]         }, add = TRUE)
[15:33:00.538]     }
[15:33:00.538]     ...future.frame <- base::sys.nframe()
[15:33:00.538]     ...future.conditions <- base::list()
[15:33:00.538]     ...future.rng <- base::globalenv()$.Random.seed
[15:33:00.538]     if (FALSE) {
[15:33:00.538]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:33:00.538]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:33:00.538]     }
[15:33:00.538]     ...future.result <- base::tryCatch({
[15:33:00.538]         base::withCallingHandlers({
[15:33:00.538]             ...future.value <- base::withVisible(base::local(NA))
[15:33:00.538]             future::FutureResult(value = ...future.value$value, 
[15:33:00.538]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:33:00.538]                   ...future.rng), globalenv = if (FALSE) 
[15:33:00.538]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:33:00.538]                     ...future.globalenv.names))
[15:33:00.538]                 else NULL, started = ...future.startTime, version = "1.8")
[15:33:00.538]         }, condition = base::local({
[15:33:00.538]             c <- base::c
[15:33:00.538]             inherits <- base::inherits
[15:33:00.538]             invokeRestart <- base::invokeRestart
[15:33:00.538]             length <- base::length
[15:33:00.538]             list <- base::list
[15:33:00.538]             seq.int <- base::seq.int
[15:33:00.538]             signalCondition <- base::signalCondition
[15:33:00.538]             sys.calls <- base::sys.calls
[15:33:00.538]             `[[` <- base::`[[`
[15:33:00.538]             `+` <- base::`+`
[15:33:00.538]             `<<-` <- base::`<<-`
[15:33:00.538]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:33:00.538]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:33:00.538]                   3L)]
[15:33:00.538]             }
[15:33:00.538]             function(cond) {
[15:33:00.538]                 is_error <- inherits(cond, "error")
[15:33:00.538]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:33:00.538]                   NULL)
[15:33:00.538]                 if (is_error) {
[15:33:00.538]                   sessionInformation <- function() {
[15:33:00.538]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:33:00.538]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:33:00.538]                       search = base::search(), system = base::Sys.info())
[15:33:00.538]                   }
[15:33:00.538]                   ...future.conditions[[length(...future.conditions) + 
[15:33:00.538]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:33:00.538]                     cond$call), session = sessionInformation(), 
[15:33:00.538]                     timestamp = base::Sys.time(), signaled = 0L)
[15:33:00.538]                   signalCondition(cond)
[15:33:00.538]                 }
[15:33:00.538]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:33:00.538]                 "immediateCondition"))) {
[15:33:00.538]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:33:00.538]                   ...future.conditions[[length(...future.conditions) + 
[15:33:00.538]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:33:00.538]                   if (TRUE && !signal) {
[15:33:00.538]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:33:00.538]                     {
[15:33:00.538]                       inherits <- base::inherits
[15:33:00.538]                       invokeRestart <- base::invokeRestart
[15:33:00.538]                       is.null <- base::is.null
[15:33:00.538]                       muffled <- FALSE
[15:33:00.538]                       if (inherits(cond, "message")) {
[15:33:00.538]                         muffled <- grepl(pattern, "muffleMessage")
[15:33:00.538]                         if (muffled) 
[15:33:00.538]                           invokeRestart("muffleMessage")
[15:33:00.538]                       }
[15:33:00.538]                       else if (inherits(cond, "warning")) {
[15:33:00.538]                         muffled <- grepl(pattern, "muffleWarning")
[15:33:00.538]                         if (muffled) 
[15:33:00.538]                           invokeRestart("muffleWarning")
[15:33:00.538]                       }
[15:33:00.538]                       else if (inherits(cond, "condition")) {
[15:33:00.538]                         if (!is.null(pattern)) {
[15:33:00.538]                           computeRestarts <- base::computeRestarts
[15:33:00.538]                           grepl <- base::grepl
[15:33:00.538]                           restarts <- computeRestarts(cond)
[15:33:00.538]                           for (restart in restarts) {
[15:33:00.538]                             name <- restart$name
[15:33:00.538]                             if (is.null(name)) 
[15:33:00.538]                               next
[15:33:00.538]                             if (!grepl(pattern, name)) 
[15:33:00.538]                               next
[15:33:00.538]                             invokeRestart(restart)
[15:33:00.538]                             muffled <- TRUE
[15:33:00.538]                             break
[15:33:00.538]                           }
[15:33:00.538]                         }
[15:33:00.538]                       }
[15:33:00.538]                       invisible(muffled)
[15:33:00.538]                     }
[15:33:00.538]                     muffleCondition(cond, pattern = "^muffle")
[15:33:00.538]                   }
[15:33:00.538]                 }
[15:33:00.538]                 else {
[15:33:00.538]                   if (TRUE) {
[15:33:00.538]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:33:00.538]                     {
[15:33:00.538]                       inherits <- base::inherits
[15:33:00.538]                       invokeRestart <- base::invokeRestart
[15:33:00.538]                       is.null <- base::is.null
[15:33:00.538]                       muffled <- FALSE
[15:33:00.538]                       if (inherits(cond, "message")) {
[15:33:00.538]                         muffled <- grepl(pattern, "muffleMessage")
[15:33:00.538]                         if (muffled) 
[15:33:00.538]                           invokeRestart("muffleMessage")
[15:33:00.538]                       }
[15:33:00.538]                       else if (inherits(cond, "warning")) {
[15:33:00.538]                         muffled <- grepl(pattern, "muffleWarning")
[15:33:00.538]                         if (muffled) 
[15:33:00.538]                           invokeRestart("muffleWarning")
[15:33:00.538]                       }
[15:33:00.538]                       else if (inherits(cond, "condition")) {
[15:33:00.538]                         if (!is.null(pattern)) {
[15:33:00.538]                           computeRestarts <- base::computeRestarts
[15:33:00.538]                           grepl <- base::grepl
[15:33:00.538]                           restarts <- computeRestarts(cond)
[15:33:00.538]                           for (restart in restarts) {
[15:33:00.538]                             name <- restart$name
[15:33:00.538]                             if (is.null(name)) 
[15:33:00.538]                               next
[15:33:00.538]                             if (!grepl(pattern, name)) 
[15:33:00.538]                               next
[15:33:00.538]                             invokeRestart(restart)
[15:33:00.538]                             muffled <- TRUE
[15:33:00.538]                             break
[15:33:00.538]                           }
[15:33:00.538]                         }
[15:33:00.538]                       }
[15:33:00.538]                       invisible(muffled)
[15:33:00.538]                     }
[15:33:00.538]                     muffleCondition(cond, pattern = "^muffle")
[15:33:00.538]                   }
[15:33:00.538]                 }
[15:33:00.538]             }
[15:33:00.538]         }))
[15:33:00.538]     }, error = function(ex) {
[15:33:00.538]         base::structure(base::list(value = NULL, visible = NULL, 
[15:33:00.538]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:33:00.538]                 ...future.rng), started = ...future.startTime, 
[15:33:00.538]             finished = Sys.time(), session_uuid = NA_character_, 
[15:33:00.538]             version = "1.8"), class = "FutureResult")
[15:33:00.538]     }, finally = {
[15:33:00.538]         if (!identical(...future.workdir, getwd())) 
[15:33:00.538]             setwd(...future.workdir)
[15:33:00.538]         {
[15:33:00.538]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:33:00.538]                 ...future.oldOptions$nwarnings <- NULL
[15:33:00.538]             }
[15:33:00.538]             base::options(...future.oldOptions)
[15:33:00.538]             if (.Platform$OS.type == "windows") {
[15:33:00.538]                 old_names <- names(...future.oldEnvVars)
[15:33:00.538]                 envs <- base::Sys.getenv()
[15:33:00.538]                 names <- names(envs)
[15:33:00.538]                 common <- intersect(names, old_names)
[15:33:00.538]                 added <- setdiff(names, old_names)
[15:33:00.538]                 removed <- setdiff(old_names, names)
[15:33:00.538]                 changed <- common[...future.oldEnvVars[common] != 
[15:33:00.538]                   envs[common]]
[15:33:00.538]                 NAMES <- toupper(changed)
[15:33:00.538]                 args <- list()
[15:33:00.538]                 for (kk in seq_along(NAMES)) {
[15:33:00.538]                   name <- changed[[kk]]
[15:33:00.538]                   NAME <- NAMES[[kk]]
[15:33:00.538]                   if (name != NAME && is.element(NAME, old_names)) 
[15:33:00.538]                     next
[15:33:00.538]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:33:00.538]                 }
[15:33:00.538]                 NAMES <- toupper(added)
[15:33:00.538]                 for (kk in seq_along(NAMES)) {
[15:33:00.538]                   name <- added[[kk]]
[15:33:00.538]                   NAME <- NAMES[[kk]]
[15:33:00.538]                   if (name != NAME && is.element(NAME, old_names)) 
[15:33:00.538]                     next
[15:33:00.538]                   args[[name]] <- ""
[15:33:00.538]                 }
[15:33:00.538]                 NAMES <- toupper(removed)
[15:33:00.538]                 for (kk in seq_along(NAMES)) {
[15:33:00.538]                   name <- removed[[kk]]
[15:33:00.538]                   NAME <- NAMES[[kk]]
[15:33:00.538]                   if (name != NAME && is.element(NAME, old_names)) 
[15:33:00.538]                     next
[15:33:00.538]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:33:00.538]                 }
[15:33:00.538]                 if (length(args) > 0) 
[15:33:00.538]                   base::do.call(base::Sys.setenv, args = args)
[15:33:00.538]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:33:00.538]             }
[15:33:00.538]             else {
[15:33:00.538]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:33:00.538]             }
[15:33:00.538]             {
[15:33:00.538]                 if (base::length(...future.futureOptionsAdded) > 
[15:33:00.538]                   0L) {
[15:33:00.538]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:33:00.538]                   base::names(opts) <- ...future.futureOptionsAdded
[15:33:00.538]                   base::options(opts)
[15:33:00.538]                 }
[15:33:00.538]                 {
[15:33:00.538]                   {
[15:33:00.538]                     NULL
[15:33:00.538]                     RNGkind("Mersenne-Twister")
[15:33:00.538]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:33:00.538]                       inherits = FALSE)
[15:33:00.538]                   }
[15:33:00.538]                   options(future.plan = NULL)
[15:33:00.538]                   if (is.na(NA_character_)) 
[15:33:00.538]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:33:00.538]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:33:00.538]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:33:00.538]                     .init = FALSE)
[15:33:00.538]                 }
[15:33:00.538]             }
[15:33:00.538]         }
[15:33:00.538]     })
[15:33:00.538]     if (TRUE) {
[15:33:00.538]         base::sink(type = "output", split = FALSE)
[15:33:00.538]         if (TRUE) {
[15:33:00.538]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:33:00.538]         }
[15:33:00.538]         else {
[15:33:00.538]             ...future.result["stdout"] <- base::list(NULL)
[15:33:00.538]         }
[15:33:00.538]         base::close(...future.stdout)
[15:33:00.538]         ...future.stdout <- NULL
[15:33:00.538]     }
[15:33:00.538]     ...future.result$conditions <- ...future.conditions
[15:33:00.538]     ...future.result$finished <- base::Sys.time()
[15:33:00.538]     ...future.result
[15:33:00.538] }
[15:33:00.545] plan(): Setting new future strategy stack:
[15:33:00.545] List of future strategies:
[15:33:00.545] 1. sequential:
[15:33:00.545]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:33:00.545]    - tweaked: FALSE
[15:33:00.545]    - call: NULL
[15:33:00.546] plan(): nbrOfWorkers() = 1
[15:33:00.548] plan(): Setting new future strategy stack:
[15:33:00.548] List of future strategies:
[15:33:00.548] 1. multisession:
[15:33:00.548]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[15:33:00.548]    - tweaked: FALSE
[15:33:00.548]    - call: plan(strategy)
[15:33:00.551] plan(): nbrOfWorkers() = 1
[15:33:00.551] SequentialFuture started (and completed)
[15:33:00.551] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
[15:33:00.554] plan(): nbrOfWorkers() = 1
* future_lapply(x, ..., future.stdout = FALSE) ...
[15:33:00.554] future_lapply() ...
[15:33:00.559] Number of chunks: 1
[15:33:00.559] getGlobalsAndPackagesXApply() ...
[15:33:00.559]  - future.globals: TRUE
[15:33:00.559] getGlobalsAndPackages() ...
[15:33:00.560] Searching for globals...
[15:33:00.562] - globals found: [5] 'FUN', '{', 'Sys.sleep', '/', 'print'
[15:33:00.562] Searching for globals ... DONE
[15:33:00.563] Resolving globals: FALSE
[15:33:00.563] The total size of the 1 globals is 4.61 KiB (4720 bytes)
[15:33:00.564] The total size of the 1 globals exported for future expression ('FUN()') is 4.61 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.61 KiB of class 'function')
[15:33:00.564] - globals: [1] 'FUN'
[15:33:00.565] 
[15:33:00.565] getGlobalsAndPackages() ... DONE
[15:33:00.565]  - globals found/used: [n=1] 'FUN'
[15:33:00.566]  - needed namespaces: [n=0] 
[15:33:00.566] Finding globals ... DONE
[15:33:00.566]  - use_args: TRUE
[15:33:00.567]  - Getting '...' globals ...
[15:33:00.567] resolve() on list ...
[15:33:00.568]  recursive: 0
[15:33:00.568]  length: 1
[15:33:00.568]  elements: '...'
[15:33:00.569]  length: 0 (resolved future 1)
[15:33:00.569] resolve() on list ... DONE
[15:33:00.569]    - '...' content: [n=0] 
[15:33:00.570] List of 1
[15:33:00.570]  $ ...: list()
[15:33:00.570]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:33:00.570]  - attr(*, "where")=List of 1
[15:33:00.570]   ..$ ...:<environment: 0x0000027fc0403bc0> 
[15:33:00.570]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:33:00.570]  - attr(*, "resolved")= logi TRUE
[15:33:00.570]  - attr(*, "total_size")= num NA
[15:33:00.575]  - Getting '...' globals ... DONE
[15:33:00.576] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:33:00.576] List of 2
[15:33:00.576]  $ ...future.FUN:function (x)  
[15:33:00.576]  $ ...          : list()
[15:33:00.576]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:33:00.576]  - attr(*, "where")=List of 2
[15:33:00.576]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:33:00.576]   ..$ ...          :<environment: 0x0000027fc0403bc0> 
[15:33:00.576]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:33:00.576]  - attr(*, "resolved")= logi FALSE
[15:33:00.576]  - attr(*, "total_size")= num 4720
[15:33:00.582] Packages to be attached in all futures: [n=0] 
[15:33:00.583] getGlobalsAndPackagesXApply() ... DONE
[15:33:00.583] Number of futures (= number of chunks): 1
[15:33:00.583] Launching 1 futures (chunks) ...
[15:33:00.584] Chunk #1 of 1 ...
[15:33:00.584]  - Finding globals in 'X' for chunk #1 ...
[15:33:00.584] getGlobalsAndPackages() ...
[15:33:00.585] Searching for globals...
[15:33:00.585] 
[15:33:00.586] Searching for globals ... DONE
[15:33:00.586] - globals: [0] <none>
[15:33:00.586] getGlobalsAndPackages() ... DONE
[15:33:00.586]    + additional globals found: [n=0] 
[15:33:00.587]    + additional namespaces needed: [n=0] 
[15:33:00.587]  - Finding globals in 'X' for chunk #1 ... DONE
[15:33:00.587]  - seeds: <none>
[15:33:00.587]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:33:00.588] getGlobalsAndPackages() ...
[15:33:00.588] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:33:00.588] Resolving globals: FALSE
[15:33:00.589] Tweak future expression to call with '...' arguments ...
[15:33:00.589] {
[15:33:00.589]     do.call(function(...) {
[15:33:00.589]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:33:00.589]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:33:00.589]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:33:00.589]             on.exit(options(oopts), add = TRUE)
[15:33:00.589]         }
[15:33:00.589]         {
[15:33:00.589]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:33:00.589]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:33:00.589]                 ...future.FUN(...future.X_jj, ...)
[15:33:00.589]             })
[15:33:00.589]         }
[15:33:00.589]     }, args = future.call.arguments)
[15:33:00.589] }
[15:33:00.590] Tweak future expression to call with '...' arguments ... DONE
[15:33:00.591] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:33:00.591] 
[15:33:00.591] getGlobalsAndPackages() ... DONE
[15:33:00.592] run() for 'Future' ...
[15:33:00.592] - state: 'created'
[15:33:00.592] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:33:00.597] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:33:00.598] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:33:00.598]   - Field: 'label'
[15:33:00.598]   - Field: 'local'
[15:33:00.599]   - Field: 'owner'
[15:33:00.599]   - Field: 'envir'
[15:33:00.600]   - Field: 'packages'
[15:33:00.600]   - Field: 'gc'
[15:33:00.600]   - Field: 'conditions'
[15:33:00.601]   - Field: 'expr'
[15:33:00.601]   - Field: 'uuid'
[15:33:00.601]   - Field: 'seed'
[15:33:00.602]   - Field: 'version'
[15:33:00.602]   - Field: 'result'
[15:33:00.602]   - Field: 'asynchronous'
[15:33:00.603]   - Field: 'calls'
[15:33:00.603]   - Field: 'globals'
[15:33:00.603]   - Field: 'stdout'
[15:33:00.607]   - Field: 'earlySignal'
[15:33:00.607]   - Field: 'lazy'
[15:33:00.607]   - Field: 'state'
[15:33:00.608] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:33:00.608] - Launch lazy future ...
[15:33:00.609] Packages needed by the future expression (n = 0): <none>
[15:33:00.609] Packages needed by future strategies (n = 0): <none>
[15:33:00.610] {
[15:33:00.610]     {
[15:33:00.610]         {
[15:33:00.610]             ...future.startTime <- base::Sys.time()
[15:33:00.610]             {
[15:33:00.610]                 {
[15:33:00.610]                   {
[15:33:00.610]                     base::local({
[15:33:00.610]                       has_future <- base::requireNamespace("future", 
[15:33:00.610]                         quietly = TRUE)
[15:33:00.610]                       if (has_future) {
[15:33:00.610]                         ns <- base::getNamespace("future")
[15:33:00.610]                         version <- ns[[".package"]][["version"]]
[15:33:00.610]                         if (is.null(version)) 
[15:33:00.610]                           version <- utils::packageVersion("future")
[15:33:00.610]                       }
[15:33:00.610]                       else {
[15:33:00.610]                         version <- NULL
[15:33:00.610]                       }
[15:33:00.610]                       if (!has_future || version < "1.8.0") {
[15:33:00.610]                         info <- base::c(r_version = base::gsub("R version ", 
[15:33:00.610]                           "", base::R.version$version.string), 
[15:33:00.610]                           platform = base::sprintf("%s (%s-bit)", 
[15:33:00.610]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:33:00.610]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:33:00.610]                             "release", "version")], collapse = " "), 
[15:33:00.610]                           hostname = base::Sys.info()[["nodename"]])
[15:33:00.610]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:33:00.610]                           info)
[15:33:00.610]                         info <- base::paste(info, collapse = "; ")
[15:33:00.610]                         if (!has_future) {
[15:33:00.610]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:33:00.610]                             info)
[15:33:00.610]                         }
[15:33:00.610]                         else {
[15:33:00.610]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:33:00.610]                             info, version)
[15:33:00.610]                         }
[15:33:00.610]                         base::stop(msg)
[15:33:00.610]                       }
[15:33:00.610]                     })
[15:33:00.610]                   }
[15:33:00.610]                   ...future.strategy.old <- future::plan("list")
[15:33:00.610]                   options(future.plan = NULL)
[15:33:00.610]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:33:00.610]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:33:00.610]                 }
[15:33:00.610]                 ...future.workdir <- getwd()
[15:33:00.610]             }
[15:33:00.610]             ...future.oldOptions <- base::as.list(base::.Options)
[15:33:00.610]             ...future.oldEnvVars <- base::Sys.getenv()
[15:33:00.610]         }
[15:33:00.610]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:33:00.610]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:33:00.610]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:33:00.610]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:33:00.610]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:33:00.610]             future.stdout.windows.reencode = NULL, width = 80L)
[15:33:00.610]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:33:00.610]             base::names(...future.oldOptions))
[15:33:00.610]     }
[15:33:00.610]     if (FALSE) {
[15:33:00.610]     }
[15:33:00.610]     else {
[15:33:00.610]         if (FALSE) {
[15:33:00.610]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:33:00.610]                 open = "w")
[15:33:00.610]         }
[15:33:00.610]         else {
[15:33:00.610]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:33:00.610]                 windows = "NUL", "/dev/null"), open = "w")
[15:33:00.610]         }
[15:33:00.610]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:33:00.610]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:33:00.610]             base::sink(type = "output", split = FALSE)
[15:33:00.610]             base::close(...future.stdout)
[15:33:00.610]         }, add = TRUE)
[15:33:00.610]     }
[15:33:00.610]     ...future.frame <- base::sys.nframe()
[15:33:00.610]     ...future.conditions <- base::list()
[15:33:00.610]     ...future.rng <- base::globalenv()$.Random.seed
[15:33:00.610]     if (FALSE) {
[15:33:00.610]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:33:00.610]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:33:00.610]     }
[15:33:00.610]     ...future.result <- base::tryCatch({
[15:33:00.610]         base::withCallingHandlers({
[15:33:00.610]             ...future.value <- base::withVisible(base::local({
[15:33:00.610]                 do.call(function(...) {
[15:33:00.610]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:33:00.610]                   if (!identical(...future.globals.maxSize.org, 
[15:33:00.610]                     ...future.globals.maxSize)) {
[15:33:00.610]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:33:00.610]                     on.exit(options(oopts), add = TRUE)
[15:33:00.610]                   }
[15:33:00.610]                   {
[15:33:00.610]                     lapply(seq_along(...future.elements_ii), 
[15:33:00.610]                       FUN = function(jj) {
[15:33:00.610]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:33:00.610]                         ...future.FUN(...future.X_jj, ...)
[15:33:00.610]                       })
[15:33:00.610]                   }
[15:33:00.610]                 }, args = future.call.arguments)
[15:33:00.610]             }))
[15:33:00.610]             future::FutureResult(value = ...future.value$value, 
[15:33:00.610]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:33:00.610]                   ...future.rng), globalenv = if (FALSE) 
[15:33:00.610]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:33:00.610]                     ...future.globalenv.names))
[15:33:00.610]                 else NULL, started = ...future.startTime, version = "1.8")
[15:33:00.610]         }, condition = base::local({
[15:33:00.610]             c <- base::c
[15:33:00.610]             inherits <- base::inherits
[15:33:00.610]             invokeRestart <- base::invokeRestart
[15:33:00.610]             length <- base::length
[15:33:00.610]             list <- base::list
[15:33:00.610]             seq.int <- base::seq.int
[15:33:00.610]             signalCondition <- base::signalCondition
[15:33:00.610]             sys.calls <- base::sys.calls
[15:33:00.610]             `[[` <- base::`[[`
[15:33:00.610]             `+` <- base::`+`
[15:33:00.610]             `<<-` <- base::`<<-`
[15:33:00.610]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:33:00.610]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:33:00.610]                   3L)]
[15:33:00.610]             }
[15:33:00.610]             function(cond) {
[15:33:00.610]                 is_error <- inherits(cond, "error")
[15:33:00.610]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:33:00.610]                   NULL)
[15:33:00.610]                 if (is_error) {
[15:33:00.610]                   sessionInformation <- function() {
[15:33:00.610]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:33:00.610]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:33:00.610]                       search = base::search(), system = base::Sys.info())
[15:33:00.610]                   }
[15:33:00.610]                   ...future.conditions[[length(...future.conditions) + 
[15:33:00.610]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:33:00.610]                     cond$call), session = sessionInformation(), 
[15:33:00.610]                     timestamp = base::Sys.time(), signaled = 0L)
[15:33:00.610]                   signalCondition(cond)
[15:33:00.610]                 }
[15:33:00.610]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:33:00.610]                 "immediateCondition"))) {
[15:33:00.610]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:33:00.610]                   ...future.conditions[[length(...future.conditions) + 
[15:33:00.610]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:33:00.610]                   if (TRUE && !signal) {
[15:33:00.610]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:33:00.610]                     {
[15:33:00.610]                       inherits <- base::inherits
[15:33:00.610]                       invokeRestart <- base::invokeRestart
[15:33:00.610]                       is.null <- base::is.null
[15:33:00.610]                       muffled <- FALSE
[15:33:00.610]                       if (inherits(cond, "message")) {
[15:33:00.610]                         muffled <- grepl(pattern, "muffleMessage")
[15:33:00.610]                         if (muffled) 
[15:33:00.610]                           invokeRestart("muffleMessage")
[15:33:00.610]                       }
[15:33:00.610]                       else if (inherits(cond, "warning")) {
[15:33:00.610]                         muffled <- grepl(pattern, "muffleWarning")
[15:33:00.610]                         if (muffled) 
[15:33:00.610]                           invokeRestart("muffleWarning")
[15:33:00.610]                       }
[15:33:00.610]                       else if (inherits(cond, "condition")) {
[15:33:00.610]                         if (!is.null(pattern)) {
[15:33:00.610]                           computeRestarts <- base::computeRestarts
[15:33:00.610]                           grepl <- base::grepl
[15:33:00.610]                           restarts <- computeRestarts(cond)
[15:33:00.610]                           for (restart in restarts) {
[15:33:00.610]                             name <- restart$name
[15:33:00.610]                             if (is.null(name)) 
[15:33:00.610]                               next
[15:33:00.610]                             if (!grepl(pattern, name)) 
[15:33:00.610]                               next
[15:33:00.610]                             invokeRestart(restart)
[15:33:00.610]                             muffled <- TRUE
[15:33:00.610]                             break
[15:33:00.610]                           }
[15:33:00.610]                         }
[15:33:00.610]                       }
[15:33:00.610]                       invisible(muffled)
[15:33:00.610]                     }
[15:33:00.610]                     muffleCondition(cond, pattern = "^muffle")
[15:33:00.610]                   }
[15:33:00.610]                 }
[15:33:00.610]                 else {
[15:33:00.610]                   if (TRUE) {
[15:33:00.610]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:33:00.610]                     {
[15:33:00.610]                       inherits <- base::inherits
[15:33:00.610]                       invokeRestart <- base::invokeRestart
[15:33:00.610]                       is.null <- base::is.null
[15:33:00.610]                       muffled <- FALSE
[15:33:00.610]                       if (inherits(cond, "message")) {
[15:33:00.610]                         muffled <- grepl(pattern, "muffleMessage")
[15:33:00.610]                         if (muffled) 
[15:33:00.610]                           invokeRestart("muffleMessage")
[15:33:00.610]                       }
[15:33:00.610]                       else if (inherits(cond, "warning")) {
[15:33:00.610]                         muffled <- grepl(pattern, "muffleWarning")
[15:33:00.610]                         if (muffled) 
[15:33:00.610]                           invokeRestart("muffleWarning")
[15:33:00.610]                       }
[15:33:00.610]                       else if (inherits(cond, "condition")) {
[15:33:00.610]                         if (!is.null(pattern)) {
[15:33:00.610]                           computeRestarts <- base::computeRestarts
[15:33:00.610]                           grepl <- base::grepl
[15:33:00.610]                           restarts <- computeRestarts(cond)
[15:33:00.610]                           for (restart in restarts) {
[15:33:00.610]                             name <- restart$name
[15:33:00.610]                             if (is.null(name)) 
[15:33:00.610]                               next
[15:33:00.610]                             if (!grepl(pattern, name)) 
[15:33:00.610]                               next
[15:33:00.610]                             invokeRestart(restart)
[15:33:00.610]                             muffled <- TRUE
[15:33:00.610]                             break
[15:33:00.610]                           }
[15:33:00.610]                         }
[15:33:00.610]                       }
[15:33:00.610]                       invisible(muffled)
[15:33:00.610]                     }
[15:33:00.610]                     muffleCondition(cond, pattern = "^muffle")
[15:33:00.610]                   }
[15:33:00.610]                 }
[15:33:00.610]             }
[15:33:00.610]         }))
[15:33:00.610]     }, error = function(ex) {
[15:33:00.610]         base::structure(base::list(value = NULL, visible = NULL, 
[15:33:00.610]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:33:00.610]                 ...future.rng), started = ...future.startTime, 
[15:33:00.610]             finished = Sys.time(), session_uuid = NA_character_, 
[15:33:00.610]             version = "1.8"), class = "FutureResult")
[15:33:00.610]     }, finally = {
[15:33:00.610]         if (!identical(...future.workdir, getwd())) 
[15:33:00.610]             setwd(...future.workdir)
[15:33:00.610]         {
[15:33:00.610]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:33:00.610]                 ...future.oldOptions$nwarnings <- NULL
[15:33:00.610]             }
[15:33:00.610]             base::options(...future.oldOptions)
[15:33:00.610]             if (.Platform$OS.type == "windows") {
[15:33:00.610]                 old_names <- names(...future.oldEnvVars)
[15:33:00.610]                 envs <- base::Sys.getenv()
[15:33:00.610]                 names <- names(envs)
[15:33:00.610]                 common <- intersect(names, old_names)
[15:33:00.610]                 added <- setdiff(names, old_names)
[15:33:00.610]                 removed <- setdiff(old_names, names)
[15:33:00.610]                 changed <- common[...future.oldEnvVars[common] != 
[15:33:00.610]                   envs[common]]
[15:33:00.610]                 NAMES <- toupper(changed)
[15:33:00.610]                 args <- list()
[15:33:00.610]                 for (kk in seq_along(NAMES)) {
[15:33:00.610]                   name <- changed[[kk]]
[15:33:00.610]                   NAME <- NAMES[[kk]]
[15:33:00.610]                   if (name != NAME && is.element(NAME, old_names)) 
[15:33:00.610]                     next
[15:33:00.610]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:33:00.610]                 }
[15:33:00.610]                 NAMES <- toupper(added)
[15:33:00.610]                 for (kk in seq_along(NAMES)) {
[15:33:00.610]                   name <- added[[kk]]
[15:33:00.610]                   NAME <- NAMES[[kk]]
[15:33:00.610]                   if (name != NAME && is.element(NAME, old_names)) 
[15:33:00.610]                     next
[15:33:00.610]                   args[[name]] <- ""
[15:33:00.610]                 }
[15:33:00.610]                 NAMES <- toupper(removed)
[15:33:00.610]                 for (kk in seq_along(NAMES)) {
[15:33:00.610]                   name <- removed[[kk]]
[15:33:00.610]                   NAME <- NAMES[[kk]]
[15:33:00.610]                   if (name != NAME && is.element(NAME, old_names)) 
[15:33:00.610]                     next
[15:33:00.610]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:33:00.610]                 }
[15:33:00.610]                 if (length(args) > 0) 
[15:33:00.610]                   base::do.call(base::Sys.setenv, args = args)
[15:33:00.610]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:33:00.610]             }
[15:33:00.610]             else {
[15:33:00.610]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:33:00.610]             }
[15:33:00.610]             {
[15:33:00.610]                 if (base::length(...future.futureOptionsAdded) > 
[15:33:00.610]                   0L) {
[15:33:00.610]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:33:00.610]                   base::names(opts) <- ...future.futureOptionsAdded
[15:33:00.610]                   base::options(opts)
[15:33:00.610]                 }
[15:33:00.610]                 {
[15:33:00.610]                   {
[15:33:00.610]                     NULL
[15:33:00.610]                     RNGkind("Mersenne-Twister")
[15:33:00.610]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:33:00.610]                       inherits = FALSE)
[15:33:00.610]                   }
[15:33:00.610]                   options(future.plan = NULL)
[15:33:00.610]                   if (is.na(NA_character_)) 
[15:33:00.610]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:33:00.610]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:33:00.610]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:33:00.610]                     .init = FALSE)
[15:33:00.610]                 }
[15:33:00.610]             }
[15:33:00.610]         }
[15:33:00.610]     })
[15:33:00.610]     if (TRUE) {
[15:33:00.610]         base::sink(type = "output", split = FALSE)
[15:33:00.610]         if (FALSE) {
[15:33:00.610]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:33:00.610]         }
[15:33:00.610]         else {
[15:33:00.610]             ...future.result["stdout"] <- base::list(NULL)
[15:33:00.610]         }
[15:33:00.610]         base::close(...future.stdout)
[15:33:00.610]         ...future.stdout <- NULL
[15:33:00.610]     }
[15:33:00.610]     ...future.result$conditions <- ...future.conditions
[15:33:00.610]     ...future.result$finished <- base::Sys.time()
[15:33:00.610]     ...future.result
[15:33:00.610] }
[15:33:00.616] assign_globals() ...
[15:33:00.616] List of 5
[15:33:00.616]  $ ...future.FUN            :function (x)  
[15:33:00.616]  $ future.call.arguments    : list()
[15:33:00.616]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:33:00.616]  $ ...future.elements_ii    :List of 2
[15:33:00.616]   ..$ : int 1
[15:33:00.616]   ..$ : int 0
[15:33:00.616]  $ ...future.seeds_ii       : NULL
[15:33:00.616]  $ ...future.globals.maxSize: NULL
[15:33:00.616]  - attr(*, "where")=List of 5
[15:33:00.616]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:33:00.616]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:33:00.616]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:33:00.616]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:33:00.616]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:33:00.616]  - attr(*, "resolved")= logi FALSE
[15:33:00.616]  - attr(*, "total_size")= num 4720
[15:33:00.616]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:33:00.616]  - attr(*, "already-done")= logi TRUE
[15:33:00.625] - reassign environment for '...future.FUN'
[15:33:00.625] - copied '...future.FUN' to environment
[15:33:00.625] - copied 'future.call.arguments' to environment
[15:33:00.626] - copied '...future.elements_ii' to environment
[15:33:00.626] - copied '...future.seeds_ii' to environment
[15:33:00.626] - copied '...future.globals.maxSize' to environment
[15:33:00.627] assign_globals() ... done
[15:33:00.627] plan(): Setting new future strategy stack:
[15:33:00.628] List of future strategies:
[15:33:00.628] 1. sequential:
[15:33:00.628]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:33:00.628]    - tweaked: FALSE
[15:33:00.628]    - call: NULL
[15:33:00.629] plan(): nbrOfWorkers() = 1
[15:33:01.142] plan(): Setting new future strategy stack:
[15:33:01.142] List of future strategies:
[15:33:01.142] 1. multisession:
[15:33:01.142]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[15:33:01.142]    - tweaked: FALSE
[15:33:01.142]    - call: plan(strategy)
[15:33:01.146] plan(): nbrOfWorkers() = 1
[15:33:01.147] SequentialFuture started (and completed)
[15:33:01.147] - Launch lazy future ... done
[15:33:01.147] run() for 'SequentialFuture' ... done
[15:33:01.148] Created future:
[15:33:01.148] SequentialFuture:
[15:33:01.148] Label: 'future_lapply-1'
[15:33:01.148] Expression:
[15:33:01.148] {
[15:33:01.148]     do.call(function(...) {
[15:33:01.148]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:33:01.148]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:33:01.148]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:33:01.148]             on.exit(options(oopts), add = TRUE)
[15:33:01.148]         }
[15:33:01.148]         {
[15:33:01.148]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:33:01.148]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:33:01.148]                 ...future.FUN(...future.X_jj, ...)
[15:33:01.148]             })
[15:33:01.148]         }
[15:33:01.148]     }, args = future.call.arguments)
[15:33:01.148] }
[15:33:01.148] Lazy evaluation: FALSE
[15:33:01.148] Asynchronous evaluation: FALSE
[15:33:01.148] Local evaluation: TRUE
[15:33:01.148] Environment: R_GlobalEnv
[15:33:01.148] Capture standard output: FALSE
[15:33:01.148] Capture condition classes: 'condition' (excluding 'nothing')
[15:33:01.148] Globals: 5 objects totaling 4.72 KiB (function '...future.FUN' of 4.61 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 112 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:33:01.148] Packages: <none>
[15:33:01.148] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:33:01.148] Resolved: TRUE
[15:33:01.148] Value: 112 bytes of class 'list'
[15:33:01.148] Early signaling: FALSE
[15:33:01.148] Owner process: bdd4bc13-919d-bf34-b2cf-84eb53f6e11f
[15:33:01.148] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:33:01.150] Chunk #1 of 1 ... DONE
[15:33:01.151] Launching 1 futures (chunks) ... DONE
[15:33:01.151] Resolving 1 futures (chunks) ...
[15:33:01.151] resolve() on list ...
[15:33:01.151]  recursive: 0
[15:33:01.152]  length: 1
[15:33:01.152] 
[15:33:01.152] resolved() for 'SequentialFuture' ...
[15:33:01.152] - state: 'finished'
[15:33:01.153] - run: TRUE
[15:33:01.153] - result: 'FutureResult'
[15:33:01.153] resolved() for 'SequentialFuture' ... done
[15:33:01.154] Future #1
[15:33:01.154] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:33:01.154] - nx: 1
[15:33:01.155] - relay: TRUE
[15:33:01.155] - stdout: TRUE
[15:33:01.155] - signal: TRUE
[15:33:01.155] - resignal: FALSE
[15:33:01.156] - force: TRUE
[15:33:01.156] - relayed: [n=1] FALSE
[15:33:01.156] - queued futures: [n=1] FALSE
[15:33:01.156]  - until=1
[15:33:01.157]  - relaying element #1
[15:33:01.157] - relayed: [n=1] TRUE
[15:33:01.157] - queued futures: [n=1] TRUE
[15:33:01.158] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:33:01.158]  length: 0 (resolved future 1)
[15:33:01.158] Relaying remaining futures
[15:33:01.158] signalConditionsASAP(NULL, pos=0) ...
[15:33:01.159] - nx: 1
[15:33:01.159] - relay: TRUE
[15:33:01.159] - stdout: TRUE
[15:33:01.160] - signal: TRUE
[15:33:01.160] - resignal: FALSE
[15:33:01.160] - force: TRUE
[15:33:01.160] - relayed: [n=1] TRUE
[15:33:01.161] - queued futures: [n=1] TRUE
 - flush all
[15:33:01.161] - relayed: [n=1] TRUE
[15:33:01.161] - queued futures: [n=1] TRUE
[15:33:01.162] signalConditionsASAP(NULL, pos=0) ... done
[15:33:01.162] resolve() on list ... DONE
[15:33:01.162]  - Number of value chunks collected: 1
[15:33:01.163] Resolving 1 futures (chunks) ... DONE
[15:33:01.163] Reducing values from 1 chunks ...
[15:33:01.163]  - Number of values collected after concatenation: 2
[15:33:01.164]  - Number of values expected: 2
[15:33:01.164] Reducing values from 1 chunks ... DONE
[15:33:01.164] future_lapply() ... DONE
* future_lapply(x, ..., future.stdout = FALSE) ... DONE
* future_lapply(x, ..., future.stdout = TRUE) ...
[15:33:01.165] future_lapply() ...
[15:33:01.173] Number of chunks: 1
[15:33:01.173] getGlobalsAndPackagesXApply() ...
[15:33:01.173]  - future.globals: TRUE
[15:33:01.174] getGlobalsAndPackages() ...
[15:33:01.174] Searching for globals...
[15:33:01.177] - globals found: [5] 'FUN', '{', 'Sys.sleep', '/', 'print'
[15:33:01.177] Searching for globals ... DONE
[15:33:01.177] Resolving globals: FALSE
[15:33:01.178] The total size of the 1 globals is 4.61 KiB (4720 bytes)
[15:33:01.179] The total size of the 1 globals exported for future expression ('FUN()') is 4.61 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.61 KiB of class 'function')
[15:33:01.179] - globals: [1] 'FUN'
[15:33:01.179] 
[15:33:01.180] getGlobalsAndPackages() ... DONE
[15:33:01.180]  - globals found/used: [n=1] 'FUN'
[15:33:01.180]  - needed namespaces: [n=0] 
[15:33:01.180] Finding globals ... DONE
[15:33:01.181]  - use_args: TRUE
[15:33:01.181]  - Getting '...' globals ...
[15:33:01.182] resolve() on list ...
[15:33:01.182]  recursive: 0
[15:33:01.182]  length: 1
[15:33:01.182]  elements: '...'
[15:33:01.183]  length: 0 (resolved future 1)
[15:33:01.183] resolve() on list ... DONE
[15:33:01.183]    - '...' content: [n=0] 
[15:33:01.184] List of 1
[15:33:01.184]  $ ...: list()
[15:33:01.184]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:33:01.184]  - attr(*, "where")=List of 1
[15:33:01.184]   ..$ ...:<environment: 0x0000027fc04ba420> 
[15:33:01.184]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:33:01.184]  - attr(*, "resolved")= logi TRUE
[15:33:01.184]  - attr(*, "total_size")= num NA
[15:33:01.189]  - Getting '...' globals ... DONE
[15:33:01.189] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:33:01.189] List of 2
[15:33:01.189]  $ ...future.FUN:function (x)  
[15:33:01.189]  $ ...          : list()
[15:33:01.189]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:33:01.189]  - attr(*, "where")=List of 2
[15:33:01.189]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:33:01.189]   ..$ ...          :<environment: 0x0000027fc04ba420> 
[15:33:01.189]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:33:01.189]  - attr(*, "resolved")= logi FALSE
[15:33:01.189]  - attr(*, "total_size")= num 4720
[15:33:01.195] Packages to be attached in all futures: [n=0] 
[15:33:01.195] getGlobalsAndPackagesXApply() ... DONE
[15:33:01.195] Number of futures (= number of chunks): 1
[15:33:01.196] Launching 1 futures (chunks) ...
[15:33:01.196] Chunk #1 of 1 ...
[15:33:01.196]  - Finding globals in 'X' for chunk #1 ...
[15:33:01.197] getGlobalsAndPackages() ...
[15:33:01.197] Searching for globals...
[15:33:01.197] 
[15:33:01.198] Searching for globals ... DONE
[15:33:01.198] - globals: [0] <none>
[15:33:01.198] getGlobalsAndPackages() ... DONE
[15:33:01.199]    + additional globals found: [n=0] 
[15:33:01.199]    + additional namespaces needed: [n=0] 
[15:33:01.199]  - Finding globals in 'X' for chunk #1 ... DONE
[15:33:01.199]  - seeds: <none>
[15:33:01.200]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:33:01.200] getGlobalsAndPackages() ...
[15:33:01.200] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:33:01.201] Resolving globals: FALSE
[15:33:01.201] Tweak future expression to call with '...' arguments ...
[15:33:01.201] {
[15:33:01.201]     do.call(function(...) {
[15:33:01.201]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:33:01.201]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:33:01.201]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:33:01.201]             on.exit(options(oopts), add = TRUE)
[15:33:01.201]         }
[15:33:01.201]         {
[15:33:01.201]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:33:01.201]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:33:01.201]                 ...future.FUN(...future.X_jj, ...)
[15:33:01.201]             })
[15:33:01.201]         }
[15:33:01.201]     }, args = future.call.arguments)
[15:33:01.201] }
[15:33:01.202] Tweak future expression to call with '...' arguments ... DONE
[15:33:01.203] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:33:01.203] 
[15:33:01.204] getGlobalsAndPackages() ... DONE
[15:33:01.204] run() for 'Future' ...
[15:33:01.205] - state: 'created'
[15:33:01.205] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:33:01.209] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:33:01.210] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:33:01.210]   - Field: 'label'
[15:33:01.210]   - Field: 'local'
[15:33:01.211]   - Field: 'owner'
[15:33:01.211]   - Field: 'envir'
[15:33:01.214]   - Field: 'packages'
[15:33:01.215]   - Field: 'gc'
[15:33:01.215]   - Field: 'conditions'
[15:33:01.215]   - Field: 'expr'
[15:33:01.216]   - Field: 'uuid'
[15:33:01.216]   - Field: 'seed'
[15:33:01.216]   - Field: 'version'
[15:33:01.216]   - Field: 'result'
[15:33:01.217]   - Field: 'asynchronous'
[15:33:01.217]   - Field: 'calls'
[15:33:01.217]   - Field: 'globals'
[15:33:01.218]   - Field: 'stdout'
[15:33:01.218]   - Field: 'earlySignal'
[15:33:01.218]   - Field: 'lazy'
[15:33:01.219]   - Field: 'state'
[15:33:01.219] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:33:01.219] - Launch lazy future ...
[15:33:01.220] Packages needed by the future expression (n = 0): <none>
[15:33:01.220] Packages needed by future strategies (n = 0): <none>
[15:33:01.221] {
[15:33:01.221]     {
[15:33:01.221]         {
[15:33:01.221]             ...future.startTime <- base::Sys.time()
[15:33:01.221]             {
[15:33:01.221]                 {
[15:33:01.221]                   {
[15:33:01.221]                     base::local({
[15:33:01.221]                       has_future <- base::requireNamespace("future", 
[15:33:01.221]                         quietly = TRUE)
[15:33:01.221]                       if (has_future) {
[15:33:01.221]                         ns <- base::getNamespace("future")
[15:33:01.221]                         version <- ns[[".package"]][["version"]]
[15:33:01.221]                         if (is.null(version)) 
[15:33:01.221]                           version <- utils::packageVersion("future")
[15:33:01.221]                       }
[15:33:01.221]                       else {
[15:33:01.221]                         version <- NULL
[15:33:01.221]                       }
[15:33:01.221]                       if (!has_future || version < "1.8.0") {
[15:33:01.221]                         info <- base::c(r_version = base::gsub("R version ", 
[15:33:01.221]                           "", base::R.version$version.string), 
[15:33:01.221]                           platform = base::sprintf("%s (%s-bit)", 
[15:33:01.221]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:33:01.221]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:33:01.221]                             "release", "version")], collapse = " "), 
[15:33:01.221]                           hostname = base::Sys.info()[["nodename"]])
[15:33:01.221]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:33:01.221]                           info)
[15:33:01.221]                         info <- base::paste(info, collapse = "; ")
[15:33:01.221]                         if (!has_future) {
[15:33:01.221]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:33:01.221]                             info)
[15:33:01.221]                         }
[15:33:01.221]                         else {
[15:33:01.221]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:33:01.221]                             info, version)
[15:33:01.221]                         }
[15:33:01.221]                         base::stop(msg)
[15:33:01.221]                       }
[15:33:01.221]                     })
[15:33:01.221]                   }
[15:33:01.221]                   ...future.strategy.old <- future::plan("list")
[15:33:01.221]                   options(future.plan = NULL)
[15:33:01.221]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:33:01.221]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:33:01.221]                 }
[15:33:01.221]                 ...future.workdir <- getwd()
[15:33:01.221]             }
[15:33:01.221]             ...future.oldOptions <- base::as.list(base::.Options)
[15:33:01.221]             ...future.oldEnvVars <- base::Sys.getenv()
[15:33:01.221]         }
[15:33:01.221]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:33:01.221]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:33:01.221]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:33:01.221]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:33:01.221]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:33:01.221]             future.stdout.windows.reencode = NULL, width = 80L)
[15:33:01.221]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:33:01.221]             base::names(...future.oldOptions))
[15:33:01.221]     }
[15:33:01.221]     if (FALSE) {
[15:33:01.221]     }
[15:33:01.221]     else {
[15:33:01.221]         if (TRUE) {
[15:33:01.221]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:33:01.221]                 open = "w")
[15:33:01.221]         }
[15:33:01.221]         else {
[15:33:01.221]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:33:01.221]                 windows = "NUL", "/dev/null"), open = "w")
[15:33:01.221]         }
[15:33:01.221]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:33:01.221]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:33:01.221]             base::sink(type = "output", split = FALSE)
[15:33:01.221]             base::close(...future.stdout)
[15:33:01.221]         }, add = TRUE)
[15:33:01.221]     }
[15:33:01.221]     ...future.frame <- base::sys.nframe()
[15:33:01.221]     ...future.conditions <- base::list()
[15:33:01.221]     ...future.rng <- base::globalenv()$.Random.seed
[15:33:01.221]     if (FALSE) {
[15:33:01.221]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:33:01.221]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:33:01.221]     }
[15:33:01.221]     ...future.result <- base::tryCatch({
[15:33:01.221]         base::withCallingHandlers({
[15:33:01.221]             ...future.value <- base::withVisible(base::local({
[15:33:01.221]                 do.call(function(...) {
[15:33:01.221]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:33:01.221]                   if (!identical(...future.globals.maxSize.org, 
[15:33:01.221]                     ...future.globals.maxSize)) {
[15:33:01.221]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:33:01.221]                     on.exit(options(oopts), add = TRUE)
[15:33:01.221]                   }
[15:33:01.221]                   {
[15:33:01.221]                     lapply(seq_along(...future.elements_ii), 
[15:33:01.221]                       FUN = function(jj) {
[15:33:01.221]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:33:01.221]                         ...future.FUN(...future.X_jj, ...)
[15:33:01.221]                       })
[15:33:01.221]                   }
[15:33:01.221]                 }, args = future.call.arguments)
[15:33:01.221]             }))
[15:33:01.221]             future::FutureResult(value = ...future.value$value, 
[15:33:01.221]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:33:01.221]                   ...future.rng), globalenv = if (FALSE) 
[15:33:01.221]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:33:01.221]                     ...future.globalenv.names))
[15:33:01.221]                 else NULL, started = ...future.startTime, version = "1.8")
[15:33:01.221]         }, condition = base::local({
[15:33:01.221]             c <- base::c
[15:33:01.221]             inherits <- base::inherits
[15:33:01.221]             invokeRestart <- base::invokeRestart
[15:33:01.221]             length <- base::length
[15:33:01.221]             list <- base::list
[15:33:01.221]             seq.int <- base::seq.int
[15:33:01.221]             signalCondition <- base::signalCondition
[15:33:01.221]             sys.calls <- base::sys.calls
[15:33:01.221]             `[[` <- base::`[[`
[15:33:01.221]             `+` <- base::`+`
[15:33:01.221]             `<<-` <- base::`<<-`
[15:33:01.221]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:33:01.221]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:33:01.221]                   3L)]
[15:33:01.221]             }
[15:33:01.221]             function(cond) {
[15:33:01.221]                 is_error <- inherits(cond, "error")
[15:33:01.221]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:33:01.221]                   NULL)
[15:33:01.221]                 if (is_error) {
[15:33:01.221]                   sessionInformation <- function() {
[15:33:01.221]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:33:01.221]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:33:01.221]                       search = base::search(), system = base::Sys.info())
[15:33:01.221]                   }
[15:33:01.221]                   ...future.conditions[[length(...future.conditions) + 
[15:33:01.221]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:33:01.221]                     cond$call), session = sessionInformation(), 
[15:33:01.221]                     timestamp = base::Sys.time(), signaled = 0L)
[15:33:01.221]                   signalCondition(cond)
[15:33:01.221]                 }
[15:33:01.221]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:33:01.221]                 "immediateCondition"))) {
[15:33:01.221]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:33:01.221]                   ...future.conditions[[length(...future.conditions) + 
[15:33:01.221]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:33:01.221]                   if (TRUE && !signal) {
[15:33:01.221]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:33:01.221]                     {
[15:33:01.221]                       inherits <- base::inherits
[15:33:01.221]                       invokeRestart <- base::invokeRestart
[15:33:01.221]                       is.null <- base::is.null
[15:33:01.221]                       muffled <- FALSE
[15:33:01.221]                       if (inherits(cond, "message")) {
[15:33:01.221]                         muffled <- grepl(pattern, "muffleMessage")
[15:33:01.221]                         if (muffled) 
[15:33:01.221]                           invokeRestart("muffleMessage")
[15:33:01.221]                       }
[15:33:01.221]                       else if (inherits(cond, "warning")) {
[15:33:01.221]                         muffled <- grepl(pattern, "muffleWarning")
[15:33:01.221]                         if (muffled) 
[15:33:01.221]                           invokeRestart("muffleWarning")
[15:33:01.221]                       }
[15:33:01.221]                       else if (inherits(cond, "condition")) {
[15:33:01.221]                         if (!is.null(pattern)) {
[15:33:01.221]                           computeRestarts <- base::computeRestarts
[15:33:01.221]                           grepl <- base::grepl
[15:33:01.221]                           restarts <- computeRestarts(cond)
[15:33:01.221]                           for (restart in restarts) {
[15:33:01.221]                             name <- restart$name
[15:33:01.221]                             if (is.null(name)) 
[15:33:01.221]                               next
[15:33:01.221]                             if (!grepl(pattern, name)) 
[15:33:01.221]                               next
[15:33:01.221]                             invokeRestart(restart)
[15:33:01.221]                             muffled <- TRUE
[15:33:01.221]                             break
[15:33:01.221]                           }
[15:33:01.221]                         }
[15:33:01.221]                       }
[15:33:01.221]                       invisible(muffled)
[15:33:01.221]                     }
[15:33:01.221]                     muffleCondition(cond, pattern = "^muffle")
[15:33:01.221]                   }
[15:33:01.221]                 }
[15:33:01.221]                 else {
[15:33:01.221]                   if (TRUE) {
[15:33:01.221]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:33:01.221]                     {
[15:33:01.221]                       inherits <- base::inherits
[15:33:01.221]                       invokeRestart <- base::invokeRestart
[15:33:01.221]                       is.null <- base::is.null
[15:33:01.221]                       muffled <- FALSE
[15:33:01.221]                       if (inherits(cond, "message")) {
[15:33:01.221]                         muffled <- grepl(pattern, "muffleMessage")
[15:33:01.221]                         if (muffled) 
[15:33:01.221]                           invokeRestart("muffleMessage")
[15:33:01.221]                       }
[15:33:01.221]                       else if (inherits(cond, "warning")) {
[15:33:01.221]                         muffled <- grepl(pattern, "muffleWarning")
[15:33:01.221]                         if (muffled) 
[15:33:01.221]                           invokeRestart("muffleWarning")
[15:33:01.221]                       }
[15:33:01.221]                       else if (inherits(cond, "condition")) {
[15:33:01.221]                         if (!is.null(pattern)) {
[15:33:01.221]                           computeRestarts <- base::computeRestarts
[15:33:01.221]                           grepl <- base::grepl
[15:33:01.221]                           restarts <- computeRestarts(cond)
[15:33:01.221]                           for (restart in restarts) {
[15:33:01.221]                             name <- restart$name
[15:33:01.221]                             if (is.null(name)) 
[15:33:01.221]                               next
[15:33:01.221]                             if (!grepl(pattern, name)) 
[15:33:01.221]                               next
[15:33:01.221]                             invokeRestart(restart)
[15:33:01.221]                             muffled <- TRUE
[15:33:01.221]                             break
[15:33:01.221]                           }
[15:33:01.221]                         }
[15:33:01.221]                       }
[15:33:01.221]                       invisible(muffled)
[15:33:01.221]                     }
[15:33:01.221]                     muffleCondition(cond, pattern = "^muffle")
[15:33:01.221]                   }
[15:33:01.221]                 }
[15:33:01.221]             }
[15:33:01.221]         }))
[15:33:01.221]     }, error = function(ex) {
[15:33:01.221]         base::structure(base::list(value = NULL, visible = NULL, 
[15:33:01.221]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:33:01.221]                 ...future.rng), started = ...future.startTime, 
[15:33:01.221]             finished = Sys.time(), session_uuid = NA_character_, 
[15:33:01.221]             version = "1.8"), class = "FutureResult")
[15:33:01.221]     }, finally = {
[15:33:01.221]         if (!identical(...future.workdir, getwd())) 
[15:33:01.221]             setwd(...future.workdir)
[15:33:01.221]         {
[15:33:01.221]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:33:01.221]                 ...future.oldOptions$nwarnings <- NULL
[15:33:01.221]             }
[15:33:01.221]             base::options(...future.oldOptions)
[15:33:01.221]             if (.Platform$OS.type == "windows") {
[15:33:01.221]                 old_names <- names(...future.oldEnvVars)
[15:33:01.221]                 envs <- base::Sys.getenv()
[15:33:01.221]                 names <- names(envs)
[15:33:01.221]                 common <- intersect(names, old_names)
[15:33:01.221]                 added <- setdiff(names, old_names)
[15:33:01.221]                 removed <- setdiff(old_names, names)
[15:33:01.221]                 changed <- common[...future.oldEnvVars[common] != 
[15:33:01.221]                   envs[common]]
[15:33:01.221]                 NAMES <- toupper(changed)
[15:33:01.221]                 args <- list()
[15:33:01.221]                 for (kk in seq_along(NAMES)) {
[15:33:01.221]                   name <- changed[[kk]]
[15:33:01.221]                   NAME <- NAMES[[kk]]
[15:33:01.221]                   if (name != NAME && is.element(NAME, old_names)) 
[15:33:01.221]                     next
[15:33:01.221]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:33:01.221]                 }
[15:33:01.221]                 NAMES <- toupper(added)
[15:33:01.221]                 for (kk in seq_along(NAMES)) {
[15:33:01.221]                   name <- added[[kk]]
[15:33:01.221]                   NAME <- NAMES[[kk]]
[15:33:01.221]                   if (name != NAME && is.element(NAME, old_names)) 
[15:33:01.221]                     next
[15:33:01.221]                   args[[name]] <- ""
[15:33:01.221]                 }
[15:33:01.221]                 NAMES <- toupper(removed)
[15:33:01.221]                 for (kk in seq_along(NAMES)) {
[15:33:01.221]                   name <- removed[[kk]]
[15:33:01.221]                   NAME <- NAMES[[kk]]
[15:33:01.221]                   if (name != NAME && is.element(NAME, old_names)) 
[15:33:01.221]                     next
[15:33:01.221]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:33:01.221]                 }
[15:33:01.221]                 if (length(args) > 0) 
[15:33:01.221]                   base::do.call(base::Sys.setenv, args = args)
[15:33:01.221]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:33:01.221]             }
[15:33:01.221]             else {
[15:33:01.221]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:33:01.221]             }
[15:33:01.221]             {
[15:33:01.221]                 if (base::length(...future.futureOptionsAdded) > 
[15:33:01.221]                   0L) {
[15:33:01.221]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:33:01.221]                   base::names(opts) <- ...future.futureOptionsAdded
[15:33:01.221]                   base::options(opts)
[15:33:01.221]                 }
[15:33:01.221]                 {
[15:33:01.221]                   {
[15:33:01.221]                     NULL
[15:33:01.221]                     RNGkind("Mersenne-Twister")
[15:33:01.221]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:33:01.221]                       inherits = FALSE)
[15:33:01.221]                   }
[15:33:01.221]                   options(future.plan = NULL)
[15:33:01.221]                   if (is.na(NA_character_)) 
[15:33:01.221]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:33:01.221]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:33:01.221]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:33:01.221]                     .init = FALSE)
[15:33:01.221]                 }
[15:33:01.221]             }
[15:33:01.221]         }
[15:33:01.221]     })
[15:33:01.221]     if (TRUE) {
[15:33:01.221]         base::sink(type = "output", split = FALSE)
[15:33:01.221]         if (TRUE) {
[15:33:01.221]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:33:01.221]         }
[15:33:01.221]         else {
[15:33:01.221]             ...future.result["stdout"] <- base::list(NULL)
[15:33:01.221]         }
[15:33:01.221]         base::close(...future.stdout)
[15:33:01.221]         ...future.stdout <- NULL
[15:33:01.221]     }
[15:33:01.221]     ...future.result$conditions <- ...future.conditions
[15:33:01.221]     ...future.result$finished <- base::Sys.time()
[15:33:01.221]     ...future.result
[15:33:01.221] }
[15:33:01.227] assign_globals() ...
[15:33:01.228] List of 5
[15:33:01.228]  $ ...future.FUN            :function (x)  
[15:33:01.228]  $ future.call.arguments    : list()
[15:33:01.228]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:33:01.228]  $ ...future.elements_ii    :List of 2
[15:33:01.228]   ..$ : int 1
[15:33:01.228]   ..$ : int 0
[15:33:01.228]  $ ...future.seeds_ii       : NULL
[15:33:01.228]  $ ...future.globals.maxSize: NULL
[15:33:01.228]  - attr(*, "where")=List of 5
[15:33:01.228]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:33:01.228]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:33:01.228]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:33:01.228]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:33:01.228]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:33:01.228]  - attr(*, "resolved")= logi FALSE
[15:33:01.228]  - attr(*, "total_size")= num 4720
[15:33:01.228]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:33:01.228]  - attr(*, "already-done")= logi TRUE
[15:33:01.237] - reassign environment for '...future.FUN'
[15:33:01.237] - copied '...future.FUN' to environment
[15:33:01.237] - copied 'future.call.arguments' to environment
[15:33:01.237] - copied '...future.elements_ii' to environment
[15:33:01.238] - copied '...future.seeds_ii' to environment
[15:33:01.238] - copied '...future.globals.maxSize' to environment
[15:33:01.238] assign_globals() ... done
[15:33:01.239] plan(): Setting new future strategy stack:
[15:33:01.239] List of future strategies:
[15:33:01.239] 1. sequential:
[15:33:01.239]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:33:01.239]    - tweaked: FALSE
[15:33:01.239]    - call: NULL
[15:33:01.240] plan(): nbrOfWorkers() = 1
[15:33:01.751] plan(): Setting new future strategy stack:
[15:33:01.751] List of future strategies:
[15:33:01.751] 1. multisession:
[15:33:01.751]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[15:33:01.751]    - tweaked: FALSE
[15:33:01.751]    - call: plan(strategy)
[15:33:01.755] plan(): nbrOfWorkers() = 1
[15:33:01.755] SequentialFuture started (and completed)
[15:33:01.756] - Launch lazy future ... done
[15:33:01.756] run() for 'SequentialFuture' ... done
[15:33:01.756] Created future:
[15:33:01.756] SequentialFuture:
[15:33:01.756] Label: 'future_lapply-1'
[15:33:01.756] Expression:
[15:33:01.756] {
[15:33:01.756]     do.call(function(...) {
[15:33:01.756]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:33:01.756]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:33:01.756]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:33:01.756]             on.exit(options(oopts), add = TRUE)
[15:33:01.756]         }
[15:33:01.756]         {
[15:33:01.756]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:33:01.756]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:33:01.756]                 ...future.FUN(...future.X_jj, ...)
[15:33:01.756]             })
[15:33:01.756]         }
[15:33:01.756]     }, args = future.call.arguments)
[15:33:01.756] }
[15:33:01.756] Lazy evaluation: FALSE
[15:33:01.756] Asynchronous evaluation: FALSE
[15:33:01.756] Local evaluation: TRUE
[15:33:01.756] Environment: R_GlobalEnv
[15:33:01.756] Capture standard output: TRUE
[15:33:01.756] Capture condition classes: 'condition' (excluding 'nothing')
[15:33:01.756] Globals: 5 objects totaling 4.72 KiB (function '...future.FUN' of 4.61 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 112 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:33:01.756] Packages: <none>
[15:33:01.756] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:33:01.756] Resolved: TRUE
[15:33:01.756] Value: 112 bytes of class 'list'
[15:33:01.756] Early signaling: FALSE
[15:33:01.756] Owner process: bdd4bc13-919d-bf34-b2cf-84eb53f6e11f
[15:33:01.756] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:33:01.759] Chunk #1 of 1 ... DONE
[15:33:01.759] Launching 1 futures (chunks) ... DONE
[15:33:01.759] Resolving 1 futures (chunks) ...
[15:33:01.759] resolve() on list ...
[15:33:01.760]  recursive: 0
[15:33:01.760]  length: 1
[15:33:01.760] 
[15:33:01.760] resolved() for 'SequentialFuture' ...
[15:33:01.761] - state: 'finished'
[15:33:01.761] - run: TRUE
[15:33:01.761] - result: 'FutureResult'
[15:33:01.761] resolved() for 'SequentialFuture' ... done
[15:33:01.762] Future #1
[15:33:01.762] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:33:01.762] - nx: 1
[15:33:01.762] - relay: TRUE
[15:33:01.763] - stdout: TRUE
[15:33:01.763] - signal: TRUE
[15:33:01.763] - resignal: FALSE
[15:33:01.763] - force: TRUE
[15:33:01.764] - relayed: [n=1] FALSE
[15:33:01.764] - queued futures: [n=1] FALSE
[15:33:01.764]  - until=1
[15:33:01.764]  - relaying element #1
[15:33:01.765] - relayed: [n=1] TRUE
[15:33:01.765] - queued futures: [n=1] TRUE
[15:33:01.765] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:33:01.765]  length: 0 (resolved future 1)
[15:33:01.766] Relaying remaining futures
[15:33:01.766] signalConditionsASAP(NULL, pos=0) ...
[15:33:01.766] - nx: 1
[15:33:01.766] - relay: TRUE
[15:33:01.767] - stdout: TRUE
[15:33:01.767] - signal: TRUE
[15:33:01.767] - resignal: FALSE
[15:33:01.767] - force: TRUE
[15:33:01.768] - relayed: [n=1] TRUE
[15:33:01.768] - queued futures: [n=1] TRUE
 - flush all
[15:33:01.768] - relayed: [n=1] TRUE
[15:33:01.768] - queued futures: [n=1] TRUE
[15:33:01.769] signalConditionsASAP(NULL, pos=0) ... done
[15:33:01.771] resolve() on list ... DONE
[15:33:01.772]  - Number of value chunks collected: 1
[15:33:01.772] Resolving 1 futures (chunks) ... DONE
[15:33:01.772] Reducing values from 1 chunks ...
[15:33:01.773]  - Number of values collected after concatenation: 2
[15:33:01.773]  - Number of values expected: 2
[15:33:01.773] Reducing values from 1 chunks ... DONE
[15:33:01.773] future_lapply() ... DONE
* future_lapply(x, ..., future.stdout = TRUE) ... DONE
* future_lapply(x, ..., future.stdout = NA) ...
[15:33:01.774] future_lapply() ...
[15:33:01.779] Number of chunks: 1
[15:33:01.779] getGlobalsAndPackagesXApply() ...
[15:33:01.779]  - future.globals: TRUE
[15:33:01.779] getGlobalsAndPackages() ...
[15:33:01.780] Searching for globals...
[15:33:01.782] - globals found: [5] 'FUN', '{', 'Sys.sleep', '/', 'print'
[15:33:01.782] Searching for globals ... DONE
[15:33:01.783] Resolving globals: FALSE
[15:33:01.783] The total size of the 1 globals is 4.61 KiB (4720 bytes)
[15:33:01.784] The total size of the 1 globals exported for future expression ('FUN()') is 4.61 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.61 KiB of class 'function')
[15:33:01.784] - globals: [1] 'FUN'
[15:33:01.785] 
[15:33:01.785] getGlobalsAndPackages() ... DONE
[15:33:01.785]  - globals found/used: [n=1] 'FUN'
[15:33:01.785]  - needed namespaces: [n=0] 
[15:33:01.786] Finding globals ... DONE
[15:33:01.786]  - use_args: TRUE
[15:33:01.786]  - Getting '...' globals ...
[15:33:01.787] resolve() on list ...
[15:33:01.787]  recursive: 0
[15:33:01.787]  length: 1
[15:33:01.787]  elements: '...'
[15:33:01.788]  length: 0 (resolved future 1)
[15:33:01.788] resolve() on list ... DONE
[15:33:01.788]    - '...' content: [n=0] 
[15:33:01.788] List of 1
[15:33:01.788]  $ ...: list()
[15:33:01.788]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:33:01.788]  - attr(*, "where")=List of 1
[15:33:01.788]   ..$ ...:<environment: 0x0000027fbe3bb998> 
[15:33:01.788]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:33:01.788]  - attr(*, "resolved")= logi TRUE
[15:33:01.788]  - attr(*, "total_size")= num NA
[15:33:01.793]  - Getting '...' globals ... DONE
[15:33:01.793] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:33:01.793] List of 2
[15:33:01.793]  $ ...future.FUN:function (x)  
[15:33:01.793]  $ ...          : list()
[15:33:01.793]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:33:01.793]  - attr(*, "where")=List of 2
[15:33:01.793]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:33:01.793]   ..$ ...          :<environment: 0x0000027fbe3bb998> 
[15:33:01.793]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:33:01.793]  - attr(*, "resolved")= logi FALSE
[15:33:01.793]  - attr(*, "total_size")= num 4720
[15:33:01.799] Packages to be attached in all futures: [n=0] 
[15:33:01.799] getGlobalsAndPackagesXApply() ... DONE
[15:33:01.800] Number of futures (= number of chunks): 1
[15:33:01.800] Launching 1 futures (chunks) ...
[15:33:01.800] Chunk #1 of 1 ...
[15:33:01.801]  - Finding globals in 'X' for chunk #1 ...
[15:33:01.801] getGlobalsAndPackages() ...
[15:33:01.801] Searching for globals...
[15:33:01.802] 
[15:33:01.802] Searching for globals ... DONE
[15:33:01.802] - globals: [0] <none>
[15:33:01.803] getGlobalsAndPackages() ... DONE
[15:33:01.803]    + additional globals found: [n=0] 
[15:33:01.803]    + additional namespaces needed: [n=0] 
[15:33:01.804]  - Finding globals in 'X' for chunk #1 ... DONE
[15:33:01.804]  - seeds: <none>
[15:33:01.804]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:33:01.804] getGlobalsAndPackages() ...
[15:33:01.805] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:33:01.805] Resolving globals: FALSE
[15:33:01.805] Tweak future expression to call with '...' arguments ...
[15:33:01.805] {
[15:33:01.805]     do.call(function(...) {
[15:33:01.805]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:33:01.805]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:33:01.805]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:33:01.805]             on.exit(options(oopts), add = TRUE)
[15:33:01.805]         }
[15:33:01.805]         {
[15:33:01.805]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:33:01.805]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:33:01.805]                 ...future.FUN(...future.X_jj, ...)
[15:33:01.805]             })
[15:33:01.805]         }
[15:33:01.805]     }, args = future.call.arguments)
[15:33:01.805] }
[15:33:01.806] Tweak future expression to call with '...' arguments ... DONE
[15:33:01.806] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:33:01.807] 
[15:33:01.807] getGlobalsAndPackages() ... DONE
[15:33:01.808] run() for 'Future' ...
[15:33:01.808] - state: 'created'
[15:33:01.809] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:33:01.815] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:33:01.816] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:33:01.816]   - Field: 'label'
[15:33:01.816]   - Field: 'local'
[15:33:01.817]   - Field: 'owner'
[15:33:01.817]   - Field: 'envir'
[15:33:01.817]   - Field: 'packages'
[15:33:01.818]   - Field: 'gc'
[15:33:01.818]   - Field: 'conditions'
[15:33:01.818]   - Field: 'expr'
[15:33:01.819]   - Field: 'uuid'
[15:33:01.819]   - Field: 'seed'
[15:33:01.819]   - Field: 'version'
[15:33:01.820]   - Field: 'result'
[15:33:01.820]   - Field: 'asynchronous'
[15:33:01.820]   - Field: 'calls'
[15:33:01.820]   - Field: 'globals'
[15:33:01.821]   - Field: 'stdout'
[15:33:01.821]   - Field: 'earlySignal'
[15:33:01.821]   - Field: 'lazy'
[15:33:01.821]   - Field: 'state'
[15:33:01.822] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:33:01.822] - Launch lazy future ...
[15:33:01.822] Packages needed by the future expression (n = 0): <none>
[15:33:01.822] Packages needed by future strategies (n = 0): <none>
[15:33:01.824] {
[15:33:01.824]     {
[15:33:01.824]         {
[15:33:01.824]             ...future.startTime <- base::Sys.time()
[15:33:01.824]             {
[15:33:01.824]                 {
[15:33:01.824]                   {
[15:33:01.824]                     base::local({
[15:33:01.824]                       has_future <- base::requireNamespace("future", 
[15:33:01.824]                         quietly = TRUE)
[15:33:01.824]                       if (has_future) {
[15:33:01.824]                         ns <- base::getNamespace("future")
[15:33:01.824]                         version <- ns[[".package"]][["version"]]
[15:33:01.824]                         if (is.null(version)) 
[15:33:01.824]                           version <- utils::packageVersion("future")
[15:33:01.824]                       }
[15:33:01.824]                       else {
[15:33:01.824]                         version <- NULL
[15:33:01.824]                       }
[15:33:01.824]                       if (!has_future || version < "1.8.0") {
[15:33:01.824]                         info <- base::c(r_version = base::gsub("R version ", 
[15:33:01.824]                           "", base::R.version$version.string), 
[15:33:01.824]                           platform = base::sprintf("%s (%s-bit)", 
[15:33:01.824]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:33:01.824]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:33:01.824]                             "release", "version")], collapse = " "), 
[15:33:01.824]                           hostname = base::Sys.info()[["nodename"]])
[15:33:01.824]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:33:01.824]                           info)
[15:33:01.824]                         info <- base::paste(info, collapse = "; ")
[15:33:01.824]                         if (!has_future) {
[15:33:01.824]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:33:01.824]                             info)
[15:33:01.824]                         }
[15:33:01.824]                         else {
[15:33:01.824]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:33:01.824]                             info, version)
[15:33:01.824]                         }
[15:33:01.824]                         base::stop(msg)
[15:33:01.824]                       }
[15:33:01.824]                     })
[15:33:01.824]                   }
[15:33:01.824]                   ...future.strategy.old <- future::plan("list")
[15:33:01.824]                   options(future.plan = NULL)
[15:33:01.824]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:33:01.824]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:33:01.824]                 }
[15:33:01.824]                 ...future.workdir <- getwd()
[15:33:01.824]             }
[15:33:01.824]             ...future.oldOptions <- base::as.list(base::.Options)
[15:33:01.824]             ...future.oldEnvVars <- base::Sys.getenv()
[15:33:01.824]         }
[15:33:01.824]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:33:01.824]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:33:01.824]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:33:01.824]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:33:01.824]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:33:01.824]             future.stdout.windows.reencode = NULL, width = 80L)
[15:33:01.824]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:33:01.824]             base::names(...future.oldOptions))
[15:33:01.824]     }
[15:33:01.824]     if (TRUE) {
[15:33:01.824]     }
[15:33:01.824]     else {
[15:33:01.824]         if (NA) {
[15:33:01.824]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:33:01.824]                 open = "w")
[15:33:01.824]         }
[15:33:01.824]         else {
[15:33:01.824]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:33:01.824]                 windows = "NUL", "/dev/null"), open = "w")
[15:33:01.824]         }
[15:33:01.824]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:33:01.824]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:33:01.824]             base::sink(type = "output", split = FALSE)
[15:33:01.824]             base::close(...future.stdout)
[15:33:01.824]         }, add = TRUE)
[15:33:01.824]     }
[15:33:01.824]     ...future.frame <- base::sys.nframe()
[15:33:01.824]     ...future.conditions <- base::list()
[15:33:01.824]     ...future.rng <- base::globalenv()$.Random.seed
[15:33:01.824]     if (FALSE) {
[15:33:01.824]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:33:01.824]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:33:01.824]     }
[15:33:01.824]     ...future.result <- base::tryCatch({
[15:33:01.824]         base::withCallingHandlers({
[15:33:01.824]             ...future.value <- base::withVisible(base::local({
[15:33:01.824]                 do.call(function(...) {
[15:33:01.824]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:33:01.824]                   if (!identical(...future.globals.maxSize.org, 
[15:33:01.824]                     ...future.globals.maxSize)) {
[15:33:01.824]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:33:01.824]                     on.exit(options(oopts), add = TRUE)
[15:33:01.824]                   }
[15:33:01.824]                   {
[15:33:01.824]                     lapply(seq_along(...future.elements_ii), 
[15:33:01.824]                       FUN = function(jj) {
[15:33:01.824]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:33:01.824]                         ...future.FUN(...future.X_jj, ...)
[15:33:01.824]                       })
[15:33:01.824]                   }
[15:33:01.824]                 }, args = future.call.arguments)
[15:33:01.824]             }))
[15:33:01.824]             future::FutureResult(value = ...future.value$value, 
[15:33:01.824]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:33:01.824]                   ...future.rng), globalenv = if (FALSE) 
[15:33:01.824]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:33:01.824]                     ...future.globalenv.names))
[15:33:01.824]                 else NULL, started = ...future.startTime, version = "1.8")
[15:33:01.824]         }, condition = base::local({
[15:33:01.824]             c <- base::c
[15:33:01.824]             inherits <- base::inherits
[15:33:01.824]             invokeRestart <- base::invokeRestart
[15:33:01.824]             length <- base::length
[15:33:01.824]             list <- base::list
[15:33:01.824]             seq.int <- base::seq.int
[15:33:01.824]             signalCondition <- base::signalCondition
[15:33:01.824]             sys.calls <- base::sys.calls
[15:33:01.824]             `[[` <- base::`[[`
[15:33:01.824]             `+` <- base::`+`
[15:33:01.824]             `<<-` <- base::`<<-`
[15:33:01.824]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:33:01.824]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:33:01.824]                   3L)]
[15:33:01.824]             }
[15:33:01.824]             function(cond) {
[15:33:01.824]                 is_error <- inherits(cond, "error")
[15:33:01.824]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:33:01.824]                   NULL)
[15:33:01.824]                 if (is_error) {
[15:33:01.824]                   sessionInformation <- function() {
[15:33:01.824]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:33:01.824]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:33:01.824]                       search = base::search(), system = base::Sys.info())
[15:33:01.824]                   }
[15:33:01.824]                   ...future.conditions[[length(...future.conditions) + 
[15:33:01.824]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:33:01.824]                     cond$call), session = sessionInformation(), 
[15:33:01.824]                     timestamp = base::Sys.time(), signaled = 0L)
[15:33:01.824]                   signalCondition(cond)
[15:33:01.824]                 }
[15:33:01.824]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:33:01.824]                 "immediateCondition"))) {
[15:33:01.824]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:33:01.824]                   ...future.conditions[[length(...future.conditions) + 
[15:33:01.824]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:33:01.824]                   if (TRUE && !signal) {
[15:33:01.824]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:33:01.824]                     {
[15:33:01.824]                       inherits <- base::inherits
[15:33:01.824]                       invokeRestart <- base::invokeRestart
[15:33:01.824]                       is.null <- base::is.null
[15:33:01.824]                       muffled <- FALSE
[15:33:01.824]                       if (inherits(cond, "message")) {
[15:33:01.824]                         muffled <- grepl(pattern, "muffleMessage")
[15:33:01.824]                         if (muffled) 
[15:33:01.824]                           invokeRestart("muffleMessage")
[15:33:01.824]                       }
[15:33:01.824]                       else if (inherits(cond, "warning")) {
[15:33:01.824]                         muffled <- grepl(pattern, "muffleWarning")
[15:33:01.824]                         if (muffled) 
[15:33:01.824]                           invokeRestart("muffleWarning")
[15:33:01.824]                       }
[15:33:01.824]                       else if (inherits(cond, "condition")) {
[15:33:01.824]                         if (!is.null(pattern)) {
[15:33:01.824]                           computeRestarts <- base::computeRestarts
[15:33:01.824]                           grepl <- base::grepl
[15:33:01.824]                           restarts <- computeRestarts(cond)
[15:33:01.824]                           for (restart in restarts) {
[15:33:01.824]                             name <- restart$name
[15:33:01.824]                             if (is.null(name)) 
[15:33:01.824]                               next
[15:33:01.824]                             if (!grepl(pattern, name)) 
[15:33:01.824]                               next
[15:33:01.824]                             invokeRestart(restart)
[15:33:01.824]                             muffled <- TRUE
[15:33:01.824]                             break
[15:33:01.824]                           }
[15:33:01.824]                         }
[15:33:01.824]                       }
[15:33:01.824]                       invisible(muffled)
[15:33:01.824]                     }
[15:33:01.824]                     muffleCondition(cond, pattern = "^muffle")
[15:33:01.824]                   }
[15:33:01.824]                 }
[15:33:01.824]                 else {
[15:33:01.824]                   if (TRUE) {
[15:33:01.824]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:33:01.824]                     {
[15:33:01.824]                       inherits <- base::inherits
[15:33:01.824]                       invokeRestart <- base::invokeRestart
[15:33:01.824]                       is.null <- base::is.null
[15:33:01.824]                       muffled <- FALSE
[15:33:01.824]                       if (inherits(cond, "message")) {
[15:33:01.824]                         muffled <- grepl(pattern, "muffleMessage")
[15:33:01.824]                         if (muffled) 
[15:33:01.824]                           invokeRestart("muffleMessage")
[15:33:01.824]                       }
[15:33:01.824]                       else if (inherits(cond, "warning")) {
[15:33:01.824]                         muffled <- grepl(pattern, "muffleWarning")
[15:33:01.824]                         if (muffled) 
[15:33:01.824]                           invokeRestart("muffleWarning")
[15:33:01.824]                       }
[15:33:01.824]                       else if (inherits(cond, "condition")) {
[15:33:01.824]                         if (!is.null(pattern)) {
[15:33:01.824]                           computeRestarts <- base::computeRestarts
[15:33:01.824]                           grepl <- base::grepl
[15:33:01.824]                           restarts <- computeRestarts(cond)
[15:33:01.824]                           for (restart in restarts) {
[15:33:01.824]                             name <- restart$name
[15:33:01.824]                             if (is.null(name)) 
[15:33:01.824]                               next
[15:33:01.824]                             if (!grepl(pattern, name)) 
[15:33:01.824]                               next
[15:33:01.824]                             invokeRestart(restart)
[15:33:01.824]                             muffled <- TRUE
[15:33:01.824]                             break
[15:33:01.824]                           }
[15:33:01.824]                         }
[15:33:01.824]                       }
[15:33:01.824]                       invisible(muffled)
[15:33:01.824]                     }
[15:33:01.824]                     muffleCondition(cond, pattern = "^muffle")
[15:33:01.824]                   }
[15:33:01.824]                 }
[15:33:01.824]             }
[15:33:01.824]         }))
[15:33:01.824]     }, error = function(ex) {
[15:33:01.824]         base::structure(base::list(value = NULL, visible = NULL, 
[15:33:01.824]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:33:01.824]                 ...future.rng), started = ...future.startTime, 
[15:33:01.824]             finished = Sys.time(), session_uuid = NA_character_, 
[15:33:01.824]             version = "1.8"), class = "FutureResult")
[15:33:01.824]     }, finally = {
[15:33:01.824]         if (!identical(...future.workdir, getwd())) 
[15:33:01.824]             setwd(...future.workdir)
[15:33:01.824]         {
[15:33:01.824]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:33:01.824]                 ...future.oldOptions$nwarnings <- NULL
[15:33:01.824]             }
[15:33:01.824]             base::options(...future.oldOptions)
[15:33:01.824]             if (.Platform$OS.type == "windows") {
[15:33:01.824]                 old_names <- names(...future.oldEnvVars)
[15:33:01.824]                 envs <- base::Sys.getenv()
[15:33:01.824]                 names <- names(envs)
[15:33:01.824]                 common <- intersect(names, old_names)
[15:33:01.824]                 added <- setdiff(names, old_names)
[15:33:01.824]                 removed <- setdiff(old_names, names)
[15:33:01.824]                 changed <- common[...future.oldEnvVars[common] != 
[15:33:01.824]                   envs[common]]
[15:33:01.824]                 NAMES <- toupper(changed)
[15:33:01.824]                 args <- list()
[15:33:01.824]                 for (kk in seq_along(NAMES)) {
[15:33:01.824]                   name <- changed[[kk]]
[15:33:01.824]                   NAME <- NAMES[[kk]]
[15:33:01.824]                   if (name != NAME && is.element(NAME, old_names)) 
[15:33:01.824]                     next
[15:33:01.824]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:33:01.824]                 }
[15:33:01.824]                 NAMES <- toupper(added)
[15:33:01.824]                 for (kk in seq_along(NAMES)) {
[15:33:01.824]                   name <- added[[kk]]
[15:33:01.824]                   NAME <- NAMES[[kk]]
[15:33:01.824]                   if (name != NAME && is.element(NAME, old_names)) 
[15:33:01.824]                     next
[15:33:01.824]                   args[[name]] <- ""
[15:33:01.824]                 }
[15:33:01.824]                 NAMES <- toupper(removed)
[15:33:01.824]                 for (kk in seq_along(NAMES)) {
[15:33:01.824]                   name <- removed[[kk]]
[15:33:01.824]                   NAME <- NAMES[[kk]]
[15:33:01.824]                   if (name != NAME && is.element(NAME, old_names)) 
[15:33:01.824]                     next
[15:33:01.824]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:33:01.824]                 }
[15:33:01.824]                 if (length(args) > 0) 
[15:33:01.824]                   base::do.call(base::Sys.setenv, args = args)
[15:33:01.824]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:33:01.824]             }
[15:33:01.824]             else {
[15:33:01.824]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:33:01.824]             }
[15:33:01.824]             {
[15:33:01.824]                 if (base::length(...future.futureOptionsAdded) > 
[15:33:01.824]                   0L) {
[15:33:01.824]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:33:01.824]                   base::names(opts) <- ...future.futureOptionsAdded
[15:33:01.824]                   base::options(opts)
[15:33:01.824]                 }
[15:33:01.824]                 {
[15:33:01.824]                   {
[15:33:01.824]                     NULL
[15:33:01.824]                     RNGkind("Mersenne-Twister")
[15:33:01.824]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:33:01.824]                       inherits = FALSE)
[15:33:01.824]                   }
[15:33:01.824]                   options(future.plan = NULL)
[15:33:01.824]                   if (is.na(NA_character_)) 
[15:33:01.824]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:33:01.824]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:33:01.824]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:33:01.824]                     .init = FALSE)
[15:33:01.824]                 }
[15:33:01.824]             }
[15:33:01.824]         }
[15:33:01.824]     })
[15:33:01.824]     if (FALSE) {
[15:33:01.824]         base::sink(type = "output", split = FALSE)
[15:33:01.824]         if (NA) {
[15:33:01.824]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:33:01.824]         }
[15:33:01.824]         else {
[15:33:01.824]             ...future.result["stdout"] <- base::list(NULL)
[15:33:01.824]         }
[15:33:01.824]         base::close(...future.stdout)
[15:33:01.824]         ...future.stdout <- NULL
[15:33:01.824]     }
[15:33:01.824]     ...future.result$conditions <- ...future.conditions
[15:33:01.824]     ...future.result$finished <- base::Sys.time()
[15:33:01.824]     ...future.result
[15:33:01.824] }
[15:33:01.830] assign_globals() ...
[15:33:01.831] List of 5
[15:33:01.831]  $ ...future.FUN            :function (x)  
[15:33:01.831]  $ future.call.arguments    : list()
[15:33:01.831]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:33:01.831]  $ ...future.elements_ii    :List of 2
[15:33:01.831]   ..$ : int 1
[15:33:01.831]   ..$ : int 0
[15:33:01.831]  $ ...future.seeds_ii       : NULL
[15:33:01.831]  $ ...future.globals.maxSize: NULL
[15:33:01.831]  - attr(*, "where")=List of 5
[15:33:01.831]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:33:01.831]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:33:01.831]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:33:01.831]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:33:01.831]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:33:01.831]  - attr(*, "resolved")= logi FALSE
[15:33:01.831]  - attr(*, "total_size")= num 4720
[15:33:01.831]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:33:01.831]  - attr(*, "already-done")= logi TRUE
[15:33:01.841] - reassign environment for '...future.FUN'
[15:33:01.841] - copied '...future.FUN' to environment
[15:33:01.842] - copied 'future.call.arguments' to environment
[15:33:01.842] - copied '...future.elements_ii' to environment
[15:33:01.842] - copied '...future.seeds_ii' to environment
[15:33:01.842] - copied '...future.globals.maxSize' to environment
[15:33:01.842] assign_globals() ... done
[15:33:01.843] plan(): Setting new future strategy stack:
[15:33:01.843] List of future strategies:
[15:33:01.843] 1. sequential:
[15:33:01.843]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:33:01.843]    - tweaked: FALSE
[15:33:01.843]    - call: NULL
[15:33:01.844] plan(): nbrOfWorkers() = 1
[15:33:02.360] plan(): Setting new future strategy stack:
[15:33:02.361] List of future strategies:
[15:33:02.361] 1. multisession:
[15:33:02.361]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[15:33:02.361]    - tweaked: FALSE
[15:33:02.361]    - call: plan(strategy)
[15:33:02.365] plan(): nbrOfWorkers() = 1
[15:33:02.366] SequentialFuture started (and completed)
[15:33:02.366] - Launch lazy future ... done
[15:33:02.366] run() for 'SequentialFuture' ... done
[15:33:02.367] Created future:
[15:33:02.367] SequentialFuture:
[15:33:02.367] Label: 'future_lapply-1'
[15:33:02.367] Expression:
[15:33:02.367] {
[15:33:02.367]     do.call(function(...) {
[15:33:02.367]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:33:02.367]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:33:02.367]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:33:02.367]             on.exit(options(oopts), add = TRUE)
[15:33:02.367]         }
[15:33:02.367]         {
[15:33:02.367]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:33:02.367]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:33:02.367]                 ...future.FUN(...future.X_jj, ...)
[15:33:02.367]             })
[15:33:02.367]         }
[15:33:02.367]     }, args = future.call.arguments)
[15:33:02.367] }
[15:33:02.367] Lazy evaluation: FALSE
[15:33:02.367] Asynchronous evaluation: FALSE
[15:33:02.367] Local evaluation: TRUE
[15:33:02.367] Environment: R_GlobalEnv
[15:33:02.367] Capture standard output: NA
[15:33:02.367] Capture condition classes: 'condition' (excluding 'nothing')
[15:33:02.367] Globals: 5 objects totaling 4.72 KiB (function '...future.FUN' of 4.61 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 112 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:33:02.367] Packages: <none>
[15:33:02.367] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:33:02.367] Resolved: TRUE
[15:33:02.367] Value: 112 bytes of class 'list'
[15:33:02.367] Early signaling: FALSE
[15:33:02.367] Owner process: bdd4bc13-919d-bf34-b2cf-84eb53f6e11f
[15:33:02.367] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:33:02.369] Chunk #1 of 1 ... DONE
[15:33:02.370] Launching 1 futures (chunks) ... DONE
[15:33:02.370] Resolving 1 futures (chunks) ...
[15:33:02.370] resolve() on list ...
[15:33:02.371]  recursive: 0
[15:33:02.371]  length: 1
[15:33:02.371] 
[15:33:02.371] resolved() for 'SequentialFuture' ...
[15:33:02.372] - state: 'finished'
[15:33:02.372] - run: TRUE
[15:33:02.372] - result: 'FutureResult'
[15:33:02.373] resolved() for 'SequentialFuture' ... done
[15:33:02.373] Future #1
[15:33:02.374] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:33:02.374] - nx: 1
[15:33:02.374] - relay: TRUE
[15:33:02.374] - stdout: TRUE
[15:33:02.375] - signal: TRUE
[15:33:02.375] - resignal: FALSE
[15:33:02.375] - force: TRUE
[15:33:02.376] - relayed: [n=1] FALSE
[15:33:02.376] - queued futures: [n=1] FALSE
[15:33:02.376]  - until=1
[15:33:02.377]  - relaying element #1
[15:33:02.417] - relayed: [n=1] TRUE
[15:33:02.418] - queued futures: [n=1] TRUE
[15:33:02.418] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:33:02.418]  length: 0 (resolved future 1)
[15:33:02.418] Relaying remaining futures
[15:33:02.419] signalConditionsASAP(NULL, pos=0) ...
[15:33:02.419] - nx: 1
[15:33:02.419] - relay: TRUE
[15:33:02.419] - stdout: TRUE
[15:33:02.419] - signal: TRUE
[15:33:02.420] - resignal: FALSE
[15:33:02.420] - force: TRUE
[15:33:02.420] - relayed: [n=1] TRUE
[15:33:02.420] - queued futures: [n=1] TRUE
 - flush all
[15:33:02.420] - relayed: [n=1] TRUE
[15:33:02.421] - queued futures: [n=1] TRUE
[15:33:02.421] signalConditionsASAP(NULL, pos=0) ... done
[15:33:02.421] resolve() on list ... DONE
[15:33:02.421]  - Number of value chunks collected: 1
[15:33:02.421] Resolving 1 futures (chunks) ... DONE
[15:33:02.422] Reducing values from 1 chunks ...
[15:33:02.422]  - Number of values collected after concatenation: 2
[15:33:02.422]  - Number of values expected: 2
[15:33:02.422] Reducing values from 1 chunks ... DONE
[15:33:02.422] future_lapply() ... DONE
* future_lapply(x, ..., future.stdout = NA) ... DONE
* future_mapply(x, ..., future.stdout = FALSE) ...
[15:33:02.423] future_mapply() ...
[15:33:02.425] Number of chunks: 1
[15:33:02.425] getGlobalsAndPackagesXApply() ...
[15:33:02.426]  - future.globals: TRUE
[15:33:02.426] getGlobalsAndPackages() ...
[15:33:02.426] Searching for globals...
[15:33:02.428] - globals found: [6] 'FUN', '{', 'Sys.sleep', '/', 'print', 'list'
[15:33:02.428] Searching for globals ... DONE
[15:33:02.428] Resolving globals: FALSE
[15:33:02.429] The total size of the 1 globals is 6.11 KiB (6256 bytes)
[15:33:02.429] The total size of the 1 globals exported for future expression ('FUN()') is 6.11 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (6.11 KiB of class 'function')
[15:33:02.430] - globals: [1] 'FUN'
[15:33:02.430] 
[15:33:02.430] getGlobalsAndPackages() ... DONE
[15:33:02.430]  - globals found/used: [n=1] 'FUN'
[15:33:02.430]  - needed namespaces: [n=0] 
[15:33:02.431] Finding globals ... DONE
[15:33:02.431] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[15:33:02.431] List of 2
[15:33:02.431]  $ ...future.FUN:function (x, y)  
[15:33:02.431]  $ MoreArgs     : NULL
[15:33:02.431]  - attr(*, "where")=List of 2
[15:33:02.431]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:33:02.431]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[15:33:02.431]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:33:02.431]  - attr(*, "resolved")= logi FALSE
[15:33:02.431]  - attr(*, "total_size")= num NA
[15:33:02.434] Packages to be attached in all futures: [n=0] 
[15:33:02.434] getGlobalsAndPackagesXApply() ... DONE
[15:33:02.435] Number of futures (= number of chunks): 1
[15:33:02.435] Launching 1 futures (chunks) ...
[15:33:02.435] Chunk #1 of 1 ...
[15:33:02.435]  - Finding globals in '...' for chunk #1 ...
[15:33:02.435] getGlobalsAndPackages() ...
[15:33:02.436] Searching for globals...
[15:33:02.436] 
[15:33:02.436] Searching for globals ... DONE
[15:33:02.436] - globals: [0] <none>
[15:33:02.437] getGlobalsAndPackages() ... DONE
[15:33:02.437]    + additional globals found: [n=0] 
[15:33:02.437]    + additional namespaces needed: [n=0] 
[15:33:02.437]  - Finding globals in '...' for chunk #1 ... DONE
[15:33:02.437]  - seeds: <none>
[15:33:02.437]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:33:02.438] getGlobalsAndPackages() ...
[15:33:02.438] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:33:02.438] Resolving globals: FALSE
[15:33:02.439] The total size of the 5 globals is 6.33 KiB (6480 bytes)
[15:33:02.439] The total size of the 5 globals exported for future expression ('{; ...future.globals.maxSize.org <- getOption("future.globals.maxSize"); if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {; oopts <- options(future.globals.maxSize = ...future.globals.maxSize); on.exit(options(oopts), add = TRUE); }; ...; do.call(mapply, args = args); }; }') is 6.33 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (6.11 KiB of class 'function'), '...future.elements_ii' (224 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[15:33:02.440] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:33:02.440] 
[15:33:02.440] getGlobalsAndPackages() ... DONE
[15:33:02.440] run() for 'Future' ...
[15:33:02.440] - state: 'created'
[15:33:02.441] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:33:02.443] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:33:02.443] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:33:02.444]   - Field: 'label'
[15:33:02.444]   - Field: 'local'
[15:33:02.444]   - Field: 'owner'
[15:33:02.444]   - Field: 'envir'
[15:33:02.444]   - Field: 'packages'
[15:33:02.445]   - Field: 'gc'
[15:33:02.445]   - Field: 'conditions'
[15:33:02.445]   - Field: 'expr'
[15:33:02.445]   - Field: 'uuid'
[15:33:02.445]   - Field: 'seed'
[15:33:02.445]   - Field: 'version'
[15:33:02.446]   - Field: 'result'
[15:33:02.446]   - Field: 'asynchronous'
[15:33:02.446]   - Field: 'calls'
[15:33:02.446]   - Field: 'globals'
[15:33:02.446]   - Field: 'stdout'
[15:33:02.447]   - Field: 'earlySignal'
[15:33:02.447]   - Field: 'lazy'
[15:33:02.447]   - Field: 'state'
[15:33:02.447] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:33:02.447] - Launch lazy future ...
[15:33:02.448] Packages needed by the future expression (n = 0): <none>
[15:33:02.448] Packages needed by future strategies (n = 0): <none>
[15:33:02.448] {
[15:33:02.448]     {
[15:33:02.448]         {
[15:33:02.448]             ...future.startTime <- base::Sys.time()
[15:33:02.448]             {
[15:33:02.448]                 {
[15:33:02.448]                   {
[15:33:02.448]                     base::local({
[15:33:02.448]                       has_future <- base::requireNamespace("future", 
[15:33:02.448]                         quietly = TRUE)
[15:33:02.448]                       if (has_future) {
[15:33:02.448]                         ns <- base::getNamespace("future")
[15:33:02.448]                         version <- ns[[".package"]][["version"]]
[15:33:02.448]                         if (is.null(version)) 
[15:33:02.448]                           version <- utils::packageVersion("future")
[15:33:02.448]                       }
[15:33:02.448]                       else {
[15:33:02.448]                         version <- NULL
[15:33:02.448]                       }
[15:33:02.448]                       if (!has_future || version < "1.8.0") {
[15:33:02.448]                         info <- base::c(r_version = base::gsub("R version ", 
[15:33:02.448]                           "", base::R.version$version.string), 
[15:33:02.448]                           platform = base::sprintf("%s (%s-bit)", 
[15:33:02.448]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:33:02.448]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:33:02.448]                             "release", "version")], collapse = " "), 
[15:33:02.448]                           hostname = base::Sys.info()[["nodename"]])
[15:33:02.448]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:33:02.448]                           info)
[15:33:02.448]                         info <- base::paste(info, collapse = "; ")
[15:33:02.448]                         if (!has_future) {
[15:33:02.448]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:33:02.448]                             info)
[15:33:02.448]                         }
[15:33:02.448]                         else {
[15:33:02.448]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:33:02.448]                             info, version)
[15:33:02.448]                         }
[15:33:02.448]                         base::stop(msg)
[15:33:02.448]                       }
[15:33:02.448]                     })
[15:33:02.448]                   }
[15:33:02.448]                   ...future.strategy.old <- future::plan("list")
[15:33:02.448]                   options(future.plan = NULL)
[15:33:02.448]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:33:02.448]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:33:02.448]                 }
[15:33:02.448]                 ...future.workdir <- getwd()
[15:33:02.448]             }
[15:33:02.448]             ...future.oldOptions <- base::as.list(base::.Options)
[15:33:02.448]             ...future.oldEnvVars <- base::Sys.getenv()
[15:33:02.448]         }
[15:33:02.448]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:33:02.448]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:33:02.448]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:33:02.448]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:33:02.448]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:33:02.448]             future.stdout.windows.reencode = NULL, width = 80L)
[15:33:02.448]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:33:02.448]             base::names(...future.oldOptions))
[15:33:02.448]     }
[15:33:02.448]     if (FALSE) {
[15:33:02.448]     }
[15:33:02.448]     else {
[15:33:02.448]         if (FALSE) {
[15:33:02.448]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:33:02.448]                 open = "w")
[15:33:02.448]         }
[15:33:02.448]         else {
[15:33:02.448]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:33:02.448]                 windows = "NUL", "/dev/null"), open = "w")
[15:33:02.448]         }
[15:33:02.448]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:33:02.448]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:33:02.448]             base::sink(type = "output", split = FALSE)
[15:33:02.448]             base::close(...future.stdout)
[15:33:02.448]         }, add = TRUE)
[15:33:02.448]     }
[15:33:02.448]     ...future.frame <- base::sys.nframe()
[15:33:02.448]     ...future.conditions <- base::list()
[15:33:02.448]     ...future.rng <- base::globalenv()$.Random.seed
[15:33:02.448]     if (FALSE) {
[15:33:02.448]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:33:02.448]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:33:02.448]     }
[15:33:02.448]     ...future.result <- base::tryCatch({
[15:33:02.448]         base::withCallingHandlers({
[15:33:02.448]             ...future.value <- base::withVisible(base::local({
[15:33:02.448]                 ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:33:02.448]                 if (!identical(...future.globals.maxSize.org, 
[15:33:02.448]                   ...future.globals.maxSize)) {
[15:33:02.448]                   oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:33:02.448]                   on.exit(options(oopts), add = TRUE)
[15:33:02.448]                 }
[15:33:02.448]                 {
[15:33:02.448]                   args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:33:02.448]                     MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:33:02.448]                     USE.NAMES = FALSE)
[15:33:02.448]                   do.call(mapply, args = args)
[15:33:02.448]                 }
[15:33:02.448]             }))
[15:33:02.448]             future::FutureResult(value = ...future.value$value, 
[15:33:02.448]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:33:02.448]                   ...future.rng), globalenv = if (FALSE) 
[15:33:02.448]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:33:02.448]                     ...future.globalenv.names))
[15:33:02.448]                 else NULL, started = ...future.startTime, version = "1.8")
[15:33:02.448]         }, condition = base::local({
[15:33:02.448]             c <- base::c
[15:33:02.448]             inherits <- base::inherits
[15:33:02.448]             invokeRestart <- base::invokeRestart
[15:33:02.448]             length <- base::length
[15:33:02.448]             list <- base::list
[15:33:02.448]             seq.int <- base::seq.int
[15:33:02.448]             signalCondition <- base::signalCondition
[15:33:02.448]             sys.calls <- base::sys.calls
[15:33:02.448]             `[[` <- base::`[[`
[15:33:02.448]             `+` <- base::`+`
[15:33:02.448]             `<<-` <- base::`<<-`
[15:33:02.448]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:33:02.448]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:33:02.448]                   3L)]
[15:33:02.448]             }
[15:33:02.448]             function(cond) {
[15:33:02.448]                 is_error <- inherits(cond, "error")
[15:33:02.448]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:33:02.448]                   NULL)
[15:33:02.448]                 if (is_error) {
[15:33:02.448]                   sessionInformation <- function() {
[15:33:02.448]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:33:02.448]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:33:02.448]                       search = base::search(), system = base::Sys.info())
[15:33:02.448]                   }
[15:33:02.448]                   ...future.conditions[[length(...future.conditions) + 
[15:33:02.448]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:33:02.448]                     cond$call), session = sessionInformation(), 
[15:33:02.448]                     timestamp = base::Sys.time(), signaled = 0L)
[15:33:02.448]                   signalCondition(cond)
[15:33:02.448]                 }
[15:33:02.448]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:33:02.448]                 "immediateCondition"))) {
[15:33:02.448]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:33:02.448]                   ...future.conditions[[length(...future.conditions) + 
[15:33:02.448]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:33:02.448]                   if (TRUE && !signal) {
[15:33:02.448]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:33:02.448]                     {
[15:33:02.448]                       inherits <- base::inherits
[15:33:02.448]                       invokeRestart <- base::invokeRestart
[15:33:02.448]                       is.null <- base::is.null
[15:33:02.448]                       muffled <- FALSE
[15:33:02.448]                       if (inherits(cond, "message")) {
[15:33:02.448]                         muffled <- grepl(pattern, "muffleMessage")
[15:33:02.448]                         if (muffled) 
[15:33:02.448]                           invokeRestart("muffleMessage")
[15:33:02.448]                       }
[15:33:02.448]                       else if (inherits(cond, "warning")) {
[15:33:02.448]                         muffled <- grepl(pattern, "muffleWarning")
[15:33:02.448]                         if (muffled) 
[15:33:02.448]                           invokeRestart("muffleWarning")
[15:33:02.448]                       }
[15:33:02.448]                       else if (inherits(cond, "condition")) {
[15:33:02.448]                         if (!is.null(pattern)) {
[15:33:02.448]                           computeRestarts <- base::computeRestarts
[15:33:02.448]                           grepl <- base::grepl
[15:33:02.448]                           restarts <- computeRestarts(cond)
[15:33:02.448]                           for (restart in restarts) {
[15:33:02.448]                             name <- restart$name
[15:33:02.448]                             if (is.null(name)) 
[15:33:02.448]                               next
[15:33:02.448]                             if (!grepl(pattern, name)) 
[15:33:02.448]                               next
[15:33:02.448]                             invokeRestart(restart)
[15:33:02.448]                             muffled <- TRUE
[15:33:02.448]                             break
[15:33:02.448]                           }
[15:33:02.448]                         }
[15:33:02.448]                       }
[15:33:02.448]                       invisible(muffled)
[15:33:02.448]                     }
[15:33:02.448]                     muffleCondition(cond, pattern = "^muffle")
[15:33:02.448]                   }
[15:33:02.448]                 }
[15:33:02.448]                 else {
[15:33:02.448]                   if (TRUE) {
[15:33:02.448]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:33:02.448]                     {
[15:33:02.448]                       inherits <- base::inherits
[15:33:02.448]                       invokeRestart <- base::invokeRestart
[15:33:02.448]                       is.null <- base::is.null
[15:33:02.448]                       muffled <- FALSE
[15:33:02.448]                       if (inherits(cond, "message")) {
[15:33:02.448]                         muffled <- grepl(pattern, "muffleMessage")
[15:33:02.448]                         if (muffled) 
[15:33:02.448]                           invokeRestart("muffleMessage")
[15:33:02.448]                       }
[15:33:02.448]                       else if (inherits(cond, "warning")) {
[15:33:02.448]                         muffled <- grepl(pattern, "muffleWarning")
[15:33:02.448]                         if (muffled) 
[15:33:02.448]                           invokeRestart("muffleWarning")
[15:33:02.448]                       }
[15:33:02.448]                       else if (inherits(cond, "condition")) {
[15:33:02.448]                         if (!is.null(pattern)) {
[15:33:02.448]                           computeRestarts <- base::computeRestarts
[15:33:02.448]                           grepl <- base::grepl
[15:33:02.448]                           restarts <- computeRestarts(cond)
[15:33:02.448]                           for (restart in restarts) {
[15:33:02.448]                             name <- restart$name
[15:33:02.448]                             if (is.null(name)) 
[15:33:02.448]                               next
[15:33:02.448]                             if (!grepl(pattern, name)) 
[15:33:02.448]                               next
[15:33:02.448]                             invokeRestart(restart)
[15:33:02.448]                             muffled <- TRUE
[15:33:02.448]                             break
[15:33:02.448]                           }
[15:33:02.448]                         }
[15:33:02.448]                       }
[15:33:02.448]                       invisible(muffled)
[15:33:02.448]                     }
[15:33:02.448]                     muffleCondition(cond, pattern = "^muffle")
[15:33:02.448]                   }
[15:33:02.448]                 }
[15:33:02.448]             }
[15:33:02.448]         }))
[15:33:02.448]     }, error = function(ex) {
[15:33:02.448]         base::structure(base::list(value = NULL, visible = NULL, 
[15:33:02.448]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:33:02.448]                 ...future.rng), started = ...future.startTime, 
[15:33:02.448]             finished = Sys.time(), session_uuid = NA_character_, 
[15:33:02.448]             version = "1.8"), class = "FutureResult")
[15:33:02.448]     }, finally = {
[15:33:02.448]         if (!identical(...future.workdir, getwd())) 
[15:33:02.448]             setwd(...future.workdir)
[15:33:02.448]         {
[15:33:02.448]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:33:02.448]                 ...future.oldOptions$nwarnings <- NULL
[15:33:02.448]             }
[15:33:02.448]             base::options(...future.oldOptions)
[15:33:02.448]             if (.Platform$OS.type == "windows") {
[15:33:02.448]                 old_names <- names(...future.oldEnvVars)
[15:33:02.448]                 envs <- base::Sys.getenv()
[15:33:02.448]                 names <- names(envs)
[15:33:02.448]                 common <- intersect(names, old_names)
[15:33:02.448]                 added <- setdiff(names, old_names)
[15:33:02.448]                 removed <- setdiff(old_names, names)
[15:33:02.448]                 changed <- common[...future.oldEnvVars[common] != 
[15:33:02.448]                   envs[common]]
[15:33:02.448]                 NAMES <- toupper(changed)
[15:33:02.448]                 args <- list()
[15:33:02.448]                 for (kk in seq_along(NAMES)) {
[15:33:02.448]                   name <- changed[[kk]]
[15:33:02.448]                   NAME <- NAMES[[kk]]
[15:33:02.448]                   if (name != NAME && is.element(NAME, old_names)) 
[15:33:02.448]                     next
[15:33:02.448]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:33:02.448]                 }
[15:33:02.448]                 NAMES <- toupper(added)
[15:33:02.448]                 for (kk in seq_along(NAMES)) {
[15:33:02.448]                   name <- added[[kk]]
[15:33:02.448]                   NAME <- NAMES[[kk]]
[15:33:02.448]                   if (name != NAME && is.element(NAME, old_names)) 
[15:33:02.448]                     next
[15:33:02.448]                   args[[name]] <- ""
[15:33:02.448]                 }
[15:33:02.448]                 NAMES <- toupper(removed)
[15:33:02.448]                 for (kk in seq_along(NAMES)) {
[15:33:02.448]                   name <- removed[[kk]]
[15:33:02.448]                   NAME <- NAMES[[kk]]
[15:33:02.448]                   if (name != NAME && is.element(NAME, old_names)) 
[15:33:02.448]                     next
[15:33:02.448]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:33:02.448]                 }
[15:33:02.448]                 if (length(args) > 0) 
[15:33:02.448]                   base::do.call(base::Sys.setenv, args = args)
[15:33:02.448]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:33:02.448]             }
[15:33:02.448]             else {
[15:33:02.448]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:33:02.448]             }
[15:33:02.448]             {
[15:33:02.448]                 if (base::length(...future.futureOptionsAdded) > 
[15:33:02.448]                   0L) {
[15:33:02.448]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:33:02.448]                   base::names(opts) <- ...future.futureOptionsAdded
[15:33:02.448]                   base::options(opts)
[15:33:02.448]                 }
[15:33:02.448]                 {
[15:33:02.448]                   {
[15:33:02.448]                     NULL
[15:33:02.448]                     RNGkind("Mersenne-Twister")
[15:33:02.448]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:33:02.448]                       inherits = FALSE)
[15:33:02.448]                   }
[15:33:02.448]                   options(future.plan = NULL)
[15:33:02.448]                   if (is.na(NA_character_)) 
[15:33:02.448]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:33:02.448]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:33:02.448]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:33:02.448]                     .init = FALSE)
[15:33:02.448]                 }
[15:33:02.448]             }
[15:33:02.448]         }
[15:33:02.448]     })
[15:33:02.448]     if (TRUE) {
[15:33:02.448]         base::sink(type = "output", split = FALSE)
[15:33:02.448]         if (FALSE) {
[15:33:02.448]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:33:02.448]         }
[15:33:02.448]         else {
[15:33:02.448]             ...future.result["stdout"] <- base::list(NULL)
[15:33:02.448]         }
[15:33:02.448]         base::close(...future.stdout)
[15:33:02.448]         ...future.stdout <- NULL
[15:33:02.448]     }
[15:33:02.448]     ...future.result$conditions <- ...future.conditions
[15:33:02.448]     ...future.result$finished <- base::Sys.time()
[15:33:02.448]     ...future.result
[15:33:02.448] }
[15:33:02.452] assign_globals() ...
[15:33:02.453] List of 5
[15:33:02.453]  $ ...future.FUN            :function (x, y)  
[15:33:02.453]  $ MoreArgs                 : NULL
[15:33:02.453]  $ ...future.elements_ii    :List of 2
[15:33:02.453]   ..$ :List of 2
[15:33:02.453]   .. ..$ : int 1
[15:33:02.453]   .. ..$ : int 0
[15:33:02.453]   ..$ :List of 2
[15:33:02.453]   .. ..$ : int 0
[15:33:02.453]   .. ..$ : int 1
[15:33:02.453]  $ ...future.seeds_ii       : NULL
[15:33:02.453]  $ ...future.globals.maxSize: NULL
[15:33:02.453]  - attr(*, "where")=List of 5
[15:33:02.453]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:33:02.453]   ..$ MoreArgs                 :<environment: R_EmptyEnv> 
[15:33:02.453]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:33:02.453]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:33:02.453]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:33:02.453]  - attr(*, "resolved")= logi FALSE
[15:33:02.453]  - attr(*, "total_size")= num 6480
[15:33:02.453]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:33:02.453]  - attr(*, "already-done")= logi TRUE
[15:33:02.466] - reassign environment for '...future.FUN'
[15:33:02.466] - copied '...future.FUN' to environment
[15:33:02.466] - copied 'MoreArgs' to environment
[15:33:02.467] - copied '...future.elements_ii' to environment
[15:33:02.467] - copied '...future.seeds_ii' to environment
[15:33:02.467] - copied '...future.globals.maxSize' to environment
[15:33:02.468] assign_globals() ... done
[15:33:02.468] plan(): Setting new future strategy stack:
[15:33:02.469] List of future strategies:
[15:33:02.469] 1. sequential:
[15:33:02.469]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:33:02.469]    - tweaked: FALSE
[15:33:02.469]    - call: NULL
[15:33:02.470] plan(): nbrOfWorkers() = 1
[15:33:02.986] plan(): Setting new future strategy stack:
[15:33:02.986] List of future strategies:
[15:33:02.986] 1. multisession:
[15:33:02.986]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[15:33:02.986]    - tweaked: FALSE
[15:33:02.986]    - call: plan(strategy)
[15:33:02.990] plan(): nbrOfWorkers() = 1
[15:33:02.991] SequentialFuture started (and completed)
[15:33:02.991] - Launch lazy future ... done
[15:33:02.992] run() for 'SequentialFuture' ... done
[15:33:02.992] Created future:
[15:33:02.992] SequentialFuture:
[15:33:02.992] Label: 'future_mapply-1'
[15:33:02.992] Expression:
[15:33:02.992] {
[15:33:02.992]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:33:02.992]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:33:02.992]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:33:02.992]         on.exit(options(oopts), add = TRUE)
[15:33:02.992]     }
[15:33:02.992]     {
[15:33:02.992]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:33:02.992]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:33:02.992]         do.call(mapply, args = args)
[15:33:02.992]     }
[15:33:02.992] }
[15:33:02.992] Lazy evaluation: FALSE
[15:33:02.992] Asynchronous evaluation: FALSE
[15:33:02.992] Local evaluation: TRUE
[15:33:02.992] Environment: R_GlobalEnv
[15:33:02.992] Capture standard output: FALSE
[15:33:02.992] Capture condition classes: 'condition' (excluding 'nothing')
[15:33:02.992] Globals: 5 objects totaling 6.33 KiB (function '...future.FUN' of 6.11 KiB, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 224 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:33:02.992] Packages: <none>
[15:33:02.992] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:33:02.992] Resolved: TRUE
[15:33:02.992] Value: 224 bytes of class 'list'
[15:33:02.992] Early signaling: FALSE
[15:33:02.992] Owner process: bdd4bc13-919d-bf34-b2cf-84eb53f6e11f
[15:33:02.992] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:33:02.995] Chunk #1 of 1 ... DONE
[15:33:02.995] Launching 1 futures (chunks) ... DONE
[15:33:02.995] Resolving 1 futures (chunks) ...
[15:33:02.996] resolve() on list ...
[15:33:02.996]  recursive: 0
[15:33:02.996]  length: 1
[15:33:02.996] 
[15:33:02.997] resolved() for 'SequentialFuture' ...
[15:33:02.997] - state: 'finished'
[15:33:02.997] - run: TRUE
[15:33:02.998] - result: 'FutureResult'
[15:33:02.998] resolved() for 'SequentialFuture' ... done
[15:33:02.998] Future #1
[15:33:02.999] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:33:02.999] - nx: 1
[15:33:03.000] - relay: TRUE
[15:33:03.000] - stdout: TRUE
[15:33:03.000] - signal: TRUE
[15:33:03.000] - resignal: FALSE
[15:33:03.001] - force: TRUE
[15:33:03.001] - relayed: [n=1] FALSE
[15:33:03.001] - queued futures: [n=1] FALSE
[15:33:03.002]  - until=1
[15:33:03.002]  - relaying element #1
[15:33:03.003] - relayed: [n=1] TRUE
[15:33:03.003] - queued futures: [n=1] TRUE
[15:33:03.003] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:33:03.004]  length: 0 (resolved future 1)
[15:33:03.004] Relaying remaining futures
[15:33:03.004] signalConditionsASAP(NULL, pos=0) ...
[15:33:03.004] - nx: 1
[15:33:03.005] - relay: TRUE
[15:33:03.005] - stdout: TRUE
[15:33:03.005] - signal: TRUE
[15:33:03.006] - resignal: FALSE
[15:33:03.006] - force: TRUE
[15:33:03.006] - relayed: [n=1] TRUE
[15:33:03.006] - queued futures: [n=1] TRUE
 - flush all
[15:33:03.007] - relayed: [n=1] TRUE
[15:33:03.007] - queued futures: [n=1] TRUE
[15:33:03.008] signalConditionsASAP(NULL, pos=0) ... done
[15:33:03.008] resolve() on list ... DONE
[15:33:03.008]  - Number of value chunks collected: 1
[15:33:03.009] Resolving 1 futures (chunks) ... DONE
[15:33:03.009] Reducing values from 1 chunks ...
[15:33:03.009]  - Number of values collected after concatenation: 2
[15:33:03.009]  - Number of values expected: 2
[15:33:03.010] Reducing values from 1 chunks ... DONE
[15:33:03.010] future_mapply() ... DONE
* future_mapply(x, ..., future.stdout = FALSE) ... DONE
* future_mapply(x, ..., future.stdout = TRUE) ...
[15:33:03.011] future_mapply() ...
[15:33:03.015] Number of chunks: 1
[15:33:03.016] getGlobalsAndPackagesXApply() ...
[15:33:03.016]  - future.globals: TRUE
[15:33:03.016] getGlobalsAndPackages() ...
[15:33:03.017] Searching for globals...
[15:33:03.020] - globals found: [6] 'FUN', '{', 'Sys.sleep', '/', 'print', 'list'
[15:33:03.020] Searching for globals ... DONE
[15:33:03.021] Resolving globals: FALSE
[15:33:03.024] The total size of the 1 globals is 6.11 KiB (6256 bytes)
[15:33:03.025] The total size of the 1 globals exported for future expression ('FUN()') is 6.11 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (6.11 KiB of class 'function')
[15:33:03.025] - globals: [1] 'FUN'
[15:33:03.025] 
[15:33:03.026] getGlobalsAndPackages() ... DONE
[15:33:03.026]  - globals found/used: [n=1] 'FUN'
[15:33:03.026]  - needed namespaces: [n=0] 
[15:33:03.027] Finding globals ... DONE
[15:33:03.027] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[15:33:03.028] List of 2
[15:33:03.028]  $ ...future.FUN:function (x, y)  
[15:33:03.028]  $ MoreArgs     : NULL
[15:33:03.028]  - attr(*, "where")=List of 2
[15:33:03.028]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:33:03.028]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[15:33:03.028]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:33:03.028]  - attr(*, "resolved")= logi FALSE
[15:33:03.028]  - attr(*, "total_size")= num NA
[15:33:03.033] Packages to be attached in all futures: [n=0] 
[15:33:03.033] getGlobalsAndPackagesXApply() ... DONE
[15:33:03.033] Number of futures (= number of chunks): 1
[15:33:03.034] Launching 1 futures (chunks) ...
[15:33:03.034] Chunk #1 of 1 ...
[15:33:03.034]  - Finding globals in '...' for chunk #1 ...
[15:33:03.035] getGlobalsAndPackages() ...
[15:33:03.035] Searching for globals...
[15:33:03.036] 
[15:33:03.036] Searching for globals ... DONE
[15:33:03.036] - globals: [0] <none>
[15:33:03.037] getGlobalsAndPackages() ... DONE
[15:33:03.037]    + additional globals found: [n=0] 
[15:33:03.037]    + additional namespaces needed: [n=0] 
[15:33:03.037]  - Finding globals in '...' for chunk #1 ... DONE
[15:33:03.038]  - seeds: <none>
[15:33:03.038]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:33:03.038] getGlobalsAndPackages() ...
[15:33:03.039] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:33:03.039] Resolving globals: FALSE
[15:33:03.040] The total size of the 5 globals is 6.33 KiB (6480 bytes)
[15:33:03.041] The total size of the 5 globals exported for future expression ('{; ...future.globals.maxSize.org <- getOption("future.globals.maxSize"); if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {; oopts <- options(future.globals.maxSize = ...future.globals.maxSize); on.exit(options(oopts), add = TRUE); }; ...; do.call(mapply, args = args); }; }') is 6.33 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (6.11 KiB of class 'function'), '...future.elements_ii' (224 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[15:33:03.042] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:33:03.042] 
[15:33:03.042] getGlobalsAndPackages() ... DONE
[15:33:03.043] run() for 'Future' ...
[15:33:03.043] - state: 'created'
[15:33:03.044] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:33:03.048] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:33:03.048] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:33:03.048]   - Field: 'label'
[15:33:03.049]   - Field: 'local'
[15:33:03.049]   - Field: 'owner'
[15:33:03.049]   - Field: 'envir'
[15:33:03.050]   - Field: 'packages'
[15:33:03.050]   - Field: 'gc'
[15:33:03.050]   - Field: 'conditions'
[15:33:03.051]   - Field: 'expr'
[15:33:03.051]   - Field: 'uuid'
[15:33:03.051]   - Field: 'seed'
[15:33:03.052]   - Field: 'version'
[15:33:03.052]   - Field: 'result'
[15:33:03.052]   - Field: 'asynchronous'
[15:33:03.053]   - Field: 'calls'
[15:33:03.053]   - Field: 'globals'
[15:33:03.053]   - Field: 'stdout'
[15:33:03.054]   - Field: 'earlySignal'
[15:33:03.054]   - Field: 'lazy'
[15:33:03.054]   - Field: 'state'
[15:33:03.055] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:33:03.055] - Launch lazy future ...
[15:33:03.055] Packages needed by the future expression (n = 0): <none>
[15:33:03.056] Packages needed by future strategies (n = 0): <none>
[15:33:03.057] {
[15:33:03.057]     {
[15:33:03.057]         {
[15:33:03.057]             ...future.startTime <- base::Sys.time()
[15:33:03.057]             {
[15:33:03.057]                 {
[15:33:03.057]                   {
[15:33:03.057]                     base::local({
[15:33:03.057]                       has_future <- base::requireNamespace("future", 
[15:33:03.057]                         quietly = TRUE)
[15:33:03.057]                       if (has_future) {
[15:33:03.057]                         ns <- base::getNamespace("future")
[15:33:03.057]                         version <- ns[[".package"]][["version"]]
[15:33:03.057]                         if (is.null(version)) 
[15:33:03.057]                           version <- utils::packageVersion("future")
[15:33:03.057]                       }
[15:33:03.057]                       else {
[15:33:03.057]                         version <- NULL
[15:33:03.057]                       }
[15:33:03.057]                       if (!has_future || version < "1.8.0") {
[15:33:03.057]                         info <- base::c(r_version = base::gsub("R version ", 
[15:33:03.057]                           "", base::R.version$version.string), 
[15:33:03.057]                           platform = base::sprintf("%s (%s-bit)", 
[15:33:03.057]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:33:03.057]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:33:03.057]                             "release", "version")], collapse = " "), 
[15:33:03.057]                           hostname = base::Sys.info()[["nodename"]])
[15:33:03.057]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:33:03.057]                           info)
[15:33:03.057]                         info <- base::paste(info, collapse = "; ")
[15:33:03.057]                         if (!has_future) {
[15:33:03.057]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:33:03.057]                             info)
[15:33:03.057]                         }
[15:33:03.057]                         else {
[15:33:03.057]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:33:03.057]                             info, version)
[15:33:03.057]                         }
[15:33:03.057]                         base::stop(msg)
[15:33:03.057]                       }
[15:33:03.057]                     })
[15:33:03.057]                   }
[15:33:03.057]                   ...future.strategy.old <- future::plan("list")
[15:33:03.057]                   options(future.plan = NULL)
[15:33:03.057]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:33:03.057]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:33:03.057]                 }
[15:33:03.057]                 ...future.workdir <- getwd()
[15:33:03.057]             }
[15:33:03.057]             ...future.oldOptions <- base::as.list(base::.Options)
[15:33:03.057]             ...future.oldEnvVars <- base::Sys.getenv()
[15:33:03.057]         }
[15:33:03.057]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:33:03.057]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:33:03.057]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:33:03.057]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:33:03.057]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:33:03.057]             future.stdout.windows.reencode = NULL, width = 80L)
[15:33:03.057]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:33:03.057]             base::names(...future.oldOptions))
[15:33:03.057]     }
[15:33:03.057]     if (FALSE) {
[15:33:03.057]     }
[15:33:03.057]     else {
[15:33:03.057]         if (TRUE) {
[15:33:03.057]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:33:03.057]                 open = "w")
[15:33:03.057]         }
[15:33:03.057]         else {
[15:33:03.057]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:33:03.057]                 windows = "NUL", "/dev/null"), open = "w")
[15:33:03.057]         }
[15:33:03.057]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:33:03.057]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:33:03.057]             base::sink(type = "output", split = FALSE)
[15:33:03.057]             base::close(...future.stdout)
[15:33:03.057]         }, add = TRUE)
[15:33:03.057]     }
[15:33:03.057]     ...future.frame <- base::sys.nframe()
[15:33:03.057]     ...future.conditions <- base::list()
[15:33:03.057]     ...future.rng <- base::globalenv()$.Random.seed
[15:33:03.057]     if (FALSE) {
[15:33:03.057]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:33:03.057]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:33:03.057]     }
[15:33:03.057]     ...future.result <- base::tryCatch({
[15:33:03.057]         base::withCallingHandlers({
[15:33:03.057]             ...future.value <- base::withVisible(base::local({
[15:33:03.057]                 ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:33:03.057]                 if (!identical(...future.globals.maxSize.org, 
[15:33:03.057]                   ...future.globals.maxSize)) {
[15:33:03.057]                   oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:33:03.057]                   on.exit(options(oopts), add = TRUE)
[15:33:03.057]                 }
[15:33:03.057]                 {
[15:33:03.057]                   args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:33:03.057]                     MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:33:03.057]                     USE.NAMES = FALSE)
[15:33:03.057]                   do.call(mapply, args = args)
[15:33:03.057]                 }
[15:33:03.057]             }))
[15:33:03.057]             future::FutureResult(value = ...future.value$value, 
[15:33:03.057]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:33:03.057]                   ...future.rng), globalenv = if (FALSE) 
[15:33:03.057]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:33:03.057]                     ...future.globalenv.names))
[15:33:03.057]                 else NULL, started = ...future.startTime, version = "1.8")
[15:33:03.057]         }, condition = base::local({
[15:33:03.057]             c <- base::c
[15:33:03.057]             inherits <- base::inherits
[15:33:03.057]             invokeRestart <- base::invokeRestart
[15:33:03.057]             length <- base::length
[15:33:03.057]             list <- base::list
[15:33:03.057]             seq.int <- base::seq.int
[15:33:03.057]             signalCondition <- base::signalCondition
[15:33:03.057]             sys.calls <- base::sys.calls
[15:33:03.057]             `[[` <- base::`[[`
[15:33:03.057]             `+` <- base::`+`
[15:33:03.057]             `<<-` <- base::`<<-`
[15:33:03.057]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:33:03.057]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:33:03.057]                   3L)]
[15:33:03.057]             }
[15:33:03.057]             function(cond) {
[15:33:03.057]                 is_error <- inherits(cond, "error")
[15:33:03.057]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:33:03.057]                   NULL)
[15:33:03.057]                 if (is_error) {
[15:33:03.057]                   sessionInformation <- function() {
[15:33:03.057]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:33:03.057]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:33:03.057]                       search = base::search(), system = base::Sys.info())
[15:33:03.057]                   }
[15:33:03.057]                   ...future.conditions[[length(...future.conditions) + 
[15:33:03.057]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:33:03.057]                     cond$call), session = sessionInformation(), 
[15:33:03.057]                     timestamp = base::Sys.time(), signaled = 0L)
[15:33:03.057]                   signalCondition(cond)
[15:33:03.057]                 }
[15:33:03.057]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:33:03.057]                 "immediateCondition"))) {
[15:33:03.057]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:33:03.057]                   ...future.conditions[[length(...future.conditions) + 
[15:33:03.057]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:33:03.057]                   if (TRUE && !signal) {
[15:33:03.057]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:33:03.057]                     {
[15:33:03.057]                       inherits <- base::inherits
[15:33:03.057]                       invokeRestart <- base::invokeRestart
[15:33:03.057]                       is.null <- base::is.null
[15:33:03.057]                       muffled <- FALSE
[15:33:03.057]                       if (inherits(cond, "message")) {
[15:33:03.057]                         muffled <- grepl(pattern, "muffleMessage")
[15:33:03.057]                         if (muffled) 
[15:33:03.057]                           invokeRestart("muffleMessage")
[15:33:03.057]                       }
[15:33:03.057]                       else if (inherits(cond, "warning")) {
[15:33:03.057]                         muffled <- grepl(pattern, "muffleWarning")
[15:33:03.057]                         if (muffled) 
[15:33:03.057]                           invokeRestart("muffleWarning")
[15:33:03.057]                       }
[15:33:03.057]                       else if (inherits(cond, "condition")) {
[15:33:03.057]                         if (!is.null(pattern)) {
[15:33:03.057]                           computeRestarts <- base::computeRestarts
[15:33:03.057]                           grepl <- base::grepl
[15:33:03.057]                           restarts <- computeRestarts(cond)
[15:33:03.057]                           for (restart in restarts) {
[15:33:03.057]                             name <- restart$name
[15:33:03.057]                             if (is.null(name)) 
[15:33:03.057]                               next
[15:33:03.057]                             if (!grepl(pattern, name)) 
[15:33:03.057]                               next
[15:33:03.057]                             invokeRestart(restart)
[15:33:03.057]                             muffled <- TRUE
[15:33:03.057]                             break
[15:33:03.057]                           }
[15:33:03.057]                         }
[15:33:03.057]                       }
[15:33:03.057]                       invisible(muffled)
[15:33:03.057]                     }
[15:33:03.057]                     muffleCondition(cond, pattern = "^muffle")
[15:33:03.057]                   }
[15:33:03.057]                 }
[15:33:03.057]                 else {
[15:33:03.057]                   if (TRUE) {
[15:33:03.057]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:33:03.057]                     {
[15:33:03.057]                       inherits <- base::inherits
[15:33:03.057]                       invokeRestart <- base::invokeRestart
[15:33:03.057]                       is.null <- base::is.null
[15:33:03.057]                       muffled <- FALSE
[15:33:03.057]                       if (inherits(cond, "message")) {
[15:33:03.057]                         muffled <- grepl(pattern, "muffleMessage")
[15:33:03.057]                         if (muffled) 
[15:33:03.057]                           invokeRestart("muffleMessage")
[15:33:03.057]                       }
[15:33:03.057]                       else if (inherits(cond, "warning")) {
[15:33:03.057]                         muffled <- grepl(pattern, "muffleWarning")
[15:33:03.057]                         if (muffled) 
[15:33:03.057]                           invokeRestart("muffleWarning")
[15:33:03.057]                       }
[15:33:03.057]                       else if (inherits(cond, "condition")) {
[15:33:03.057]                         if (!is.null(pattern)) {
[15:33:03.057]                           computeRestarts <- base::computeRestarts
[15:33:03.057]                           grepl <- base::grepl
[15:33:03.057]                           restarts <- computeRestarts(cond)
[15:33:03.057]                           for (restart in restarts) {
[15:33:03.057]                             name <- restart$name
[15:33:03.057]                             if (is.null(name)) 
[15:33:03.057]                               next
[15:33:03.057]                             if (!grepl(pattern, name)) 
[15:33:03.057]                               next
[15:33:03.057]                             invokeRestart(restart)
[15:33:03.057]                             muffled <- TRUE
[15:33:03.057]                             break
[15:33:03.057]                           }
[15:33:03.057]                         }
[15:33:03.057]                       }
[15:33:03.057]                       invisible(muffled)
[15:33:03.057]                     }
[15:33:03.057]                     muffleCondition(cond, pattern = "^muffle")
[15:33:03.057]                   }
[15:33:03.057]                 }
[15:33:03.057]             }
[15:33:03.057]         }))
[15:33:03.057]     }, error = function(ex) {
[15:33:03.057]         base::structure(base::list(value = NULL, visible = NULL, 
[15:33:03.057]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:33:03.057]                 ...future.rng), started = ...future.startTime, 
[15:33:03.057]             finished = Sys.time(), session_uuid = NA_character_, 
[15:33:03.057]             version = "1.8"), class = "FutureResult")
[15:33:03.057]     }, finally = {
[15:33:03.057]         if (!identical(...future.workdir, getwd())) 
[15:33:03.057]             setwd(...future.workdir)
[15:33:03.057]         {
[15:33:03.057]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:33:03.057]                 ...future.oldOptions$nwarnings <- NULL
[15:33:03.057]             }
[15:33:03.057]             base::options(...future.oldOptions)
[15:33:03.057]             if (.Platform$OS.type == "windows") {
[15:33:03.057]                 old_names <- names(...future.oldEnvVars)
[15:33:03.057]                 envs <- base::Sys.getenv()
[15:33:03.057]                 names <- names(envs)
[15:33:03.057]                 common <- intersect(names, old_names)
[15:33:03.057]                 added <- setdiff(names, old_names)
[15:33:03.057]                 removed <- setdiff(old_names, names)
[15:33:03.057]                 changed <- common[...future.oldEnvVars[common] != 
[15:33:03.057]                   envs[common]]
[15:33:03.057]                 NAMES <- toupper(changed)
[15:33:03.057]                 args <- list()
[15:33:03.057]                 for (kk in seq_along(NAMES)) {
[15:33:03.057]                   name <- changed[[kk]]
[15:33:03.057]                   NAME <- NAMES[[kk]]
[15:33:03.057]                   if (name != NAME && is.element(NAME, old_names)) 
[15:33:03.057]                     next
[15:33:03.057]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:33:03.057]                 }
[15:33:03.057]                 NAMES <- toupper(added)
[15:33:03.057]                 for (kk in seq_along(NAMES)) {
[15:33:03.057]                   name <- added[[kk]]
[15:33:03.057]                   NAME <- NAMES[[kk]]
[15:33:03.057]                   if (name != NAME && is.element(NAME, old_names)) 
[15:33:03.057]                     next
[15:33:03.057]                   args[[name]] <- ""
[15:33:03.057]                 }
[15:33:03.057]                 NAMES <- toupper(removed)
[15:33:03.057]                 for (kk in seq_along(NAMES)) {
[15:33:03.057]                   name <- removed[[kk]]
[15:33:03.057]                   NAME <- NAMES[[kk]]
[15:33:03.057]                   if (name != NAME && is.element(NAME, old_names)) 
[15:33:03.057]                     next
[15:33:03.057]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:33:03.057]                 }
[15:33:03.057]                 if (length(args) > 0) 
[15:33:03.057]                   base::do.call(base::Sys.setenv, args = args)
[15:33:03.057]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:33:03.057]             }
[15:33:03.057]             else {
[15:33:03.057]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:33:03.057]             }
[15:33:03.057]             {
[15:33:03.057]                 if (base::length(...future.futureOptionsAdded) > 
[15:33:03.057]                   0L) {
[15:33:03.057]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:33:03.057]                   base::names(opts) <- ...future.futureOptionsAdded
[15:33:03.057]                   base::options(opts)
[15:33:03.057]                 }
[15:33:03.057]                 {
[15:33:03.057]                   {
[15:33:03.057]                     NULL
[15:33:03.057]                     RNGkind("Mersenne-Twister")
[15:33:03.057]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:33:03.057]                       inherits = FALSE)
[15:33:03.057]                   }
[15:33:03.057]                   options(future.plan = NULL)
[15:33:03.057]                   if (is.na(NA_character_)) 
[15:33:03.057]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:33:03.057]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:33:03.057]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:33:03.057]                     .init = FALSE)
[15:33:03.057]                 }
[15:33:03.057]             }
[15:33:03.057]         }
[15:33:03.057]     })
[15:33:03.057]     if (TRUE) {
[15:33:03.057]         base::sink(type = "output", split = FALSE)
[15:33:03.057]         if (TRUE) {
[15:33:03.057]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:33:03.057]         }
[15:33:03.057]         else {
[15:33:03.057]             ...future.result["stdout"] <- base::list(NULL)
[15:33:03.057]         }
[15:33:03.057]         base::close(...future.stdout)
[15:33:03.057]         ...future.stdout <- NULL
[15:33:03.057]     }
[15:33:03.057]     ...future.result$conditions <- ...future.conditions
[15:33:03.057]     ...future.result$finished <- base::Sys.time()
[15:33:03.057]     ...future.result
[15:33:03.057] }
[15:33:03.063] assign_globals() ...
[15:33:03.064] List of 5
[15:33:03.064]  $ ...future.FUN            :function (x, y)  
[15:33:03.064]  $ MoreArgs                 : NULL
[15:33:03.064]  $ ...future.elements_ii    :List of 2
[15:33:03.064]   ..$ :List of 2
[15:33:03.064]   .. ..$ : int 1
[15:33:03.064]   .. ..$ : int 0
[15:33:03.064]   ..$ :List of 2
[15:33:03.064]   .. ..$ : int 0
[15:33:03.064]   .. ..$ : int 1
[15:33:03.064]  $ ...future.seeds_ii       : NULL
[15:33:03.064]  $ ...future.globals.maxSize: NULL
[15:33:03.064]  - attr(*, "where")=List of 5
[15:33:03.064]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:33:03.064]   ..$ MoreArgs                 :<environment: R_EmptyEnv> 
[15:33:03.064]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:33:03.064]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:33:03.064]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:33:03.064]  - attr(*, "resolved")= logi FALSE
[15:33:03.064]  - attr(*, "total_size")= num 6480
[15:33:03.064]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:33:03.064]  - attr(*, "already-done")= logi TRUE
[15:33:03.077] - reassign environment for '...future.FUN'
[15:33:03.077] - copied '...future.FUN' to environment
[15:33:03.078] - copied 'MoreArgs' to environment
[15:33:03.078] - copied '...future.elements_ii' to environment
[15:33:03.078] - copied '...future.seeds_ii' to environment
[15:33:03.079] - copied '...future.globals.maxSize' to environment
[15:33:03.082] assign_globals() ... done
[15:33:03.082] plan(): Setting new future strategy stack:
[15:33:03.083] List of future strategies:
[15:33:03.083] 1. sequential:
[15:33:03.083]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:33:03.083]    - tweaked: FALSE
[15:33:03.083]    - call: NULL
[15:33:03.084] plan(): nbrOfWorkers() = 1
[15:33:03.595] plan(): Setting new future strategy stack:
[15:33:03.595] List of future strategies:
[15:33:03.595] 1. multisession:
[15:33:03.595]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[15:33:03.595]    - tweaked: FALSE
[15:33:03.595]    - call: plan(strategy)
[15:33:03.600] plan(): nbrOfWorkers() = 1
[15:33:03.601] SequentialFuture started (and completed)
[15:33:03.601] - Launch lazy future ... done
[15:33:03.601] run() for 'SequentialFuture' ... done
[15:33:03.602] Created future:
[15:33:03.602] SequentialFuture:
[15:33:03.602] Label: 'future_mapply-1'
[15:33:03.602] Expression:
[15:33:03.602] {
[15:33:03.602]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:33:03.602]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:33:03.602]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:33:03.602]         on.exit(options(oopts), add = TRUE)
[15:33:03.602]     }
[15:33:03.602]     {
[15:33:03.602]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:33:03.602]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:33:03.602]         do.call(mapply, args = args)
[15:33:03.602]     }
[15:33:03.602] }
[15:33:03.602] Lazy evaluation: FALSE
[15:33:03.602] Asynchronous evaluation: FALSE
[15:33:03.602] Local evaluation: TRUE
[15:33:03.602] Environment: R_GlobalEnv
[15:33:03.602] Capture standard output: TRUE
[15:33:03.602] Capture condition classes: 'condition' (excluding 'nothing')
[15:33:03.602] Globals: 5 objects totaling 6.33 KiB (function '...future.FUN' of 6.11 KiB, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 224 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:33:03.602] Packages: <none>
[15:33:03.602] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:33:03.602] Resolved: TRUE
[15:33:03.602] Value: 224 bytes of class 'list'
[15:33:03.602] Early signaling: FALSE
[15:33:03.602] Owner process: bdd4bc13-919d-bf34-b2cf-84eb53f6e11f
[15:33:03.602] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:33:03.605] Chunk #1 of 1 ... DONE
[15:33:03.605] Launching 1 futures (chunks) ... DONE
[15:33:03.605] Resolving 1 futures (chunks) ...
[15:33:03.606] resolve() on list ...
[15:33:03.606]  recursive: 0
[15:33:03.606]  length: 1
[15:33:03.606] 
[15:33:03.607] resolved() for 'SequentialFuture' ...
[15:33:03.607] - state: 'finished'
[15:33:03.607] - run: TRUE
[15:33:03.608] - result: 'FutureResult'
[15:33:03.608] resolved() for 'SequentialFuture' ... done
[15:33:03.609] Future #1
[15:33:03.609] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:33:03.609] - nx: 1
[15:33:03.610] - relay: TRUE
[15:33:03.610] - stdout: TRUE
[15:33:03.610] - signal: TRUE
[15:33:03.610] - resignal: FALSE
[15:33:03.611] - force: TRUE
[15:33:03.611] - relayed: [n=1] FALSE
[15:33:03.611] - queued futures: [n=1] FALSE
[15:33:03.612]  - until=1
[15:33:03.612]  - relaying element #1
[15:33:03.612] - relayed: [n=1] TRUE
[15:33:03.613] - queued futures: [n=1] TRUE
[15:33:03.613] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:33:03.613]  length: 0 (resolved future 1)
[15:33:03.613] Relaying remaining futures
[15:33:03.614] signalConditionsASAP(NULL, pos=0) ...
[15:33:03.614] - nx: 1
[15:33:03.614] - relay: TRUE
[15:33:03.615] - stdout: TRUE
[15:33:03.615] - signal: TRUE
[15:33:03.615] - resignal: FALSE
[15:33:03.615] - force: TRUE
[15:33:03.616] - relayed: [n=1] TRUE
[15:33:03.616] - queued futures: [n=1] TRUE
 - flush all
[15:33:03.616] - relayed: [n=1] TRUE
[15:33:03.616] - queued futures: [n=1] TRUE
[15:33:03.617] signalConditionsASAP(NULL, pos=0) ... done
[15:33:03.617] resolve() on list ... DONE
[15:33:03.618]  - Number of value chunks collected: 1
[15:33:03.618] Resolving 1 futures (chunks) ... DONE
[15:33:03.618] Reducing values from 1 chunks ...
[15:33:03.618]  - Number of values collected after concatenation: 2
[15:33:03.619]  - Number of values expected: 2
[15:33:03.619] Reducing values from 1 chunks ... DONE
[15:33:03.620] future_mapply() ... DONE
* future_mapply(x, ..., future.stdout = TRUE) ... DONE
* future_mapply(x, ..., future.stdout = NA) ...
[15:33:03.621] future_mapply() ...
[15:33:03.629] Number of chunks: 1
[15:33:03.629] getGlobalsAndPackagesXApply() ...
[15:33:03.630]  - future.globals: TRUE
[15:33:03.630] getGlobalsAndPackages() ...
[15:33:03.631] Searching for globals...
[15:33:03.638] - globals found: [6] 'FUN', '{', 'Sys.sleep', '/', 'print', 'list'
[15:33:03.638] Searching for globals ... DONE
[15:33:03.639] Resolving globals: FALSE
[15:33:03.640] The total size of the 1 globals is 6.11 KiB (6256 bytes)
[15:33:03.641] The total size of the 1 globals exported for future expression ('FUN()') is 6.11 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (6.11 KiB of class 'function')
[15:33:03.641] - globals: [1] 'FUN'
[15:33:03.642] 
[15:33:03.642] getGlobalsAndPackages() ... DONE
[15:33:03.642]  - globals found/used: [n=1] 'FUN'
[15:33:03.643]  - needed namespaces: [n=0] 
[15:33:03.643] Finding globals ... DONE
[15:33:03.643] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[15:33:03.644] List of 2
[15:33:03.644]  $ ...future.FUN:function (x, y)  
[15:33:03.644]  $ MoreArgs     : NULL
[15:33:03.644]  - attr(*, "where")=List of 2
[15:33:03.644]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:33:03.644]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[15:33:03.644]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:33:03.644]  - attr(*, "resolved")= logi FALSE
[15:33:03.644]  - attr(*, "total_size")= num NA
[15:33:03.650] Packages to be attached in all futures: [n=0] 
[15:33:03.650] getGlobalsAndPackagesXApply() ... DONE
[15:33:03.651] Number of futures (= number of chunks): 1
[15:33:03.651] Launching 1 futures (chunks) ...
[15:33:03.652] Chunk #1 of 1 ...
[15:33:03.652]  - Finding globals in '...' for chunk #1 ...
[15:33:03.653] getGlobalsAndPackages() ...
[15:33:03.653] Searching for globals...
[15:33:03.654] 
[15:33:03.654] Searching for globals ... DONE
[15:33:03.654] - globals: [0] <none>
[15:33:03.655] getGlobalsAndPackages() ... DONE
[15:33:03.655]    + additional globals found: [n=0] 
[15:33:03.655]    + additional namespaces needed: [n=0] 
[15:33:03.655]  - Finding globals in '...' for chunk #1 ... DONE
[15:33:03.656]  - seeds: <none>
[15:33:03.656]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:33:03.658] getGlobalsAndPackages() ...
[15:33:03.659] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:33:03.659] Resolving globals: FALSE
[15:33:03.660] The total size of the 5 globals is 6.33 KiB (6480 bytes)
[15:33:03.661] The total size of the 5 globals exported for future expression ('{; ...future.globals.maxSize.org <- getOption("future.globals.maxSize"); if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {; oopts <- options(future.globals.maxSize = ...future.globals.maxSize); on.exit(options(oopts), add = TRUE); }; ...; do.call(mapply, args = args); }; }') is 6.33 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (6.11 KiB of class 'function'), '...future.elements_ii' (224 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[15:33:03.661] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:33:03.662] 
[15:33:03.662] getGlobalsAndPackages() ... DONE
[15:33:03.663] run() for 'Future' ...
[15:33:03.663] - state: 'created'
[15:33:03.663] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:33:03.667] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:33:03.667] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:33:03.668]   - Field: 'label'
[15:33:03.668]   - Field: 'local'
[15:33:03.668]   - Field: 'owner'
[15:33:03.668]   - Field: 'envir'
[15:33:03.669]   - Field: 'packages'
[15:33:03.669]   - Field: 'gc'
[15:33:03.669]   - Field: 'conditions'
[15:33:03.670]   - Field: 'expr'
[15:33:03.670]   - Field: 'uuid'
[15:33:03.670]   - Field: 'seed'
[15:33:03.670]   - Field: 'version'
[15:33:03.671]   - Field: 'result'
[15:33:03.671]   - Field: 'asynchronous'
[15:33:03.671]   - Field: 'calls'
[15:33:03.671]   - Field: 'globals'
[15:33:03.672]   - Field: 'stdout'
[15:33:03.672]   - Field: 'earlySignal'
[15:33:03.672]   - Field: 'lazy'
[15:33:03.673]   - Field: 'state'
[15:33:03.673] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:33:03.673] - Launch lazy future ...
[15:33:03.676] Packages needed by the future expression (n = 0): <none>
[15:33:03.676] Packages needed by future strategies (n = 0): <none>
[15:33:03.678] {
[15:33:03.678]     {
[15:33:03.678]         {
[15:33:03.678]             ...future.startTime <- base::Sys.time()
[15:33:03.678]             {
[15:33:03.678]                 {
[15:33:03.678]                   {
[15:33:03.678]                     base::local({
[15:33:03.678]                       has_future <- base::requireNamespace("future", 
[15:33:03.678]                         quietly = TRUE)
[15:33:03.678]                       if (has_future) {
[15:33:03.678]                         ns <- base::getNamespace("future")
[15:33:03.678]                         version <- ns[[".package"]][["version"]]
[15:33:03.678]                         if (is.null(version)) 
[15:33:03.678]                           version <- utils::packageVersion("future")
[15:33:03.678]                       }
[15:33:03.678]                       else {
[15:33:03.678]                         version <- NULL
[15:33:03.678]                       }
[15:33:03.678]                       if (!has_future || version < "1.8.0") {
[15:33:03.678]                         info <- base::c(r_version = base::gsub("R version ", 
[15:33:03.678]                           "", base::R.version$version.string), 
[15:33:03.678]                           platform = base::sprintf("%s (%s-bit)", 
[15:33:03.678]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:33:03.678]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:33:03.678]                             "release", "version")], collapse = " "), 
[15:33:03.678]                           hostname = base::Sys.info()[["nodename"]])
[15:33:03.678]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:33:03.678]                           info)
[15:33:03.678]                         info <- base::paste(info, collapse = "; ")
[15:33:03.678]                         if (!has_future) {
[15:33:03.678]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:33:03.678]                             info)
[15:33:03.678]                         }
[15:33:03.678]                         else {
[15:33:03.678]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:33:03.678]                             info, version)
[15:33:03.678]                         }
[15:33:03.678]                         base::stop(msg)
[15:33:03.678]                       }
[15:33:03.678]                     })
[15:33:03.678]                   }
[15:33:03.678]                   ...future.strategy.old <- future::plan("list")
[15:33:03.678]                   options(future.plan = NULL)
[15:33:03.678]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:33:03.678]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:33:03.678]                 }
[15:33:03.678]                 ...future.workdir <- getwd()
[15:33:03.678]             }
[15:33:03.678]             ...future.oldOptions <- base::as.list(base::.Options)
[15:33:03.678]             ...future.oldEnvVars <- base::Sys.getenv()
[15:33:03.678]         }
[15:33:03.678]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:33:03.678]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:33:03.678]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:33:03.678]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:33:03.678]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:33:03.678]             future.stdout.windows.reencode = NULL, width = 80L)
[15:33:03.678]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:33:03.678]             base::names(...future.oldOptions))
[15:33:03.678]     }
[15:33:03.678]     if (TRUE) {
[15:33:03.678]     }
[15:33:03.678]     else {
[15:33:03.678]         if (NA) {
[15:33:03.678]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:33:03.678]                 open = "w")
[15:33:03.678]         }
[15:33:03.678]         else {
[15:33:03.678]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:33:03.678]                 windows = "NUL", "/dev/null"), open = "w")
[15:33:03.678]         }
[15:33:03.678]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:33:03.678]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:33:03.678]             base::sink(type = "output", split = FALSE)
[15:33:03.678]             base::close(...future.stdout)
[15:33:03.678]         }, add = TRUE)
[15:33:03.678]     }
[15:33:03.678]     ...future.frame <- base::sys.nframe()
[15:33:03.678]     ...future.conditions <- base::list()
[15:33:03.678]     ...future.rng <- base::globalenv()$.Random.seed
[15:33:03.678]     if (FALSE) {
[15:33:03.678]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:33:03.678]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:33:03.678]     }
[15:33:03.678]     ...future.result <- base::tryCatch({
[15:33:03.678]         base::withCallingHandlers({
[15:33:03.678]             ...future.value <- base::withVisible(base::local({
[15:33:03.678]                 ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:33:03.678]                 if (!identical(...future.globals.maxSize.org, 
[15:33:03.678]                   ...future.globals.maxSize)) {
[15:33:03.678]                   oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:33:03.678]                   on.exit(options(oopts), add = TRUE)
[15:33:03.678]                 }
[15:33:03.678]                 {
[15:33:03.678]                   args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:33:03.678]                     MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:33:03.678]                     USE.NAMES = FALSE)
[15:33:03.678]                   do.call(mapply, args = args)
[15:33:03.678]                 }
[15:33:03.678]             }))
[15:33:03.678]             future::FutureResult(value = ...future.value$value, 
[15:33:03.678]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:33:03.678]                   ...future.rng), globalenv = if (FALSE) 
[15:33:03.678]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:33:03.678]                     ...future.globalenv.names))
[15:33:03.678]                 else NULL, started = ...future.startTime, version = "1.8")
[15:33:03.678]         }, condition = base::local({
[15:33:03.678]             c <- base::c
[15:33:03.678]             inherits <- base::inherits
[15:33:03.678]             invokeRestart <- base::invokeRestart
[15:33:03.678]             length <- base::length
[15:33:03.678]             list <- base::list
[15:33:03.678]             seq.int <- base::seq.int
[15:33:03.678]             signalCondition <- base::signalCondition
[15:33:03.678]             sys.calls <- base::sys.calls
[15:33:03.678]             `[[` <- base::`[[`
[15:33:03.678]             `+` <- base::`+`
[15:33:03.678]             `<<-` <- base::`<<-`
[15:33:03.678]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:33:03.678]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:33:03.678]                   3L)]
[15:33:03.678]             }
[15:33:03.678]             function(cond) {
[15:33:03.678]                 is_error <- inherits(cond, "error")
[15:33:03.678]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:33:03.678]                   NULL)
[15:33:03.678]                 if (is_error) {
[15:33:03.678]                   sessionInformation <- function() {
[15:33:03.678]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:33:03.678]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:33:03.678]                       search = base::search(), system = base::Sys.info())
[15:33:03.678]                   }
[15:33:03.678]                   ...future.conditions[[length(...future.conditions) + 
[15:33:03.678]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:33:03.678]                     cond$call), session = sessionInformation(), 
[15:33:03.678]                     timestamp = base::Sys.time(), signaled = 0L)
[15:33:03.678]                   signalCondition(cond)
[15:33:03.678]                 }
[15:33:03.678]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:33:03.678]                 "immediateCondition"))) {
[15:33:03.678]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:33:03.678]                   ...future.conditions[[length(...future.conditions) + 
[15:33:03.678]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:33:03.678]                   if (TRUE && !signal) {
[15:33:03.678]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:33:03.678]                     {
[15:33:03.678]                       inherits <- base::inherits
[15:33:03.678]                       invokeRestart <- base::invokeRestart
[15:33:03.678]                       is.null <- base::is.null
[15:33:03.678]                       muffled <- FALSE
[15:33:03.678]                       if (inherits(cond, "message")) {
[15:33:03.678]                         muffled <- grepl(pattern, "muffleMessage")
[15:33:03.678]                         if (muffled) 
[15:33:03.678]                           invokeRestart("muffleMessage")
[15:33:03.678]                       }
[15:33:03.678]                       else if (inherits(cond, "warning")) {
[15:33:03.678]                         muffled <- grepl(pattern, "muffleWarning")
[15:33:03.678]                         if (muffled) 
[15:33:03.678]                           invokeRestart("muffleWarning")
[15:33:03.678]                       }
[15:33:03.678]                       else if (inherits(cond, "condition")) {
[15:33:03.678]                         if (!is.null(pattern)) {
[15:33:03.678]                           computeRestarts <- base::computeRestarts
[15:33:03.678]                           grepl <- base::grepl
[15:33:03.678]                           restarts <- computeRestarts(cond)
[15:33:03.678]                           for (restart in restarts) {
[15:33:03.678]                             name <- restart$name
[15:33:03.678]                             if (is.null(name)) 
[15:33:03.678]                               next
[15:33:03.678]                             if (!grepl(pattern, name)) 
[15:33:03.678]                               next
[15:33:03.678]                             invokeRestart(restart)
[15:33:03.678]                             muffled <- TRUE
[15:33:03.678]                             break
[15:33:03.678]                           }
[15:33:03.678]                         }
[15:33:03.678]                       }
[15:33:03.678]                       invisible(muffled)
[15:33:03.678]                     }
[15:33:03.678]                     muffleCondition(cond, pattern = "^muffle")
[15:33:03.678]                   }
[15:33:03.678]                 }
[15:33:03.678]                 else {
[15:33:03.678]                   if (TRUE) {
[15:33:03.678]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:33:03.678]                     {
[15:33:03.678]                       inherits <- base::inherits
[15:33:03.678]                       invokeRestart <- base::invokeRestart
[15:33:03.678]                       is.null <- base::is.null
[15:33:03.678]                       muffled <- FALSE
[15:33:03.678]                       if (inherits(cond, "message")) {
[15:33:03.678]                         muffled <- grepl(pattern, "muffleMessage")
[15:33:03.678]                         if (muffled) 
[15:33:03.678]                           invokeRestart("muffleMessage")
[15:33:03.678]                       }
[15:33:03.678]                       else if (inherits(cond, "warning")) {
[15:33:03.678]                         muffled <- grepl(pattern, "muffleWarning")
[15:33:03.678]                         if (muffled) 
[15:33:03.678]                           invokeRestart("muffleWarning")
[15:33:03.678]                       }
[15:33:03.678]                       else if (inherits(cond, "condition")) {
[15:33:03.678]                         if (!is.null(pattern)) {
[15:33:03.678]                           computeRestarts <- base::computeRestarts
[15:33:03.678]                           grepl <- base::grepl
[15:33:03.678]                           restarts <- computeRestarts(cond)
[15:33:03.678]                           for (restart in restarts) {
[15:33:03.678]                             name <- restart$name
[15:33:03.678]                             if (is.null(name)) 
[15:33:03.678]                               next
[15:33:03.678]                             if (!grepl(pattern, name)) 
[15:33:03.678]                               next
[15:33:03.678]                             invokeRestart(restart)
[15:33:03.678]                             muffled <- TRUE
[15:33:03.678]                             break
[15:33:03.678]                           }
[15:33:03.678]                         }
[15:33:03.678]                       }
[15:33:03.678]                       invisible(muffled)
[15:33:03.678]                     }
[15:33:03.678]                     muffleCondition(cond, pattern = "^muffle")
[15:33:03.678]                   }
[15:33:03.678]                 }
[15:33:03.678]             }
[15:33:03.678]         }))
[15:33:03.678]     }, error = function(ex) {
[15:33:03.678]         base::structure(base::list(value = NULL, visible = NULL, 
[15:33:03.678]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:33:03.678]                 ...future.rng), started = ...future.startTime, 
[15:33:03.678]             finished = Sys.time(), session_uuid = NA_character_, 
[15:33:03.678]             version = "1.8"), class = "FutureResult")
[15:33:03.678]     }, finally = {
[15:33:03.678]         if (!identical(...future.workdir, getwd())) 
[15:33:03.678]             setwd(...future.workdir)
[15:33:03.678]         {
[15:33:03.678]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:33:03.678]                 ...future.oldOptions$nwarnings <- NULL
[15:33:03.678]             }
[15:33:03.678]             base::options(...future.oldOptions)
[15:33:03.678]             if (.Platform$OS.type == "windows") {
[15:33:03.678]                 old_names <- names(...future.oldEnvVars)
[15:33:03.678]                 envs <- base::Sys.getenv()
[15:33:03.678]                 names <- names(envs)
[15:33:03.678]                 common <- intersect(names, old_names)
[15:33:03.678]                 added <- setdiff(names, old_names)
[15:33:03.678]                 removed <- setdiff(old_names, names)
[15:33:03.678]                 changed <- common[...future.oldEnvVars[common] != 
[15:33:03.678]                   envs[common]]
[15:33:03.678]                 NAMES <- toupper(changed)
[15:33:03.678]                 args <- list()
[15:33:03.678]                 for (kk in seq_along(NAMES)) {
[15:33:03.678]                   name <- changed[[kk]]
[15:33:03.678]                   NAME <- NAMES[[kk]]
[15:33:03.678]                   if (name != NAME && is.element(NAME, old_names)) 
[15:33:03.678]                     next
[15:33:03.678]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:33:03.678]                 }
[15:33:03.678]                 NAMES <- toupper(added)
[15:33:03.678]                 for (kk in seq_along(NAMES)) {
[15:33:03.678]                   name <- added[[kk]]
[15:33:03.678]                   NAME <- NAMES[[kk]]
[15:33:03.678]                   if (name != NAME && is.element(NAME, old_names)) 
[15:33:03.678]                     next
[15:33:03.678]                   args[[name]] <- ""
[15:33:03.678]                 }
[15:33:03.678]                 NAMES <- toupper(removed)
[15:33:03.678]                 for (kk in seq_along(NAMES)) {
[15:33:03.678]                   name <- removed[[kk]]
[15:33:03.678]                   NAME <- NAMES[[kk]]
[15:33:03.678]                   if (name != NAME && is.element(NAME, old_names)) 
[15:33:03.678]                     next
[15:33:03.678]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:33:03.678]                 }
[15:33:03.678]                 if (length(args) > 0) 
[15:33:03.678]                   base::do.call(base::Sys.setenv, args = args)
[15:33:03.678]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:33:03.678]             }
[15:33:03.678]             else {
[15:33:03.678]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:33:03.678]             }
[15:33:03.678]             {
[15:33:03.678]                 if (base::length(...future.futureOptionsAdded) > 
[15:33:03.678]                   0L) {
[15:33:03.678]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:33:03.678]                   base::names(opts) <- ...future.futureOptionsAdded
[15:33:03.678]                   base::options(opts)
[15:33:03.678]                 }
[15:33:03.678]                 {
[15:33:03.678]                   {
[15:33:03.678]                     NULL
[15:33:03.678]                     RNGkind("Mersenne-Twister")
[15:33:03.678]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:33:03.678]                       inherits = FALSE)
[15:33:03.678]                   }
[15:33:03.678]                   options(future.plan = NULL)
[15:33:03.678]                   if (is.na(NA_character_)) 
[15:33:03.678]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:33:03.678]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:33:03.678]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:33:03.678]                     .init = FALSE)
[15:33:03.678]                 }
[15:33:03.678]             }
[15:33:03.678]         }
[15:33:03.678]     })
[15:33:03.678]     if (FALSE) {
[15:33:03.678]         base::sink(type = "output", split = FALSE)
[15:33:03.678]         if (NA) {
[15:33:03.678]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:33:03.678]         }
[15:33:03.678]         else {
[15:33:03.678]             ...future.result["stdout"] <- base::list(NULL)
[15:33:03.678]         }
[15:33:03.678]         base::close(...future.stdout)
[15:33:03.678]         ...future.stdout <- NULL
[15:33:03.678]     }
[15:33:03.678]     ...future.result$conditions <- ...future.conditions
[15:33:03.678]     ...future.result$finished <- base::Sys.time()
[15:33:03.678]     ...future.result
[15:33:03.678] }
[15:33:03.685] assign_globals() ...
[15:33:03.686] List of 5
[15:33:03.686]  $ ...future.FUN            :function (x, y)  
[15:33:03.686]  $ MoreArgs                 : NULL
[15:33:03.686]  $ ...future.elements_ii    :List of 2
[15:33:03.686]   ..$ :List of 2
[15:33:03.686]   .. ..$ : int 1
[15:33:03.686]   .. ..$ : int 0
[15:33:03.686]   ..$ :List of 2
[15:33:03.686]   .. ..$ : int 0
[15:33:03.686]   .. ..$ : int 1
[15:33:03.686]  $ ...future.seeds_ii       : NULL
[15:33:03.686]  $ ...future.globals.maxSize: NULL
[15:33:03.686]  - attr(*, "where")=List of 5
[15:33:03.686]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:33:03.686]   ..$ MoreArgs                 :<environment: R_EmptyEnv> 
[15:33:03.686]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:33:03.686]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:33:03.686]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:33:03.686]  - attr(*, "resolved")= logi FALSE
[15:33:03.686]  - attr(*, "total_size")= num 6480
[15:33:03.686]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:33:03.686]  - attr(*, "already-done")= logi TRUE
[15:33:03.699] - reassign environment for '...future.FUN'
[15:33:03.699] - copied '...future.FUN' to environment
[15:33:03.699] - copied 'MoreArgs' to environment
[15:33:03.699] - copied '...future.elements_ii' to environment
[15:33:03.700] - copied '...future.seeds_ii' to environment
[15:33:03.700] - copied '...future.globals.maxSize' to environment
[15:33:03.700] assign_globals() ... done
[15:33:03.701] plan(): Setting new future strategy stack:
[15:33:03.701] List of future strategies:
[15:33:03.701] 1. sequential:
[15:33:03.701]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:33:03.701]    - tweaked: FALSE
[15:33:03.701]    - call: NULL
[15:33:03.702] plan(): nbrOfWorkers() = 1
[15:33:04.205] plan(): Setting new future strategy stack:
[15:33:04.205] List of future strategies:
[15:33:04.205] 1. multisession:
[15:33:04.205]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[15:33:04.205]    - tweaked: FALSE
[15:33:04.205]    - call: plan(strategy)
[15:33:04.210] plan(): nbrOfWorkers() = 1
[15:33:04.211] SequentialFuture started (and completed)
[15:33:04.211] - Launch lazy future ... done
[15:33:04.212] run() for 'SequentialFuture' ... done
[15:33:04.212] Created future:
[15:33:04.212] SequentialFuture:
[15:33:04.212] Label: 'future_mapply-1'
[15:33:04.212] Expression:
[15:33:04.212] {
[15:33:04.212]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:33:04.212]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:33:04.212]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:33:04.212]         on.exit(options(oopts), add = TRUE)
[15:33:04.212]     }
[15:33:04.212]     {
[15:33:04.212]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:33:04.212]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:33:04.212]         do.call(mapply, args = args)
[15:33:04.212]     }
[15:33:04.212] }
[15:33:04.212] Lazy evaluation: FALSE
[15:33:04.212] Asynchronous evaluation: FALSE
[15:33:04.212] Local evaluation: TRUE
[15:33:04.212] Environment: R_GlobalEnv
[15:33:04.212] Capture standard output: NA
[15:33:04.212] Capture condition classes: 'condition' (excluding 'nothing')
[15:33:04.212] Globals: 5 objects totaling 6.33 KiB (function '...future.FUN' of 6.11 KiB, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 224 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:33:04.212] Packages: <none>
[15:33:04.212] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:33:04.212] Resolved: TRUE
[15:33:04.212] Value: 224 bytes of class 'list'
[15:33:04.212] Early signaling: FALSE
[15:33:04.212] Owner process: bdd4bc13-919d-bf34-b2cf-84eb53f6e11f
[15:33:04.212] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:33:04.215] Chunk #1 of 1 ... DONE
[15:33:04.215] Launching 1 futures (chunks) ... DONE
[15:33:04.215] Resolving 1 futures (chunks) ...
[15:33:04.216] resolve() on list ...
[15:33:04.216]  recursive: 0
[15:33:04.216]  length: 1
[15:33:04.217] 
[15:33:04.217] resolved() for 'SequentialFuture' ...
[15:33:04.217] - state: 'finished'
[15:33:04.218] - run: TRUE
[15:33:04.218] - result: 'FutureResult'
[15:33:04.218] resolved() for 'SequentialFuture' ... done
[15:33:04.219] Future #1
[15:33:04.219] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:33:04.220] - nx: 1
[15:33:04.220] - relay: TRUE
[15:33:04.220] - stdout: TRUE
[15:33:04.221] - signal: TRUE
[15:33:04.225] - resignal: FALSE
[15:33:04.225] - force: TRUE
[15:33:04.225] - relayed: [n=1] FALSE
[15:33:04.226] - queued futures: [n=1] FALSE
[15:33:04.226]  - until=1
[15:33:04.226]  - relaying element #1
[15:33:04.227] - relayed: [n=1] TRUE
[15:33:04.227] - queued futures: [n=1] TRUE
[15:33:04.228] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:33:04.228]  length: 0 (resolved future 1)
[15:33:04.229] Relaying remaining futures
[15:33:04.229] signalConditionsASAP(NULL, pos=0) ...
[15:33:04.229] - nx: 1
[15:33:04.230] - relay: TRUE
[15:33:04.230] - stdout: TRUE
[15:33:04.230] - signal: TRUE
[15:33:04.230] - resignal: FALSE
[15:33:04.231] - force: TRUE
[15:33:04.231] - relayed: [n=1] TRUE
[15:33:04.231] - queued futures: [n=1] TRUE
 - flush all
[15:33:04.232] - relayed: [n=1] TRUE
[15:33:04.232] - queued futures: [n=1] TRUE
[15:33:04.232] signalConditionsASAP(NULL, pos=0) ... done
[15:33:04.233] resolve() on list ... DONE
[15:33:04.233]  - Number of value chunks collected: 1
[15:33:04.234] Resolving 1 futures (chunks) ... DONE
[15:33:04.234] Reducing values from 1 chunks ...
[15:33:04.234]  - Number of values collected after concatenation: 2
[15:33:04.235]  - Number of values expected: 2
[15:33:04.235] Reducing values from 1 chunks ... DONE
[15:33:04.235] future_mapply() ... DONE
* future_mapply(x, ..., future.stdout = NA) ... DONE
* plan('multisession') ... DONE
  - Testing with 1 cores ... DONE
  - Testing with 2 cores ...
* plan('multisession') ...
[15:33:04.244] plan(): Setting new future strategy stack:
[15:33:04.245] List of future strategies:
[15:33:04.245] 1. multisession:
[15:33:04.245]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[15:33:04.245]    - tweaked: FALSE
[15:33:04.245]    - call: plan(strategy)
[15:33:04.246] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
[15:33:04.246] multisession:
[15:33:04.246] - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[15:33:04.246] - tweaked: FALSE
[15:33:04.246] - call: plan(strategy)
[15:33:04.254] getGlobalsAndPackages() ...
[15:33:04.255] Not searching for globals
[15:33:04.255] - globals: [0] <none>
[15:33:04.255] getGlobalsAndPackages() ... DONE
[15:33:04.256] [local output] makeClusterPSOCK() ...
[15:33:04.319] [local output] Workers: [n = 2] 'localhost', 'localhost'
[15:33:04.326] [local output] Base port: 23413
[15:33:04.327] [local output] Getting setup options for 2 cluster nodes ...
[15:33:04.327] [local output]  - Node 1 of 2 ...
[15:33:04.328] [local output] localMachine=TRUE => revtunnel=FALSE

[15:33:04.330] Testing if worker's PID can be inferred: '"D:/RCompile/recent/R/bin/x64/Rscript" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpIrSVxe/worker.rank=1.parallelly.parent=67624.1082865833030.pid\")), silent = TRUE)" -e "file.exists(\"D:/temp/RtmpIrSVxe/worker.rank=1.parallelly.parent=67624.1082865833030.pid\")"'
[15:33:04.656] - Possible to infer worker's PID: TRUE
[15:33:04.657] [local output] Rscript port: 23413

[15:33:04.658] [local output]  - Node 2 of 2 ...
[15:33:04.659] [local output] localMachine=TRUE => revtunnel=FALSE

[15:33:04.661] [local output] Rscript port: 23413

[15:33:04.661] [local output] Getting setup options for 2 cluster nodes ... done
[15:33:04.662] [local output]  - Parallel setup requested for some PSOCK nodes
[15:33:04.663] [local output] Setting up PSOCK nodes in parallel
[15:33:04.663] List of 36
[15:33:04.663]  $ worker          : chr "localhost"
[15:33:04.663]   ..- attr(*, "localhost")= logi TRUE
[15:33:04.663]  $ master          : chr "localhost"
[15:33:04.663]  $ port            : int 23413
[15:33:04.663]  $ connectTimeout  : num 120
[15:33:04.663]  $ timeout         : num 120
[15:33:04.663]  $ rscript         : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\""
[15:33:04.663]  $ homogeneous     : logi TRUE
[15:33:04.663]  $ rscript_args    : chr "--default-packages=datasets,utils,grDevices,graphics,stats,methods -e \"#label=stdout.R:67624:CRANWIN3:CRAN\" -"| __truncated__
[15:33:04.663]  $ rscript_envs    : NULL
[15:33:04.663]  $ rscript_libs    : chr [1:2] "D:/temp/RtmpIhDozX/RLIBS_2bbc83f2b47c7" "D:/RCompile/recent/R/library"
[15:33:04.663]  $ rscript_startup : NULL
[15:33:04.663]  $ rscript_sh      : chr "cmd"
[15:33:04.663]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[15:33:04.663]  $ methods         : logi TRUE
[15:33:04.663]  $ socketOptions   : chr "no-delay"
[15:33:04.663]  $ useXDR          : logi FALSE
[15:33:04.663]  $ outfile         : chr "/dev/null"
[15:33:04.663]  $ renice          : int NA
[15:33:04.663]  $ rshcmd          : NULL
[15:33:04.663]  $ user            : chr(0) 
[15:33:04.663]  $ revtunnel       : logi FALSE
[15:33:04.663]  $ rshlogfile      : NULL
[15:33:04.663]  $ rshopts         : chr(0) 
[15:33:04.663]  $ rank            : int 1
[15:33:04.663]  $ manual          : logi FALSE
[15:33:04.663]  $ dryrun          : logi FALSE
[15:33:04.663]  $ quiet           : logi FALSE
[15:33:04.663]  $ setup_strategy  : chr "parallel"
[15:33:04.663]  $ local_cmd       : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[15:33:04.663]  $ pidfile         : chr "D:/temp/RtmpIrSVxe/worker.rank=1.parallelly.parent=67624.1082865833030.pid"
[15:33:04.663]  $ rshcmd_label    : NULL
[15:33:04.663]  $ rsh_call        : NULL
[15:33:04.663]  $ cmd             : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[15:33:04.663]  $ localMachine    : logi TRUE
[15:33:04.663]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[15:33:04.663]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[15:33:04.663]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[15:33:04.663]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[15:33:04.663]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[15:33:04.663]         "cmd", "sh"), default_packages = c("datasets", "utils", "grDevices", 
[15:33:04.663]         "graphics", "stats", if (methods) "methods"), methods = TRUE, socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[15:33:04.663]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[15:33:04.663]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[15:33:04.663]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[15:33:04.663]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[15:33:04.663]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[15:33:04.663]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[15:33:04.663]  $ arguments       :List of 28
[15:33:04.663]   ..$ worker          : chr "localhost"
[15:33:04.663]   ..$ master          : NULL
[15:33:04.663]   ..$ port            : int 23413
[15:33:04.663]   ..$ connectTimeout  : num 120
[15:33:04.663]   ..$ timeout         : num 120
[15:33:04.663]   ..$ rscript         : NULL
[15:33:04.663]   ..$ homogeneous     : NULL
[15:33:04.663]   ..$ rscript_args    : NULL
[15:33:04.663]   ..$ rscript_envs    : NULL
[15:33:04.663]   ..$ rscript_libs    : chr [1:2] "D:/temp/RtmpIhDozX/RLIBS_2bbc83f2b47c7" "D:/RCompile/recent/R/library"
[15:33:04.663]   ..$ rscript_startup : NULL
[15:33:04.663]   ..$ rscript_sh      : chr [1:3] "auto" "cmd" "sh"
[15:33:04.663]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[15:33:04.663]   ..$ methods         : logi TRUE
[15:33:04.663]   ..$ socketOptions   : chr "no-delay"
[15:33:04.663]   ..$ useXDR          : logi FALSE
[15:33:04.663]   ..$ outfile         : chr "/dev/null"
[15:33:04.663]   ..$ renice          : int NA
[15:33:04.663]   ..$ rshcmd          : NULL
[15:33:04.663]   ..$ user            : NULL
[15:33:04.663]   ..$ revtunnel       : logi NA
[15:33:04.663]   ..$ rshlogfile      : NULL
[15:33:04.663]   ..$ rshopts         : NULL
[15:33:04.663]   ..$ rank            : int 1
[15:33:04.663]   ..$ manual          : logi FALSE
[15:33:04.663]   ..$ dryrun          : logi FALSE
[15:33:04.663]   ..$ quiet           : logi FALSE
[15:33:04.663]   ..$ setup_strategy  : chr "parallel"
[15:33:04.663]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[15:33:04.695] [local output] System call to launch all workers:
[15:33:04.695] [local output] "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=stdout.R:67624:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpIrSVxe/worker.rank=1.parallelly.parent=67624.1082865833030.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=23413 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[15:33:04.696] [local output] Starting PSOCK main server
[15:33:04.705] [local output] Workers launched
[15:33:04.706] [local output] Waiting for workers to connect back
[15:33:04.706]  - [local output] 0 workers out of 2 ready
[15:33:04.950]  - [local output] 0 workers out of 2 ready
[15:33:04.950]  - [local output] 1 workers out of 2 ready
[15:33:04.961]  - [local output] 1 workers out of 2 ready
[15:33:04.962]  - [local output] 2 workers out of 2 ready
[15:33:04.962] [local output] Launching of workers completed
[15:33:04.962] [local output] Collecting session information from workers
[15:33:04.964] [local output]  - Worker #1 of 2
[15:33:04.965] [local output]  - Worker #2 of 2
[15:33:04.965] [local output] makeClusterPSOCK() ... done
[15:33:04.979] Packages needed by the future expression (n = 0): <none>
[15:33:04.979] Packages needed by future strategies (n = 0): <none>
[15:33:04.980] {
[15:33:04.980]     {
[15:33:04.980]         {
[15:33:04.980]             ...future.startTime <- base::Sys.time()
[15:33:04.980]             {
[15:33:04.980]                 {
[15:33:04.980]                   {
[15:33:04.980]                     {
[15:33:04.980]                       base::local({
[15:33:04.980]                         has_future <- base::requireNamespace("future", 
[15:33:04.980]                           quietly = TRUE)
[15:33:04.980]                         if (has_future) {
[15:33:04.980]                           ns <- base::getNamespace("future")
[15:33:04.980]                           version <- ns[[".package"]][["version"]]
[15:33:04.980]                           if (is.null(version)) 
[15:33:04.980]                             version <- utils::packageVersion("future")
[15:33:04.980]                         }
[15:33:04.980]                         else {
[15:33:04.980]                           version <- NULL
[15:33:04.980]                         }
[15:33:04.980]                         if (!has_future || version < "1.8.0") {
[15:33:04.980]                           info <- base::c(r_version = base::gsub("R version ", 
[15:33:04.980]                             "", base::R.version$version.string), 
[15:33:04.980]                             platform = base::sprintf("%s (%s-bit)", 
[15:33:04.980]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:33:04.980]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:33:04.980]                               "release", "version")], collapse = " "), 
[15:33:04.980]                             hostname = base::Sys.info()[["nodename"]])
[15:33:04.980]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:33:04.980]                             info)
[15:33:04.980]                           info <- base::paste(info, collapse = "; ")
[15:33:04.980]                           if (!has_future) {
[15:33:04.980]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:33:04.980]                               info)
[15:33:04.980]                           }
[15:33:04.980]                           else {
[15:33:04.980]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:33:04.980]                               info, version)
[15:33:04.980]                           }
[15:33:04.980]                           base::stop(msg)
[15:33:04.980]                         }
[15:33:04.980]                       })
[15:33:04.980]                     }
[15:33:04.980]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:33:04.980]                     base::options(mc.cores = 1L)
[15:33:04.980]                   }
[15:33:04.980]                   ...future.strategy.old <- future::plan("list")
[15:33:04.980]                   options(future.plan = NULL)
[15:33:04.980]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:33:04.980]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:33:04.980]                 }
[15:33:04.980]                 ...future.workdir <- getwd()
[15:33:04.980]             }
[15:33:04.980]             ...future.oldOptions <- base::as.list(base::.Options)
[15:33:04.980]             ...future.oldEnvVars <- base::Sys.getenv()
[15:33:04.980]         }
[15:33:04.980]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:33:04.980]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:33:04.980]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:33:04.980]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:33:04.980]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:33:04.980]             future.stdout.windows.reencode = NULL, width = 80L)
[15:33:04.980]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:33:04.980]             base::names(...future.oldOptions))
[15:33:04.980]     }
[15:33:04.980]     if (FALSE) {
[15:33:04.980]     }
[15:33:04.980]     else {
[15:33:04.980]         if (TRUE) {
[15:33:04.980]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:33:04.980]                 open = "w")
[15:33:04.980]         }
[15:33:04.980]         else {
[15:33:04.980]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:33:04.980]                 windows = "NUL", "/dev/null"), open = "w")
[15:33:04.980]         }
[15:33:04.980]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:33:04.980]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:33:04.980]             base::sink(type = "output", split = FALSE)
[15:33:04.980]             base::close(...future.stdout)
[15:33:04.980]         }, add = TRUE)
[15:33:04.980]     }
[15:33:04.980]     ...future.frame <- base::sys.nframe()
[15:33:04.980]     ...future.conditions <- base::list()
[15:33:04.980]     ...future.rng <- base::globalenv()$.Random.seed
[15:33:04.980]     if (FALSE) {
[15:33:04.980]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:33:04.980]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:33:04.980]     }
[15:33:04.980]     ...future.result <- base::tryCatch({
[15:33:04.980]         base::withCallingHandlers({
[15:33:04.980]             ...future.value <- base::withVisible(base::local({
[15:33:04.980]                 ...future.makeSendCondition <- base::local({
[15:33:04.980]                   sendCondition <- NULL
[15:33:04.980]                   function(frame = 1L) {
[15:33:04.980]                     if (is.function(sendCondition)) 
[15:33:04.980]                       return(sendCondition)
[15:33:04.980]                     ns <- getNamespace("parallel")
[15:33:04.980]                     if (exists("sendData", mode = "function", 
[15:33:04.980]                       envir = ns)) {
[15:33:04.980]                       parallel_sendData <- get("sendData", mode = "function", 
[15:33:04.980]                         envir = ns)
[15:33:04.980]                       envir <- sys.frame(frame)
[15:33:04.980]                       master <- NULL
[15:33:04.980]                       while (!identical(envir, .GlobalEnv) && 
[15:33:04.980]                         !identical(envir, emptyenv())) {
[15:33:04.980]                         if (exists("master", mode = "list", envir = envir, 
[15:33:04.980]                           inherits = FALSE)) {
[15:33:04.980]                           master <- get("master", mode = "list", 
[15:33:04.980]                             envir = envir, inherits = FALSE)
[15:33:04.980]                           if (inherits(master, c("SOCKnode", 
[15:33:04.980]                             "SOCK0node"))) {
[15:33:04.980]                             sendCondition <<- function(cond) {
[15:33:04.980]                               data <- list(type = "VALUE", value = cond, 
[15:33:04.980]                                 success = TRUE)
[15:33:04.980]                               parallel_sendData(master, data)
[15:33:04.980]                             }
[15:33:04.980]                             return(sendCondition)
[15:33:04.980]                           }
[15:33:04.980]                         }
[15:33:04.980]                         frame <- frame + 1L
[15:33:04.980]                         envir <- sys.frame(frame)
[15:33:04.980]                       }
[15:33:04.980]                     }
[15:33:04.980]                     sendCondition <<- function(cond) NULL
[15:33:04.980]                   }
[15:33:04.980]                 })
[15:33:04.980]                 withCallingHandlers({
[15:33:04.980]                   NA
[15:33:04.980]                 }, immediateCondition = function(cond) {
[15:33:04.980]                   sendCondition <- ...future.makeSendCondition()
[15:33:04.980]                   sendCondition(cond)
[15:33:04.980]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:33:04.980]                   {
[15:33:04.980]                     inherits <- base::inherits
[15:33:04.980]                     invokeRestart <- base::invokeRestart
[15:33:04.980]                     is.null <- base::is.null
[15:33:04.980]                     muffled <- FALSE
[15:33:04.980]                     if (inherits(cond, "message")) {
[15:33:04.980]                       muffled <- grepl(pattern, "muffleMessage")
[15:33:04.980]                       if (muffled) 
[15:33:04.980]                         invokeRestart("muffleMessage")
[15:33:04.980]                     }
[15:33:04.980]                     else if (inherits(cond, "warning")) {
[15:33:04.980]                       muffled <- grepl(pattern, "muffleWarning")
[15:33:04.980]                       if (muffled) 
[15:33:04.980]                         invokeRestart("muffleWarning")
[15:33:04.980]                     }
[15:33:04.980]                     else if (inherits(cond, "condition")) {
[15:33:04.980]                       if (!is.null(pattern)) {
[15:33:04.980]                         computeRestarts <- base::computeRestarts
[15:33:04.980]                         grepl <- base::grepl
[15:33:04.980]                         restarts <- computeRestarts(cond)
[15:33:04.980]                         for (restart in restarts) {
[15:33:04.980]                           name <- restart$name
[15:33:04.980]                           if (is.null(name)) 
[15:33:04.980]                             next
[15:33:04.980]                           if (!grepl(pattern, name)) 
[15:33:04.980]                             next
[15:33:04.980]                           invokeRestart(restart)
[15:33:04.980]                           muffled <- TRUE
[15:33:04.980]                           break
[15:33:04.980]                         }
[15:33:04.980]                       }
[15:33:04.980]                     }
[15:33:04.980]                     invisible(muffled)
[15:33:04.980]                   }
[15:33:04.980]                   muffleCondition(cond)
[15:33:04.980]                 })
[15:33:04.980]             }))
[15:33:04.980]             future::FutureResult(value = ...future.value$value, 
[15:33:04.980]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:33:04.980]                   ...future.rng), globalenv = if (FALSE) 
[15:33:04.980]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:33:04.980]                     ...future.globalenv.names))
[15:33:04.980]                 else NULL, started = ...future.startTime, version = "1.8")
[15:33:04.980]         }, condition = base::local({
[15:33:04.980]             c <- base::c
[15:33:04.980]             inherits <- base::inherits
[15:33:04.980]             invokeRestart <- base::invokeRestart
[15:33:04.980]             length <- base::length
[15:33:04.980]             list <- base::list
[15:33:04.980]             seq.int <- base::seq.int
[15:33:04.980]             signalCondition <- base::signalCondition
[15:33:04.980]             sys.calls <- base::sys.calls
[15:33:04.980]             `[[` <- base::`[[`
[15:33:04.980]             `+` <- base::`+`
[15:33:04.980]             `<<-` <- base::`<<-`
[15:33:04.980]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:33:04.980]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:33:04.980]                   3L)]
[15:33:04.980]             }
[15:33:04.980]             function(cond) {
[15:33:04.980]                 is_error <- inherits(cond, "error")
[15:33:04.980]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:33:04.980]                   NULL)
[15:33:04.980]                 if (is_error) {
[15:33:04.980]                   sessionInformation <- function() {
[15:33:04.980]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:33:04.980]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:33:04.980]                       search = base::search(), system = base::Sys.info())
[15:33:04.980]                   }
[15:33:04.980]                   ...future.conditions[[length(...future.conditions) + 
[15:33:04.980]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:33:04.980]                     cond$call), session = sessionInformation(), 
[15:33:04.980]                     timestamp = base::Sys.time(), signaled = 0L)
[15:33:04.980]                   signalCondition(cond)
[15:33:04.980]                 }
[15:33:04.980]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:33:04.980]                 "immediateCondition"))) {
[15:33:04.980]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:33:04.980]                   ...future.conditions[[length(...future.conditions) + 
[15:33:04.980]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:33:04.980]                   if (TRUE && !signal) {
[15:33:04.980]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:33:04.980]                     {
[15:33:04.980]                       inherits <- base::inherits
[15:33:04.980]                       invokeRestart <- base::invokeRestart
[15:33:04.980]                       is.null <- base::is.null
[15:33:04.980]                       muffled <- FALSE
[15:33:04.980]                       if (inherits(cond, "message")) {
[15:33:04.980]                         muffled <- grepl(pattern, "muffleMessage")
[15:33:04.980]                         if (muffled) 
[15:33:04.980]                           invokeRestart("muffleMessage")
[15:33:04.980]                       }
[15:33:04.980]                       else if (inherits(cond, "warning")) {
[15:33:04.980]                         muffled <- grepl(pattern, "muffleWarning")
[15:33:04.980]                         if (muffled) 
[15:33:04.980]                           invokeRestart("muffleWarning")
[15:33:04.980]                       }
[15:33:04.980]                       else if (inherits(cond, "condition")) {
[15:33:04.980]                         if (!is.null(pattern)) {
[15:33:04.980]                           computeRestarts <- base::computeRestarts
[15:33:04.980]                           grepl <- base::grepl
[15:33:04.980]                           restarts <- computeRestarts(cond)
[15:33:04.980]                           for (restart in restarts) {
[15:33:04.980]                             name <- restart$name
[15:33:04.980]                             if (is.null(name)) 
[15:33:04.980]                               next
[15:33:04.980]                             if (!grepl(pattern, name)) 
[15:33:04.980]                               next
[15:33:04.980]                             invokeRestart(restart)
[15:33:04.980]                             muffled <- TRUE
[15:33:04.980]                             break
[15:33:04.980]                           }
[15:33:04.980]                         }
[15:33:04.980]                       }
[15:33:04.980]                       invisible(muffled)
[15:33:04.980]                     }
[15:33:04.980]                     muffleCondition(cond, pattern = "^muffle")
[15:33:04.980]                   }
[15:33:04.980]                 }
[15:33:04.980]                 else {
[15:33:04.980]                   if (TRUE) {
[15:33:04.980]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:33:04.980]                     {
[15:33:04.980]                       inherits <- base::inherits
[15:33:04.980]                       invokeRestart <- base::invokeRestart
[15:33:04.980]                       is.null <- base::is.null
[15:33:04.980]                       muffled <- FALSE
[15:33:04.980]                       if (inherits(cond, "message")) {
[15:33:04.980]                         muffled <- grepl(pattern, "muffleMessage")
[15:33:04.980]                         if (muffled) 
[15:33:04.980]                           invokeRestart("muffleMessage")
[15:33:04.980]                       }
[15:33:04.980]                       else if (inherits(cond, "warning")) {
[15:33:04.980]                         muffled <- grepl(pattern, "muffleWarning")
[15:33:04.980]                         if (muffled) 
[15:33:04.980]                           invokeRestart("muffleWarning")
[15:33:04.980]                       }
[15:33:04.980]                       else if (inherits(cond, "condition")) {
[15:33:04.980]                         if (!is.null(pattern)) {
[15:33:04.980]                           computeRestarts <- base::computeRestarts
[15:33:04.980]                           grepl <- base::grepl
[15:33:04.980]                           restarts <- computeRestarts(cond)
[15:33:04.980]                           for (restart in restarts) {
[15:33:04.980]                             name <- restart$name
[15:33:04.980]                             if (is.null(name)) 
[15:33:04.980]                               next
[15:33:04.980]                             if (!grepl(pattern, name)) 
[15:33:04.980]                               next
[15:33:04.980]                             invokeRestart(restart)
[15:33:04.980]                             muffled <- TRUE
[15:33:04.980]                             break
[15:33:04.980]                           }
[15:33:04.980]                         }
[15:33:04.980]                       }
[15:33:04.980]                       invisible(muffled)
[15:33:04.980]                     }
[15:33:04.980]                     muffleCondition(cond, pattern = "^muffle")
[15:33:04.980]                   }
[15:33:04.980]                 }
[15:33:04.980]             }
[15:33:04.980]         }))
[15:33:04.980]     }, error = function(ex) {
[15:33:04.980]         base::structure(base::list(value = NULL, visible = NULL, 
[15:33:04.980]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:33:04.980]                 ...future.rng), started = ...future.startTime, 
[15:33:04.980]             finished = Sys.time(), session_uuid = NA_character_, 
[15:33:04.980]             version = "1.8"), class = "FutureResult")
[15:33:04.980]     }, finally = {
[15:33:04.980]         if (!identical(...future.workdir, getwd())) 
[15:33:04.980]             setwd(...future.workdir)
[15:33:04.980]         {
[15:33:04.980]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:33:04.980]                 ...future.oldOptions$nwarnings <- NULL
[15:33:04.980]             }
[15:33:04.980]             base::options(...future.oldOptions)
[15:33:04.980]             if (.Platform$OS.type == "windows") {
[15:33:04.980]                 old_names <- names(...future.oldEnvVars)
[15:33:04.980]                 envs <- base::Sys.getenv()
[15:33:04.980]                 names <- names(envs)
[15:33:04.980]                 common <- intersect(names, old_names)
[15:33:04.980]                 added <- setdiff(names, old_names)
[15:33:04.980]                 removed <- setdiff(old_names, names)
[15:33:04.980]                 changed <- common[...future.oldEnvVars[common] != 
[15:33:04.980]                   envs[common]]
[15:33:04.980]                 NAMES <- toupper(changed)
[15:33:04.980]                 args <- list()
[15:33:04.980]                 for (kk in seq_along(NAMES)) {
[15:33:04.980]                   name <- changed[[kk]]
[15:33:04.980]                   NAME <- NAMES[[kk]]
[15:33:04.980]                   if (name != NAME && is.element(NAME, old_names)) 
[15:33:04.980]                     next
[15:33:04.980]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:33:04.980]                 }
[15:33:04.980]                 NAMES <- toupper(added)
[15:33:04.980]                 for (kk in seq_along(NAMES)) {
[15:33:04.980]                   name <- added[[kk]]
[15:33:04.980]                   NAME <- NAMES[[kk]]
[15:33:04.980]                   if (name != NAME && is.element(NAME, old_names)) 
[15:33:04.980]                     next
[15:33:04.980]                   args[[name]] <- ""
[15:33:04.980]                 }
[15:33:04.980]                 NAMES <- toupper(removed)
[15:33:04.980]                 for (kk in seq_along(NAMES)) {
[15:33:04.980]                   name <- removed[[kk]]
[15:33:04.980]                   NAME <- NAMES[[kk]]
[15:33:04.980]                   if (name != NAME && is.element(NAME, old_names)) 
[15:33:04.980]                     next
[15:33:04.980]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:33:04.980]                 }
[15:33:04.980]                 if (length(args) > 0) 
[15:33:04.980]                   base::do.call(base::Sys.setenv, args = args)
[15:33:04.980]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:33:04.980]             }
[15:33:04.980]             else {
[15:33:04.980]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:33:04.980]             }
[15:33:04.980]             {
[15:33:04.980]                 if (base::length(...future.futureOptionsAdded) > 
[15:33:04.980]                   0L) {
[15:33:04.980]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:33:04.980]                   base::names(opts) <- ...future.futureOptionsAdded
[15:33:04.980]                   base::options(opts)
[15:33:04.980]                 }
[15:33:04.980]                 {
[15:33:04.980]                   {
[15:33:04.980]                     base::options(mc.cores = ...future.mc.cores.old)
[15:33:04.980]                     NULL
[15:33:04.980]                   }
[15:33:04.980]                   options(future.plan = NULL)
[15:33:04.980]                   if (is.na(NA_character_)) 
[15:33:04.980]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:33:04.980]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:33:04.980]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:33:04.980]                     .init = FALSE)
[15:33:04.980]                 }
[15:33:04.980]             }
[15:33:04.980]         }
[15:33:04.980]     })
[15:33:04.980]     if (TRUE) {
[15:33:04.980]         base::sink(type = "output", split = FALSE)
[15:33:04.980]         if (TRUE) {
[15:33:04.980]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:33:04.980]         }
[15:33:04.980]         else {
[15:33:04.980]             ...future.result["stdout"] <- base::list(NULL)
[15:33:04.980]         }
[15:33:04.980]         base::close(...future.stdout)
[15:33:04.980]         ...future.stdout <- NULL
[15:33:04.980]     }
[15:33:04.980]     ...future.result$conditions <- ...future.conditions
[15:33:04.980]     ...future.result$finished <- base::Sys.time()
[15:33:04.980]     ...future.result
[15:33:04.980] }
[15:33:05.088] MultisessionFuture started
[15:33:05.089] result() for ClusterFuture ...
[15:33:05.090] receiveMessageFromWorker() for ClusterFuture ...
[15:33:05.090] - Validating connection of MultisessionFuture
[15:33:05.171] - received message: FutureResult
[15:33:05.171] - Received FutureResult
[15:33:05.177] - Erased future from FutureRegistry
[15:33:05.177] result() for ClusterFuture ...
[15:33:05.178] - result already collected: FutureResult
[15:33:05.178] result() for ClusterFuture ... done
[15:33:05.178] receiveMessageFromWorker() for ClusterFuture ... done
[15:33:05.178] result() for ClusterFuture ... done
[15:33:05.178] result() for ClusterFuture ...
[15:33:05.179] - result already collected: FutureResult
[15:33:05.179] result() for ClusterFuture ... done
[15:33:05.179] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
[15:33:05.182] plan(): nbrOfWorkers() = 2
* future_lapply(x, ..., future.stdout = FALSE) ...
[15:33:05.182] future_lapply() ...
[15:33:05.188] Number of chunks: 2
[15:33:05.188] getGlobalsAndPackagesXApply() ...
[15:33:05.188]  - future.globals: TRUE
[15:33:05.189] getGlobalsAndPackages() ...
[15:33:05.189] Searching for globals...
[15:33:05.193] - globals found: [5] 'FUN', '{', 'Sys.sleep', '/', 'print'
[15:33:05.193] Searching for globals ... DONE
[15:33:05.194] Resolving globals: FALSE
[15:33:05.195] The total size of the 1 globals is 4.61 KiB (4720 bytes)
[15:33:05.195] The total size of the 1 globals exported for future expression ('FUN()') is 4.61 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.61 KiB of class 'function')
[15:33:05.196] - globals: [1] 'FUN'
[15:33:05.196] 
[15:33:05.197] getGlobalsAndPackages() ... DONE
[15:33:05.197]  - globals found/used: [n=1] 'FUN'
[15:33:05.197]  - needed namespaces: [n=0] 
[15:33:05.198] Finding globals ... DONE
[15:33:05.198]  - use_args: TRUE
[15:33:05.198]  - Getting '...' globals ...
[15:33:05.199] resolve() on list ...
[15:33:05.199]  recursive: 0
[15:33:05.199]  length: 1
[15:33:05.199]  elements: '...'
[15:33:05.199]  length: 0 (resolved future 1)
[15:33:05.200] resolve() on list ... DONE
[15:33:05.200]    - '...' content: [n=0] 
[15:33:05.200] List of 1
[15:33:05.200]  $ ...: list()
[15:33:05.200]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:33:05.200]  - attr(*, "where")=List of 1
[15:33:05.200]   ..$ ...:<environment: 0x0000027fc28b7e28> 
[15:33:05.200]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:33:05.200]  - attr(*, "resolved")= logi TRUE
[15:33:05.200]  - attr(*, "total_size")= num NA
[15:33:05.205]  - Getting '...' globals ... DONE
[15:33:05.205] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:33:05.205] List of 2
[15:33:05.205]  $ ...future.FUN:function (x)  
[15:33:05.205]  $ ...          : list()
[15:33:05.205]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:33:05.205]  - attr(*, "where")=List of 2
[15:33:05.205]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:33:05.205]   ..$ ...          :<environment: 0x0000027fc28b7e28> 
[15:33:05.205]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:33:05.205]  - attr(*, "resolved")= logi FALSE
[15:33:05.205]  - attr(*, "total_size")= num 4720
[15:33:05.211] Packages to be attached in all futures: [n=0] 
[15:33:05.212] getGlobalsAndPackagesXApply() ... DONE
[15:33:05.212] Number of futures (= number of chunks): 2
[15:33:05.212] Launching 2 futures (chunks) ...
[15:33:05.213] Chunk #1 of 2 ...
[15:33:05.213]  - Finding globals in 'X' for chunk #1 ...
[15:33:05.213] getGlobalsAndPackages() ...
[15:33:05.214] Searching for globals...
[15:33:05.214] 
[15:33:05.214] Searching for globals ... DONE
[15:33:05.215] - globals: [0] <none>
[15:33:05.215] getGlobalsAndPackages() ... DONE
[15:33:05.215]    + additional globals found: [n=0] 
[15:33:05.216]    + additional namespaces needed: [n=0] 
[15:33:05.216]  - Finding globals in 'X' for chunk #1 ... DONE
[15:33:05.216]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:33:05.217]  - seeds: <none>
[15:33:05.217]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:33:05.217] getGlobalsAndPackages() ...
[15:33:05.217] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:33:05.218] Resolving globals: FALSE
[15:33:05.218] Tweak future expression to call with '...' arguments ...
[15:33:05.218] {
[15:33:05.218]     do.call(function(...) {
[15:33:05.218]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:33:05.218]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:33:05.218]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:33:05.218]             on.exit(options(oopts), add = TRUE)
[15:33:05.218]         }
[15:33:05.218]         {
[15:33:05.218]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:33:05.218]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:33:05.218]                 ...future.FUN(...future.X_jj, ...)
[15:33:05.218]             })
[15:33:05.218]         }
[15:33:05.218]     }, args = future.call.arguments)
[15:33:05.218] }
[15:33:05.219] Tweak future expression to call with '...' arguments ... DONE
[15:33:05.220] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:33:05.220] 
[15:33:05.221] getGlobalsAndPackages() ... DONE
[15:33:05.221] run() for 'Future' ...
[15:33:05.222] - state: 'created'
[15:33:05.222] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:33:05.240] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:33:05.241] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:33:05.241]   - Field: 'node'
[15:33:05.241]   - Field: 'label'
[15:33:05.242]   - Field: 'local'
[15:33:05.242]   - Field: 'owner'
[15:33:05.242]   - Field: 'envir'
[15:33:05.243]   - Field: 'workers'
[15:33:05.243]   - Field: 'packages'
[15:33:05.243]   - Field: 'gc'
[15:33:05.244]   - Field: 'conditions'
[15:33:05.244]   - Field: 'persistent'
[15:33:05.244]   - Field: 'expr'
[15:33:05.244]   - Field: 'uuid'
[15:33:05.245]   - Field: 'seed'
[15:33:05.245]   - Field: 'version'
[15:33:05.245]   - Field: 'result'
[15:33:05.246]   - Field: 'asynchronous'
[15:33:05.246]   - Field: 'calls'
[15:33:05.246]   - Field: 'globals'
[15:33:05.247]   - Field: 'stdout'
[15:33:05.247]   - Field: 'earlySignal'
[15:33:05.247]   - Field: 'lazy'
[15:33:05.247]   - Field: 'state'
[15:33:05.248] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:33:05.248] - Launch lazy future ...
[15:33:05.249] Packages needed by the future expression (n = 0): <none>
[15:33:05.249] Packages needed by future strategies (n = 0): <none>
[15:33:05.250] {
[15:33:05.250]     {
[15:33:05.250]         {
[15:33:05.250]             ...future.startTime <- base::Sys.time()
[15:33:05.250]             {
[15:33:05.250]                 {
[15:33:05.250]                   {
[15:33:05.250]                     {
[15:33:05.250]                       base::local({
[15:33:05.250]                         has_future <- base::requireNamespace("future", 
[15:33:05.250]                           quietly = TRUE)
[15:33:05.250]                         if (has_future) {
[15:33:05.250]                           ns <- base::getNamespace("future")
[15:33:05.250]                           version <- ns[[".package"]][["version"]]
[15:33:05.250]                           if (is.null(version)) 
[15:33:05.250]                             version <- utils::packageVersion("future")
[15:33:05.250]                         }
[15:33:05.250]                         else {
[15:33:05.250]                           version <- NULL
[15:33:05.250]                         }
[15:33:05.250]                         if (!has_future || version < "1.8.0") {
[15:33:05.250]                           info <- base::c(r_version = base::gsub("R version ", 
[15:33:05.250]                             "", base::R.version$version.string), 
[15:33:05.250]                             platform = base::sprintf("%s (%s-bit)", 
[15:33:05.250]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:33:05.250]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:33:05.250]                               "release", "version")], collapse = " "), 
[15:33:05.250]                             hostname = base::Sys.info()[["nodename"]])
[15:33:05.250]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:33:05.250]                             info)
[15:33:05.250]                           info <- base::paste(info, collapse = "; ")
[15:33:05.250]                           if (!has_future) {
[15:33:05.250]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:33:05.250]                               info)
[15:33:05.250]                           }
[15:33:05.250]                           else {
[15:33:05.250]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:33:05.250]                               info, version)
[15:33:05.250]                           }
[15:33:05.250]                           base::stop(msg)
[15:33:05.250]                         }
[15:33:05.250]                       })
[15:33:05.250]                     }
[15:33:05.250]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:33:05.250]                     base::options(mc.cores = 1L)
[15:33:05.250]                   }
[15:33:05.250]                   ...future.strategy.old <- future::plan("list")
[15:33:05.250]                   options(future.plan = NULL)
[15:33:05.250]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:33:05.250]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:33:05.250]                 }
[15:33:05.250]                 ...future.workdir <- getwd()
[15:33:05.250]             }
[15:33:05.250]             ...future.oldOptions <- base::as.list(base::.Options)
[15:33:05.250]             ...future.oldEnvVars <- base::Sys.getenv()
[15:33:05.250]         }
[15:33:05.250]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:33:05.250]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:33:05.250]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:33:05.250]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:33:05.250]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:33:05.250]             future.stdout.windows.reencode = NULL, width = 80L)
[15:33:05.250]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:33:05.250]             base::names(...future.oldOptions))
[15:33:05.250]     }
[15:33:05.250]     if (FALSE) {
[15:33:05.250]     }
[15:33:05.250]     else {
[15:33:05.250]         if (FALSE) {
[15:33:05.250]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:33:05.250]                 open = "w")
[15:33:05.250]         }
[15:33:05.250]         else {
[15:33:05.250]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:33:05.250]                 windows = "NUL", "/dev/null"), open = "w")
[15:33:05.250]         }
[15:33:05.250]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:33:05.250]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:33:05.250]             base::sink(type = "output", split = FALSE)
[15:33:05.250]             base::close(...future.stdout)
[15:33:05.250]         }, add = TRUE)
[15:33:05.250]     }
[15:33:05.250]     ...future.frame <- base::sys.nframe()
[15:33:05.250]     ...future.conditions <- base::list()
[15:33:05.250]     ...future.rng <- base::globalenv()$.Random.seed
[15:33:05.250]     if (FALSE) {
[15:33:05.250]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:33:05.250]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:33:05.250]     }
[15:33:05.250]     ...future.result <- base::tryCatch({
[15:33:05.250]         base::withCallingHandlers({
[15:33:05.250]             ...future.value <- base::withVisible(base::local({
[15:33:05.250]                 ...future.makeSendCondition <- base::local({
[15:33:05.250]                   sendCondition <- NULL
[15:33:05.250]                   function(frame = 1L) {
[15:33:05.250]                     if (is.function(sendCondition)) 
[15:33:05.250]                       return(sendCondition)
[15:33:05.250]                     ns <- getNamespace("parallel")
[15:33:05.250]                     if (exists("sendData", mode = "function", 
[15:33:05.250]                       envir = ns)) {
[15:33:05.250]                       parallel_sendData <- get("sendData", mode = "function", 
[15:33:05.250]                         envir = ns)
[15:33:05.250]                       envir <- sys.frame(frame)
[15:33:05.250]                       master <- NULL
[15:33:05.250]                       while (!identical(envir, .GlobalEnv) && 
[15:33:05.250]                         !identical(envir, emptyenv())) {
[15:33:05.250]                         if (exists("master", mode = "list", envir = envir, 
[15:33:05.250]                           inherits = FALSE)) {
[15:33:05.250]                           master <- get("master", mode = "list", 
[15:33:05.250]                             envir = envir, inherits = FALSE)
[15:33:05.250]                           if (inherits(master, c("SOCKnode", 
[15:33:05.250]                             "SOCK0node"))) {
[15:33:05.250]                             sendCondition <<- function(cond) {
[15:33:05.250]                               data <- list(type = "VALUE", value = cond, 
[15:33:05.250]                                 success = TRUE)
[15:33:05.250]                               parallel_sendData(master, data)
[15:33:05.250]                             }
[15:33:05.250]                             return(sendCondition)
[15:33:05.250]                           }
[15:33:05.250]                         }
[15:33:05.250]                         frame <- frame + 1L
[15:33:05.250]                         envir <- sys.frame(frame)
[15:33:05.250]                       }
[15:33:05.250]                     }
[15:33:05.250]                     sendCondition <<- function(cond) NULL
[15:33:05.250]                   }
[15:33:05.250]                 })
[15:33:05.250]                 withCallingHandlers({
[15:33:05.250]                   {
[15:33:05.250]                     do.call(function(...) {
[15:33:05.250]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:33:05.250]                       if (!identical(...future.globals.maxSize.org, 
[15:33:05.250]                         ...future.globals.maxSize)) {
[15:33:05.250]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:33:05.250]                         on.exit(options(oopts), add = TRUE)
[15:33:05.250]                       }
[15:33:05.250]                       {
[15:33:05.250]                         lapply(seq_along(...future.elements_ii), 
[15:33:05.250]                           FUN = function(jj) {
[15:33:05.250]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:33:05.250]                             ...future.FUN(...future.X_jj, ...)
[15:33:05.250]                           })
[15:33:05.250]                       }
[15:33:05.250]                     }, args = future.call.arguments)
[15:33:05.250]                   }
[15:33:05.250]                 }, immediateCondition = function(cond) {
[15:33:05.250]                   sendCondition <- ...future.makeSendCondition()
[15:33:05.250]                   sendCondition(cond)
[15:33:05.250]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:33:05.250]                   {
[15:33:05.250]                     inherits <- base::inherits
[15:33:05.250]                     invokeRestart <- base::invokeRestart
[15:33:05.250]                     is.null <- base::is.null
[15:33:05.250]                     muffled <- FALSE
[15:33:05.250]                     if (inherits(cond, "message")) {
[15:33:05.250]                       muffled <- grepl(pattern, "muffleMessage")
[15:33:05.250]                       if (muffled) 
[15:33:05.250]                         invokeRestart("muffleMessage")
[15:33:05.250]                     }
[15:33:05.250]                     else if (inherits(cond, "warning")) {
[15:33:05.250]                       muffled <- grepl(pattern, "muffleWarning")
[15:33:05.250]                       if (muffled) 
[15:33:05.250]                         invokeRestart("muffleWarning")
[15:33:05.250]                     }
[15:33:05.250]                     else if (inherits(cond, "condition")) {
[15:33:05.250]                       if (!is.null(pattern)) {
[15:33:05.250]                         computeRestarts <- base::computeRestarts
[15:33:05.250]                         grepl <- base::grepl
[15:33:05.250]                         restarts <- computeRestarts(cond)
[15:33:05.250]                         for (restart in restarts) {
[15:33:05.250]                           name <- restart$name
[15:33:05.250]                           if (is.null(name)) 
[15:33:05.250]                             next
[15:33:05.250]                           if (!grepl(pattern, name)) 
[15:33:05.250]                             next
[15:33:05.250]                           invokeRestart(restart)
[15:33:05.250]                           muffled <- TRUE
[15:33:05.250]                           break
[15:33:05.250]                         }
[15:33:05.250]                       }
[15:33:05.250]                     }
[15:33:05.250]                     invisible(muffled)
[15:33:05.250]                   }
[15:33:05.250]                   muffleCondition(cond)
[15:33:05.250]                 })
[15:33:05.250]             }))
[15:33:05.250]             future::FutureResult(value = ...future.value$value, 
[15:33:05.250]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:33:05.250]                   ...future.rng), globalenv = if (FALSE) 
[15:33:05.250]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:33:05.250]                     ...future.globalenv.names))
[15:33:05.250]                 else NULL, started = ...future.startTime, version = "1.8")
[15:33:05.250]         }, condition = base::local({
[15:33:05.250]             c <- base::c
[15:33:05.250]             inherits <- base::inherits
[15:33:05.250]             invokeRestart <- base::invokeRestart
[15:33:05.250]             length <- base::length
[15:33:05.250]             list <- base::list
[15:33:05.250]             seq.int <- base::seq.int
[15:33:05.250]             signalCondition <- base::signalCondition
[15:33:05.250]             sys.calls <- base::sys.calls
[15:33:05.250]             `[[` <- base::`[[`
[15:33:05.250]             `+` <- base::`+`
[15:33:05.250]             `<<-` <- base::`<<-`
[15:33:05.250]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:33:05.250]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:33:05.250]                   3L)]
[15:33:05.250]             }
[15:33:05.250]             function(cond) {
[15:33:05.250]                 is_error <- inherits(cond, "error")
[15:33:05.250]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:33:05.250]                   NULL)
[15:33:05.250]                 if (is_error) {
[15:33:05.250]                   sessionInformation <- function() {
[15:33:05.250]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:33:05.250]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:33:05.250]                       search = base::search(), system = base::Sys.info())
[15:33:05.250]                   }
[15:33:05.250]                   ...future.conditions[[length(...future.conditions) + 
[15:33:05.250]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:33:05.250]                     cond$call), session = sessionInformation(), 
[15:33:05.250]                     timestamp = base::Sys.time(), signaled = 0L)
[15:33:05.250]                   signalCondition(cond)
[15:33:05.250]                 }
[15:33:05.250]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:33:05.250]                 "immediateCondition"))) {
[15:33:05.250]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:33:05.250]                   ...future.conditions[[length(...future.conditions) + 
[15:33:05.250]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:33:05.250]                   if (TRUE && !signal) {
[15:33:05.250]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:33:05.250]                     {
[15:33:05.250]                       inherits <- base::inherits
[15:33:05.250]                       invokeRestart <- base::invokeRestart
[15:33:05.250]                       is.null <- base::is.null
[15:33:05.250]                       muffled <- FALSE
[15:33:05.250]                       if (inherits(cond, "message")) {
[15:33:05.250]                         muffled <- grepl(pattern, "muffleMessage")
[15:33:05.250]                         if (muffled) 
[15:33:05.250]                           invokeRestart("muffleMessage")
[15:33:05.250]                       }
[15:33:05.250]                       else if (inherits(cond, "warning")) {
[15:33:05.250]                         muffled <- grepl(pattern, "muffleWarning")
[15:33:05.250]                         if (muffled) 
[15:33:05.250]                           invokeRestart("muffleWarning")
[15:33:05.250]                       }
[15:33:05.250]                       else if (inherits(cond, "condition")) {
[15:33:05.250]                         if (!is.null(pattern)) {
[15:33:05.250]                           computeRestarts <- base::computeRestarts
[15:33:05.250]                           grepl <- base::grepl
[15:33:05.250]                           restarts <- computeRestarts(cond)
[15:33:05.250]                           for (restart in restarts) {
[15:33:05.250]                             name <- restart$name
[15:33:05.250]                             if (is.null(name)) 
[15:33:05.250]                               next
[15:33:05.250]                             if (!grepl(pattern, name)) 
[15:33:05.250]                               next
[15:33:05.250]                             invokeRestart(restart)
[15:33:05.250]                             muffled <- TRUE
[15:33:05.250]                             break
[15:33:05.250]                           }
[15:33:05.250]                         }
[15:33:05.250]                       }
[15:33:05.250]                       invisible(muffled)
[15:33:05.250]                     }
[15:33:05.250]                     muffleCondition(cond, pattern = "^muffle")
[15:33:05.250]                   }
[15:33:05.250]                 }
[15:33:05.250]                 else {
[15:33:05.250]                   if (TRUE) {
[15:33:05.250]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:33:05.250]                     {
[15:33:05.250]                       inherits <- base::inherits
[15:33:05.250]                       invokeRestart <- base::invokeRestart
[15:33:05.250]                       is.null <- base::is.null
[15:33:05.250]                       muffled <- FALSE
[15:33:05.250]                       if (inherits(cond, "message")) {
[15:33:05.250]                         muffled <- grepl(pattern, "muffleMessage")
[15:33:05.250]                         if (muffled) 
[15:33:05.250]                           invokeRestart("muffleMessage")
[15:33:05.250]                       }
[15:33:05.250]                       else if (inherits(cond, "warning")) {
[15:33:05.250]                         muffled <- grepl(pattern, "muffleWarning")
[15:33:05.250]                         if (muffled) 
[15:33:05.250]                           invokeRestart("muffleWarning")
[15:33:05.250]                       }
[15:33:05.250]                       else if (inherits(cond, "condition")) {
[15:33:05.250]                         if (!is.null(pattern)) {
[15:33:05.250]                           computeRestarts <- base::computeRestarts
[15:33:05.250]                           grepl <- base::grepl
[15:33:05.250]                           restarts <- computeRestarts(cond)
[15:33:05.250]                           for (restart in restarts) {
[15:33:05.250]                             name <- restart$name
[15:33:05.250]                             if (is.null(name)) 
[15:33:05.250]                               next
[15:33:05.250]                             if (!grepl(pattern, name)) 
[15:33:05.250]                               next
[15:33:05.250]                             invokeRestart(restart)
[15:33:05.250]                             muffled <- TRUE
[15:33:05.250]                             break
[15:33:05.250]                           }
[15:33:05.250]                         }
[15:33:05.250]                       }
[15:33:05.250]                       invisible(muffled)
[15:33:05.250]                     }
[15:33:05.250]                     muffleCondition(cond, pattern = "^muffle")
[15:33:05.250]                   }
[15:33:05.250]                 }
[15:33:05.250]             }
[15:33:05.250]         }))
[15:33:05.250]     }, error = function(ex) {
[15:33:05.250]         base::structure(base::list(value = NULL, visible = NULL, 
[15:33:05.250]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:33:05.250]                 ...future.rng), started = ...future.startTime, 
[15:33:05.250]             finished = Sys.time(), session_uuid = NA_character_, 
[15:33:05.250]             version = "1.8"), class = "FutureResult")
[15:33:05.250]     }, finally = {
[15:33:05.250]         if (!identical(...future.workdir, getwd())) 
[15:33:05.250]             setwd(...future.workdir)
[15:33:05.250]         {
[15:33:05.250]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:33:05.250]                 ...future.oldOptions$nwarnings <- NULL
[15:33:05.250]             }
[15:33:05.250]             base::options(...future.oldOptions)
[15:33:05.250]             if (.Platform$OS.type == "windows") {
[15:33:05.250]                 old_names <- names(...future.oldEnvVars)
[15:33:05.250]                 envs <- base::Sys.getenv()
[15:33:05.250]                 names <- names(envs)
[15:33:05.250]                 common <- intersect(names, old_names)
[15:33:05.250]                 added <- setdiff(names, old_names)
[15:33:05.250]                 removed <- setdiff(old_names, names)
[15:33:05.250]                 changed <- common[...future.oldEnvVars[common] != 
[15:33:05.250]                   envs[common]]
[15:33:05.250]                 NAMES <- toupper(changed)
[15:33:05.250]                 args <- list()
[15:33:05.250]                 for (kk in seq_along(NAMES)) {
[15:33:05.250]                   name <- changed[[kk]]
[15:33:05.250]                   NAME <- NAMES[[kk]]
[15:33:05.250]                   if (name != NAME && is.element(NAME, old_names)) 
[15:33:05.250]                     next
[15:33:05.250]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:33:05.250]                 }
[15:33:05.250]                 NAMES <- toupper(added)
[15:33:05.250]                 for (kk in seq_along(NAMES)) {
[15:33:05.250]                   name <- added[[kk]]
[15:33:05.250]                   NAME <- NAMES[[kk]]
[15:33:05.250]                   if (name != NAME && is.element(NAME, old_names)) 
[15:33:05.250]                     next
[15:33:05.250]                   args[[name]] <- ""
[15:33:05.250]                 }
[15:33:05.250]                 NAMES <- toupper(removed)
[15:33:05.250]                 for (kk in seq_along(NAMES)) {
[15:33:05.250]                   name <- removed[[kk]]
[15:33:05.250]                   NAME <- NAMES[[kk]]
[15:33:05.250]                   if (name != NAME && is.element(NAME, old_names)) 
[15:33:05.250]                     next
[15:33:05.250]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:33:05.250]                 }
[15:33:05.250]                 if (length(args) > 0) 
[15:33:05.250]                   base::do.call(base::Sys.setenv, args = args)
[15:33:05.250]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:33:05.250]             }
[15:33:05.250]             else {
[15:33:05.250]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:33:05.250]             }
[15:33:05.250]             {
[15:33:05.250]                 if (base::length(...future.futureOptionsAdded) > 
[15:33:05.250]                   0L) {
[15:33:05.250]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:33:05.250]                   base::names(opts) <- ...future.futureOptionsAdded
[15:33:05.250]                   base::options(opts)
[15:33:05.250]                 }
[15:33:05.250]                 {
[15:33:05.250]                   {
[15:33:05.250]                     base::options(mc.cores = ...future.mc.cores.old)
[15:33:05.250]                     NULL
[15:33:05.250]                   }
[15:33:05.250]                   options(future.plan = NULL)
[15:33:05.250]                   if (is.na(NA_character_)) 
[15:33:05.250]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:33:05.250]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:33:05.250]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:33:05.250]                     .init = FALSE)
[15:33:05.250]                 }
[15:33:05.250]             }
[15:33:05.250]         }
[15:33:05.250]     })
[15:33:05.250]     if (TRUE) {
[15:33:05.250]         base::sink(type = "output", split = FALSE)
[15:33:05.250]         if (FALSE) {
[15:33:05.250]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:33:05.250]         }
[15:33:05.250]         else {
[15:33:05.250]             ...future.result["stdout"] <- base::list(NULL)
[15:33:05.250]         }
[15:33:05.250]         base::close(...future.stdout)
[15:33:05.250]         ...future.stdout <- NULL
[15:33:05.250]     }
[15:33:05.250]     ...future.result$conditions <- ...future.conditions
[15:33:05.250]     ...future.result$finished <- base::Sys.time()
[15:33:05.250]     ...future.result
[15:33:05.250] }
[15:33:05.260] Exporting 5 global objects (4.61 KiB) to cluster node #1 ...
[15:33:05.260] Exporting '...future.FUN' (4.61 KiB) to cluster node #1 ...
[15:33:05.261] Exporting '...future.FUN' (4.61 KiB) to cluster node #1 ... DONE
[15:33:05.262] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:33:05.263] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:33:05.263] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ...
[15:33:05.264] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ... DONE
[15:33:05.264] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:33:05.265] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:33:05.266] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:33:05.266] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:33:05.267] Exporting 5 global objects (4.61 KiB) to cluster node #1 ... DONE
[15:33:05.268] MultisessionFuture started
[15:33:05.268] - Launch lazy future ... done
[15:33:05.269] run() for 'MultisessionFuture' ... done
[15:33:05.269] Created future:
[15:33:05.269] MultisessionFuture:
[15:33:05.269] Label: 'future_lapply-1'
[15:33:05.269] Expression:
[15:33:05.269] {
[15:33:05.269]     do.call(function(...) {
[15:33:05.269]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:33:05.269]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:33:05.269]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:33:05.269]             on.exit(options(oopts), add = TRUE)
[15:33:05.269]         }
[15:33:05.269]         {
[15:33:05.269]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:33:05.269]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:33:05.269]                 ...future.FUN(...future.X_jj, ...)
[15:33:05.269]             })
[15:33:05.269]         }
[15:33:05.269]     }, args = future.call.arguments)
[15:33:05.269] }
[15:33:05.269] Lazy evaluation: FALSE
[15:33:05.269] Asynchronous evaluation: TRUE
[15:33:05.269] Local evaluation: TRUE
[15:33:05.269] Environment: R_GlobalEnv
[15:33:05.269] Capture standard output: FALSE
[15:33:05.269] Capture condition classes: 'condition' (excluding 'nothing')
[15:33:05.269] Globals: 5 objects totaling 4.66 KiB (function '...future.FUN' of 4.61 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 56 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:33:05.269] Packages: <none>
[15:33:05.269] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:33:05.269] Resolved: FALSE
[15:33:05.269] Value: <not collected>
[15:33:05.269] Conditions captured: <none>
[15:33:05.269] Early signaling: FALSE
[15:33:05.269] Owner process: bdd4bc13-919d-bf34-b2cf-84eb53f6e11f
[15:33:05.269] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:33:05.469] Chunk #1 of 2 ... DONE
[15:33:05.470] Chunk #2 of 2 ...
[15:33:05.470]  - Finding globals in 'X' for chunk #2 ...
[15:33:05.470] getGlobalsAndPackages() ...
[15:33:05.471] Searching for globals...
[15:33:05.472] 
[15:33:05.472] Searching for globals ... DONE
[15:33:05.472] - globals: [0] <none>
[15:33:05.473] getGlobalsAndPackages() ... DONE
[15:33:05.473]    + additional globals found: [n=0] 
[15:33:05.474]    + additional namespaces needed: [n=0] 
[15:33:05.474]  - Finding globals in 'X' for chunk #2 ... DONE
[15:33:05.474]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:33:05.475]  - seeds: <none>
[15:33:05.475]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:33:05.476] getGlobalsAndPackages() ...
[15:33:05.476] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:33:05.477] Resolving globals: FALSE
[15:33:05.477] Tweak future expression to call with '...' arguments ...
[15:33:05.477] {
[15:33:05.477]     do.call(function(...) {
[15:33:05.477]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:33:05.477]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:33:05.477]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:33:05.477]             on.exit(options(oopts), add = TRUE)
[15:33:05.477]         }
[15:33:05.477]         {
[15:33:05.477]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:33:05.477]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:33:05.477]                 ...future.FUN(...future.X_jj, ...)
[15:33:05.477]             })
[15:33:05.477]         }
[15:33:05.477]     }, args = future.call.arguments)
[15:33:05.477] }
[15:33:05.479] Tweak future expression to call with '...' arguments ... DONE
[15:33:05.480] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:33:05.480] 
[15:33:05.481] getGlobalsAndPackages() ... DONE
[15:33:05.481] run() for 'Future' ...
[15:33:05.482] - state: 'created'
[15:33:05.483] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:33:05.507] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:33:05.508] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:33:05.508]   - Field: 'node'
[15:33:05.509]   - Field: 'label'
[15:33:05.509]   - Field: 'local'
[15:33:05.509]   - Field: 'owner'
[15:33:05.510]   - Field: 'envir'
[15:33:05.510]   - Field: 'workers'
[15:33:05.511]   - Field: 'packages'
[15:33:05.511]   - Field: 'gc'
[15:33:05.511]   - Field: 'conditions'
[15:33:05.512]   - Field: 'persistent'
[15:33:05.512]   - Field: 'expr'
[15:33:05.513]   - Field: 'uuid'
[15:33:05.513]   - Field: 'seed'
[15:33:05.513]   - Field: 'version'
[15:33:05.514]   - Field: 'result'
[15:33:05.514]   - Field: 'asynchronous'
[15:33:05.515]   - Field: 'calls'
[15:33:05.515]   - Field: 'globals'
[15:33:05.515]   - Field: 'stdout'
[15:33:05.516]   - Field: 'earlySignal'
[15:33:05.516]   - Field: 'lazy'
[15:33:05.517]   - Field: 'state'
[15:33:05.517] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:33:05.518] - Launch lazy future ...
[15:33:05.519] Packages needed by the future expression (n = 0): <none>
[15:33:05.519] Packages needed by future strategies (n = 0): <none>
[15:33:05.520] {
[15:33:05.520]     {
[15:33:05.520]         {
[15:33:05.520]             ...future.startTime <- base::Sys.time()
[15:33:05.520]             {
[15:33:05.520]                 {
[15:33:05.520]                   {
[15:33:05.520]                     {
[15:33:05.520]                       base::local({
[15:33:05.520]                         has_future <- base::requireNamespace("future", 
[15:33:05.520]                           quietly = TRUE)
[15:33:05.520]                         if (has_future) {
[15:33:05.520]                           ns <- base::getNamespace("future")
[15:33:05.520]                           version <- ns[[".package"]][["version"]]
[15:33:05.520]                           if (is.null(version)) 
[15:33:05.520]                             version <- utils::packageVersion("future")
[15:33:05.520]                         }
[15:33:05.520]                         else {
[15:33:05.520]                           version <- NULL
[15:33:05.520]                         }
[15:33:05.520]                         if (!has_future || version < "1.8.0") {
[15:33:05.520]                           info <- base::c(r_version = base::gsub("R version ", 
[15:33:05.520]                             "", base::R.version$version.string), 
[15:33:05.520]                             platform = base::sprintf("%s (%s-bit)", 
[15:33:05.520]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:33:05.520]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:33:05.520]                               "release", "version")], collapse = " "), 
[15:33:05.520]                             hostname = base::Sys.info()[["nodename"]])
[15:33:05.520]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:33:05.520]                             info)
[15:33:05.520]                           info <- base::paste(info, collapse = "; ")
[15:33:05.520]                           if (!has_future) {
[15:33:05.520]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:33:05.520]                               info)
[15:33:05.520]                           }
[15:33:05.520]                           else {
[15:33:05.520]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:33:05.520]                               info, version)
[15:33:05.520]                           }
[15:33:05.520]                           base::stop(msg)
[15:33:05.520]                         }
[15:33:05.520]                       })
[15:33:05.520]                     }
[15:33:05.520]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:33:05.520]                     base::options(mc.cores = 1L)
[15:33:05.520]                   }
[15:33:05.520]                   ...future.strategy.old <- future::plan("list")
[15:33:05.520]                   options(future.plan = NULL)
[15:33:05.520]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:33:05.520]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:33:05.520]                 }
[15:33:05.520]                 ...future.workdir <- getwd()
[15:33:05.520]             }
[15:33:05.520]             ...future.oldOptions <- base::as.list(base::.Options)
[15:33:05.520]             ...future.oldEnvVars <- base::Sys.getenv()
[15:33:05.520]         }
[15:33:05.520]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:33:05.520]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:33:05.520]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:33:05.520]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:33:05.520]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:33:05.520]             future.stdout.windows.reencode = NULL, width = 80L)
[15:33:05.520]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:33:05.520]             base::names(...future.oldOptions))
[15:33:05.520]     }
[15:33:05.520]     if (FALSE) {
[15:33:05.520]     }
[15:33:05.520]     else {
[15:33:05.520]         if (FALSE) {
[15:33:05.520]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:33:05.520]                 open = "w")
[15:33:05.520]         }
[15:33:05.520]         else {
[15:33:05.520]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:33:05.520]                 windows = "NUL", "/dev/null"), open = "w")
[15:33:05.520]         }
[15:33:05.520]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:33:05.520]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:33:05.520]             base::sink(type = "output", split = FALSE)
[15:33:05.520]             base::close(...future.stdout)
[15:33:05.520]         }, add = TRUE)
[15:33:05.520]     }
[15:33:05.520]     ...future.frame <- base::sys.nframe()
[15:33:05.520]     ...future.conditions <- base::list()
[15:33:05.520]     ...future.rng <- base::globalenv()$.Random.seed
[15:33:05.520]     if (FALSE) {
[15:33:05.520]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:33:05.520]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:33:05.520]     }
[15:33:05.520]     ...future.result <- base::tryCatch({
[15:33:05.520]         base::withCallingHandlers({
[15:33:05.520]             ...future.value <- base::withVisible(base::local({
[15:33:05.520]                 ...future.makeSendCondition <- base::local({
[15:33:05.520]                   sendCondition <- NULL
[15:33:05.520]                   function(frame = 1L) {
[15:33:05.520]                     if (is.function(sendCondition)) 
[15:33:05.520]                       return(sendCondition)
[15:33:05.520]                     ns <- getNamespace("parallel")
[15:33:05.520]                     if (exists("sendData", mode = "function", 
[15:33:05.520]                       envir = ns)) {
[15:33:05.520]                       parallel_sendData <- get("sendData", mode = "function", 
[15:33:05.520]                         envir = ns)
[15:33:05.520]                       envir <- sys.frame(frame)
[15:33:05.520]                       master <- NULL
[15:33:05.520]                       while (!identical(envir, .GlobalEnv) && 
[15:33:05.520]                         !identical(envir, emptyenv())) {
[15:33:05.520]                         if (exists("master", mode = "list", envir = envir, 
[15:33:05.520]                           inherits = FALSE)) {
[15:33:05.520]                           master <- get("master", mode = "list", 
[15:33:05.520]                             envir = envir, inherits = FALSE)
[15:33:05.520]                           if (inherits(master, c("SOCKnode", 
[15:33:05.520]                             "SOCK0node"))) {
[15:33:05.520]                             sendCondition <<- function(cond) {
[15:33:05.520]                               data <- list(type = "VALUE", value = cond, 
[15:33:05.520]                                 success = TRUE)
[15:33:05.520]                               parallel_sendData(master, data)
[15:33:05.520]                             }
[15:33:05.520]                             return(sendCondition)
[15:33:05.520]                           }
[15:33:05.520]                         }
[15:33:05.520]                         frame <- frame + 1L
[15:33:05.520]                         envir <- sys.frame(frame)
[15:33:05.520]                       }
[15:33:05.520]                     }
[15:33:05.520]                     sendCondition <<- function(cond) NULL
[15:33:05.520]                   }
[15:33:05.520]                 })
[15:33:05.520]                 withCallingHandlers({
[15:33:05.520]                   {
[15:33:05.520]                     do.call(function(...) {
[15:33:05.520]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:33:05.520]                       if (!identical(...future.globals.maxSize.org, 
[15:33:05.520]                         ...future.globals.maxSize)) {
[15:33:05.520]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:33:05.520]                         on.exit(options(oopts), add = TRUE)
[15:33:05.520]                       }
[15:33:05.520]                       {
[15:33:05.520]                         lapply(seq_along(...future.elements_ii), 
[15:33:05.520]                           FUN = function(jj) {
[15:33:05.520]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:33:05.520]                             ...future.FUN(...future.X_jj, ...)
[15:33:05.520]                           })
[15:33:05.520]                       }
[15:33:05.520]                     }, args = future.call.arguments)
[15:33:05.520]                   }
[15:33:05.520]                 }, immediateCondition = function(cond) {
[15:33:05.520]                   sendCondition <- ...future.makeSendCondition()
[15:33:05.520]                   sendCondition(cond)
[15:33:05.520]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:33:05.520]                   {
[15:33:05.520]                     inherits <- base::inherits
[15:33:05.520]                     invokeRestart <- base::invokeRestart
[15:33:05.520]                     is.null <- base::is.null
[15:33:05.520]                     muffled <- FALSE
[15:33:05.520]                     if (inherits(cond, "message")) {
[15:33:05.520]                       muffled <- grepl(pattern, "muffleMessage")
[15:33:05.520]                       if (muffled) 
[15:33:05.520]                         invokeRestart("muffleMessage")
[15:33:05.520]                     }
[15:33:05.520]                     else if (inherits(cond, "warning")) {
[15:33:05.520]                       muffled <- grepl(pattern, "muffleWarning")
[15:33:05.520]                       if (muffled) 
[15:33:05.520]                         invokeRestart("muffleWarning")
[15:33:05.520]                     }
[15:33:05.520]                     else if (inherits(cond, "condition")) {
[15:33:05.520]                       if (!is.null(pattern)) {
[15:33:05.520]                         computeRestarts <- base::computeRestarts
[15:33:05.520]                         grepl <- base::grepl
[15:33:05.520]                         restarts <- computeRestarts(cond)
[15:33:05.520]                         for (restart in restarts) {
[15:33:05.520]                           name <- restart$name
[15:33:05.520]                           if (is.null(name)) 
[15:33:05.520]                             next
[15:33:05.520]                           if (!grepl(pattern, name)) 
[15:33:05.520]                             next
[15:33:05.520]                           invokeRestart(restart)
[15:33:05.520]                           muffled <- TRUE
[15:33:05.520]                           break
[15:33:05.520]                         }
[15:33:05.520]                       }
[15:33:05.520]                     }
[15:33:05.520]                     invisible(muffled)
[15:33:05.520]                   }
[15:33:05.520]                   muffleCondition(cond)
[15:33:05.520]                 })
[15:33:05.520]             }))
[15:33:05.520]             future::FutureResult(value = ...future.value$value, 
[15:33:05.520]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:33:05.520]                   ...future.rng), globalenv = if (FALSE) 
[15:33:05.520]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:33:05.520]                     ...future.globalenv.names))
[15:33:05.520]                 else NULL, started = ...future.startTime, version = "1.8")
[15:33:05.520]         }, condition = base::local({
[15:33:05.520]             c <- base::c
[15:33:05.520]             inherits <- base::inherits
[15:33:05.520]             invokeRestart <- base::invokeRestart
[15:33:05.520]             length <- base::length
[15:33:05.520]             list <- base::list
[15:33:05.520]             seq.int <- base::seq.int
[15:33:05.520]             signalCondition <- base::signalCondition
[15:33:05.520]             sys.calls <- base::sys.calls
[15:33:05.520]             `[[` <- base::`[[`
[15:33:05.520]             `+` <- base::`+`
[15:33:05.520]             `<<-` <- base::`<<-`
[15:33:05.520]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:33:05.520]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:33:05.520]                   3L)]
[15:33:05.520]             }
[15:33:05.520]             function(cond) {
[15:33:05.520]                 is_error <- inherits(cond, "error")
[15:33:05.520]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:33:05.520]                   NULL)
[15:33:05.520]                 if (is_error) {
[15:33:05.520]                   sessionInformation <- function() {
[15:33:05.520]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:33:05.520]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:33:05.520]                       search = base::search(), system = base::Sys.info())
[15:33:05.520]                   }
[15:33:05.520]                   ...future.conditions[[length(...future.conditions) + 
[15:33:05.520]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:33:05.520]                     cond$call), session = sessionInformation(), 
[15:33:05.520]                     timestamp = base::Sys.time(), signaled = 0L)
[15:33:05.520]                   signalCondition(cond)
[15:33:05.520]                 }
[15:33:05.520]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:33:05.520]                 "immediateCondition"))) {
[15:33:05.520]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:33:05.520]                   ...future.conditions[[length(...future.conditions) + 
[15:33:05.520]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:33:05.520]                   if (TRUE && !signal) {
[15:33:05.520]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:33:05.520]                     {
[15:33:05.520]                       inherits <- base::inherits
[15:33:05.520]                       invokeRestart <- base::invokeRestart
[15:33:05.520]                       is.null <- base::is.null
[15:33:05.520]                       muffled <- FALSE
[15:33:05.520]                       if (inherits(cond, "message")) {
[15:33:05.520]                         muffled <- grepl(pattern, "muffleMessage")
[15:33:05.520]                         if (muffled) 
[15:33:05.520]                           invokeRestart("muffleMessage")
[15:33:05.520]                       }
[15:33:05.520]                       else if (inherits(cond, "warning")) {
[15:33:05.520]                         muffled <- grepl(pattern, "muffleWarning")
[15:33:05.520]                         if (muffled) 
[15:33:05.520]                           invokeRestart("muffleWarning")
[15:33:05.520]                       }
[15:33:05.520]                       else if (inherits(cond, "condition")) {
[15:33:05.520]                         if (!is.null(pattern)) {
[15:33:05.520]                           computeRestarts <- base::computeRestarts
[15:33:05.520]                           grepl <- base::grepl
[15:33:05.520]                           restarts <- computeRestarts(cond)
[15:33:05.520]                           for (restart in restarts) {
[15:33:05.520]                             name <- restart$name
[15:33:05.520]                             if (is.null(name)) 
[15:33:05.520]                               next
[15:33:05.520]                             if (!grepl(pattern, name)) 
[15:33:05.520]                               next
[15:33:05.520]                             invokeRestart(restart)
[15:33:05.520]                             muffled <- TRUE
[15:33:05.520]                             break
[15:33:05.520]                           }
[15:33:05.520]                         }
[15:33:05.520]                       }
[15:33:05.520]                       invisible(muffled)
[15:33:05.520]                     }
[15:33:05.520]                     muffleCondition(cond, pattern = "^muffle")
[15:33:05.520]                   }
[15:33:05.520]                 }
[15:33:05.520]                 else {
[15:33:05.520]                   if (TRUE) {
[15:33:05.520]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:33:05.520]                     {
[15:33:05.520]                       inherits <- base::inherits
[15:33:05.520]                       invokeRestart <- base::invokeRestart
[15:33:05.520]                       is.null <- base::is.null
[15:33:05.520]                       muffled <- FALSE
[15:33:05.520]                       if (inherits(cond, "message")) {
[15:33:05.520]                         muffled <- grepl(pattern, "muffleMessage")
[15:33:05.520]                         if (muffled) 
[15:33:05.520]                           invokeRestart("muffleMessage")
[15:33:05.520]                       }
[15:33:05.520]                       else if (inherits(cond, "warning")) {
[15:33:05.520]                         muffled <- grepl(pattern, "muffleWarning")
[15:33:05.520]                         if (muffled) 
[15:33:05.520]                           invokeRestart("muffleWarning")
[15:33:05.520]                       }
[15:33:05.520]                       else if (inherits(cond, "condition")) {
[15:33:05.520]                         if (!is.null(pattern)) {
[15:33:05.520]                           computeRestarts <- base::computeRestarts
[15:33:05.520]                           grepl <- base::grepl
[15:33:05.520]                           restarts <- computeRestarts(cond)
[15:33:05.520]                           for (restart in restarts) {
[15:33:05.520]                             name <- restart$name
[15:33:05.520]                             if (is.null(name)) 
[15:33:05.520]                               next
[15:33:05.520]                             if (!grepl(pattern, name)) 
[15:33:05.520]                               next
[15:33:05.520]                             invokeRestart(restart)
[15:33:05.520]                             muffled <- TRUE
[15:33:05.520]                             break
[15:33:05.520]                           }
[15:33:05.520]                         }
[15:33:05.520]                       }
[15:33:05.520]                       invisible(muffled)
[15:33:05.520]                     }
[15:33:05.520]                     muffleCondition(cond, pattern = "^muffle")
[15:33:05.520]                   }
[15:33:05.520]                 }
[15:33:05.520]             }
[15:33:05.520]         }))
[15:33:05.520]     }, error = function(ex) {
[15:33:05.520]         base::structure(base::list(value = NULL, visible = NULL, 
[15:33:05.520]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:33:05.520]                 ...future.rng), started = ...future.startTime, 
[15:33:05.520]             finished = Sys.time(), session_uuid = NA_character_, 
[15:33:05.520]             version = "1.8"), class = "FutureResult")
[15:33:05.520]     }, finally = {
[15:33:05.520]         if (!identical(...future.workdir, getwd())) 
[15:33:05.520]             setwd(...future.workdir)
[15:33:05.520]         {
[15:33:05.520]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:33:05.520]                 ...future.oldOptions$nwarnings <- NULL
[15:33:05.520]             }
[15:33:05.520]             base::options(...future.oldOptions)
[15:33:05.520]             if (.Platform$OS.type == "windows") {
[15:33:05.520]                 old_names <- names(...future.oldEnvVars)
[15:33:05.520]                 envs <- base::Sys.getenv()
[15:33:05.520]                 names <- names(envs)
[15:33:05.520]                 common <- intersect(names, old_names)
[15:33:05.520]                 added <- setdiff(names, old_names)
[15:33:05.520]                 removed <- setdiff(old_names, names)
[15:33:05.520]                 changed <- common[...future.oldEnvVars[common] != 
[15:33:05.520]                   envs[common]]
[15:33:05.520]                 NAMES <- toupper(changed)
[15:33:05.520]                 args <- list()
[15:33:05.520]                 for (kk in seq_along(NAMES)) {
[15:33:05.520]                   name <- changed[[kk]]
[15:33:05.520]                   NAME <- NAMES[[kk]]
[15:33:05.520]                   if (name != NAME && is.element(NAME, old_names)) 
[15:33:05.520]                     next
[15:33:05.520]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:33:05.520]                 }
[15:33:05.520]                 NAMES <- toupper(added)
[15:33:05.520]                 for (kk in seq_along(NAMES)) {
[15:33:05.520]                   name <- added[[kk]]
[15:33:05.520]                   NAME <- NAMES[[kk]]
[15:33:05.520]                   if (name != NAME && is.element(NAME, old_names)) 
[15:33:05.520]                     next
[15:33:05.520]                   args[[name]] <- ""
[15:33:05.520]                 }
[15:33:05.520]                 NAMES <- toupper(removed)
[15:33:05.520]                 for (kk in seq_along(NAMES)) {
[15:33:05.520]                   name <- removed[[kk]]
[15:33:05.520]                   NAME <- NAMES[[kk]]
[15:33:05.520]                   if (name != NAME && is.element(NAME, old_names)) 
[15:33:05.520]                     next
[15:33:05.520]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:33:05.520]                 }
[15:33:05.520]                 if (length(args) > 0) 
[15:33:05.520]                   base::do.call(base::Sys.setenv, args = args)
[15:33:05.520]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:33:05.520]             }
[15:33:05.520]             else {
[15:33:05.520]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:33:05.520]             }
[15:33:05.520]             {
[15:33:05.520]                 if (base::length(...future.futureOptionsAdded) > 
[15:33:05.520]                   0L) {
[15:33:05.520]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:33:05.520]                   base::names(opts) <- ...future.futureOptionsAdded
[15:33:05.520]                   base::options(opts)
[15:33:05.520]                 }
[15:33:05.520]                 {
[15:33:05.520]                   {
[15:33:05.520]                     base::options(mc.cores = ...future.mc.cores.old)
[15:33:05.520]                     NULL
[15:33:05.520]                   }
[15:33:05.520]                   options(future.plan = NULL)
[15:33:05.520]                   if (is.na(NA_character_)) 
[15:33:05.520]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:33:05.520]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:33:05.520]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:33:05.520]                     .init = FALSE)
[15:33:05.520]                 }
[15:33:05.520]             }
[15:33:05.520]         }
[15:33:05.520]     })
[15:33:05.520]     if (TRUE) {
[15:33:05.520]         base::sink(type = "output", split = FALSE)
[15:33:05.520]         if (FALSE) {
[15:33:05.520]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:33:05.520]         }
[15:33:05.520]         else {
[15:33:05.520]             ...future.result["stdout"] <- base::list(NULL)
[15:33:05.520]         }
[15:33:05.520]         base::close(...future.stdout)
[15:33:05.520]         ...future.stdout <- NULL
[15:33:05.520]     }
[15:33:05.520]     ...future.result$conditions <- ...future.conditions
[15:33:05.520]     ...future.result$finished <- base::Sys.time()
[15:33:05.520]     ...future.result
[15:33:05.520] }
[15:33:05.673] Exporting 5 global objects (4.61 KiB) to cluster node #2 ...
[15:33:05.673] Exporting '...future.FUN' (4.61 KiB) to cluster node #2 ...
[15:33:05.674] Exporting '...future.FUN' (4.61 KiB) to cluster node #2 ... DONE
[15:33:05.678] Exporting 'future.call.arguments' (0 bytes) to cluster node #2 ...
[15:33:05.679] Exporting 'future.call.arguments' (0 bytes) to cluster node #2 ... DONE
[15:33:05.679] Exporting '...future.elements_ii' (56 bytes) to cluster node #2 ...
[15:33:05.680] Exporting '...future.elements_ii' (56 bytes) to cluster node #2 ... DONE
[15:33:05.680] Exporting '...future.seeds_ii' (0 bytes) to cluster node #2 ...
[15:33:05.681] Exporting '...future.seeds_ii' (0 bytes) to cluster node #2 ... DONE
[15:33:05.681] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #2 ...
[15:33:05.682] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #2 ... DONE
[15:33:05.682] Exporting 5 global objects (4.61 KiB) to cluster node #2 ... DONE
[15:33:05.683] MultisessionFuture started
[15:33:05.684] - Launch lazy future ... done
[15:33:05.684] run() for 'MultisessionFuture' ... done
[15:33:05.684] Created future:
[15:33:05.779] receiveMessageFromWorker() for ClusterFuture ...
[15:33:05.780] - Validating connection of MultisessionFuture
[15:33:05.780] - received message: FutureResult
[15:33:05.781] - Received FutureResult
[15:33:05.781] - Erased future from FutureRegistry
[15:33:05.781] result() for ClusterFuture ...
[15:33:05.781] - result already collected: FutureResult
[15:33:05.781] result() for ClusterFuture ... done
[15:33:05.782] receiveMessageFromWorker() for ClusterFuture ... done
[15:33:05.684] MultisessionFuture:
[15:33:05.684] Label: 'future_lapply-2'
[15:33:05.684] Expression:
[15:33:05.684] {
[15:33:05.684]     do.call(function(...) {
[15:33:05.684]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:33:05.684]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:33:05.684]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:33:05.684]             on.exit(options(oopts), add = TRUE)
[15:33:05.684]         }
[15:33:05.684]         {
[15:33:05.684]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:33:05.684]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:33:05.684]                 ...future.FUN(...future.X_jj, ...)
[15:33:05.684]             })
[15:33:05.684]         }
[15:33:05.684]     }, args = future.call.arguments)
[15:33:05.684] }
[15:33:05.684] Lazy evaluation: FALSE
[15:33:05.684] Asynchronous evaluation: TRUE
[15:33:05.684] Local evaluation: TRUE
[15:33:05.684] Environment: R_GlobalEnv
[15:33:05.684] Capture standard output: FALSE
[15:33:05.684] Capture condition classes: 'condition' (excluding 'nothing')
[15:33:05.684] Globals: 5 objects totaling 4.66 KiB (function '...future.FUN' of 4.61 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 56 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:33:05.684] Packages: <none>
[15:33:05.684] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:33:05.684] Resolved: TRUE
[15:33:05.684] Value: <not collected>
[15:33:05.684] Conditions captured: <none>
[15:33:05.684] Early signaling: FALSE
[15:33:05.684] Owner process: bdd4bc13-919d-bf34-b2cf-84eb53f6e11f
[15:33:05.684] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:33:05.782] Chunk #2 of 2 ... DONE
[15:33:05.783] Launching 2 futures (chunks) ... DONE
[15:33:05.783] Resolving 2 futures (chunks) ...
[15:33:05.783] resolve() on list ...
[15:33:05.783]  recursive: 0
[15:33:05.783]  length: 2
[15:33:05.783] 
[15:33:05.799] receiveMessageFromWorker() for ClusterFuture ...
[15:33:05.800] - Validating connection of MultisessionFuture
[15:33:05.800] - received message: FutureResult
[15:33:05.800] - Received FutureResult
[15:33:05.801] - Erased future from FutureRegistry
[15:33:05.801] result() for ClusterFuture ...
[15:33:05.801] - result already collected: FutureResult
[15:33:05.801] result() for ClusterFuture ... done
[15:33:05.801] receiveMessageFromWorker() for ClusterFuture ... done
[15:33:05.802] Future #1
[15:33:05.802] result() for ClusterFuture ...
[15:33:05.802] - result already collected: FutureResult
[15:33:05.802] result() for ClusterFuture ... done
[15:33:05.802] result() for ClusterFuture ...
[15:33:05.802] - result already collected: FutureResult
[15:33:05.802] result() for ClusterFuture ... done
[15:33:05.803] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:33:05.803] - nx: 2
[15:33:05.803] - relay: TRUE
[15:33:05.803] - stdout: TRUE
[15:33:05.803] - signal: TRUE
[15:33:05.803] - resignal: FALSE
[15:33:05.804] - force: TRUE
[15:33:05.804] - relayed: [n=2] FALSE, FALSE
[15:33:05.804] - queued futures: [n=2] FALSE, FALSE
[15:33:05.804]  - until=1
[15:33:05.804]  - relaying element #1
[15:33:05.804] result() for ClusterFuture ...
[15:33:05.805] - result already collected: FutureResult
[15:33:05.805] result() for ClusterFuture ... done
[15:33:05.805] result() for ClusterFuture ...
[15:33:05.805] - result already collected: FutureResult
[15:33:05.805] result() for ClusterFuture ... done
[15:33:05.805] result() for ClusterFuture ...
[15:33:05.806] - result already collected: FutureResult
[15:33:05.806] result() for ClusterFuture ... done
[15:33:05.806] result() for ClusterFuture ...
[15:33:05.806] - result already collected: FutureResult
[15:33:05.806] result() for ClusterFuture ... done
[15:33:05.806] - relayed: [n=2] TRUE, FALSE
[15:33:05.807] - queued futures: [n=2] TRUE, FALSE
[15:33:05.807] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:33:05.807]  length: 1 (resolved future 1)
[15:33:05.807] Future #2
[15:33:05.807] result() for ClusterFuture ...
[15:33:05.808] - result already collected: FutureResult
[15:33:05.808] result() for ClusterFuture ... done
[15:33:05.808] result() for ClusterFuture ...
[15:33:05.808] - result already collected: FutureResult
[15:33:05.808] result() for ClusterFuture ... done
[15:33:05.808] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:33:05.809] - nx: 2
[15:33:05.809] - relay: TRUE
[15:33:05.809] - stdout: TRUE
[15:33:05.809] - signal: TRUE
[15:33:05.809] - resignal: FALSE
[15:33:05.809] - force: TRUE
[15:33:05.809] - relayed: [n=2] TRUE, FALSE
[15:33:05.810] - queued futures: [n=2] TRUE, FALSE
[15:33:05.810]  - until=2
[15:33:05.810]  - relaying element #2
[15:33:05.810] result() for ClusterFuture ...
[15:33:05.810] - result already collected: FutureResult
[15:33:05.810] result() for ClusterFuture ... done
[15:33:05.811] result() for ClusterFuture ...
[15:33:05.811] - result already collected: FutureResult
[15:33:05.811] result() for ClusterFuture ... done
[15:33:05.811] result() for ClusterFuture ...
[15:33:05.811] - result already collected: FutureResult
[15:33:05.811] result() for ClusterFuture ... done
[15:33:05.812] result() for ClusterFuture ...
[15:33:05.812] - result already collected: FutureResult
[15:33:05.812] result() for ClusterFuture ... done
[15:33:05.812] - relayed: [n=2] TRUE, TRUE
[15:33:05.812] - queued futures: [n=2] TRUE, TRUE
[15:33:05.812] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:33:05.813]  length: 0 (resolved future 2)
[15:33:05.813] Relaying remaining futures
[15:33:05.813] signalConditionsASAP(NULL, pos=0) ...
[15:33:05.813] - nx: 2
[15:33:05.813] - relay: TRUE
[15:33:05.813] - stdout: TRUE
[15:33:05.814] - signal: TRUE
[15:33:05.814] - resignal: FALSE
[15:33:05.814] - force: TRUE
[15:33:05.814] - relayed: [n=2] TRUE, TRUE
[15:33:05.814] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:33:05.814] - relayed: [n=2] TRUE, TRUE
[15:33:05.815] - queued futures: [n=2] TRUE, TRUE
[15:33:05.815] signalConditionsASAP(NULL, pos=0) ... done
[15:33:05.815] resolve() on list ... DONE
[15:33:05.815] result() for ClusterFuture ...
[15:33:05.815] - result already collected: FutureResult
[15:33:05.815] result() for ClusterFuture ... done
[15:33:05.816] result() for ClusterFuture ...
[15:33:05.816] - result already collected: FutureResult
[15:33:05.816] result() for ClusterFuture ... done
[15:33:05.816] result() for ClusterFuture ...
[15:33:05.816] - result already collected: FutureResult
[15:33:05.816] result() for ClusterFuture ... done
[15:33:05.817] result() for ClusterFuture ...
[15:33:05.817] - result already collected: FutureResult
[15:33:05.817] result() for ClusterFuture ... done
[15:33:05.817]  - Number of value chunks collected: 2
[15:33:05.817] Resolving 2 futures (chunks) ... DONE
[15:33:05.817] Reducing values from 2 chunks ...
[15:33:05.818]  - Number of values collected after concatenation: 2
[15:33:05.818]  - Number of values expected: 2
[15:33:05.818] Reducing values from 2 chunks ... DONE
[15:33:05.818] future_lapply() ... DONE
* future_lapply(x, ..., future.stdout = FALSE) ... DONE
* future_lapply(x, ..., future.stdout = TRUE) ...
[15:33:05.819] future_lapply() ...
[15:33:05.822] Number of chunks: 2
[15:33:05.822] getGlobalsAndPackagesXApply() ...
[15:33:05.823]  - future.globals: TRUE
[15:33:05.823] getGlobalsAndPackages() ...
[15:33:05.823] Searching for globals...
[15:33:05.825] - globals found: [5] 'FUN', '{', 'Sys.sleep', '/', 'print'
[15:33:05.825] Searching for globals ... DONE
[15:33:05.825] Resolving globals: FALSE
[15:33:05.826] The total size of the 1 globals is 4.61 KiB (4720 bytes)
[15:33:05.826] The total size of the 1 globals exported for future expression ('FUN()') is 4.61 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.61 KiB of class 'function')
[15:33:05.826] - globals: [1] 'FUN'
[15:33:05.827] 
[15:33:05.827] getGlobalsAndPackages() ... DONE
[15:33:05.827]  - globals found/used: [n=1] 'FUN'
[15:33:05.827]  - needed namespaces: [n=0] 
[15:33:05.827] Finding globals ... DONE
[15:33:05.827]  - use_args: TRUE
[15:33:05.828]  - Getting '...' globals ...
[15:33:05.828] resolve() on list ...
[15:33:05.828]  recursive: 0
[15:33:05.829]  length: 1
[15:33:05.829]  elements: '...'
[15:33:05.829]  length: 0 (resolved future 1)
[15:33:05.829] resolve() on list ... DONE
[15:33:05.830]    - '...' content: [n=0] 
[15:33:05.830] List of 1
[15:33:05.830]  $ ...: list()
[15:33:05.830]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:33:05.830]  - attr(*, "where")=List of 1
[15:33:05.830]   ..$ ...:<environment: 0x0000027fbe5ae5d8> 
[15:33:05.830]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:33:05.830]  - attr(*, "resolved")= logi TRUE
[15:33:05.830]  - attr(*, "total_size")= num NA
[15:33:05.833]  - Getting '...' globals ... DONE
[15:33:05.833] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:33:05.834] List of 2
[15:33:05.834]  $ ...future.FUN:function (x)  
[15:33:05.834]  $ ...          : list()
[15:33:05.834]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:33:05.834]  - attr(*, "where")=List of 2
[15:33:05.834]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:33:05.834]   ..$ ...          :<environment: 0x0000027fbe5ae5d8> 
[15:33:05.834]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:33:05.834]  - attr(*, "resolved")= logi FALSE
[15:33:05.834]  - attr(*, "total_size")= num 4720
[15:33:05.837] Packages to be attached in all futures: [n=0] 
[15:33:05.837] getGlobalsAndPackagesXApply() ... DONE
[15:33:05.837] Number of futures (= number of chunks): 2
[15:33:05.838] Launching 2 futures (chunks) ...
[15:33:05.838] Chunk #1 of 2 ...
[15:33:05.838]  - Finding globals in 'X' for chunk #1 ...
[15:33:05.838] getGlobalsAndPackages() ...
[15:33:05.838] Searching for globals...
[15:33:05.839] 
[15:33:05.839] Searching for globals ... DONE
[15:33:05.839] - globals: [0] <none>
[15:33:05.839] getGlobalsAndPackages() ... DONE
[15:33:05.839]    + additional globals found: [n=0] 
[15:33:05.840]    + additional namespaces needed: [n=0] 
[15:33:05.840]  - Finding globals in 'X' for chunk #1 ... DONE
[15:33:05.840]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:33:05.840]  - seeds: <none>
[15:33:05.840]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:33:05.840] getGlobalsAndPackages() ...
[15:33:05.841] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:33:05.841] Resolving globals: FALSE
[15:33:05.841] Tweak future expression to call with '...' arguments ...
[15:33:05.841] {
[15:33:05.841]     do.call(function(...) {
[15:33:05.841]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:33:05.841]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:33:05.841]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:33:05.841]             on.exit(options(oopts), add = TRUE)
[15:33:05.841]         }
[15:33:05.841]         {
[15:33:05.841]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:33:05.841]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:33:05.841]                 ...future.FUN(...future.X_jj, ...)
[15:33:05.841]             })
[15:33:05.841]         }
[15:33:05.841]     }, args = future.call.arguments)
[15:33:05.841] }
[15:33:05.842] Tweak future expression to call with '...' arguments ... DONE
[15:33:05.842] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:33:05.842] 
[15:33:05.843] getGlobalsAndPackages() ... DONE
[15:33:05.843] run() for 'Future' ...
[15:33:05.843] - state: 'created'
[15:33:05.843] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:33:05.860] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:33:05.860] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:33:05.861]   - Field: 'node'
[15:33:05.861]   - Field: 'label'
[15:33:05.861]   - Field: 'local'
[15:33:05.862]   - Field: 'owner'
[15:33:05.862]   - Field: 'envir'
[15:33:05.862]   - Field: 'workers'
[15:33:05.863]   - Field: 'packages'
[15:33:05.863]   - Field: 'gc'
[15:33:05.863]   - Field: 'conditions'
[15:33:05.863]   - Field: 'persistent'
[15:33:05.864]   - Field: 'expr'
[15:33:05.864]   - Field: 'uuid'
[15:33:05.864]   - Field: 'seed'
[15:33:05.865]   - Field: 'version'
[15:33:05.865]   - Field: 'result'
[15:33:05.865]   - Field: 'asynchronous'
[15:33:05.866]   - Field: 'calls'
[15:33:05.866]   - Field: 'globals'
[15:33:05.866]   - Field: 'stdout'
[15:33:05.866]   - Field: 'earlySignal'
[15:33:05.867]   - Field: 'lazy'
[15:33:05.867]   - Field: 'state'
[15:33:05.867] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:33:05.868] - Launch lazy future ...
[15:33:05.868] Packages needed by the future expression (n = 0): <none>
[15:33:05.869] Packages needed by future strategies (n = 0): <none>
[15:33:05.869] {
[15:33:05.869]     {
[15:33:05.869]         {
[15:33:05.869]             ...future.startTime <- base::Sys.time()
[15:33:05.869]             {
[15:33:05.869]                 {
[15:33:05.869]                   {
[15:33:05.869]                     {
[15:33:05.869]                       base::local({
[15:33:05.869]                         has_future <- base::requireNamespace("future", 
[15:33:05.869]                           quietly = TRUE)
[15:33:05.869]                         if (has_future) {
[15:33:05.869]                           ns <- base::getNamespace("future")
[15:33:05.869]                           version <- ns[[".package"]][["version"]]
[15:33:05.869]                           if (is.null(version)) 
[15:33:05.869]                             version <- utils::packageVersion("future")
[15:33:05.869]                         }
[15:33:05.869]                         else {
[15:33:05.869]                           version <- NULL
[15:33:05.869]                         }
[15:33:05.869]                         if (!has_future || version < "1.8.0") {
[15:33:05.869]                           info <- base::c(r_version = base::gsub("R version ", 
[15:33:05.869]                             "", base::R.version$version.string), 
[15:33:05.869]                             platform = base::sprintf("%s (%s-bit)", 
[15:33:05.869]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:33:05.869]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:33:05.869]                               "release", "version")], collapse = " "), 
[15:33:05.869]                             hostname = base::Sys.info()[["nodename"]])
[15:33:05.869]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:33:05.869]                             info)
[15:33:05.869]                           info <- base::paste(info, collapse = "; ")
[15:33:05.869]                           if (!has_future) {
[15:33:05.869]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:33:05.869]                               info)
[15:33:05.869]                           }
[15:33:05.869]                           else {
[15:33:05.869]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:33:05.869]                               info, version)
[15:33:05.869]                           }
[15:33:05.869]                           base::stop(msg)
[15:33:05.869]                         }
[15:33:05.869]                       })
[15:33:05.869]                     }
[15:33:05.869]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:33:05.869]                     base::options(mc.cores = 1L)
[15:33:05.869]                   }
[15:33:05.869]                   ...future.strategy.old <- future::plan("list")
[15:33:05.869]                   options(future.plan = NULL)
[15:33:05.869]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:33:05.869]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:33:05.869]                 }
[15:33:05.869]                 ...future.workdir <- getwd()
[15:33:05.869]             }
[15:33:05.869]             ...future.oldOptions <- base::as.list(base::.Options)
[15:33:05.869]             ...future.oldEnvVars <- base::Sys.getenv()
[15:33:05.869]         }
[15:33:05.869]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:33:05.869]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:33:05.869]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:33:05.869]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:33:05.869]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:33:05.869]             future.stdout.windows.reencode = NULL, width = 80L)
[15:33:05.869]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:33:05.869]             base::names(...future.oldOptions))
[15:33:05.869]     }
[15:33:05.869]     if (FALSE) {
[15:33:05.869]     }
[15:33:05.869]     else {
[15:33:05.869]         if (TRUE) {
[15:33:05.869]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:33:05.869]                 open = "w")
[15:33:05.869]         }
[15:33:05.869]         else {
[15:33:05.869]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:33:05.869]                 windows = "NUL", "/dev/null"), open = "w")
[15:33:05.869]         }
[15:33:05.869]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:33:05.869]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:33:05.869]             base::sink(type = "output", split = FALSE)
[15:33:05.869]             base::close(...future.stdout)
[15:33:05.869]         }, add = TRUE)
[15:33:05.869]     }
[15:33:05.869]     ...future.frame <- base::sys.nframe()
[15:33:05.869]     ...future.conditions <- base::list()
[15:33:05.869]     ...future.rng <- base::globalenv()$.Random.seed
[15:33:05.869]     if (FALSE) {
[15:33:05.869]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:33:05.869]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:33:05.869]     }
[15:33:05.869]     ...future.result <- base::tryCatch({
[15:33:05.869]         base::withCallingHandlers({
[15:33:05.869]             ...future.value <- base::withVisible(base::local({
[15:33:05.869]                 ...future.makeSendCondition <- base::local({
[15:33:05.869]                   sendCondition <- NULL
[15:33:05.869]                   function(frame = 1L) {
[15:33:05.869]                     if (is.function(sendCondition)) 
[15:33:05.869]                       return(sendCondition)
[15:33:05.869]                     ns <- getNamespace("parallel")
[15:33:05.869]                     if (exists("sendData", mode = "function", 
[15:33:05.869]                       envir = ns)) {
[15:33:05.869]                       parallel_sendData <- get("sendData", mode = "function", 
[15:33:05.869]                         envir = ns)
[15:33:05.869]                       envir <- sys.frame(frame)
[15:33:05.869]                       master <- NULL
[15:33:05.869]                       while (!identical(envir, .GlobalEnv) && 
[15:33:05.869]                         !identical(envir, emptyenv())) {
[15:33:05.869]                         if (exists("master", mode = "list", envir = envir, 
[15:33:05.869]                           inherits = FALSE)) {
[15:33:05.869]                           master <- get("master", mode = "list", 
[15:33:05.869]                             envir = envir, inherits = FALSE)
[15:33:05.869]                           if (inherits(master, c("SOCKnode", 
[15:33:05.869]                             "SOCK0node"))) {
[15:33:05.869]                             sendCondition <<- function(cond) {
[15:33:05.869]                               data <- list(type = "VALUE", value = cond, 
[15:33:05.869]                                 success = TRUE)
[15:33:05.869]                               parallel_sendData(master, data)
[15:33:05.869]                             }
[15:33:05.869]                             return(sendCondition)
[15:33:05.869]                           }
[15:33:05.869]                         }
[15:33:05.869]                         frame <- frame + 1L
[15:33:05.869]                         envir <- sys.frame(frame)
[15:33:05.869]                       }
[15:33:05.869]                     }
[15:33:05.869]                     sendCondition <<- function(cond) NULL
[15:33:05.869]                   }
[15:33:05.869]                 })
[15:33:05.869]                 withCallingHandlers({
[15:33:05.869]                   {
[15:33:05.869]                     do.call(function(...) {
[15:33:05.869]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:33:05.869]                       if (!identical(...future.globals.maxSize.org, 
[15:33:05.869]                         ...future.globals.maxSize)) {
[15:33:05.869]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:33:05.869]                         on.exit(options(oopts), add = TRUE)
[15:33:05.869]                       }
[15:33:05.869]                       {
[15:33:05.869]                         lapply(seq_along(...future.elements_ii), 
[15:33:05.869]                           FUN = function(jj) {
[15:33:05.869]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:33:05.869]                             ...future.FUN(...future.X_jj, ...)
[15:33:05.869]                           })
[15:33:05.869]                       }
[15:33:05.869]                     }, args = future.call.arguments)
[15:33:05.869]                   }
[15:33:05.869]                 }, immediateCondition = function(cond) {
[15:33:05.869]                   sendCondition <- ...future.makeSendCondition()
[15:33:05.869]                   sendCondition(cond)
[15:33:05.869]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:33:05.869]                   {
[15:33:05.869]                     inherits <- base::inherits
[15:33:05.869]                     invokeRestart <- base::invokeRestart
[15:33:05.869]                     is.null <- base::is.null
[15:33:05.869]                     muffled <- FALSE
[15:33:05.869]                     if (inherits(cond, "message")) {
[15:33:05.869]                       muffled <- grepl(pattern, "muffleMessage")
[15:33:05.869]                       if (muffled) 
[15:33:05.869]                         invokeRestart("muffleMessage")
[15:33:05.869]                     }
[15:33:05.869]                     else if (inherits(cond, "warning")) {
[15:33:05.869]                       muffled <- grepl(pattern, "muffleWarning")
[15:33:05.869]                       if (muffled) 
[15:33:05.869]                         invokeRestart("muffleWarning")
[15:33:05.869]                     }
[15:33:05.869]                     else if (inherits(cond, "condition")) {
[15:33:05.869]                       if (!is.null(pattern)) {
[15:33:05.869]                         computeRestarts <- base::computeRestarts
[15:33:05.869]                         grepl <- base::grepl
[15:33:05.869]                         restarts <- computeRestarts(cond)
[15:33:05.869]                         for (restart in restarts) {
[15:33:05.869]                           name <- restart$name
[15:33:05.869]                           if (is.null(name)) 
[15:33:05.869]                             next
[15:33:05.869]                           if (!grepl(pattern, name)) 
[15:33:05.869]                             next
[15:33:05.869]                           invokeRestart(restart)
[15:33:05.869]                           muffled <- TRUE
[15:33:05.869]                           break
[15:33:05.869]                         }
[15:33:05.869]                       }
[15:33:05.869]                     }
[15:33:05.869]                     invisible(muffled)
[15:33:05.869]                   }
[15:33:05.869]                   muffleCondition(cond)
[15:33:05.869]                 })
[15:33:05.869]             }))
[15:33:05.869]             future::FutureResult(value = ...future.value$value, 
[15:33:05.869]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:33:05.869]                   ...future.rng), globalenv = if (FALSE) 
[15:33:05.869]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:33:05.869]                     ...future.globalenv.names))
[15:33:05.869]                 else NULL, started = ...future.startTime, version = "1.8")
[15:33:05.869]         }, condition = base::local({
[15:33:05.869]             c <- base::c
[15:33:05.869]             inherits <- base::inherits
[15:33:05.869]             invokeRestart <- base::invokeRestart
[15:33:05.869]             length <- base::length
[15:33:05.869]             list <- base::list
[15:33:05.869]             seq.int <- base::seq.int
[15:33:05.869]             signalCondition <- base::signalCondition
[15:33:05.869]             sys.calls <- base::sys.calls
[15:33:05.869]             `[[` <- base::`[[`
[15:33:05.869]             `+` <- base::`+`
[15:33:05.869]             `<<-` <- base::`<<-`
[15:33:05.869]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:33:05.869]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:33:05.869]                   3L)]
[15:33:05.869]             }
[15:33:05.869]             function(cond) {
[15:33:05.869]                 is_error <- inherits(cond, "error")
[15:33:05.869]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:33:05.869]                   NULL)
[15:33:05.869]                 if (is_error) {
[15:33:05.869]                   sessionInformation <- function() {
[15:33:05.869]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:33:05.869]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:33:05.869]                       search = base::search(), system = base::Sys.info())
[15:33:05.869]                   }
[15:33:05.869]                   ...future.conditions[[length(...future.conditions) + 
[15:33:05.869]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:33:05.869]                     cond$call), session = sessionInformation(), 
[15:33:05.869]                     timestamp = base::Sys.time(), signaled = 0L)
[15:33:05.869]                   signalCondition(cond)
[15:33:05.869]                 }
[15:33:05.869]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:33:05.869]                 "immediateCondition"))) {
[15:33:05.869]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:33:05.869]                   ...future.conditions[[length(...future.conditions) + 
[15:33:05.869]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:33:05.869]                   if (TRUE && !signal) {
[15:33:05.869]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:33:05.869]                     {
[15:33:05.869]                       inherits <- base::inherits
[15:33:05.869]                       invokeRestart <- base::invokeRestart
[15:33:05.869]                       is.null <- base::is.null
[15:33:05.869]                       muffled <- FALSE
[15:33:05.869]                       if (inherits(cond, "message")) {
[15:33:05.869]                         muffled <- grepl(pattern, "muffleMessage")
[15:33:05.869]                         if (muffled) 
[15:33:05.869]                           invokeRestart("muffleMessage")
[15:33:05.869]                       }
[15:33:05.869]                       else if (inherits(cond, "warning")) {
[15:33:05.869]                         muffled <- grepl(pattern, "muffleWarning")
[15:33:05.869]                         if (muffled) 
[15:33:05.869]                           invokeRestart("muffleWarning")
[15:33:05.869]                       }
[15:33:05.869]                       else if (inherits(cond, "condition")) {
[15:33:05.869]                         if (!is.null(pattern)) {
[15:33:05.869]                           computeRestarts <- base::computeRestarts
[15:33:05.869]                           grepl <- base::grepl
[15:33:05.869]                           restarts <- computeRestarts(cond)
[15:33:05.869]                           for (restart in restarts) {
[15:33:05.869]                             name <- restart$name
[15:33:05.869]                             if (is.null(name)) 
[15:33:05.869]                               next
[15:33:05.869]                             if (!grepl(pattern, name)) 
[15:33:05.869]                               next
[15:33:05.869]                             invokeRestart(restart)
[15:33:05.869]                             muffled <- TRUE
[15:33:05.869]                             break
[15:33:05.869]                           }
[15:33:05.869]                         }
[15:33:05.869]                       }
[15:33:05.869]                       invisible(muffled)
[15:33:05.869]                     }
[15:33:05.869]                     muffleCondition(cond, pattern = "^muffle")
[15:33:05.869]                   }
[15:33:05.869]                 }
[15:33:05.869]                 else {
[15:33:05.869]                   if (TRUE) {
[15:33:05.869]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:33:05.869]                     {
[15:33:05.869]                       inherits <- base::inherits
[15:33:05.869]                       invokeRestart <- base::invokeRestart
[15:33:05.869]                       is.null <- base::is.null
[15:33:05.869]                       muffled <- FALSE
[15:33:05.869]                       if (inherits(cond, "message")) {
[15:33:05.869]                         muffled <- grepl(pattern, "muffleMessage")
[15:33:05.869]                         if (muffled) 
[15:33:05.869]                           invokeRestart("muffleMessage")
[15:33:05.869]                       }
[15:33:05.869]                       else if (inherits(cond, "warning")) {
[15:33:05.869]                         muffled <- grepl(pattern, "muffleWarning")
[15:33:05.869]                         if (muffled) 
[15:33:05.869]                           invokeRestart("muffleWarning")
[15:33:05.869]                       }
[15:33:05.869]                       else if (inherits(cond, "condition")) {
[15:33:05.869]                         if (!is.null(pattern)) {
[15:33:05.869]                           computeRestarts <- base::computeRestarts
[15:33:05.869]                           grepl <- base::grepl
[15:33:05.869]                           restarts <- computeRestarts(cond)
[15:33:05.869]                           for (restart in restarts) {
[15:33:05.869]                             name <- restart$name
[15:33:05.869]                             if (is.null(name)) 
[15:33:05.869]                               next
[15:33:05.869]                             if (!grepl(pattern, name)) 
[15:33:05.869]                               next
[15:33:05.869]                             invokeRestart(restart)
[15:33:05.869]                             muffled <- TRUE
[15:33:05.869]                             break
[15:33:05.869]                           }
[15:33:05.869]                         }
[15:33:05.869]                       }
[15:33:05.869]                       invisible(muffled)
[15:33:05.869]                     }
[15:33:05.869]                     muffleCondition(cond, pattern = "^muffle")
[15:33:05.869]                   }
[15:33:05.869]                 }
[15:33:05.869]             }
[15:33:05.869]         }))
[15:33:05.869]     }, error = function(ex) {
[15:33:05.869]         base::structure(base::list(value = NULL, visible = NULL, 
[15:33:05.869]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:33:05.869]                 ...future.rng), started = ...future.startTime, 
[15:33:05.869]             finished = Sys.time(), session_uuid = NA_character_, 
[15:33:05.869]             version = "1.8"), class = "FutureResult")
[15:33:05.869]     }, finally = {
[15:33:05.869]         if (!identical(...future.workdir, getwd())) 
[15:33:05.869]             setwd(...future.workdir)
[15:33:05.869]         {
[15:33:05.869]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:33:05.869]                 ...future.oldOptions$nwarnings <- NULL
[15:33:05.869]             }
[15:33:05.869]             base::options(...future.oldOptions)
[15:33:05.869]             if (.Platform$OS.type == "windows") {
[15:33:05.869]                 old_names <- names(...future.oldEnvVars)
[15:33:05.869]                 envs <- base::Sys.getenv()
[15:33:05.869]                 names <- names(envs)
[15:33:05.869]                 common <- intersect(names, old_names)
[15:33:05.869]                 added <- setdiff(names, old_names)
[15:33:05.869]                 removed <- setdiff(old_names, names)
[15:33:05.869]                 changed <- common[...future.oldEnvVars[common] != 
[15:33:05.869]                   envs[common]]
[15:33:05.869]                 NAMES <- toupper(changed)
[15:33:05.869]                 args <- list()
[15:33:05.869]                 for (kk in seq_along(NAMES)) {
[15:33:05.869]                   name <- changed[[kk]]
[15:33:05.869]                   NAME <- NAMES[[kk]]
[15:33:05.869]                   if (name != NAME && is.element(NAME, old_names)) 
[15:33:05.869]                     next
[15:33:05.869]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:33:05.869]                 }
[15:33:05.869]                 NAMES <- toupper(added)
[15:33:05.869]                 for (kk in seq_along(NAMES)) {
[15:33:05.869]                   name <- added[[kk]]
[15:33:05.869]                   NAME <- NAMES[[kk]]
[15:33:05.869]                   if (name != NAME && is.element(NAME, old_names)) 
[15:33:05.869]                     next
[15:33:05.869]                   args[[name]] <- ""
[15:33:05.869]                 }
[15:33:05.869]                 NAMES <- toupper(removed)
[15:33:05.869]                 for (kk in seq_along(NAMES)) {
[15:33:05.869]                   name <- removed[[kk]]
[15:33:05.869]                   NAME <- NAMES[[kk]]
[15:33:05.869]                   if (name != NAME && is.element(NAME, old_names)) 
[15:33:05.869]                     next
[15:33:05.869]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:33:05.869]                 }
[15:33:05.869]                 if (length(args) > 0) 
[15:33:05.869]                   base::do.call(base::Sys.setenv, args = args)
[15:33:05.869]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:33:05.869]             }
[15:33:05.869]             else {
[15:33:05.869]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:33:05.869]             }
[15:33:05.869]             {
[15:33:05.869]                 if (base::length(...future.futureOptionsAdded) > 
[15:33:05.869]                   0L) {
[15:33:05.869]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:33:05.869]                   base::names(opts) <- ...future.futureOptionsAdded
[15:33:05.869]                   base::options(opts)
[15:33:05.869]                 }
[15:33:05.869]                 {
[15:33:05.869]                   {
[15:33:05.869]                     base::options(mc.cores = ...future.mc.cores.old)
[15:33:05.869]                     NULL
[15:33:05.869]                   }
[15:33:05.869]                   options(future.plan = NULL)
[15:33:05.869]                   if (is.na(NA_character_)) 
[15:33:05.869]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:33:05.869]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:33:05.869]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:33:05.869]                     .init = FALSE)
[15:33:05.869]                 }
[15:33:05.869]             }
[15:33:05.869]         }
[15:33:05.869]     })
[15:33:05.869]     if (TRUE) {
[15:33:05.869]         base::sink(type = "output", split = FALSE)
[15:33:05.869]         if (TRUE) {
[15:33:05.869]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:33:05.869]         }
[15:33:05.869]         else {
[15:33:05.869]             ...future.result["stdout"] <- base::list(NULL)
[15:33:05.869]         }
[15:33:05.869]         base::close(...future.stdout)
[15:33:05.869]         ...future.stdout <- NULL
[15:33:05.869]     }
[15:33:05.869]     ...future.result$conditions <- ...future.conditions
[15:33:05.869]     ...future.result$finished <- base::Sys.time()
[15:33:05.869]     ...future.result
[15:33:05.869] }
[15:33:05.878] Exporting 5 global objects (4.61 KiB) to cluster node #1 ...
[15:33:05.878] Exporting '...future.FUN' (4.61 KiB) to cluster node #1 ...
[15:33:05.879] Exporting '...future.FUN' (4.61 KiB) to cluster node #1 ... DONE
[15:33:05.880] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:33:05.881] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:33:05.881] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ...
[15:33:05.882] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ... DONE
[15:33:05.882] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:33:05.882] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:33:05.883] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:33:05.883] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:33:05.884] Exporting 5 global objects (4.61 KiB) to cluster node #1 ... DONE
[15:33:05.885] MultisessionFuture started
[15:33:05.885] - Launch lazy future ... done
[15:33:05.885] run() for 'MultisessionFuture' ... done
[15:33:05.886] Created future:
[15:33:05.886] MultisessionFuture:
[15:33:05.886] Label: 'future_lapply-1'
[15:33:05.886] Expression:
[15:33:05.886] {
[15:33:05.886]     do.call(function(...) {
[15:33:05.886]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:33:05.886]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:33:05.886]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:33:05.886]             on.exit(options(oopts), add = TRUE)
[15:33:05.886]         }
[15:33:05.886]         {
[15:33:05.886]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:33:05.886]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:33:05.886]                 ...future.FUN(...future.X_jj, ...)
[15:33:05.886]             })
[15:33:05.886]         }
[15:33:05.886]     }, args = future.call.arguments)
[15:33:05.886] }
[15:33:05.886] Lazy evaluation: FALSE
[15:33:05.886] Asynchronous evaluation: TRUE
[15:33:05.886] Local evaluation: TRUE
[15:33:05.886] Environment: R_GlobalEnv
[15:33:05.886] Capture standard output: TRUE
[15:33:05.886] Capture condition classes: 'condition' (excluding 'nothing')
[15:33:05.886] Globals: 5 objects totaling 4.66 KiB (function '...future.FUN' of 4.61 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 56 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:33:05.886] Packages: <none>
[15:33:05.886] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:33:05.886] Resolved: FALSE
[15:33:05.886] Value: <not collected>
[15:33:05.886] Conditions captured: <none>
[15:33:05.886] Early signaling: FALSE
[15:33:05.886] Owner process: bdd4bc13-919d-bf34-b2cf-84eb53f6e11f
[15:33:05.886] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:33:06.078] Chunk #1 of 2 ... DONE
[15:33:06.079] Chunk #2 of 2 ...
[15:33:06.079]  - Finding globals in 'X' for chunk #2 ...
[15:33:06.079] getGlobalsAndPackages() ...
[15:33:06.080] Searching for globals...
[15:33:06.080] 
[15:33:06.080] Searching for globals ... DONE
[15:33:06.080] - globals: [0] <none>
[15:33:06.081] getGlobalsAndPackages() ... DONE
[15:33:06.081]    + additional globals found: [n=0] 
[15:33:06.081]    + additional namespaces needed: [n=0] 
[15:33:06.081]  - Finding globals in 'X' for chunk #2 ... DONE
[15:33:06.081]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:33:06.082]  - seeds: <none>
[15:33:06.082]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:33:06.082] getGlobalsAndPackages() ...
[15:33:06.082] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:33:06.083] Resolving globals: FALSE
[15:33:06.083] Tweak future expression to call with '...' arguments ...
[15:33:06.083] {
[15:33:06.083]     do.call(function(...) {
[15:33:06.083]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:33:06.083]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:33:06.083]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:33:06.083]             on.exit(options(oopts), add = TRUE)
[15:33:06.083]         }
[15:33:06.083]         {
[15:33:06.083]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:33:06.083]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:33:06.083]                 ...future.FUN(...future.X_jj, ...)
[15:33:06.083]             })
[15:33:06.083]         }
[15:33:06.083]     }, args = future.call.arguments)
[15:33:06.083] }
[15:33:06.084] Tweak future expression to call with '...' arguments ... DONE
[15:33:06.085] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:33:06.085] 
[15:33:06.086] getGlobalsAndPackages() ... DONE
[15:33:06.086] run() for 'Future' ...
[15:33:06.087] - state: 'created'
[15:33:06.087] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:33:06.105] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:33:06.105] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:33:06.105]   - Field: 'node'
[15:33:06.106]   - Field: 'label'
[15:33:06.106]   - Field: 'local'
[15:33:06.106]   - Field: 'owner'
[15:33:06.107]   - Field: 'envir'
[15:33:06.107]   - Field: 'workers'
[15:33:06.107]   - Field: 'packages'
[15:33:06.108]   - Field: 'gc'
[15:33:06.108]   - Field: 'conditions'
[15:33:06.108]   - Field: 'persistent'
[15:33:06.109]   - Field: 'expr'
[15:33:06.109]   - Field: 'uuid'
[15:33:06.109]   - Field: 'seed'
[15:33:06.110]   - Field: 'version'
[15:33:06.110]   - Field: 'result'
[15:33:06.110]   - Field: 'asynchronous'
[15:33:06.110]   - Field: 'calls'
[15:33:06.111]   - Field: 'globals'
[15:33:06.111]   - Field: 'stdout'
[15:33:06.111]   - Field: 'earlySignal'
[15:33:06.112]   - Field: 'lazy'
[15:33:06.112]   - Field: 'state'
[15:33:06.112] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:33:06.112] - Launch lazy future ...
[15:33:06.113] Packages needed by the future expression (n = 0): <none>
[15:33:06.113] Packages needed by future strategies (n = 0): <none>
[15:33:06.114] {
[15:33:06.114]     {
[15:33:06.114]         {
[15:33:06.114]             ...future.startTime <- base::Sys.time()
[15:33:06.114]             {
[15:33:06.114]                 {
[15:33:06.114]                   {
[15:33:06.114]                     {
[15:33:06.114]                       base::local({
[15:33:06.114]                         has_future <- base::requireNamespace("future", 
[15:33:06.114]                           quietly = TRUE)
[15:33:06.114]                         if (has_future) {
[15:33:06.114]                           ns <- base::getNamespace("future")
[15:33:06.114]                           version <- ns[[".package"]][["version"]]
[15:33:06.114]                           if (is.null(version)) 
[15:33:06.114]                             version <- utils::packageVersion("future")
[15:33:06.114]                         }
[15:33:06.114]                         else {
[15:33:06.114]                           version <- NULL
[15:33:06.114]                         }
[15:33:06.114]                         if (!has_future || version < "1.8.0") {
[15:33:06.114]                           info <- base::c(r_version = base::gsub("R version ", 
[15:33:06.114]                             "", base::R.version$version.string), 
[15:33:06.114]                             platform = base::sprintf("%s (%s-bit)", 
[15:33:06.114]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:33:06.114]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:33:06.114]                               "release", "version")], collapse = " "), 
[15:33:06.114]                             hostname = base::Sys.info()[["nodename"]])
[15:33:06.114]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:33:06.114]                             info)
[15:33:06.114]                           info <- base::paste(info, collapse = "; ")
[15:33:06.114]                           if (!has_future) {
[15:33:06.114]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:33:06.114]                               info)
[15:33:06.114]                           }
[15:33:06.114]                           else {
[15:33:06.114]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:33:06.114]                               info, version)
[15:33:06.114]                           }
[15:33:06.114]                           base::stop(msg)
[15:33:06.114]                         }
[15:33:06.114]                       })
[15:33:06.114]                     }
[15:33:06.114]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:33:06.114]                     base::options(mc.cores = 1L)
[15:33:06.114]                   }
[15:33:06.114]                   ...future.strategy.old <- future::plan("list")
[15:33:06.114]                   options(future.plan = NULL)
[15:33:06.114]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:33:06.114]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:33:06.114]                 }
[15:33:06.114]                 ...future.workdir <- getwd()
[15:33:06.114]             }
[15:33:06.114]             ...future.oldOptions <- base::as.list(base::.Options)
[15:33:06.114]             ...future.oldEnvVars <- base::Sys.getenv()
[15:33:06.114]         }
[15:33:06.114]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:33:06.114]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:33:06.114]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:33:06.114]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:33:06.114]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:33:06.114]             future.stdout.windows.reencode = NULL, width = 80L)
[15:33:06.114]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:33:06.114]             base::names(...future.oldOptions))
[15:33:06.114]     }
[15:33:06.114]     if (FALSE) {
[15:33:06.114]     }
[15:33:06.114]     else {
[15:33:06.114]         if (TRUE) {
[15:33:06.114]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:33:06.114]                 open = "w")
[15:33:06.114]         }
[15:33:06.114]         else {
[15:33:06.114]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:33:06.114]                 windows = "NUL", "/dev/null"), open = "w")
[15:33:06.114]         }
[15:33:06.114]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:33:06.114]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:33:06.114]             base::sink(type = "output", split = FALSE)
[15:33:06.114]             base::close(...future.stdout)
[15:33:06.114]         }, add = TRUE)
[15:33:06.114]     }
[15:33:06.114]     ...future.frame <- base::sys.nframe()
[15:33:06.114]     ...future.conditions <- base::list()
[15:33:06.114]     ...future.rng <- base::globalenv()$.Random.seed
[15:33:06.114]     if (FALSE) {
[15:33:06.114]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:33:06.114]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:33:06.114]     }
[15:33:06.114]     ...future.result <- base::tryCatch({
[15:33:06.114]         base::withCallingHandlers({
[15:33:06.114]             ...future.value <- base::withVisible(base::local({
[15:33:06.114]                 ...future.makeSendCondition <- base::local({
[15:33:06.114]                   sendCondition <- NULL
[15:33:06.114]                   function(frame = 1L) {
[15:33:06.114]                     if (is.function(sendCondition)) 
[15:33:06.114]                       return(sendCondition)
[15:33:06.114]                     ns <- getNamespace("parallel")
[15:33:06.114]                     if (exists("sendData", mode = "function", 
[15:33:06.114]                       envir = ns)) {
[15:33:06.114]                       parallel_sendData <- get("sendData", mode = "function", 
[15:33:06.114]                         envir = ns)
[15:33:06.114]                       envir <- sys.frame(frame)
[15:33:06.114]                       master <- NULL
[15:33:06.114]                       while (!identical(envir, .GlobalEnv) && 
[15:33:06.114]                         !identical(envir, emptyenv())) {
[15:33:06.114]                         if (exists("master", mode = "list", envir = envir, 
[15:33:06.114]                           inherits = FALSE)) {
[15:33:06.114]                           master <- get("master", mode = "list", 
[15:33:06.114]                             envir = envir, inherits = FALSE)
[15:33:06.114]                           if (inherits(master, c("SOCKnode", 
[15:33:06.114]                             "SOCK0node"))) {
[15:33:06.114]                             sendCondition <<- function(cond) {
[15:33:06.114]                               data <- list(type = "VALUE", value = cond, 
[15:33:06.114]                                 success = TRUE)
[15:33:06.114]                               parallel_sendData(master, data)
[15:33:06.114]                             }
[15:33:06.114]                             return(sendCondition)
[15:33:06.114]                           }
[15:33:06.114]                         }
[15:33:06.114]                         frame <- frame + 1L
[15:33:06.114]                         envir <- sys.frame(frame)
[15:33:06.114]                       }
[15:33:06.114]                     }
[15:33:06.114]                     sendCondition <<- function(cond) NULL
[15:33:06.114]                   }
[15:33:06.114]                 })
[15:33:06.114]                 withCallingHandlers({
[15:33:06.114]                   {
[15:33:06.114]                     do.call(function(...) {
[15:33:06.114]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:33:06.114]                       if (!identical(...future.globals.maxSize.org, 
[15:33:06.114]                         ...future.globals.maxSize)) {
[15:33:06.114]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:33:06.114]                         on.exit(options(oopts), add = TRUE)
[15:33:06.114]                       }
[15:33:06.114]                       {
[15:33:06.114]                         lapply(seq_along(...future.elements_ii), 
[15:33:06.114]                           FUN = function(jj) {
[15:33:06.114]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:33:06.114]                             ...future.FUN(...future.X_jj, ...)
[15:33:06.114]                           })
[15:33:06.114]                       }
[15:33:06.114]                     }, args = future.call.arguments)
[15:33:06.114]                   }
[15:33:06.114]                 }, immediateCondition = function(cond) {
[15:33:06.114]                   sendCondition <- ...future.makeSendCondition()
[15:33:06.114]                   sendCondition(cond)
[15:33:06.114]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:33:06.114]                   {
[15:33:06.114]                     inherits <- base::inherits
[15:33:06.114]                     invokeRestart <- base::invokeRestart
[15:33:06.114]                     is.null <- base::is.null
[15:33:06.114]                     muffled <- FALSE
[15:33:06.114]                     if (inherits(cond, "message")) {
[15:33:06.114]                       muffled <- grepl(pattern, "muffleMessage")
[15:33:06.114]                       if (muffled) 
[15:33:06.114]                         invokeRestart("muffleMessage")
[15:33:06.114]                     }
[15:33:06.114]                     else if (inherits(cond, "warning")) {
[15:33:06.114]                       muffled <- grepl(pattern, "muffleWarning")
[15:33:06.114]                       if (muffled) 
[15:33:06.114]                         invokeRestart("muffleWarning")
[15:33:06.114]                     }
[15:33:06.114]                     else if (inherits(cond, "condition")) {
[15:33:06.114]                       if (!is.null(pattern)) {
[15:33:06.114]                         computeRestarts <- base::computeRestarts
[15:33:06.114]                         grepl <- base::grepl
[15:33:06.114]                         restarts <- computeRestarts(cond)
[15:33:06.114]                         for (restart in restarts) {
[15:33:06.114]                           name <- restart$name
[15:33:06.114]                           if (is.null(name)) 
[15:33:06.114]                             next
[15:33:06.114]                           if (!grepl(pattern, name)) 
[15:33:06.114]                             next
[15:33:06.114]                           invokeRestart(restart)
[15:33:06.114]                           muffled <- TRUE
[15:33:06.114]                           break
[15:33:06.114]                         }
[15:33:06.114]                       }
[15:33:06.114]                     }
[15:33:06.114]                     invisible(muffled)
[15:33:06.114]                   }
[15:33:06.114]                   muffleCondition(cond)
[15:33:06.114]                 })
[15:33:06.114]             }))
[15:33:06.114]             future::FutureResult(value = ...future.value$value, 
[15:33:06.114]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:33:06.114]                   ...future.rng), globalenv = if (FALSE) 
[15:33:06.114]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:33:06.114]                     ...future.globalenv.names))
[15:33:06.114]                 else NULL, started = ...future.startTime, version = "1.8")
[15:33:06.114]         }, condition = base::local({
[15:33:06.114]             c <- base::c
[15:33:06.114]             inherits <- base::inherits
[15:33:06.114]             invokeRestart <- base::invokeRestart
[15:33:06.114]             length <- base::length
[15:33:06.114]             list <- base::list
[15:33:06.114]             seq.int <- base::seq.int
[15:33:06.114]             signalCondition <- base::signalCondition
[15:33:06.114]             sys.calls <- base::sys.calls
[15:33:06.114]             `[[` <- base::`[[`
[15:33:06.114]             `+` <- base::`+`
[15:33:06.114]             `<<-` <- base::`<<-`
[15:33:06.114]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:33:06.114]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:33:06.114]                   3L)]
[15:33:06.114]             }
[15:33:06.114]             function(cond) {
[15:33:06.114]                 is_error <- inherits(cond, "error")
[15:33:06.114]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:33:06.114]                   NULL)
[15:33:06.114]                 if (is_error) {
[15:33:06.114]                   sessionInformation <- function() {
[15:33:06.114]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:33:06.114]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:33:06.114]                       search = base::search(), system = base::Sys.info())
[15:33:06.114]                   }
[15:33:06.114]                   ...future.conditions[[length(...future.conditions) + 
[15:33:06.114]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:33:06.114]                     cond$call), session = sessionInformation(), 
[15:33:06.114]                     timestamp = base::Sys.time(), signaled = 0L)
[15:33:06.114]                   signalCondition(cond)
[15:33:06.114]                 }
[15:33:06.114]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:33:06.114]                 "immediateCondition"))) {
[15:33:06.114]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:33:06.114]                   ...future.conditions[[length(...future.conditions) + 
[15:33:06.114]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:33:06.114]                   if (TRUE && !signal) {
[15:33:06.114]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:33:06.114]                     {
[15:33:06.114]                       inherits <- base::inherits
[15:33:06.114]                       invokeRestart <- base::invokeRestart
[15:33:06.114]                       is.null <- base::is.null
[15:33:06.114]                       muffled <- FALSE
[15:33:06.114]                       if (inherits(cond, "message")) {
[15:33:06.114]                         muffled <- grepl(pattern, "muffleMessage")
[15:33:06.114]                         if (muffled) 
[15:33:06.114]                           invokeRestart("muffleMessage")
[15:33:06.114]                       }
[15:33:06.114]                       else if (inherits(cond, "warning")) {
[15:33:06.114]                         muffled <- grepl(pattern, "muffleWarning")
[15:33:06.114]                         if (muffled) 
[15:33:06.114]                           invokeRestart("muffleWarning")
[15:33:06.114]                       }
[15:33:06.114]                       else if (inherits(cond, "condition")) {
[15:33:06.114]                         if (!is.null(pattern)) {
[15:33:06.114]                           computeRestarts <- base::computeRestarts
[15:33:06.114]                           grepl <- base::grepl
[15:33:06.114]                           restarts <- computeRestarts(cond)
[15:33:06.114]                           for (restart in restarts) {
[15:33:06.114]                             name <- restart$name
[15:33:06.114]                             if (is.null(name)) 
[15:33:06.114]                               next
[15:33:06.114]                             if (!grepl(pattern, name)) 
[15:33:06.114]                               next
[15:33:06.114]                             invokeRestart(restart)
[15:33:06.114]                             muffled <- TRUE
[15:33:06.114]                             break
[15:33:06.114]                           }
[15:33:06.114]                         }
[15:33:06.114]                       }
[15:33:06.114]                       invisible(muffled)
[15:33:06.114]                     }
[15:33:06.114]                     muffleCondition(cond, pattern = "^muffle")
[15:33:06.114]                   }
[15:33:06.114]                 }
[15:33:06.114]                 else {
[15:33:06.114]                   if (TRUE) {
[15:33:06.114]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:33:06.114]                     {
[15:33:06.114]                       inherits <- base::inherits
[15:33:06.114]                       invokeRestart <- base::invokeRestart
[15:33:06.114]                       is.null <- base::is.null
[15:33:06.114]                       muffled <- FALSE
[15:33:06.114]                       if (inherits(cond, "message")) {
[15:33:06.114]                         muffled <- grepl(pattern, "muffleMessage")
[15:33:06.114]                         if (muffled) 
[15:33:06.114]                           invokeRestart("muffleMessage")
[15:33:06.114]                       }
[15:33:06.114]                       else if (inherits(cond, "warning")) {
[15:33:06.114]                         muffled <- grepl(pattern, "muffleWarning")
[15:33:06.114]                         if (muffled) 
[15:33:06.114]                           invokeRestart("muffleWarning")
[15:33:06.114]                       }
[15:33:06.114]                       else if (inherits(cond, "condition")) {
[15:33:06.114]                         if (!is.null(pattern)) {
[15:33:06.114]                           computeRestarts <- base::computeRestarts
[15:33:06.114]                           grepl <- base::grepl
[15:33:06.114]                           restarts <- computeRestarts(cond)
[15:33:06.114]                           for (restart in restarts) {
[15:33:06.114]                             name <- restart$name
[15:33:06.114]                             if (is.null(name)) 
[15:33:06.114]                               next
[15:33:06.114]                             if (!grepl(pattern, name)) 
[15:33:06.114]                               next
[15:33:06.114]                             invokeRestart(restart)
[15:33:06.114]                             muffled <- TRUE
[15:33:06.114]                             break
[15:33:06.114]                           }
[15:33:06.114]                         }
[15:33:06.114]                       }
[15:33:06.114]                       invisible(muffled)
[15:33:06.114]                     }
[15:33:06.114]                     muffleCondition(cond, pattern = "^muffle")
[15:33:06.114]                   }
[15:33:06.114]                 }
[15:33:06.114]             }
[15:33:06.114]         }))
[15:33:06.114]     }, error = function(ex) {
[15:33:06.114]         base::structure(base::list(value = NULL, visible = NULL, 
[15:33:06.114]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:33:06.114]                 ...future.rng), started = ...future.startTime, 
[15:33:06.114]             finished = Sys.time(), session_uuid = NA_character_, 
[15:33:06.114]             version = "1.8"), class = "FutureResult")
[15:33:06.114]     }, finally = {
[15:33:06.114]         if (!identical(...future.workdir, getwd())) 
[15:33:06.114]             setwd(...future.workdir)
[15:33:06.114]         {
[15:33:06.114]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:33:06.114]                 ...future.oldOptions$nwarnings <- NULL
[15:33:06.114]             }
[15:33:06.114]             base::options(...future.oldOptions)
[15:33:06.114]             if (.Platform$OS.type == "windows") {
[15:33:06.114]                 old_names <- names(...future.oldEnvVars)
[15:33:06.114]                 envs <- base::Sys.getenv()
[15:33:06.114]                 names <- names(envs)
[15:33:06.114]                 common <- intersect(names, old_names)
[15:33:06.114]                 added <- setdiff(names, old_names)
[15:33:06.114]                 removed <- setdiff(old_names, names)
[15:33:06.114]                 changed <- common[...future.oldEnvVars[common] != 
[15:33:06.114]                   envs[common]]
[15:33:06.114]                 NAMES <- toupper(changed)
[15:33:06.114]                 args <- list()
[15:33:06.114]                 for (kk in seq_along(NAMES)) {
[15:33:06.114]                   name <- changed[[kk]]
[15:33:06.114]                   NAME <- NAMES[[kk]]
[15:33:06.114]                   if (name != NAME && is.element(NAME, old_names)) 
[15:33:06.114]                     next
[15:33:06.114]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:33:06.114]                 }
[15:33:06.114]                 NAMES <- toupper(added)
[15:33:06.114]                 for (kk in seq_along(NAMES)) {
[15:33:06.114]                   name <- added[[kk]]
[15:33:06.114]                   NAME <- NAMES[[kk]]
[15:33:06.114]                   if (name != NAME && is.element(NAME, old_names)) 
[15:33:06.114]                     next
[15:33:06.114]                   args[[name]] <- ""
[15:33:06.114]                 }
[15:33:06.114]                 NAMES <- toupper(removed)
[15:33:06.114]                 for (kk in seq_along(NAMES)) {
[15:33:06.114]                   name <- removed[[kk]]
[15:33:06.114]                   NAME <- NAMES[[kk]]
[15:33:06.114]                   if (name != NAME && is.element(NAME, old_names)) 
[15:33:06.114]                     next
[15:33:06.114]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:33:06.114]                 }
[15:33:06.114]                 if (length(args) > 0) 
[15:33:06.114]                   base::do.call(base::Sys.setenv, args = args)
[15:33:06.114]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:33:06.114]             }
[15:33:06.114]             else {
[15:33:06.114]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:33:06.114]             }
[15:33:06.114]             {
[15:33:06.114]                 if (base::length(...future.futureOptionsAdded) > 
[15:33:06.114]                   0L) {
[15:33:06.114]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:33:06.114]                   base::names(opts) <- ...future.futureOptionsAdded
[15:33:06.114]                   base::options(opts)
[15:33:06.114]                 }
[15:33:06.114]                 {
[15:33:06.114]                   {
[15:33:06.114]                     base::options(mc.cores = ...future.mc.cores.old)
[15:33:06.114]                     NULL
[15:33:06.114]                   }
[15:33:06.114]                   options(future.plan = NULL)
[15:33:06.114]                   if (is.na(NA_character_)) 
[15:33:06.114]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:33:06.114]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:33:06.114]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:33:06.114]                     .init = FALSE)
[15:33:06.114]                 }
[15:33:06.114]             }
[15:33:06.114]         }
[15:33:06.114]     })
[15:33:06.114]     if (TRUE) {
[15:33:06.114]         base::sink(type = "output", split = FALSE)
[15:33:06.114]         if (TRUE) {
[15:33:06.114]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:33:06.114]         }
[15:33:06.114]         else {
[15:33:06.114]             ...future.result["stdout"] <- base::list(NULL)
[15:33:06.114]         }
[15:33:06.114]         base::close(...future.stdout)
[15:33:06.114]         ...future.stdout <- NULL
[15:33:06.114]     }
[15:33:06.114]     ...future.result$conditions <- ...future.conditions
[15:33:06.114]     ...future.result$finished <- base::Sys.time()
[15:33:06.114]     ...future.result
[15:33:06.114] }
[15:33:06.124] Exporting 5 global objects (4.61 KiB) to cluster node #2 ...
[15:33:06.124] Exporting '...future.FUN' (4.61 KiB) to cluster node #2 ...
[15:33:06.125] Exporting '...future.FUN' (4.61 KiB) to cluster node #2 ... DONE
[15:33:06.126] Exporting 'future.call.arguments' (0 bytes) to cluster node #2 ...
[15:33:06.127] Exporting 'future.call.arguments' (0 bytes) to cluster node #2 ... DONE
[15:33:06.127] Exporting '...future.elements_ii' (56 bytes) to cluster node #2 ...
[15:33:06.128] Exporting '...future.elements_ii' (56 bytes) to cluster node #2 ... DONE
[15:33:06.129] Exporting '...future.seeds_ii' (0 bytes) to cluster node #2 ...
[15:33:06.130] Exporting '...future.seeds_ii' (0 bytes) to cluster node #2 ... DONE
[15:33:06.130] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #2 ...
[15:33:06.131] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #2 ... DONE
[15:33:06.132] Exporting 5 global objects (4.61 KiB) to cluster node #2 ... DONE
[15:33:06.133] MultisessionFuture started
[15:33:06.133] - Launch lazy future ... done
[15:33:06.133] run() for 'MultisessionFuture' ... done
[15:33:06.134] Created future:
[15:33:06.163] receiveMessageFromWorker() for ClusterFuture ...
[15:33:06.164] - Validating connection of MultisessionFuture
[15:33:06.164] - received message: FutureResult
[15:33:06.164] - Received FutureResult
[15:33:06.165] - Erased future from FutureRegistry
[15:33:06.165] result() for ClusterFuture ...
[15:33:06.165] - result already collected: FutureResult
[15:33:06.166] result() for ClusterFuture ... done
[15:33:06.166] receiveMessageFromWorker() for ClusterFuture ... done
[15:33:06.134] MultisessionFuture:
[15:33:06.134] Label: 'future_lapply-2'
[15:33:06.134] Expression:
[15:33:06.134] {
[15:33:06.134]     do.call(function(...) {
[15:33:06.134]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:33:06.134]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:33:06.134]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:33:06.134]             on.exit(options(oopts), add = TRUE)
[15:33:06.134]         }
[15:33:06.134]         {
[15:33:06.134]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:33:06.134]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:33:06.134]                 ...future.FUN(...future.X_jj, ...)
[15:33:06.134]             })
[15:33:06.134]         }
[15:33:06.134]     }, args = future.call.arguments)
[15:33:06.134] }
[15:33:06.134] Lazy evaluation: FALSE
[15:33:06.134] Asynchronous evaluation: TRUE
[15:33:06.134] Local evaluation: TRUE
[15:33:06.134] Environment: R_GlobalEnv
[15:33:06.134] Capture standard output: TRUE
[15:33:06.134] Capture condition classes: 'condition' (excluding 'nothing')
[15:33:06.134] Globals: 5 objects totaling 4.66 KiB (function '...future.FUN' of 4.61 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 56 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:33:06.134] Packages: <none>
[15:33:06.134] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:33:06.134] Resolved: TRUE
[15:33:06.134] Value: <not collected>
[15:33:06.134] Conditions captured: <none>
[15:33:06.134] Early signaling: FALSE
[15:33:06.134] Owner process: bdd4bc13-919d-bf34-b2cf-84eb53f6e11f
[15:33:06.134] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:33:06.167] Chunk #2 of 2 ... DONE
[15:33:06.167] Launching 2 futures (chunks) ... DONE
[15:33:06.167] Resolving 2 futures (chunks) ...
[15:33:06.167] resolve() on list ...
[15:33:06.168]  recursive: 0
[15:33:06.168]  length: 2
[15:33:06.168] 
[15:33:06.359] Future #2
[15:33:06.360] result() for ClusterFuture ...
[15:33:06.360] - result already collected: FutureResult
[15:33:06.360] result() for ClusterFuture ... done
[15:33:06.360] result() for ClusterFuture ...
[15:33:06.361] - result already collected: FutureResult
[15:33:06.361] result() for ClusterFuture ... done
[15:33:06.361] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:33:06.362] - nx: 2
[15:33:06.362] - relay: TRUE
[15:33:06.362] - stdout: TRUE
[15:33:06.362] - signal: TRUE
[15:33:06.363] - resignal: FALSE
[15:33:06.363] - force: TRUE
[15:33:06.363] - relayed: [n=2] FALSE, FALSE
[15:33:06.363] - queued futures: [n=2] FALSE, FALSE
[15:33:06.364]  - until=1
[15:33:06.364]  - relaying element #1
[15:33:06.364] - relayed: [n=2] FALSE, FALSE
[15:33:06.365] - queued futures: [n=2] FALSE, TRUE
[15:33:06.365] signalConditionsASAP(NULL, pos=2) ... done
[15:33:06.365]  length: 1 (resolved future 2)
[15:33:06.415] receiveMessageFromWorker() for ClusterFuture ...
[15:33:06.416] - Validating connection of MultisessionFuture
[15:33:06.416] - received message: FutureResult
[15:33:06.417] - Received FutureResult
[15:33:06.417] - Erased future from FutureRegistry
[15:33:06.417] result() for ClusterFuture ...
[15:33:06.418] - result already collected: FutureResult
[15:33:06.418] result() for ClusterFuture ... done
[15:33:06.418] receiveMessageFromWorker() for ClusterFuture ... done
[15:33:06.418] Future #1
[15:33:06.419] result() for ClusterFuture ...
[15:33:06.419] - result already collected: FutureResult
[15:33:06.419] result() for ClusterFuture ... done
[15:33:06.419] result() for ClusterFuture ...
[15:33:06.420] - result already collected: FutureResult
[15:33:06.420] result() for ClusterFuture ... done
[15:33:06.420] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:33:06.420] - nx: 2
[15:33:06.420] - relay: TRUE
[15:33:06.421] - stdout: TRUE
[15:33:06.421] - signal: TRUE
[15:33:06.421] - resignal: FALSE
[15:33:06.421] - force: TRUE
[15:33:06.422] - relayed: [n=2] FALSE, FALSE
[15:33:06.422] - queued futures: [n=2] FALSE, TRUE
[15:33:06.422]  - until=1
[15:33:06.423]  - relaying element #1
[15:33:06.423] result() for ClusterFuture ...
[15:33:06.423] - result already collected: FutureResult
[15:33:06.424] result() for ClusterFuture ... done
[15:33:06.424] result() for ClusterFuture ...
[15:33:06.424] - result already collected: FutureResult
[15:33:06.425] result() for ClusterFuture ... done
[15:33:06.425] result() for ClusterFuture ...
[15:33:06.425] - result already collected: FutureResult
[15:33:06.426] result() for ClusterFuture ... done
[15:33:06.426] result() for ClusterFuture ...
[15:33:06.426] - result already collected: FutureResult
[15:33:06.427] result() for ClusterFuture ... done
[15:33:06.427] - relayed: [n=2] TRUE, FALSE
[15:33:06.427] - queued futures: [n=2] TRUE, TRUE
[15:33:06.428] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:33:06.428]  length: 0 (resolved future 1)
[15:33:06.428] Relaying remaining futures
[15:33:06.429] signalConditionsASAP(NULL, pos=0) ...
[15:33:06.429] - nx: 2
[15:33:06.429] - relay: TRUE
[15:33:06.430] - stdout: TRUE
[15:33:06.430] - signal: TRUE
[15:33:06.430] - resignal: FALSE
[15:33:06.431] - force: TRUE
[15:33:06.431] - relayed: [n=2] TRUE, FALSE
[15:33:06.431] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:33:06.432]  - relaying element #2
[15:33:06.432] result() for ClusterFuture ...
[15:33:06.433] - result already collected: FutureResult
[15:33:06.433] result() for ClusterFuture ... done
[15:33:06.433] result() for ClusterFuture ...
[15:33:06.434] - result already collected: FutureResult
[15:33:06.434] result() for ClusterFuture ... done
[15:33:06.435] result() for ClusterFuture ...
[15:33:06.435] - result already collected: FutureResult
[15:33:06.435] result() for ClusterFuture ... done
[15:33:06.435] result() for ClusterFuture ...
[15:33:06.436] - result already collected: FutureResult
[15:33:06.436] result() for ClusterFuture ... done
[15:33:06.436] - relayed: [n=2] TRUE, TRUE
[15:33:06.436] - queued futures: [n=2] TRUE, TRUE
[15:33:06.437] signalConditionsASAP(MultisessionFuture, pos=0) ... done
[15:33:06.437] resolve() on list ... DONE
[15:33:06.437] result() for ClusterFuture ...
[15:33:06.437] - result already collected: FutureResult
[15:33:06.438] result() for ClusterFuture ... done
[15:33:06.438] result() for ClusterFuture ...
[15:33:06.438] - result already collected: FutureResult
[15:33:06.439] result() for ClusterFuture ... done
[15:33:06.439] result() for ClusterFuture ...
[15:33:06.439] - result already collected: FutureResult
[15:33:06.440] result() for ClusterFuture ... done
[15:33:06.440] result() for ClusterFuture ...
[15:33:06.440] - result already collected: FutureResult
[15:33:06.441] result() for ClusterFuture ... done
[15:33:06.441]  - Number of value chunks collected: 2
[15:33:06.441] Resolving 2 futures (chunks) ... DONE
[15:33:06.442] Reducing values from 2 chunks ...
[15:33:06.442]  - Number of values collected after concatenation: 2
[15:33:06.442]  - Number of values expected: 2
[15:33:06.443] Reducing values from 2 chunks ... DONE
[15:33:06.443] future_lapply() ... DONE
* future_lapply(x, ..., future.stdout = TRUE) ... DONE
* future_lapply(x, ..., future.stdout = NA) ...
[15:33:06.444] future_lapply() ...
[15:33:06.450] Number of chunks: 2
[15:33:06.450] getGlobalsAndPackagesXApply() ...
[15:33:06.450]  - future.globals: TRUE
[15:33:06.451] getGlobalsAndPackages() ...
[15:33:06.451] Searching for globals...
[15:33:06.458] - globals found: [5] 'FUN', '{', 'Sys.sleep', '/', 'print'
[15:33:06.458] Searching for globals ... DONE
[15:33:06.459] Resolving globals: FALSE
[15:33:06.460] The total size of the 1 globals is 4.61 KiB (4720 bytes)
[15:33:06.461] The total size of the 1 globals exported for future expression ('FUN()') is 4.61 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.61 KiB of class 'function')
[15:33:06.461] - globals: [1] 'FUN'
[15:33:06.461] 
[15:33:06.462] getGlobalsAndPackages() ... DONE
[15:33:06.462]  - globals found/used: [n=1] 'FUN'
[15:33:06.462]  - needed namespaces: [n=0] 
[15:33:06.463] Finding globals ... DONE
[15:33:06.463]  - use_args: TRUE
[15:33:06.463]  - Getting '...' globals ...
[15:33:06.464] resolve() on list ...
[15:33:06.464]  recursive: 0
[15:33:06.465]  length: 1
[15:33:06.465]  elements: '...'
[15:33:06.465]  length: 0 (resolved future 1)
[15:33:06.466] resolve() on list ... DONE
[15:33:06.466]    - '...' content: [n=0] 
[15:33:06.466] List of 1
[15:33:06.466]  $ ...: list()
[15:33:06.466]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:33:06.466]  - attr(*, "where")=List of 1
[15:33:06.466]   ..$ ...:<environment: 0x0000027fc3d12d18> 
[15:33:06.466]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:33:06.466]  - attr(*, "resolved")= logi TRUE
[15:33:06.466]  - attr(*, "total_size")= num NA
[15:33:06.472]  - Getting '...' globals ... DONE
[15:33:06.473] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:33:06.473] List of 2
[15:33:06.473]  $ ...future.FUN:function (x)  
[15:33:06.473]  $ ...          : list()
[15:33:06.473]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:33:06.473]  - attr(*, "where")=List of 2
[15:33:06.473]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:33:06.473]   ..$ ...          :<environment: 0x0000027fc3d12d18> 
[15:33:06.473]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:33:06.473]  - attr(*, "resolved")= logi FALSE
[15:33:06.473]  - attr(*, "total_size")= num 4720
[15:33:06.480] Packages to be attached in all futures: [n=0] 
[15:33:06.480] getGlobalsAndPackagesXApply() ... DONE
[15:33:06.481] Number of futures (= number of chunks): 2
[15:33:06.481] Launching 2 futures (chunks) ...
[15:33:06.482] Chunk #1 of 2 ...
[15:33:06.482]  - Finding globals in 'X' for chunk #1 ...
[15:33:06.482] getGlobalsAndPackages() ...
[15:33:06.483] Searching for globals...
[15:33:06.484] 
[15:33:06.484] Searching for globals ... DONE
[15:33:06.484] - globals: [0] <none>
[15:33:06.485] getGlobalsAndPackages() ... DONE
[15:33:06.485]    + additional globals found: [n=0] 
[15:33:06.485]    + additional namespaces needed: [n=0] 
[15:33:06.486]  - Finding globals in 'X' for chunk #1 ... DONE
[15:33:06.486]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:33:06.486]  - seeds: <none>
[15:33:06.487]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:33:06.487] getGlobalsAndPackages() ...
[15:33:06.487] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:33:06.488] Resolving globals: FALSE
[15:33:06.488] Tweak future expression to call with '...' arguments ...
[15:33:06.489] {
[15:33:06.489]     do.call(function(...) {
[15:33:06.489]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:33:06.489]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:33:06.489]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:33:06.489]             on.exit(options(oopts), add = TRUE)
[15:33:06.489]         }
[15:33:06.489]         {
[15:33:06.489]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:33:06.489]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:33:06.489]                 ...future.FUN(...future.X_jj, ...)
[15:33:06.489]             })
[15:33:06.489]         }
[15:33:06.489]     }, args = future.call.arguments)
[15:33:06.489] }
[15:33:06.490] Tweak future expression to call with '...' arguments ... DONE
[15:33:06.491] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:33:06.491] 
[15:33:06.491] getGlobalsAndPackages() ... DONE
[15:33:06.492] run() for 'Future' ...
[15:33:06.492] - state: 'created'
[15:33:06.493] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:33:06.513] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:33:06.513] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:33:06.514]   - Field: 'node'
[15:33:06.514]   - Field: 'label'
[15:33:06.514]   - Field: 'local'
[15:33:06.515]   - Field: 'owner'
[15:33:06.515]   - Field: 'envir'
[15:33:06.515]   - Field: 'workers'
[15:33:06.515]   - Field: 'packages'
[15:33:06.516]   - Field: 'gc'
[15:33:06.516]   - Field: 'conditions'
[15:33:06.516]   - Field: 'persistent'
[15:33:06.517]   - Field: 'expr'
[15:33:06.517]   - Field: 'uuid'
[15:33:06.517]   - Field: 'seed'
[15:33:06.518]   - Field: 'version'
[15:33:06.518]   - Field: 'result'
[15:33:06.518]   - Field: 'asynchronous'
[15:33:06.519]   - Field: 'calls'
[15:33:06.519]   - Field: 'globals'
[15:33:06.519]   - Field: 'stdout'
[15:33:06.519]   - Field: 'earlySignal'
[15:33:06.520]   - Field: 'lazy'
[15:33:06.520]   - Field: 'state'
[15:33:06.520] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:33:06.521] - Launch lazy future ...
[15:33:06.521] Packages needed by the future expression (n = 0): <none>
[15:33:06.522] Packages needed by future strategies (n = 0): <none>
[15:33:06.523] {
[15:33:06.523]     {
[15:33:06.523]         {
[15:33:06.523]             ...future.startTime <- base::Sys.time()
[15:33:06.523]             {
[15:33:06.523]                 {
[15:33:06.523]                   {
[15:33:06.523]                     {
[15:33:06.523]                       base::local({
[15:33:06.523]                         has_future <- base::requireNamespace("future", 
[15:33:06.523]                           quietly = TRUE)
[15:33:06.523]                         if (has_future) {
[15:33:06.523]                           ns <- base::getNamespace("future")
[15:33:06.523]                           version <- ns[[".package"]][["version"]]
[15:33:06.523]                           if (is.null(version)) 
[15:33:06.523]                             version <- utils::packageVersion("future")
[15:33:06.523]                         }
[15:33:06.523]                         else {
[15:33:06.523]                           version <- NULL
[15:33:06.523]                         }
[15:33:06.523]                         if (!has_future || version < "1.8.0") {
[15:33:06.523]                           info <- base::c(r_version = base::gsub("R version ", 
[15:33:06.523]                             "", base::R.version$version.string), 
[15:33:06.523]                             platform = base::sprintf("%s (%s-bit)", 
[15:33:06.523]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:33:06.523]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:33:06.523]                               "release", "version")], collapse = " "), 
[15:33:06.523]                             hostname = base::Sys.info()[["nodename"]])
[15:33:06.523]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:33:06.523]                             info)
[15:33:06.523]                           info <- base::paste(info, collapse = "; ")
[15:33:06.523]                           if (!has_future) {
[15:33:06.523]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:33:06.523]                               info)
[15:33:06.523]                           }
[15:33:06.523]                           else {
[15:33:06.523]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:33:06.523]                               info, version)
[15:33:06.523]                           }
[15:33:06.523]                           base::stop(msg)
[15:33:06.523]                         }
[15:33:06.523]                       })
[15:33:06.523]                     }
[15:33:06.523]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:33:06.523]                     base::options(mc.cores = 1L)
[15:33:06.523]                   }
[15:33:06.523]                   ...future.strategy.old <- future::plan("list")
[15:33:06.523]                   options(future.plan = NULL)
[15:33:06.523]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:33:06.523]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:33:06.523]                 }
[15:33:06.523]                 ...future.workdir <- getwd()
[15:33:06.523]             }
[15:33:06.523]             ...future.oldOptions <- base::as.list(base::.Options)
[15:33:06.523]             ...future.oldEnvVars <- base::Sys.getenv()
[15:33:06.523]         }
[15:33:06.523]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:33:06.523]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:33:06.523]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:33:06.523]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:33:06.523]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:33:06.523]             future.stdout.windows.reencode = NULL, width = 80L)
[15:33:06.523]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:33:06.523]             base::names(...future.oldOptions))
[15:33:06.523]     }
[15:33:06.523]     if (TRUE) {
[15:33:06.523]     }
[15:33:06.523]     else {
[15:33:06.523]         if (NA) {
[15:33:06.523]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:33:06.523]                 open = "w")
[15:33:06.523]         }
[15:33:06.523]         else {
[15:33:06.523]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:33:06.523]                 windows = "NUL", "/dev/null"), open = "w")
[15:33:06.523]         }
[15:33:06.523]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:33:06.523]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:33:06.523]             base::sink(type = "output", split = FALSE)
[15:33:06.523]             base::close(...future.stdout)
[15:33:06.523]         }, add = TRUE)
[15:33:06.523]     }
[15:33:06.523]     ...future.frame <- base::sys.nframe()
[15:33:06.523]     ...future.conditions <- base::list()
[15:33:06.523]     ...future.rng <- base::globalenv()$.Random.seed
[15:33:06.523]     if (FALSE) {
[15:33:06.523]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:33:06.523]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:33:06.523]     }
[15:33:06.523]     ...future.result <- base::tryCatch({
[15:33:06.523]         base::withCallingHandlers({
[15:33:06.523]             ...future.value <- base::withVisible(base::local({
[15:33:06.523]                 ...future.makeSendCondition <- base::local({
[15:33:06.523]                   sendCondition <- NULL
[15:33:06.523]                   function(frame = 1L) {
[15:33:06.523]                     if (is.function(sendCondition)) 
[15:33:06.523]                       return(sendCondition)
[15:33:06.523]                     ns <- getNamespace("parallel")
[15:33:06.523]                     if (exists("sendData", mode = "function", 
[15:33:06.523]                       envir = ns)) {
[15:33:06.523]                       parallel_sendData <- get("sendData", mode = "function", 
[15:33:06.523]                         envir = ns)
[15:33:06.523]                       envir <- sys.frame(frame)
[15:33:06.523]                       master <- NULL
[15:33:06.523]                       while (!identical(envir, .GlobalEnv) && 
[15:33:06.523]                         !identical(envir, emptyenv())) {
[15:33:06.523]                         if (exists("master", mode = "list", envir = envir, 
[15:33:06.523]                           inherits = FALSE)) {
[15:33:06.523]                           master <- get("master", mode = "list", 
[15:33:06.523]                             envir = envir, inherits = FALSE)
[15:33:06.523]                           if (inherits(master, c("SOCKnode", 
[15:33:06.523]                             "SOCK0node"))) {
[15:33:06.523]                             sendCondition <<- function(cond) {
[15:33:06.523]                               data <- list(type = "VALUE", value = cond, 
[15:33:06.523]                                 success = TRUE)
[15:33:06.523]                               parallel_sendData(master, data)
[15:33:06.523]                             }
[15:33:06.523]                             return(sendCondition)
[15:33:06.523]                           }
[15:33:06.523]                         }
[15:33:06.523]                         frame <- frame + 1L
[15:33:06.523]                         envir <- sys.frame(frame)
[15:33:06.523]                       }
[15:33:06.523]                     }
[15:33:06.523]                     sendCondition <<- function(cond) NULL
[15:33:06.523]                   }
[15:33:06.523]                 })
[15:33:06.523]                 withCallingHandlers({
[15:33:06.523]                   {
[15:33:06.523]                     do.call(function(...) {
[15:33:06.523]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:33:06.523]                       if (!identical(...future.globals.maxSize.org, 
[15:33:06.523]                         ...future.globals.maxSize)) {
[15:33:06.523]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:33:06.523]                         on.exit(options(oopts), add = TRUE)
[15:33:06.523]                       }
[15:33:06.523]                       {
[15:33:06.523]                         lapply(seq_along(...future.elements_ii), 
[15:33:06.523]                           FUN = function(jj) {
[15:33:06.523]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:33:06.523]                             ...future.FUN(...future.X_jj, ...)
[15:33:06.523]                           })
[15:33:06.523]                       }
[15:33:06.523]                     }, args = future.call.arguments)
[15:33:06.523]                   }
[15:33:06.523]                 }, immediateCondition = function(cond) {
[15:33:06.523]                   sendCondition <- ...future.makeSendCondition()
[15:33:06.523]                   sendCondition(cond)
[15:33:06.523]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:33:06.523]                   {
[15:33:06.523]                     inherits <- base::inherits
[15:33:06.523]                     invokeRestart <- base::invokeRestart
[15:33:06.523]                     is.null <- base::is.null
[15:33:06.523]                     muffled <- FALSE
[15:33:06.523]                     if (inherits(cond, "message")) {
[15:33:06.523]                       muffled <- grepl(pattern, "muffleMessage")
[15:33:06.523]                       if (muffled) 
[15:33:06.523]                         invokeRestart("muffleMessage")
[15:33:06.523]                     }
[15:33:06.523]                     else if (inherits(cond, "warning")) {
[15:33:06.523]                       muffled <- grepl(pattern, "muffleWarning")
[15:33:06.523]                       if (muffled) 
[15:33:06.523]                         invokeRestart("muffleWarning")
[15:33:06.523]                     }
[15:33:06.523]                     else if (inherits(cond, "condition")) {
[15:33:06.523]                       if (!is.null(pattern)) {
[15:33:06.523]                         computeRestarts <- base::computeRestarts
[15:33:06.523]                         grepl <- base::grepl
[15:33:06.523]                         restarts <- computeRestarts(cond)
[15:33:06.523]                         for (restart in restarts) {
[15:33:06.523]                           name <- restart$name
[15:33:06.523]                           if (is.null(name)) 
[15:33:06.523]                             next
[15:33:06.523]                           if (!grepl(pattern, name)) 
[15:33:06.523]                             next
[15:33:06.523]                           invokeRestart(restart)
[15:33:06.523]                           muffled <- TRUE
[15:33:06.523]                           break
[15:33:06.523]                         }
[15:33:06.523]                       }
[15:33:06.523]                     }
[15:33:06.523]                     invisible(muffled)
[15:33:06.523]                   }
[15:33:06.523]                   muffleCondition(cond)
[15:33:06.523]                 })
[15:33:06.523]             }))
[15:33:06.523]             future::FutureResult(value = ...future.value$value, 
[15:33:06.523]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:33:06.523]                   ...future.rng), globalenv = if (FALSE) 
[15:33:06.523]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:33:06.523]                     ...future.globalenv.names))
[15:33:06.523]                 else NULL, started = ...future.startTime, version = "1.8")
[15:33:06.523]         }, condition = base::local({
[15:33:06.523]             c <- base::c
[15:33:06.523]             inherits <- base::inherits
[15:33:06.523]             invokeRestart <- base::invokeRestart
[15:33:06.523]             length <- base::length
[15:33:06.523]             list <- base::list
[15:33:06.523]             seq.int <- base::seq.int
[15:33:06.523]             signalCondition <- base::signalCondition
[15:33:06.523]             sys.calls <- base::sys.calls
[15:33:06.523]             `[[` <- base::`[[`
[15:33:06.523]             `+` <- base::`+`
[15:33:06.523]             `<<-` <- base::`<<-`
[15:33:06.523]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:33:06.523]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:33:06.523]                   3L)]
[15:33:06.523]             }
[15:33:06.523]             function(cond) {
[15:33:06.523]                 is_error <- inherits(cond, "error")
[15:33:06.523]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:33:06.523]                   NULL)
[15:33:06.523]                 if (is_error) {
[15:33:06.523]                   sessionInformation <- function() {
[15:33:06.523]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:33:06.523]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:33:06.523]                       search = base::search(), system = base::Sys.info())
[15:33:06.523]                   }
[15:33:06.523]                   ...future.conditions[[length(...future.conditions) + 
[15:33:06.523]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:33:06.523]                     cond$call), session = sessionInformation(), 
[15:33:06.523]                     timestamp = base::Sys.time(), signaled = 0L)
[15:33:06.523]                   signalCondition(cond)
[15:33:06.523]                 }
[15:33:06.523]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:33:06.523]                 "immediateCondition"))) {
[15:33:06.523]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:33:06.523]                   ...future.conditions[[length(...future.conditions) + 
[15:33:06.523]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:33:06.523]                   if (TRUE && !signal) {
[15:33:06.523]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:33:06.523]                     {
[15:33:06.523]                       inherits <- base::inherits
[15:33:06.523]                       invokeRestart <- base::invokeRestart
[15:33:06.523]                       is.null <- base::is.null
[15:33:06.523]                       muffled <- FALSE
[15:33:06.523]                       if (inherits(cond, "message")) {
[15:33:06.523]                         muffled <- grepl(pattern, "muffleMessage")
[15:33:06.523]                         if (muffled) 
[15:33:06.523]                           invokeRestart("muffleMessage")
[15:33:06.523]                       }
[15:33:06.523]                       else if (inherits(cond, "warning")) {
[15:33:06.523]                         muffled <- grepl(pattern, "muffleWarning")
[15:33:06.523]                         if (muffled) 
[15:33:06.523]                           invokeRestart("muffleWarning")
[15:33:06.523]                       }
[15:33:06.523]                       else if (inherits(cond, "condition")) {
[15:33:06.523]                         if (!is.null(pattern)) {
[15:33:06.523]                           computeRestarts <- base::computeRestarts
[15:33:06.523]                           grepl <- base::grepl
[15:33:06.523]                           restarts <- computeRestarts(cond)
[15:33:06.523]                           for (restart in restarts) {
[15:33:06.523]                             name <- restart$name
[15:33:06.523]                             if (is.null(name)) 
[15:33:06.523]                               next
[15:33:06.523]                             if (!grepl(pattern, name)) 
[15:33:06.523]                               next
[15:33:06.523]                             invokeRestart(restart)
[15:33:06.523]                             muffled <- TRUE
[15:33:06.523]                             break
[15:33:06.523]                           }
[15:33:06.523]                         }
[15:33:06.523]                       }
[15:33:06.523]                       invisible(muffled)
[15:33:06.523]                     }
[15:33:06.523]                     muffleCondition(cond, pattern = "^muffle")
[15:33:06.523]                   }
[15:33:06.523]                 }
[15:33:06.523]                 else {
[15:33:06.523]                   if (TRUE) {
[15:33:06.523]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:33:06.523]                     {
[15:33:06.523]                       inherits <- base::inherits
[15:33:06.523]                       invokeRestart <- base::invokeRestart
[15:33:06.523]                       is.null <- base::is.null
[15:33:06.523]                       muffled <- FALSE
[15:33:06.523]                       if (inherits(cond, "message")) {
[15:33:06.523]                         muffled <- grepl(pattern, "muffleMessage")
[15:33:06.523]                         if (muffled) 
[15:33:06.523]                           invokeRestart("muffleMessage")
[15:33:06.523]                       }
[15:33:06.523]                       else if (inherits(cond, "warning")) {
[15:33:06.523]                         muffled <- grepl(pattern, "muffleWarning")
[15:33:06.523]                         if (muffled) 
[15:33:06.523]                           invokeRestart("muffleWarning")
[15:33:06.523]                       }
[15:33:06.523]                       else if (inherits(cond, "condition")) {
[15:33:06.523]                         if (!is.null(pattern)) {
[15:33:06.523]                           computeRestarts <- base::computeRestarts
[15:33:06.523]                           grepl <- base::grepl
[15:33:06.523]                           restarts <- computeRestarts(cond)
[15:33:06.523]                           for (restart in restarts) {
[15:33:06.523]                             name <- restart$name
[15:33:06.523]                             if (is.null(name)) 
[15:33:06.523]                               next
[15:33:06.523]                             if (!grepl(pattern, name)) 
[15:33:06.523]                               next
[15:33:06.523]                             invokeRestart(restart)
[15:33:06.523]                             muffled <- TRUE
[15:33:06.523]                             break
[15:33:06.523]                           }
[15:33:06.523]                         }
[15:33:06.523]                       }
[15:33:06.523]                       invisible(muffled)
[15:33:06.523]                     }
[15:33:06.523]                     muffleCondition(cond, pattern = "^muffle")
[15:33:06.523]                   }
[15:33:06.523]                 }
[15:33:06.523]             }
[15:33:06.523]         }))
[15:33:06.523]     }, error = function(ex) {
[15:33:06.523]         base::structure(base::list(value = NULL, visible = NULL, 
[15:33:06.523]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:33:06.523]                 ...future.rng), started = ...future.startTime, 
[15:33:06.523]             finished = Sys.time(), session_uuid = NA_character_, 
[15:33:06.523]             version = "1.8"), class = "FutureResult")
[15:33:06.523]     }, finally = {
[15:33:06.523]         if (!identical(...future.workdir, getwd())) 
[15:33:06.523]             setwd(...future.workdir)
[15:33:06.523]         {
[15:33:06.523]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:33:06.523]                 ...future.oldOptions$nwarnings <- NULL
[15:33:06.523]             }
[15:33:06.523]             base::options(...future.oldOptions)
[15:33:06.523]             if (.Platform$OS.type == "windows") {
[15:33:06.523]                 old_names <- names(...future.oldEnvVars)
[15:33:06.523]                 envs <- base::Sys.getenv()
[15:33:06.523]                 names <- names(envs)
[15:33:06.523]                 common <- intersect(names, old_names)
[15:33:06.523]                 added <- setdiff(names, old_names)
[15:33:06.523]                 removed <- setdiff(old_names, names)
[15:33:06.523]                 changed <- common[...future.oldEnvVars[common] != 
[15:33:06.523]                   envs[common]]
[15:33:06.523]                 NAMES <- toupper(changed)
[15:33:06.523]                 args <- list()
[15:33:06.523]                 for (kk in seq_along(NAMES)) {
[15:33:06.523]                   name <- changed[[kk]]
[15:33:06.523]                   NAME <- NAMES[[kk]]
[15:33:06.523]                   if (name != NAME && is.element(NAME, old_names)) 
[15:33:06.523]                     next
[15:33:06.523]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:33:06.523]                 }
[15:33:06.523]                 NAMES <- toupper(added)
[15:33:06.523]                 for (kk in seq_along(NAMES)) {
[15:33:06.523]                   name <- added[[kk]]
[15:33:06.523]                   NAME <- NAMES[[kk]]
[15:33:06.523]                   if (name != NAME && is.element(NAME, old_names)) 
[15:33:06.523]                     next
[15:33:06.523]                   args[[name]] <- ""
[15:33:06.523]                 }
[15:33:06.523]                 NAMES <- toupper(removed)
[15:33:06.523]                 for (kk in seq_along(NAMES)) {
[15:33:06.523]                   name <- removed[[kk]]
[15:33:06.523]                   NAME <- NAMES[[kk]]
[15:33:06.523]                   if (name != NAME && is.element(NAME, old_names)) 
[15:33:06.523]                     next
[15:33:06.523]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:33:06.523]                 }
[15:33:06.523]                 if (length(args) > 0) 
[15:33:06.523]                   base::do.call(base::Sys.setenv, args = args)
[15:33:06.523]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:33:06.523]             }
[15:33:06.523]             else {
[15:33:06.523]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:33:06.523]             }
[15:33:06.523]             {
[15:33:06.523]                 if (base::length(...future.futureOptionsAdded) > 
[15:33:06.523]                   0L) {
[15:33:06.523]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:33:06.523]                   base::names(opts) <- ...future.futureOptionsAdded
[15:33:06.523]                   base::options(opts)
[15:33:06.523]                 }
[15:33:06.523]                 {
[15:33:06.523]                   {
[15:33:06.523]                     base::options(mc.cores = ...future.mc.cores.old)
[15:33:06.523]                     NULL
[15:33:06.523]                   }
[15:33:06.523]                   options(future.plan = NULL)
[15:33:06.523]                   if (is.na(NA_character_)) 
[15:33:06.523]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:33:06.523]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:33:06.523]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:33:06.523]                     .init = FALSE)
[15:33:06.523]                 }
[15:33:06.523]             }
[15:33:06.523]         }
[15:33:06.523]     })
[15:33:06.523]     if (FALSE) {
[15:33:06.523]         base::sink(type = "output", split = FALSE)
[15:33:06.523]         if (NA) {
[15:33:06.523]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:33:06.523]         }
[15:33:06.523]         else {
[15:33:06.523]             ...future.result["stdout"] <- base::list(NULL)
[15:33:06.523]         }
[15:33:06.523]         base::close(...future.stdout)
[15:33:06.523]         ...future.stdout <- NULL
[15:33:06.523]     }
[15:33:06.523]     ...future.result$conditions <- ...future.conditions
[15:33:06.523]     ...future.result$finished <- base::Sys.time()
[15:33:06.523]     ...future.result
[15:33:06.523] }
[15:33:06.531] Exporting 5 global objects (4.61 KiB) to cluster node #1 ...
[15:33:06.532] Exporting '...future.FUN' (4.61 KiB) to cluster node #1 ...
[15:33:06.532] Exporting '...future.FUN' (4.61 KiB) to cluster node #1 ... DONE
[15:33:06.533] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:33:06.534] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:33:06.534] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ...
[15:33:06.535] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ... DONE
[15:33:06.536] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:33:06.537] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:33:06.537] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:33:06.538] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:33:06.538] Exporting 5 global objects (4.61 KiB) to cluster node #1 ... DONE
[15:33:06.540] MultisessionFuture started
[15:33:06.540] - Launch lazy future ... done
[15:33:06.540] run() for 'MultisessionFuture' ... done
[15:33:06.541] Created future:
[15:33:06.541] MultisessionFuture:
[15:33:06.541] Label: 'future_lapply-1'
[15:33:06.541] Expression:
[15:33:06.541] {
[15:33:06.541]     do.call(function(...) {
[15:33:06.541]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:33:06.541]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:33:06.541]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:33:06.541]             on.exit(options(oopts), add = TRUE)
[15:33:06.541]         }
[15:33:06.541]         {
[15:33:06.541]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:33:06.541]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:33:06.541]                 ...future.FUN(...future.X_jj, ...)
[15:33:06.541]             })
[15:33:06.541]         }
[15:33:06.541]     }, args = future.call.arguments)
[15:33:06.541] }
[15:33:06.541] Lazy evaluation: FALSE
[15:33:06.541] Asynchronous evaluation: TRUE
[15:33:06.541] Local evaluation: TRUE
[15:33:06.541] Environment: R_GlobalEnv
[15:33:06.541] Capture standard output: NA
[15:33:06.541] Capture condition classes: 'condition' (excluding 'nothing')
[15:33:06.541] Globals: 5 objects totaling 4.66 KiB (function '...future.FUN' of 4.61 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 56 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:33:06.541] Packages: <none>
[15:33:06.541] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:33:06.541] Resolved: FALSE
[15:33:06.541] Value: <not collected>
[15:33:06.541] Conditions captured: <none>
[15:33:06.541] Early signaling: FALSE
[15:33:06.541] Owner process: bdd4bc13-919d-bf34-b2cf-84eb53f6e11f
[15:33:06.541] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:33:06.735] Chunk #1 of 2 ... DONE
[15:33:06.735] Chunk #2 of 2 ...
[15:33:06.735]  - Finding globals in 'X' for chunk #2 ...
[15:33:06.736] getGlobalsAndPackages() ...
[15:33:06.736] Searching for globals...
[15:33:06.736] 
[15:33:06.737] Searching for globals ... DONE
[15:33:06.737] - globals: [0] <none>
[15:33:06.737] getGlobalsAndPackages() ... DONE
[15:33:06.737]    + additional globals found: [n=0] 
[15:33:06.738]    + additional namespaces needed: [n=0] 
[15:33:06.738]  - Finding globals in 'X' for chunk #2 ... DONE
[15:33:06.738]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:33:06.738]  - seeds: <none>
[15:33:06.739]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:33:06.739] getGlobalsAndPackages() ...
[15:33:06.739] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:33:06.739] Resolving globals: FALSE
[15:33:06.740] Tweak future expression to call with '...' arguments ...
[15:33:06.740] {
[15:33:06.740]     do.call(function(...) {
[15:33:06.740]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:33:06.740]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:33:06.740]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:33:06.740]             on.exit(options(oopts), add = TRUE)
[15:33:06.740]         }
[15:33:06.740]         {
[15:33:06.740]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:33:06.740]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:33:06.740]                 ...future.FUN(...future.X_jj, ...)
[15:33:06.740]             })
[15:33:06.740]         }
[15:33:06.740]     }, args = future.call.arguments)
[15:33:06.740] }
[15:33:06.741] Tweak future expression to call with '...' arguments ... DONE
[15:33:06.741] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:33:06.742] 
[15:33:06.742] getGlobalsAndPackages() ... DONE
[15:33:06.742] run() for 'Future' ...
[15:33:06.743] - state: 'created'
[15:33:06.743] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:33:06.760] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:33:06.761] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:33:06.761]   - Field: 'node'
[15:33:06.761]   - Field: 'label'
[15:33:06.761]   - Field: 'local'
[15:33:06.762]   - Field: 'owner'
[15:33:06.762]   - Field: 'envir'
[15:33:06.762]   - Field: 'workers'
[15:33:06.763]   - Field: 'packages'
[15:33:06.763]   - Field: 'gc'
[15:33:06.763]   - Field: 'conditions'
[15:33:06.763]   - Field: 'persistent'
[15:33:06.764]   - Field: 'expr'
[15:33:06.764]   - Field: 'uuid'
[15:33:06.764]   - Field: 'seed'
[15:33:06.764]   - Field: 'version'
[15:33:06.765]   - Field: 'result'
[15:33:06.765]   - Field: 'asynchronous'
[15:33:06.765]   - Field: 'calls'
[15:33:06.765]   - Field: 'globals'
[15:33:06.766]   - Field: 'stdout'
[15:33:06.766]   - Field: 'earlySignal'
[15:33:06.766]   - Field: 'lazy'
[15:33:06.766]   - Field: 'state'
[15:33:06.767] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:33:06.767] - Launch lazy future ...
[15:33:06.767] Packages needed by the future expression (n = 0): <none>
[15:33:06.768] Packages needed by future strategies (n = 0): <none>
[15:33:06.768] {
[15:33:06.768]     {
[15:33:06.768]         {
[15:33:06.768]             ...future.startTime <- base::Sys.time()
[15:33:06.768]             {
[15:33:06.768]                 {
[15:33:06.768]                   {
[15:33:06.768]                     {
[15:33:06.768]                       base::local({
[15:33:06.768]                         has_future <- base::requireNamespace("future", 
[15:33:06.768]                           quietly = TRUE)
[15:33:06.768]                         if (has_future) {
[15:33:06.768]                           ns <- base::getNamespace("future")
[15:33:06.768]                           version <- ns[[".package"]][["version"]]
[15:33:06.768]                           if (is.null(version)) 
[15:33:06.768]                             version <- utils::packageVersion("future")
[15:33:06.768]                         }
[15:33:06.768]                         else {
[15:33:06.768]                           version <- NULL
[15:33:06.768]                         }
[15:33:06.768]                         if (!has_future || version < "1.8.0") {
[15:33:06.768]                           info <- base::c(r_version = base::gsub("R version ", 
[15:33:06.768]                             "", base::R.version$version.string), 
[15:33:06.768]                             platform = base::sprintf("%s (%s-bit)", 
[15:33:06.768]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:33:06.768]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:33:06.768]                               "release", "version")], collapse = " "), 
[15:33:06.768]                             hostname = base::Sys.info()[["nodename"]])
[15:33:06.768]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:33:06.768]                             info)
[15:33:06.768]                           info <- base::paste(info, collapse = "; ")
[15:33:06.768]                           if (!has_future) {
[15:33:06.768]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:33:06.768]                               info)
[15:33:06.768]                           }
[15:33:06.768]                           else {
[15:33:06.768]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:33:06.768]                               info, version)
[15:33:06.768]                           }
[15:33:06.768]                           base::stop(msg)
[15:33:06.768]                         }
[15:33:06.768]                       })
[15:33:06.768]                     }
[15:33:06.768]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:33:06.768]                     base::options(mc.cores = 1L)
[15:33:06.768]                   }
[15:33:06.768]                   ...future.strategy.old <- future::plan("list")
[15:33:06.768]                   options(future.plan = NULL)
[15:33:06.768]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:33:06.768]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:33:06.768]                 }
[15:33:06.768]                 ...future.workdir <- getwd()
[15:33:06.768]             }
[15:33:06.768]             ...future.oldOptions <- base::as.list(base::.Options)
[15:33:06.768]             ...future.oldEnvVars <- base::Sys.getenv()
[15:33:06.768]         }
[15:33:06.768]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:33:06.768]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:33:06.768]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:33:06.768]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:33:06.768]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:33:06.768]             future.stdout.windows.reencode = NULL, width = 80L)
[15:33:06.768]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:33:06.768]             base::names(...future.oldOptions))
[15:33:06.768]     }
[15:33:06.768]     if (TRUE) {
[15:33:06.768]     }
[15:33:06.768]     else {
[15:33:06.768]         if (NA) {
[15:33:06.768]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:33:06.768]                 open = "w")
[15:33:06.768]         }
[15:33:06.768]         else {
[15:33:06.768]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:33:06.768]                 windows = "NUL", "/dev/null"), open = "w")
[15:33:06.768]         }
[15:33:06.768]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:33:06.768]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:33:06.768]             base::sink(type = "output", split = FALSE)
[15:33:06.768]             base::close(...future.stdout)
[15:33:06.768]         }, add = TRUE)
[15:33:06.768]     }
[15:33:06.768]     ...future.frame <- base::sys.nframe()
[15:33:06.768]     ...future.conditions <- base::list()
[15:33:06.768]     ...future.rng <- base::globalenv()$.Random.seed
[15:33:06.768]     if (FALSE) {
[15:33:06.768]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:33:06.768]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:33:06.768]     }
[15:33:06.768]     ...future.result <- base::tryCatch({
[15:33:06.768]         base::withCallingHandlers({
[15:33:06.768]             ...future.value <- base::withVisible(base::local({
[15:33:06.768]                 ...future.makeSendCondition <- base::local({
[15:33:06.768]                   sendCondition <- NULL
[15:33:06.768]                   function(frame = 1L) {
[15:33:06.768]                     if (is.function(sendCondition)) 
[15:33:06.768]                       return(sendCondition)
[15:33:06.768]                     ns <- getNamespace("parallel")
[15:33:06.768]                     if (exists("sendData", mode = "function", 
[15:33:06.768]                       envir = ns)) {
[15:33:06.768]                       parallel_sendData <- get("sendData", mode = "function", 
[15:33:06.768]                         envir = ns)
[15:33:06.768]                       envir <- sys.frame(frame)
[15:33:06.768]                       master <- NULL
[15:33:06.768]                       while (!identical(envir, .GlobalEnv) && 
[15:33:06.768]                         !identical(envir, emptyenv())) {
[15:33:06.768]                         if (exists("master", mode = "list", envir = envir, 
[15:33:06.768]                           inherits = FALSE)) {
[15:33:06.768]                           master <- get("master", mode = "list", 
[15:33:06.768]                             envir = envir, inherits = FALSE)
[15:33:06.768]                           if (inherits(master, c("SOCKnode", 
[15:33:06.768]                             "SOCK0node"))) {
[15:33:06.768]                             sendCondition <<- function(cond) {
[15:33:06.768]                               data <- list(type = "VALUE", value = cond, 
[15:33:06.768]                                 success = TRUE)
[15:33:06.768]                               parallel_sendData(master, data)
[15:33:06.768]                             }
[15:33:06.768]                             return(sendCondition)
[15:33:06.768]                           }
[15:33:06.768]                         }
[15:33:06.768]                         frame <- frame + 1L
[15:33:06.768]                         envir <- sys.frame(frame)
[15:33:06.768]                       }
[15:33:06.768]                     }
[15:33:06.768]                     sendCondition <<- function(cond) NULL
[15:33:06.768]                   }
[15:33:06.768]                 })
[15:33:06.768]                 withCallingHandlers({
[15:33:06.768]                   {
[15:33:06.768]                     do.call(function(...) {
[15:33:06.768]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:33:06.768]                       if (!identical(...future.globals.maxSize.org, 
[15:33:06.768]                         ...future.globals.maxSize)) {
[15:33:06.768]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:33:06.768]                         on.exit(options(oopts), add = TRUE)
[15:33:06.768]                       }
[15:33:06.768]                       {
[15:33:06.768]                         lapply(seq_along(...future.elements_ii), 
[15:33:06.768]                           FUN = function(jj) {
[15:33:06.768]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:33:06.768]                             ...future.FUN(...future.X_jj, ...)
[15:33:06.768]                           })
[15:33:06.768]                       }
[15:33:06.768]                     }, args = future.call.arguments)
[15:33:06.768]                   }
[15:33:06.768]                 }, immediateCondition = function(cond) {
[15:33:06.768]                   sendCondition <- ...future.makeSendCondition()
[15:33:06.768]                   sendCondition(cond)
[15:33:06.768]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:33:06.768]                   {
[15:33:06.768]                     inherits <- base::inherits
[15:33:06.768]                     invokeRestart <- base::invokeRestart
[15:33:06.768]                     is.null <- base::is.null
[15:33:06.768]                     muffled <- FALSE
[15:33:06.768]                     if (inherits(cond, "message")) {
[15:33:06.768]                       muffled <- grepl(pattern, "muffleMessage")
[15:33:06.768]                       if (muffled) 
[15:33:06.768]                         invokeRestart("muffleMessage")
[15:33:06.768]                     }
[15:33:06.768]                     else if (inherits(cond, "warning")) {
[15:33:06.768]                       muffled <- grepl(pattern, "muffleWarning")
[15:33:06.768]                       if (muffled) 
[15:33:06.768]                         invokeRestart("muffleWarning")
[15:33:06.768]                     }
[15:33:06.768]                     else if (inherits(cond, "condition")) {
[15:33:06.768]                       if (!is.null(pattern)) {
[15:33:06.768]                         computeRestarts <- base::computeRestarts
[15:33:06.768]                         grepl <- base::grepl
[15:33:06.768]                         restarts <- computeRestarts(cond)
[15:33:06.768]                         for (restart in restarts) {
[15:33:06.768]                           name <- restart$name
[15:33:06.768]                           if (is.null(name)) 
[15:33:06.768]                             next
[15:33:06.768]                           if (!grepl(pattern, name)) 
[15:33:06.768]                             next
[15:33:06.768]                           invokeRestart(restart)
[15:33:06.768]                           muffled <- TRUE
[15:33:06.768]                           break
[15:33:06.768]                         }
[15:33:06.768]                       }
[15:33:06.768]                     }
[15:33:06.768]                     invisible(muffled)
[15:33:06.768]                   }
[15:33:06.768]                   muffleCondition(cond)
[15:33:06.768]                 })
[15:33:06.768]             }))
[15:33:06.768]             future::FutureResult(value = ...future.value$value, 
[15:33:06.768]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:33:06.768]                   ...future.rng), globalenv = if (FALSE) 
[15:33:06.768]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:33:06.768]                     ...future.globalenv.names))
[15:33:06.768]                 else NULL, started = ...future.startTime, version = "1.8")
[15:33:06.768]         }, condition = base::local({
[15:33:06.768]             c <- base::c
[15:33:06.768]             inherits <- base::inherits
[15:33:06.768]             invokeRestart <- base::invokeRestart
[15:33:06.768]             length <- base::length
[15:33:06.768]             list <- base::list
[15:33:06.768]             seq.int <- base::seq.int
[15:33:06.768]             signalCondition <- base::signalCondition
[15:33:06.768]             sys.calls <- base::sys.calls
[15:33:06.768]             `[[` <- base::`[[`
[15:33:06.768]             `+` <- base::`+`
[15:33:06.768]             `<<-` <- base::`<<-`
[15:33:06.768]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:33:06.768]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:33:06.768]                   3L)]
[15:33:06.768]             }
[15:33:06.768]             function(cond) {
[15:33:06.768]                 is_error <- inherits(cond, "error")
[15:33:06.768]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:33:06.768]                   NULL)
[15:33:06.768]                 if (is_error) {
[15:33:06.768]                   sessionInformation <- function() {
[15:33:06.768]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:33:06.768]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:33:06.768]                       search = base::search(), system = base::Sys.info())
[15:33:06.768]                   }
[15:33:06.768]                   ...future.conditions[[length(...future.conditions) + 
[15:33:06.768]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:33:06.768]                     cond$call), session = sessionInformation(), 
[15:33:06.768]                     timestamp = base::Sys.time(), signaled = 0L)
[15:33:06.768]                   signalCondition(cond)
[15:33:06.768]                 }
[15:33:06.768]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:33:06.768]                 "immediateCondition"))) {
[15:33:06.768]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:33:06.768]                   ...future.conditions[[length(...future.conditions) + 
[15:33:06.768]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:33:06.768]                   if (TRUE && !signal) {
[15:33:06.768]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:33:06.768]                     {
[15:33:06.768]                       inherits <- base::inherits
[15:33:06.768]                       invokeRestart <- base::invokeRestart
[15:33:06.768]                       is.null <- base::is.null
[15:33:06.768]                       muffled <- FALSE
[15:33:06.768]                       if (inherits(cond, "message")) {
[15:33:06.768]                         muffled <- grepl(pattern, "muffleMessage")
[15:33:06.768]                         if (muffled) 
[15:33:06.768]                           invokeRestart("muffleMessage")
[15:33:06.768]                       }
[15:33:06.768]                       else if (inherits(cond, "warning")) {
[15:33:06.768]                         muffled <- grepl(pattern, "muffleWarning")
[15:33:06.768]                         if (muffled) 
[15:33:06.768]                           invokeRestart("muffleWarning")
[15:33:06.768]                       }
[15:33:06.768]                       else if (inherits(cond, "condition")) {
[15:33:06.768]                         if (!is.null(pattern)) {
[15:33:06.768]                           computeRestarts <- base::computeRestarts
[15:33:06.768]                           grepl <- base::grepl
[15:33:06.768]                           restarts <- computeRestarts(cond)
[15:33:06.768]                           for (restart in restarts) {
[15:33:06.768]                             name <- restart$name
[15:33:06.768]                             if (is.null(name)) 
[15:33:06.768]                               next
[15:33:06.768]                             if (!grepl(pattern, name)) 
[15:33:06.768]                               next
[15:33:06.768]                             invokeRestart(restart)
[15:33:06.768]                             muffled <- TRUE
[15:33:06.768]                             break
[15:33:06.768]                           }
[15:33:06.768]                         }
[15:33:06.768]                       }
[15:33:06.768]                       invisible(muffled)
[15:33:06.768]                     }
[15:33:06.768]                     muffleCondition(cond, pattern = "^muffle")
[15:33:06.768]                   }
[15:33:06.768]                 }
[15:33:06.768]                 else {
[15:33:06.768]                   if (TRUE) {
[15:33:06.768]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:33:06.768]                     {
[15:33:06.768]                       inherits <- base::inherits
[15:33:06.768]                       invokeRestart <- base::invokeRestart
[15:33:06.768]                       is.null <- base::is.null
[15:33:06.768]                       muffled <- FALSE
[15:33:06.768]                       if (inherits(cond, "message")) {
[15:33:06.768]                         muffled <- grepl(pattern, "muffleMessage")
[15:33:06.768]                         if (muffled) 
[15:33:06.768]                           invokeRestart("muffleMessage")
[15:33:06.768]                       }
[15:33:06.768]                       else if (inherits(cond, "warning")) {
[15:33:06.768]                         muffled <- grepl(pattern, "muffleWarning")
[15:33:06.768]                         if (muffled) 
[15:33:06.768]                           invokeRestart("muffleWarning")
[15:33:06.768]                       }
[15:33:06.768]                       else if (inherits(cond, "condition")) {
[15:33:06.768]                         if (!is.null(pattern)) {
[15:33:06.768]                           computeRestarts <- base::computeRestarts
[15:33:06.768]                           grepl <- base::grepl
[15:33:06.768]                           restarts <- computeRestarts(cond)
[15:33:06.768]                           for (restart in restarts) {
[15:33:06.768]                             name <- restart$name
[15:33:06.768]                             if (is.null(name)) 
[15:33:06.768]                               next
[15:33:06.768]                             if (!grepl(pattern, name)) 
[15:33:06.768]                               next
[15:33:06.768]                             invokeRestart(restart)
[15:33:06.768]                             muffled <- TRUE
[15:33:06.768]                             break
[15:33:06.768]                           }
[15:33:06.768]                         }
[15:33:06.768]                       }
[15:33:06.768]                       invisible(muffled)
[15:33:06.768]                     }
[15:33:06.768]                     muffleCondition(cond, pattern = "^muffle")
[15:33:06.768]                   }
[15:33:06.768]                 }
[15:33:06.768]             }
[15:33:06.768]         }))
[15:33:06.768]     }, error = function(ex) {
[15:33:06.768]         base::structure(base::list(value = NULL, visible = NULL, 
[15:33:06.768]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:33:06.768]                 ...future.rng), started = ...future.startTime, 
[15:33:06.768]             finished = Sys.time(), session_uuid = NA_character_, 
[15:33:06.768]             version = "1.8"), class = "FutureResult")
[15:33:06.768]     }, finally = {
[15:33:06.768]         if (!identical(...future.workdir, getwd())) 
[15:33:06.768]             setwd(...future.workdir)
[15:33:06.768]         {
[15:33:06.768]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:33:06.768]                 ...future.oldOptions$nwarnings <- NULL
[15:33:06.768]             }
[15:33:06.768]             base::options(...future.oldOptions)
[15:33:06.768]             if (.Platform$OS.type == "windows") {
[15:33:06.768]                 old_names <- names(...future.oldEnvVars)
[15:33:06.768]                 envs <- base::Sys.getenv()
[15:33:06.768]                 names <- names(envs)
[15:33:06.768]                 common <- intersect(names, old_names)
[15:33:06.768]                 added <- setdiff(names, old_names)
[15:33:06.768]                 removed <- setdiff(old_names, names)
[15:33:06.768]                 changed <- common[...future.oldEnvVars[common] != 
[15:33:06.768]                   envs[common]]
[15:33:06.768]                 NAMES <- toupper(changed)
[15:33:06.768]                 args <- list()
[15:33:06.768]                 for (kk in seq_along(NAMES)) {
[15:33:06.768]                   name <- changed[[kk]]
[15:33:06.768]                   NAME <- NAMES[[kk]]
[15:33:06.768]                   if (name != NAME && is.element(NAME, old_names)) 
[15:33:06.768]                     next
[15:33:06.768]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:33:06.768]                 }
[15:33:06.768]                 NAMES <- toupper(added)
[15:33:06.768]                 for (kk in seq_along(NAMES)) {
[15:33:06.768]                   name <- added[[kk]]
[15:33:06.768]                   NAME <- NAMES[[kk]]
[15:33:06.768]                   if (name != NAME && is.element(NAME, old_names)) 
[15:33:06.768]                     next
[15:33:06.768]                   args[[name]] <- ""
[15:33:06.768]                 }
[15:33:06.768]                 NAMES <- toupper(removed)
[15:33:06.768]                 for (kk in seq_along(NAMES)) {
[15:33:06.768]                   name <- removed[[kk]]
[15:33:06.768]                   NAME <- NAMES[[kk]]
[15:33:06.768]                   if (name != NAME && is.element(NAME, old_names)) 
[15:33:06.768]                     next
[15:33:06.768]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:33:06.768]                 }
[15:33:06.768]                 if (length(args) > 0) 
[15:33:06.768]                   base::do.call(base::Sys.setenv, args = args)
[15:33:06.768]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:33:06.768]             }
[15:33:06.768]             else {
[15:33:06.768]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:33:06.768]             }
[15:33:06.768]             {
[15:33:06.768]                 if (base::length(...future.futureOptionsAdded) > 
[15:33:06.768]                   0L) {
[15:33:06.768]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:33:06.768]                   base::names(opts) <- ...future.futureOptionsAdded
[15:33:06.768]                   base::options(opts)
[15:33:06.768]                 }
[15:33:06.768]                 {
[15:33:06.768]                   {
[15:33:06.768]                     base::options(mc.cores = ...future.mc.cores.old)
[15:33:06.768]                     NULL
[15:33:06.768]                   }
[15:33:06.768]                   options(future.plan = NULL)
[15:33:06.768]                   if (is.na(NA_character_)) 
[15:33:06.768]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:33:06.768]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:33:06.768]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:33:06.768]                     .init = FALSE)
[15:33:06.768]                 }
[15:33:06.768]             }
[15:33:06.768]         }
[15:33:06.768]     })
[15:33:06.768]     if (FALSE) {
[15:33:06.768]         base::sink(type = "output", split = FALSE)
[15:33:06.768]         if (NA) {
[15:33:06.768]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:33:06.768]         }
[15:33:06.768]         else {
[15:33:06.768]             ...future.result["stdout"] <- base::list(NULL)
[15:33:06.768]         }
[15:33:06.768]         base::close(...future.stdout)
[15:33:06.768]         ...future.stdout <- NULL
[15:33:06.768]     }
[15:33:06.768]     ...future.result$conditions <- ...future.conditions
[15:33:06.768]     ...future.result$finished <- base::Sys.time()
[15:33:06.768]     ...future.result
[15:33:06.768] }
[15:33:06.776] Exporting 5 global objects (4.61 KiB) to cluster node #2 ...
[15:33:06.777] Exporting '...future.FUN' (4.61 KiB) to cluster node #2 ...
[15:33:06.777] Exporting '...future.FUN' (4.61 KiB) to cluster node #2 ... DONE
[15:33:06.778] Exporting 'future.call.arguments' (0 bytes) to cluster node #2 ...
[15:33:06.778] Exporting 'future.call.arguments' (0 bytes) to cluster node #2 ... DONE
[15:33:06.779] Exporting '...future.elements_ii' (56 bytes) to cluster node #2 ...
[15:33:06.779] Exporting '...future.elements_ii' (56 bytes) to cluster node #2 ... DONE
[15:33:06.779] Exporting '...future.seeds_ii' (0 bytes) to cluster node #2 ...
[15:33:06.780] Exporting '...future.seeds_ii' (0 bytes) to cluster node #2 ... DONE
[15:33:06.780] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #2 ...
[15:33:06.781] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #2 ... DONE
[15:33:06.781] Exporting 5 global objects (4.61 KiB) to cluster node #2 ... DONE
[15:33:06.782] MultisessionFuture started
[15:33:06.782] - Launch lazy future ... done
[15:33:06.782] run() for 'MultisessionFuture' ... done
[15:33:06.783] Created future:
[15:33:06.807] receiveMessageFromWorker() for ClusterFuture ...
[15:33:06.807] - Validating connection of MultisessionFuture
[15:33:06.807] - received message: FutureResult
[15:33:06.808] - Received FutureResult
[15:33:06.808] - Erased future from FutureRegistry
[15:33:06.808] result() for ClusterFuture ...
[15:33:06.808] - result already collected: FutureResult
[15:33:06.809] result() for ClusterFuture ... done
[15:33:06.809] receiveMessageFromWorker() for ClusterFuture ... done
[15:33:06.783] MultisessionFuture:
[15:33:06.783] Label: 'future_lapply-2'
[15:33:06.783] Expression:
[15:33:06.783] {
[15:33:06.783]     do.call(function(...) {
[15:33:06.783]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:33:06.783]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:33:06.783]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:33:06.783]             on.exit(options(oopts), add = TRUE)
[15:33:06.783]         }
[15:33:06.783]         {
[15:33:06.783]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:33:06.783]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:33:06.783]                 ...future.FUN(...future.X_jj, ...)
[15:33:06.783]             })
[15:33:06.783]         }
[15:33:06.783]     }, args = future.call.arguments)
[15:33:06.783] }
[15:33:06.783] Lazy evaluation: FALSE
[15:33:06.783] Asynchronous evaluation: TRUE
[15:33:06.783] Local evaluation: TRUE
[15:33:06.783] Environment: R_GlobalEnv
[15:33:06.783] Capture standard output: NA
[15:33:06.783] Capture condition classes: 'condition' (excluding 'nothing')
[15:33:06.783] Globals: 5 objects totaling 4.66 KiB (function '...future.FUN' of 4.61 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 56 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:33:06.783] Packages: <none>
[15:33:06.783] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:33:06.783] Resolved: TRUE
[15:33:06.783] Value: <not collected>
[15:33:06.783] Conditions captured: <none>
[15:33:06.783] Early signaling: FALSE
[15:33:06.783] Owner process: bdd4bc13-919d-bf34-b2cf-84eb53f6e11f
[15:33:06.783] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:33:06.809] Chunk #2 of 2 ... DONE
[15:33:06.810] Launching 2 futures (chunks) ... DONE
[15:33:06.810] Resolving 2 futures (chunks) ...
[15:33:06.810] resolve() on list ...
[15:33:06.810]  recursive: 0
[15:33:06.811]  length: 2
[15:33:06.811] 
[15:33:07.000] Future #2
[15:33:07.000] result() for ClusterFuture ...
[15:33:07.000] - result already collected: FutureResult
[15:33:07.001] result() for ClusterFuture ... done
[15:33:07.001] result() for ClusterFuture ...
[15:33:07.001] - result already collected: FutureResult
[15:33:07.002] result() for ClusterFuture ... done
[15:33:07.002] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:33:07.002] - nx: 2
[15:33:07.003] - relay: TRUE
[15:33:07.003] - stdout: TRUE
[15:33:07.003] - signal: TRUE
[15:33:07.003] - resignal: FALSE
[15:33:07.004] - force: TRUE
[15:33:07.004] - relayed: [n=2] FALSE, FALSE
[15:33:07.004] - queued futures: [n=2] FALSE, FALSE
[15:33:07.004]  - until=1
[15:33:07.005]  - relaying element #1
[15:33:07.005] - relayed: [n=2] FALSE, FALSE
[15:33:07.005] - queued futures: [n=2] FALSE, TRUE
[15:33:07.006] signalConditionsASAP(NULL, pos=2) ... done
[15:33:07.006]  length: 1 (resolved future 2)
[15:33:07.072] receiveMessageFromWorker() for ClusterFuture ...
[15:33:07.072] - Validating connection of MultisessionFuture
[15:33:07.072] - received message: FutureResult
[15:33:07.073] - Received FutureResult
[15:33:07.073] - Erased future from FutureRegistry
[15:33:07.073] result() for ClusterFuture ...
[15:33:07.073] - result already collected: FutureResult
[15:33:07.073] result() for ClusterFuture ... done
[15:33:07.073] receiveMessageFromWorker() for ClusterFuture ... done
[15:33:07.074] Future #1
[15:33:07.074] result() for ClusterFuture ...
[15:33:07.074] - result already collected: FutureResult
[15:33:07.074] result() for ClusterFuture ... done
[15:33:07.074] result() for ClusterFuture ...
[15:33:07.074] - result already collected: FutureResult
[15:33:07.075] result() for ClusterFuture ... done
[15:33:07.075] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:33:07.075] - nx: 2
[15:33:07.075] - relay: TRUE
[15:33:07.075] - stdout: TRUE
[15:33:07.075] - signal: TRUE
[15:33:07.076] - resignal: FALSE
[15:33:07.076] - force: TRUE
[15:33:07.076] - relayed: [n=2] FALSE, FALSE
[15:33:07.076] - queued futures: [n=2] FALSE, TRUE
[15:33:07.076]  - until=1
[15:33:07.076]  - relaying element #1
[15:33:07.077] result() for ClusterFuture ...
[15:33:07.077] - result already collected: FutureResult
[15:33:07.077] result() for ClusterFuture ... done
[15:33:07.077] result() for ClusterFuture ...
[15:33:07.077] - result already collected: FutureResult
[15:33:07.077] result() for ClusterFuture ... done
[15:33:07.078] result() for ClusterFuture ...
[15:33:07.078] - result already collected: FutureResult
[15:33:07.078] result() for ClusterFuture ... done
[15:33:07.078] result() for ClusterFuture ...
[15:33:07.078] - result already collected: FutureResult
[15:33:07.079] result() for ClusterFuture ... done
[15:33:07.079] - relayed: [n=2] TRUE, FALSE
[15:33:07.079] - queued futures: [n=2] TRUE, TRUE
[15:33:07.079] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:33:07.080]  length: 0 (resolved future 1)
[15:33:07.080] Relaying remaining futures
[15:33:07.080] signalConditionsASAP(NULL, pos=0) ...
[15:33:07.080] - nx: 2
[15:33:07.081] - relay: TRUE
[15:33:07.081] - stdout: TRUE
[15:33:07.081] - signal: TRUE
[15:33:07.081] - resignal: FALSE
[15:33:07.082] - force: TRUE
[15:33:07.082] - relayed: [n=2] TRUE, FALSE
[15:33:07.082] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:33:07.083]  - relaying element #2
[15:33:07.083] result() for ClusterFuture ...
[15:33:07.083] - result already collected: FutureResult
[15:33:07.083] result() for ClusterFuture ... done
[15:33:07.084] result() for ClusterFuture ...
[15:33:07.084] - result already collected: FutureResult
[15:33:07.084] result() for ClusterFuture ... done
[15:33:07.084] result() for ClusterFuture ...
[15:33:07.084] - result already collected: FutureResult
[15:33:07.084] result() for ClusterFuture ... done
[15:33:07.085] result() for ClusterFuture ...
[15:33:07.085] - result already collected: FutureResult
[15:33:07.085] result() for ClusterFuture ... done
[15:33:07.085] - relayed: [n=2] TRUE, TRUE
[15:33:07.085] - queued futures: [n=2] TRUE, TRUE
[15:33:07.086] signalConditionsASAP(MultisessionFuture, pos=0) ... done
[15:33:07.086] resolve() on list ... DONE
[15:33:07.086] result() for ClusterFuture ...
[15:33:07.086] - result already collected: FutureResult
[15:33:07.087] result() for ClusterFuture ... done
[15:33:07.087] result() for ClusterFuture ...
[15:33:07.087] - result already collected: FutureResult
[15:33:07.087] result() for ClusterFuture ... done
[15:33:07.087] result() for ClusterFuture ...
[15:33:07.088] - result already collected: FutureResult
[15:33:07.088] result() for ClusterFuture ... done
[15:33:07.088] result() for ClusterFuture ...
[15:33:07.088] - result already collected: FutureResult
[15:33:07.088] result() for ClusterFuture ... done
[15:33:07.088]  - Number of value chunks collected: 2
[15:33:07.089] Resolving 2 futures (chunks) ... DONE
[15:33:07.089] Reducing values from 2 chunks ...
[15:33:07.089]  - Number of values collected after concatenation: 2
[15:33:07.089]  - Number of values expected: 2
[15:33:07.089] Reducing values from 2 chunks ... DONE
[15:33:07.089] future_lapply() ... DONE
* future_lapply(x, ..., future.stdout = NA) ... DONE
* future_mapply(x, ..., future.stdout = FALSE) ...
[15:33:07.090] future_mapply() ...
[15:33:07.095] Number of chunks: 2
[15:33:07.095] getGlobalsAndPackagesXApply() ...
[15:33:07.095]  - future.globals: TRUE
[15:33:07.095] getGlobalsAndPackages() ...
[15:33:07.096] Searching for globals...
[15:33:07.098] - globals found: [6] 'FUN', '{', 'Sys.sleep', '/', 'print', 'list'
[15:33:07.098] Searching for globals ... DONE
[15:33:07.099] Resolving globals: FALSE
[15:33:07.100] The total size of the 1 globals is 6.11 KiB (6256 bytes)
[15:33:07.100] The total size of the 1 globals exported for future expression ('FUN()') is 6.11 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (6.11 KiB of class 'function')
[15:33:07.101] - globals: [1] 'FUN'
[15:33:07.101] 
[15:33:07.101] getGlobalsAndPackages() ... DONE
[15:33:07.101]  - globals found/used: [n=1] 'FUN'
[15:33:07.102]  - needed namespaces: [n=0] 
[15:33:07.102] Finding globals ... DONE
[15:33:07.102] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[15:33:07.102] List of 2
[15:33:07.102]  $ ...future.FUN:function (x, y)  
[15:33:07.102]  $ MoreArgs     : NULL
[15:33:07.102]  - attr(*, "where")=List of 2
[15:33:07.102]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:33:07.102]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[15:33:07.102]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:33:07.102]  - attr(*, "resolved")= logi FALSE
[15:33:07.102]  - attr(*, "total_size")= num NA
[15:33:07.107] Packages to be attached in all futures: [n=0] 
[15:33:07.107] getGlobalsAndPackagesXApply() ... DONE
[15:33:07.107] Number of futures (= number of chunks): 2
[15:33:07.107] Launching 2 futures (chunks) ...
[15:33:07.107] Chunk #1 of 2 ...
[15:33:07.108]  - Finding globals in '...' for chunk #1 ...
[15:33:07.108] getGlobalsAndPackages() ...
[15:33:07.108] Searching for globals...
[15:33:07.108] 
[15:33:07.109] Searching for globals ... DONE
[15:33:07.109] - globals: [0] <none>
[15:33:07.109] getGlobalsAndPackages() ... DONE
[15:33:07.109]    + additional globals found: [n=0] 
[15:33:07.109]    + additional namespaces needed: [n=0] 
[15:33:07.110]  - Finding globals in '...' for chunk #1 ... DONE
[15:33:07.110]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:33:07.110]  - seeds: <none>
[15:33:07.110]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:33:07.111] getGlobalsAndPackages() ...
[15:33:07.111] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:33:07.111] Resolving globals: FALSE
[15:33:07.112] The total size of the 5 globals is 6.22 KiB (6368 bytes)
[15:33:07.113] The total size of the 5 globals exported for future expression ('{; ...future.globals.maxSize.org <- getOption("future.globals.maxSize"); if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {; oopts <- options(future.globals.maxSize = ...future.globals.maxSize); on.exit(options(oopts), add = TRUE); }; ...; do.call(mapply, args = args); }; }') is 6.22 KiB.. This exceeds the maximum allowed size of 0.98 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (6.11 KiB of class 'function'), '...future.elements_ii' (112 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[15:33:07.113] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:33:07.114] 
[15:33:07.114] getGlobalsAndPackages() ... DONE
[15:33:07.114] run() for 'Future' ...
[15:33:07.114] - state: 'created'
[15:33:07.115] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:33:07.133] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:33:07.134] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:33:07.134]   - Field: 'node'
[15:33:07.134]   - Field: 'label'
[15:33:07.135]   - Field: 'local'
[15:33:07.135]   - Field: 'owner'
[15:33:07.135]   - Field: 'envir'
[15:33:07.136]   - Field: 'workers'
[15:33:07.136]   - Field: 'packages'
[15:33:07.136]   - Field: 'gc'
[15:33:07.137]   - Field: 'conditions'
[15:33:07.137]   - Field: 'persistent'
[15:33:07.137]   - Field: 'expr'
[15:33:07.138]   - Field: 'uuid'
[15:33:07.138]   - Field: 'seed'
[15:33:07.138]   - Field: 'version'
[15:33:07.138]   - Field: 'result'
[15:33:07.139]   - Field: 'asynchronous'
[15:33:07.139]   - Field: 'calls'
[15:33:07.139]   - Field: 'globals'
[15:33:07.140]   - Field: 'stdout'
[15:33:07.140]   - Field: 'earlySignal'
[15:33:07.140]   - Field: 'lazy'
[15:33:07.140]   - Field: 'state'
[15:33:07.141] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:33:07.141] - Launch lazy future ...
[15:33:07.142] Packages needed by the future expression (n = 0): <none>
[15:33:07.142] Packages needed by future strategies (n = 0): <none>
[15:33:07.143] {
[15:33:07.143]     {
[15:33:07.143]         {
[15:33:07.143]             ...future.startTime <- base::Sys.time()
[15:33:07.143]             {
[15:33:07.143]                 {
[15:33:07.143]                   {
[15:33:07.143]                     {
[15:33:07.143]                       base::local({
[15:33:07.143]                         has_future <- base::requireNamespace("future", 
[15:33:07.143]                           quietly = TRUE)
[15:33:07.143]                         if (has_future) {
[15:33:07.143]                           ns <- base::getNamespace("future")
[15:33:07.143]                           version <- ns[[".package"]][["version"]]
[15:33:07.143]                           if (is.null(version)) 
[15:33:07.143]                             version <- utils::packageVersion("future")
[15:33:07.143]                         }
[15:33:07.143]                         else {
[15:33:07.143]                           version <- NULL
[15:33:07.143]                         }
[15:33:07.143]                         if (!has_future || version < "1.8.0") {
[15:33:07.143]                           info <- base::c(r_version = base::gsub("R version ", 
[15:33:07.143]                             "", base::R.version$version.string), 
[15:33:07.143]                             platform = base::sprintf("%s (%s-bit)", 
[15:33:07.143]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:33:07.143]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:33:07.143]                               "release", "version")], collapse = " "), 
[15:33:07.143]                             hostname = base::Sys.info()[["nodename"]])
[15:33:07.143]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:33:07.143]                             info)
[15:33:07.143]                           info <- base::paste(info, collapse = "; ")
[15:33:07.143]                           if (!has_future) {
[15:33:07.143]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:33:07.143]                               info)
[15:33:07.143]                           }
[15:33:07.143]                           else {
[15:33:07.143]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:33:07.143]                               info, version)
[15:33:07.143]                           }
[15:33:07.143]                           base::stop(msg)
[15:33:07.143]                         }
[15:33:07.143]                       })
[15:33:07.143]                     }
[15:33:07.143]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:33:07.143]                     base::options(mc.cores = 1L)
[15:33:07.143]                   }
[15:33:07.143]                   ...future.strategy.old <- future::plan("list")
[15:33:07.143]                   options(future.plan = NULL)
[15:33:07.143]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:33:07.143]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:33:07.143]                 }
[15:33:07.143]                 ...future.workdir <- getwd()
[15:33:07.143]             }
[15:33:07.143]             ...future.oldOptions <- base::as.list(base::.Options)
[15:33:07.143]             ...future.oldEnvVars <- base::Sys.getenv()
[15:33:07.143]         }
[15:33:07.143]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:33:07.143]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:33:07.143]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:33:07.143]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:33:07.143]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:33:07.143]             future.stdout.windows.reencode = NULL, width = 80L)
[15:33:07.143]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:33:07.143]             base::names(...future.oldOptions))
[15:33:07.143]     }
[15:33:07.143]     if (FALSE) {
[15:33:07.143]     }
[15:33:07.143]     else {
[15:33:07.143]         if (FALSE) {
[15:33:07.143]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:33:07.143]                 open = "w")
[15:33:07.143]         }
[15:33:07.143]         else {
[15:33:07.143]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:33:07.143]                 windows = "NUL", "/dev/null"), open = "w")
[15:33:07.143]         }
[15:33:07.143]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:33:07.143]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:33:07.143]             base::sink(type = "output", split = FALSE)
[15:33:07.143]             base::close(...future.stdout)
[15:33:07.143]         }, add = TRUE)
[15:33:07.143]     }
[15:33:07.143]     ...future.frame <- base::sys.nframe()
[15:33:07.143]     ...future.conditions <- base::list()
[15:33:07.143]     ...future.rng <- base::globalenv()$.Random.seed
[15:33:07.143]     if (FALSE) {
[15:33:07.143]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:33:07.143]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:33:07.143]     }
[15:33:07.143]     ...future.result <- base::tryCatch({
[15:33:07.143]         base::withCallingHandlers({
[15:33:07.143]             ...future.value <- base::withVisible(base::local({
[15:33:07.143]                 ...future.makeSendCondition <- base::local({
[15:33:07.143]                   sendCondition <- NULL
[15:33:07.143]                   function(frame = 1L) {
[15:33:07.143]                     if (is.function(sendCondition)) 
[15:33:07.143]                       return(sendCondition)
[15:33:07.143]                     ns <- getNamespace("parallel")
[15:33:07.143]                     if (exists("sendData", mode = "function", 
[15:33:07.143]                       envir = ns)) {
[15:33:07.143]                       parallel_sendData <- get("sendData", mode = "function", 
[15:33:07.143]                         envir = ns)
[15:33:07.143]                       envir <- sys.frame(frame)
[15:33:07.143]                       master <- NULL
[15:33:07.143]                       while (!identical(envir, .GlobalEnv) && 
[15:33:07.143]                         !identical(envir, emptyenv())) {
[15:33:07.143]                         if (exists("master", mode = "list", envir = envir, 
[15:33:07.143]                           inherits = FALSE)) {
[15:33:07.143]                           master <- get("master", mode = "list", 
[15:33:07.143]                             envir = envir, inherits = FALSE)
[15:33:07.143]                           if (inherits(master, c("SOCKnode", 
[15:33:07.143]                             "SOCK0node"))) {
[15:33:07.143]                             sendCondition <<- function(cond) {
[15:33:07.143]                               data <- list(type = "VALUE", value = cond, 
[15:33:07.143]                                 success = TRUE)
[15:33:07.143]                               parallel_sendData(master, data)
[15:33:07.143]                             }
[15:33:07.143]                             return(sendCondition)
[15:33:07.143]                           }
[15:33:07.143]                         }
[15:33:07.143]                         frame <- frame + 1L
[15:33:07.143]                         envir <- sys.frame(frame)
[15:33:07.143]                       }
[15:33:07.143]                     }
[15:33:07.143]                     sendCondition <<- function(cond) NULL
[15:33:07.143]                   }
[15:33:07.143]                 })
[15:33:07.143]                 withCallingHandlers({
[15:33:07.143]                   {
[15:33:07.143]                     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:33:07.143]                     if (!identical(...future.globals.maxSize.org, 
[15:33:07.143]                       ...future.globals.maxSize)) {
[15:33:07.143]                       oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:33:07.143]                       on.exit(options(oopts), add = TRUE)
[15:33:07.143]                     }
[15:33:07.143]                     {
[15:33:07.143]                       args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:33:07.143]                         MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:33:07.143]                         USE.NAMES = FALSE)
[15:33:07.143]                       do.call(mapply, args = args)
[15:33:07.143]                     }
[15:33:07.143]                   }
[15:33:07.143]                 }, immediateCondition = function(cond) {
[15:33:07.143]                   sendCondition <- ...future.makeSendCondition()
[15:33:07.143]                   sendCondition(cond)
[15:33:07.143]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:33:07.143]                   {
[15:33:07.143]                     inherits <- base::inherits
[15:33:07.143]                     invokeRestart <- base::invokeRestart
[15:33:07.143]                     is.null <- base::is.null
[15:33:07.143]                     muffled <- FALSE
[15:33:07.143]                     if (inherits(cond, "message")) {
[15:33:07.143]                       muffled <- grepl(pattern, "muffleMessage")
[15:33:07.143]                       if (muffled) 
[15:33:07.143]                         invokeRestart("muffleMessage")
[15:33:07.143]                     }
[15:33:07.143]                     else if (inherits(cond, "warning")) {
[15:33:07.143]                       muffled <- grepl(pattern, "muffleWarning")
[15:33:07.143]                       if (muffled) 
[15:33:07.143]                         invokeRestart("muffleWarning")
[15:33:07.143]                     }
[15:33:07.143]                     else if (inherits(cond, "condition")) {
[15:33:07.143]                       if (!is.null(pattern)) {
[15:33:07.143]                         computeRestarts <- base::computeRestarts
[15:33:07.143]                         grepl <- base::grepl
[15:33:07.143]                         restarts <- computeRestarts(cond)
[15:33:07.143]                         for (restart in restarts) {
[15:33:07.143]                           name <- restart$name
[15:33:07.143]                           if (is.null(name)) 
[15:33:07.143]                             next
[15:33:07.143]                           if (!grepl(pattern, name)) 
[15:33:07.143]                             next
[15:33:07.143]                           invokeRestart(restart)
[15:33:07.143]                           muffled <- TRUE
[15:33:07.143]                           break
[15:33:07.143]                         }
[15:33:07.143]                       }
[15:33:07.143]                     }
[15:33:07.143]                     invisible(muffled)
[15:33:07.143]                   }
[15:33:07.143]                   muffleCondition(cond)
[15:33:07.143]                 })
[15:33:07.143]             }))
[15:33:07.143]             future::FutureResult(value = ...future.value$value, 
[15:33:07.143]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:33:07.143]                   ...future.rng), globalenv = if (FALSE) 
[15:33:07.143]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:33:07.143]                     ...future.globalenv.names))
[15:33:07.143]                 else NULL, started = ...future.startTime, version = "1.8")
[15:33:07.143]         }, condition = base::local({
[15:33:07.143]             c <- base::c
[15:33:07.143]             inherits <- base::inherits
[15:33:07.143]             invokeRestart <- base::invokeRestart
[15:33:07.143]             length <- base::length
[15:33:07.143]             list <- base::list
[15:33:07.143]             seq.int <- base::seq.int
[15:33:07.143]             signalCondition <- base::signalCondition
[15:33:07.143]             sys.calls <- base::sys.calls
[15:33:07.143]             `[[` <- base::`[[`
[15:33:07.143]             `+` <- base::`+`
[15:33:07.143]             `<<-` <- base::`<<-`
[15:33:07.143]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:33:07.143]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:33:07.143]                   3L)]
[15:33:07.143]             }
[15:33:07.143]             function(cond) {
[15:33:07.143]                 is_error <- inherits(cond, "error")
[15:33:07.143]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:33:07.143]                   NULL)
[15:33:07.143]                 if (is_error) {
[15:33:07.143]                   sessionInformation <- function() {
[15:33:07.143]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:33:07.143]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:33:07.143]                       search = base::search(), system = base::Sys.info())
[15:33:07.143]                   }
[15:33:07.143]                   ...future.conditions[[length(...future.conditions) + 
[15:33:07.143]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:33:07.143]                     cond$call), session = sessionInformation(), 
[15:33:07.143]                     timestamp = base::Sys.time(), signaled = 0L)
[15:33:07.143]                   signalCondition(cond)
[15:33:07.143]                 }
[15:33:07.143]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:33:07.143]                 "immediateCondition"))) {
[15:33:07.143]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:33:07.143]                   ...future.conditions[[length(...future.conditions) + 
[15:33:07.143]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:33:07.143]                   if (TRUE && !signal) {
[15:33:07.143]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:33:07.143]                     {
[15:33:07.143]                       inherits <- base::inherits
[15:33:07.143]                       invokeRestart <- base::invokeRestart
[15:33:07.143]                       is.null <- base::is.null
[15:33:07.143]                       muffled <- FALSE
[15:33:07.143]                       if (inherits(cond, "message")) {
[15:33:07.143]                         muffled <- grepl(pattern, "muffleMessage")
[15:33:07.143]                         if (muffled) 
[15:33:07.143]                           invokeRestart("muffleMessage")
[15:33:07.143]                       }
[15:33:07.143]                       else if (inherits(cond, "warning")) {
[15:33:07.143]                         muffled <- grepl(pattern, "muffleWarning")
[15:33:07.143]                         if (muffled) 
[15:33:07.143]                           invokeRestart("muffleWarning")
[15:33:07.143]                       }
[15:33:07.143]                       else if (inherits(cond, "condition")) {
[15:33:07.143]                         if (!is.null(pattern)) {
[15:33:07.143]                           computeRestarts <- base::computeRestarts
[15:33:07.143]                           grepl <- base::grepl
[15:33:07.143]                           restarts <- computeRestarts(cond)
[15:33:07.143]                           for (restart in restarts) {
[15:33:07.143]                             name <- restart$name
[15:33:07.143]                             if (is.null(name)) 
[15:33:07.143]                               next
[15:33:07.143]                             if (!grepl(pattern, name)) 
[15:33:07.143]                               next
[15:33:07.143]                             invokeRestart(restart)
[15:33:07.143]                             muffled <- TRUE
[15:33:07.143]                             break
[15:33:07.143]                           }
[15:33:07.143]                         }
[15:33:07.143]                       }
[15:33:07.143]                       invisible(muffled)
[15:33:07.143]                     }
[15:33:07.143]                     muffleCondition(cond, pattern = "^muffle")
[15:33:07.143]                   }
[15:33:07.143]                 }
[15:33:07.143]                 else {
[15:33:07.143]                   if (TRUE) {
[15:33:07.143]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:33:07.143]                     {
[15:33:07.143]                       inherits <- base::inherits
[15:33:07.143]                       invokeRestart <- base::invokeRestart
[15:33:07.143]                       is.null <- base::is.null
[15:33:07.143]                       muffled <- FALSE
[15:33:07.143]                       if (inherits(cond, "message")) {
[15:33:07.143]                         muffled <- grepl(pattern, "muffleMessage")
[15:33:07.143]                         if (muffled) 
[15:33:07.143]                           invokeRestart("muffleMessage")
[15:33:07.143]                       }
[15:33:07.143]                       else if (inherits(cond, "warning")) {
[15:33:07.143]                         muffled <- grepl(pattern, "muffleWarning")
[15:33:07.143]                         if (muffled) 
[15:33:07.143]                           invokeRestart("muffleWarning")
[15:33:07.143]                       }
[15:33:07.143]                       else if (inherits(cond, "condition")) {
[15:33:07.143]                         if (!is.null(pattern)) {
[15:33:07.143]                           computeRestarts <- base::computeRestarts
[15:33:07.143]                           grepl <- base::grepl
[15:33:07.143]                           restarts <- computeRestarts(cond)
[15:33:07.143]                           for (restart in restarts) {
[15:33:07.143]                             name <- restart$name
[15:33:07.143]                             if (is.null(name)) 
[15:33:07.143]                               next
[15:33:07.143]                             if (!grepl(pattern, name)) 
[15:33:07.143]                               next
[15:33:07.143]                             invokeRestart(restart)
[15:33:07.143]                             muffled <- TRUE
[15:33:07.143]                             break
[15:33:07.143]                           }
[15:33:07.143]                         }
[15:33:07.143]                       }
[15:33:07.143]                       invisible(muffled)
[15:33:07.143]                     }
[15:33:07.143]                     muffleCondition(cond, pattern = "^muffle")
[15:33:07.143]                   }
[15:33:07.143]                 }
[15:33:07.143]             }
[15:33:07.143]         }))
[15:33:07.143]     }, error = function(ex) {
[15:33:07.143]         base::structure(base::list(value = NULL, visible = NULL, 
[15:33:07.143]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:33:07.143]                 ...future.rng), started = ...future.startTime, 
[15:33:07.143]             finished = Sys.time(), session_uuid = NA_character_, 
[15:33:07.143]             version = "1.8"), class = "FutureResult")
[15:33:07.143]     }, finally = {
[15:33:07.143]         if (!identical(...future.workdir, getwd())) 
[15:33:07.143]             setwd(...future.workdir)
[15:33:07.143]         {
[15:33:07.143]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:33:07.143]                 ...future.oldOptions$nwarnings <- NULL
[15:33:07.143]             }
[15:33:07.143]             base::options(...future.oldOptions)
[15:33:07.143]             if (.Platform$OS.type == "windows") {
[15:33:07.143]                 old_names <- names(...future.oldEnvVars)
[15:33:07.143]                 envs <- base::Sys.getenv()
[15:33:07.143]                 names <- names(envs)
[15:33:07.143]                 common <- intersect(names, old_names)
[15:33:07.143]                 added <- setdiff(names, old_names)
[15:33:07.143]                 removed <- setdiff(old_names, names)
[15:33:07.143]                 changed <- common[...future.oldEnvVars[common] != 
[15:33:07.143]                   envs[common]]
[15:33:07.143]                 NAMES <- toupper(changed)
[15:33:07.143]                 args <- list()
[15:33:07.143]                 for (kk in seq_along(NAMES)) {
[15:33:07.143]                   name <- changed[[kk]]
[15:33:07.143]                   NAME <- NAMES[[kk]]
[15:33:07.143]                   if (name != NAME && is.element(NAME, old_names)) 
[15:33:07.143]                     next
[15:33:07.143]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:33:07.143]                 }
[15:33:07.143]                 NAMES <- toupper(added)
[15:33:07.143]                 for (kk in seq_along(NAMES)) {
[15:33:07.143]                   name <- added[[kk]]
[15:33:07.143]                   NAME <- NAMES[[kk]]
[15:33:07.143]                   if (name != NAME && is.element(NAME, old_names)) 
[15:33:07.143]                     next
[15:33:07.143]                   args[[name]] <- ""
[15:33:07.143]                 }
[15:33:07.143]                 NAMES <- toupper(removed)
[15:33:07.143]                 for (kk in seq_along(NAMES)) {
[15:33:07.143]                   name <- removed[[kk]]
[15:33:07.143]                   NAME <- NAMES[[kk]]
[15:33:07.143]                   if (name != NAME && is.element(NAME, old_names)) 
[15:33:07.143]                     next
[15:33:07.143]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:33:07.143]                 }
[15:33:07.143]                 if (length(args) > 0) 
[15:33:07.143]                   base::do.call(base::Sys.setenv, args = args)
[15:33:07.143]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:33:07.143]             }
[15:33:07.143]             else {
[15:33:07.143]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:33:07.143]             }
[15:33:07.143]             {
[15:33:07.143]                 if (base::length(...future.futureOptionsAdded) > 
[15:33:07.143]                   0L) {
[15:33:07.143]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:33:07.143]                   base::names(opts) <- ...future.futureOptionsAdded
[15:33:07.143]                   base::options(opts)
[15:33:07.143]                 }
[15:33:07.143]                 {
[15:33:07.143]                   {
[15:33:07.143]                     base::options(mc.cores = ...future.mc.cores.old)
[15:33:07.143]                     NULL
[15:33:07.143]                   }
[15:33:07.143]                   options(future.plan = NULL)
[15:33:07.143]                   if (is.na(NA_character_)) 
[15:33:07.143]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:33:07.143]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:33:07.143]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:33:07.143]                     .init = FALSE)
[15:33:07.143]                 }
[15:33:07.143]             }
[15:33:07.143]         }
[15:33:07.143]     })
[15:33:07.143]     if (TRUE) {
[15:33:07.143]         base::sink(type = "output", split = FALSE)
[15:33:07.143]         if (FALSE) {
[15:33:07.143]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:33:07.143]         }
[15:33:07.143]         else {
[15:33:07.143]             ...future.result["stdout"] <- base::list(NULL)
[15:33:07.143]         }
[15:33:07.143]         base::close(...future.stdout)
[15:33:07.143]         ...future.stdout <- NULL
[15:33:07.143]     }
[15:33:07.143]     ...future.result$conditions <- ...future.conditions
[15:33:07.143]     ...future.result$finished <- base::Sys.time()
[15:33:07.143]     ...future.result
[15:33:07.143] }
[15:33:07.152] Exporting 5 global objects (6.22 KiB) to cluster node #1 ...
[15:33:07.152] Exporting '...future.FUN' (6.11 KiB) to cluster node #1 ...
[15:33:07.153] Exporting '...future.FUN' (6.11 KiB) to cluster node #1 ... DONE
[15:33:07.153] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ...
[15:33:07.153] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ... DONE
[15:33:07.154] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:33:07.154] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:33:07.154] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:33:07.155] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:33:07.155] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:33:07.155] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:33:07.156] Exporting 5 global objects (6.22 KiB) to cluster node #1 ... DONE
[15:33:07.156] MultisessionFuture started
[15:33:07.157] - Launch lazy future ... done
[15:33:07.157] run() for 'MultisessionFuture' ... done
[15:33:07.157] Created future:
[15:33:07.157] MultisessionFuture:
[15:33:07.157] Label: 'future_mapply-1'
[15:33:07.157] Expression:
[15:33:07.157] {
[15:33:07.157]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:33:07.157]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:33:07.157]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:33:07.157]         on.exit(options(oopts), add = TRUE)
[15:33:07.157]     }
[15:33:07.157]     {
[15:33:07.157]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:33:07.157]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:33:07.157]         do.call(mapply, args = args)
[15:33:07.157]     }
[15:33:07.157] }
[15:33:07.157] Lazy evaluation: FALSE
[15:33:07.157] Asynchronous evaluation: TRUE
[15:33:07.157] Local evaluation: TRUE
[15:33:07.157] Environment: R_GlobalEnv
[15:33:07.157] Capture standard output: FALSE
[15:33:07.157] Capture condition classes: 'condition' (excluding 'nothing')
[15:33:07.157] Globals: 5 objects totaling 6.22 KiB (function '...future.FUN' of 6.11 KiB, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 112 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:33:07.157] Packages: <none>
[15:33:07.157] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:33:07.157] Resolved: FALSE
[15:33:07.157] Value: <not collected>
[15:33:07.157] Conditions captured: <none>
[15:33:07.157] Early signaling: FALSE
[15:33:07.157] Owner process: bdd4bc13-919d-bf34-b2cf-84eb53f6e11f
[15:33:07.157] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:33:07.360] Chunk #1 of 2 ... DONE
[15:33:07.360] Chunk #2 of 2 ...
[15:33:07.361]  - Finding globals in '...' for chunk #2 ...
[15:33:07.361] getGlobalsAndPackages() ...
[15:33:07.361] Searching for globals...
[15:33:07.362] 
[15:33:07.362] Searching for globals ... DONE
[15:33:07.363] - globals: [0] <none>
[15:33:07.363] getGlobalsAndPackages() ... DONE
[15:33:07.363]    + additional globals found: [n=0] 
[15:33:07.363]    + additional namespaces needed: [n=0] 
[15:33:07.364]  - Finding globals in '...' for chunk #2 ... DONE
[15:33:07.364]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:33:07.364]  - seeds: <none>
[15:33:07.369]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:33:07.370] getGlobalsAndPackages() ...
[15:33:07.370] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:33:07.370] Resolving globals: FALSE
[15:33:07.372] The total size of the 5 globals is 6.22 KiB (6368 bytes)
[15:33:07.373] The total size of the 5 globals exported for future expression ('{; ...future.globals.maxSize.org <- getOption("future.globals.maxSize"); if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {; oopts <- options(future.globals.maxSize = ...future.globals.maxSize); on.exit(options(oopts), add = TRUE); }; ...; do.call(mapply, args = args); }; }') is 6.22 KiB.. This exceeds the maximum allowed size of 0.98 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (6.11 KiB of class 'function'), '...future.elements_ii' (112 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[15:33:07.373] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:33:07.373] 
[15:33:07.373] getGlobalsAndPackages() ... DONE
[15:33:07.374] run() for 'Future' ...
[15:33:07.374] - state: 'created'
[15:33:07.375] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:33:07.393] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:33:07.394] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:33:07.394]   - Field: 'node'
[15:33:07.394]   - Field: 'label'
[15:33:07.395]   - Field: 'local'
[15:33:07.395]   - Field: 'owner'
[15:33:07.395]   - Field: 'envir'
[15:33:07.396]   - Field: 'workers'
[15:33:07.396]   - Field: 'packages'
[15:33:07.396]   - Field: 'gc'
[15:33:07.397]   - Field: 'conditions'
[15:33:07.397]   - Field: 'persistent'
[15:33:07.397]   - Field: 'expr'
[15:33:07.397]   - Field: 'uuid'
[15:33:07.398]   - Field: 'seed'
[15:33:07.398]   - Field: 'version'
[15:33:07.398]   - Field: 'result'
[15:33:07.398]   - Field: 'asynchronous'
[15:33:07.399]   - Field: 'calls'
[15:33:07.399]   - Field: 'globals'
[15:33:07.399]   - Field: 'stdout'
[15:33:07.399]   - Field: 'earlySignal'
[15:33:07.400]   - Field: 'lazy'
[15:33:07.400]   - Field: 'state'
[15:33:07.400] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:33:07.401] - Launch lazy future ...
[15:33:07.401] Packages needed by the future expression (n = 0): <none>
[15:33:07.402] Packages needed by future strategies (n = 0): <none>
[15:33:07.403] {
[15:33:07.403]     {
[15:33:07.403]         {
[15:33:07.403]             ...future.startTime <- base::Sys.time()
[15:33:07.403]             {
[15:33:07.403]                 {
[15:33:07.403]                   {
[15:33:07.403]                     {
[15:33:07.403]                       base::local({
[15:33:07.403]                         has_future <- base::requireNamespace("future", 
[15:33:07.403]                           quietly = TRUE)
[15:33:07.403]                         if (has_future) {
[15:33:07.403]                           ns <- base::getNamespace("future")
[15:33:07.403]                           version <- ns[[".package"]][["version"]]
[15:33:07.403]                           if (is.null(version)) 
[15:33:07.403]                             version <- utils::packageVersion("future")
[15:33:07.403]                         }
[15:33:07.403]                         else {
[15:33:07.403]                           version <- NULL
[15:33:07.403]                         }
[15:33:07.403]                         if (!has_future || version < "1.8.0") {
[15:33:07.403]                           info <- base::c(r_version = base::gsub("R version ", 
[15:33:07.403]                             "", base::R.version$version.string), 
[15:33:07.403]                             platform = base::sprintf("%s (%s-bit)", 
[15:33:07.403]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:33:07.403]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:33:07.403]                               "release", "version")], collapse = " "), 
[15:33:07.403]                             hostname = base::Sys.info()[["nodename"]])
[15:33:07.403]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:33:07.403]                             info)
[15:33:07.403]                           info <- base::paste(info, collapse = "; ")
[15:33:07.403]                           if (!has_future) {
[15:33:07.403]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:33:07.403]                               info)
[15:33:07.403]                           }
[15:33:07.403]                           else {
[15:33:07.403]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:33:07.403]                               info, version)
[15:33:07.403]                           }
[15:33:07.403]                           base::stop(msg)
[15:33:07.403]                         }
[15:33:07.403]                       })
[15:33:07.403]                     }
[15:33:07.403]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:33:07.403]                     base::options(mc.cores = 1L)
[15:33:07.403]                   }
[15:33:07.403]                   ...future.strategy.old <- future::plan("list")
[15:33:07.403]                   options(future.plan = NULL)
[15:33:07.403]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:33:07.403]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:33:07.403]                 }
[15:33:07.403]                 ...future.workdir <- getwd()
[15:33:07.403]             }
[15:33:07.403]             ...future.oldOptions <- base::as.list(base::.Options)
[15:33:07.403]             ...future.oldEnvVars <- base::Sys.getenv()
[15:33:07.403]         }
[15:33:07.403]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:33:07.403]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:33:07.403]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:33:07.403]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:33:07.403]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:33:07.403]             future.stdout.windows.reencode = NULL, width = 80L)
[15:33:07.403]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:33:07.403]             base::names(...future.oldOptions))
[15:33:07.403]     }
[15:33:07.403]     if (FALSE) {
[15:33:07.403]     }
[15:33:07.403]     else {
[15:33:07.403]         if (FALSE) {
[15:33:07.403]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:33:07.403]                 open = "w")
[15:33:07.403]         }
[15:33:07.403]         else {
[15:33:07.403]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:33:07.403]                 windows = "NUL", "/dev/null"), open = "w")
[15:33:07.403]         }
[15:33:07.403]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:33:07.403]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:33:07.403]             base::sink(type = "output", split = FALSE)
[15:33:07.403]             base::close(...future.stdout)
[15:33:07.403]         }, add = TRUE)
[15:33:07.403]     }
[15:33:07.403]     ...future.frame <- base::sys.nframe()
[15:33:07.403]     ...future.conditions <- base::list()
[15:33:07.403]     ...future.rng <- base::globalenv()$.Random.seed
[15:33:07.403]     if (FALSE) {
[15:33:07.403]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:33:07.403]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:33:07.403]     }
[15:33:07.403]     ...future.result <- base::tryCatch({
[15:33:07.403]         base::withCallingHandlers({
[15:33:07.403]             ...future.value <- base::withVisible(base::local({
[15:33:07.403]                 ...future.makeSendCondition <- base::local({
[15:33:07.403]                   sendCondition <- NULL
[15:33:07.403]                   function(frame = 1L) {
[15:33:07.403]                     if (is.function(sendCondition)) 
[15:33:07.403]                       return(sendCondition)
[15:33:07.403]                     ns <- getNamespace("parallel")
[15:33:07.403]                     if (exists("sendData", mode = "function", 
[15:33:07.403]                       envir = ns)) {
[15:33:07.403]                       parallel_sendData <- get("sendData", mode = "function", 
[15:33:07.403]                         envir = ns)
[15:33:07.403]                       envir <- sys.frame(frame)
[15:33:07.403]                       master <- NULL
[15:33:07.403]                       while (!identical(envir, .GlobalEnv) && 
[15:33:07.403]                         !identical(envir, emptyenv())) {
[15:33:07.403]                         if (exists("master", mode = "list", envir = envir, 
[15:33:07.403]                           inherits = FALSE)) {
[15:33:07.403]                           master <- get("master", mode = "list", 
[15:33:07.403]                             envir = envir, inherits = FALSE)
[15:33:07.403]                           if (inherits(master, c("SOCKnode", 
[15:33:07.403]                             "SOCK0node"))) {
[15:33:07.403]                             sendCondition <<- function(cond) {
[15:33:07.403]                               data <- list(type = "VALUE", value = cond, 
[15:33:07.403]                                 success = TRUE)
[15:33:07.403]                               parallel_sendData(master, data)
[15:33:07.403]                             }
[15:33:07.403]                             return(sendCondition)
[15:33:07.403]                           }
[15:33:07.403]                         }
[15:33:07.403]                         frame <- frame + 1L
[15:33:07.403]                         envir <- sys.frame(frame)
[15:33:07.403]                       }
[15:33:07.403]                     }
[15:33:07.403]                     sendCondition <<- function(cond) NULL
[15:33:07.403]                   }
[15:33:07.403]                 })
[15:33:07.403]                 withCallingHandlers({
[15:33:07.403]                   {
[15:33:07.403]                     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:33:07.403]                     if (!identical(...future.globals.maxSize.org, 
[15:33:07.403]                       ...future.globals.maxSize)) {
[15:33:07.403]                       oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:33:07.403]                       on.exit(options(oopts), add = TRUE)
[15:33:07.403]                     }
[15:33:07.403]                     {
[15:33:07.403]                       args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:33:07.403]                         MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:33:07.403]                         USE.NAMES = FALSE)
[15:33:07.403]                       do.call(mapply, args = args)
[15:33:07.403]                     }
[15:33:07.403]                   }
[15:33:07.403]                 }, immediateCondition = function(cond) {
[15:33:07.403]                   sendCondition <- ...future.makeSendCondition()
[15:33:07.403]                   sendCondition(cond)
[15:33:07.403]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:33:07.403]                   {
[15:33:07.403]                     inherits <- base::inherits
[15:33:07.403]                     invokeRestart <- base::invokeRestart
[15:33:07.403]                     is.null <- base::is.null
[15:33:07.403]                     muffled <- FALSE
[15:33:07.403]                     if (inherits(cond, "message")) {
[15:33:07.403]                       muffled <- grepl(pattern, "muffleMessage")
[15:33:07.403]                       if (muffled) 
[15:33:07.403]                         invokeRestart("muffleMessage")
[15:33:07.403]                     }
[15:33:07.403]                     else if (inherits(cond, "warning")) {
[15:33:07.403]                       muffled <- grepl(pattern, "muffleWarning")
[15:33:07.403]                       if (muffled) 
[15:33:07.403]                         invokeRestart("muffleWarning")
[15:33:07.403]                     }
[15:33:07.403]                     else if (inherits(cond, "condition")) {
[15:33:07.403]                       if (!is.null(pattern)) {
[15:33:07.403]                         computeRestarts <- base::computeRestarts
[15:33:07.403]                         grepl <- base::grepl
[15:33:07.403]                         restarts <- computeRestarts(cond)
[15:33:07.403]                         for (restart in restarts) {
[15:33:07.403]                           name <- restart$name
[15:33:07.403]                           if (is.null(name)) 
[15:33:07.403]                             next
[15:33:07.403]                           if (!grepl(pattern, name)) 
[15:33:07.403]                             next
[15:33:07.403]                           invokeRestart(restart)
[15:33:07.403]                           muffled <- TRUE
[15:33:07.403]                           break
[15:33:07.403]                         }
[15:33:07.403]                       }
[15:33:07.403]                     }
[15:33:07.403]                     invisible(muffled)
[15:33:07.403]                   }
[15:33:07.403]                   muffleCondition(cond)
[15:33:07.403]                 })
[15:33:07.403]             }))
[15:33:07.403]             future::FutureResult(value = ...future.value$value, 
[15:33:07.403]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:33:07.403]                   ...future.rng), globalenv = if (FALSE) 
[15:33:07.403]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:33:07.403]                     ...future.globalenv.names))
[15:33:07.403]                 else NULL, started = ...future.startTime, version = "1.8")
[15:33:07.403]         }, condition = base::local({
[15:33:07.403]             c <- base::c
[15:33:07.403]             inherits <- base::inherits
[15:33:07.403]             invokeRestart <- base::invokeRestart
[15:33:07.403]             length <- base::length
[15:33:07.403]             list <- base::list
[15:33:07.403]             seq.int <- base::seq.int
[15:33:07.403]             signalCondition <- base::signalCondition
[15:33:07.403]             sys.calls <- base::sys.calls
[15:33:07.403]             `[[` <- base::`[[`
[15:33:07.403]             `+` <- base::`+`
[15:33:07.403]             `<<-` <- base::`<<-`
[15:33:07.403]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:33:07.403]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:33:07.403]                   3L)]
[15:33:07.403]             }
[15:33:07.403]             function(cond) {
[15:33:07.403]                 is_error <- inherits(cond, "error")
[15:33:07.403]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:33:07.403]                   NULL)
[15:33:07.403]                 if (is_error) {
[15:33:07.403]                   sessionInformation <- function() {
[15:33:07.403]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:33:07.403]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:33:07.403]                       search = base::search(), system = base::Sys.info())
[15:33:07.403]                   }
[15:33:07.403]                   ...future.conditions[[length(...future.conditions) + 
[15:33:07.403]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:33:07.403]                     cond$call), session = sessionInformation(), 
[15:33:07.403]                     timestamp = base::Sys.time(), signaled = 0L)
[15:33:07.403]                   signalCondition(cond)
[15:33:07.403]                 }
[15:33:07.403]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:33:07.403]                 "immediateCondition"))) {
[15:33:07.403]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:33:07.403]                   ...future.conditions[[length(...future.conditions) + 
[15:33:07.403]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:33:07.403]                   if (TRUE && !signal) {
[15:33:07.403]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:33:07.403]                     {
[15:33:07.403]                       inherits <- base::inherits
[15:33:07.403]                       invokeRestart <- base::invokeRestart
[15:33:07.403]                       is.null <- base::is.null
[15:33:07.403]                       muffled <- FALSE
[15:33:07.403]                       if (inherits(cond, "message")) {
[15:33:07.403]                         muffled <- grepl(pattern, "muffleMessage")
[15:33:07.403]                         if (muffled) 
[15:33:07.403]                           invokeRestart("muffleMessage")
[15:33:07.403]                       }
[15:33:07.403]                       else if (inherits(cond, "warning")) {
[15:33:07.403]                         muffled <- grepl(pattern, "muffleWarning")
[15:33:07.403]                         if (muffled) 
[15:33:07.403]                           invokeRestart("muffleWarning")
[15:33:07.403]                       }
[15:33:07.403]                       else if (inherits(cond, "condition")) {
[15:33:07.403]                         if (!is.null(pattern)) {
[15:33:07.403]                           computeRestarts <- base::computeRestarts
[15:33:07.403]                           grepl <- base::grepl
[15:33:07.403]                           restarts <- computeRestarts(cond)
[15:33:07.403]                           for (restart in restarts) {
[15:33:07.403]                             name <- restart$name
[15:33:07.403]                             if (is.null(name)) 
[15:33:07.403]                               next
[15:33:07.403]                             if (!grepl(pattern, name)) 
[15:33:07.403]                               next
[15:33:07.403]                             invokeRestart(restart)
[15:33:07.403]                             muffled <- TRUE
[15:33:07.403]                             break
[15:33:07.403]                           }
[15:33:07.403]                         }
[15:33:07.403]                       }
[15:33:07.403]                       invisible(muffled)
[15:33:07.403]                     }
[15:33:07.403]                     muffleCondition(cond, pattern = "^muffle")
[15:33:07.403]                   }
[15:33:07.403]                 }
[15:33:07.403]                 else {
[15:33:07.403]                   if (TRUE) {
[15:33:07.403]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:33:07.403]                     {
[15:33:07.403]                       inherits <- base::inherits
[15:33:07.403]                       invokeRestart <- base::invokeRestart
[15:33:07.403]                       is.null <- base::is.null
[15:33:07.403]                       muffled <- FALSE
[15:33:07.403]                       if (inherits(cond, "message")) {
[15:33:07.403]                         muffled <- grepl(pattern, "muffleMessage")
[15:33:07.403]                         if (muffled) 
[15:33:07.403]                           invokeRestart("muffleMessage")
[15:33:07.403]                       }
[15:33:07.403]                       else if (inherits(cond, "warning")) {
[15:33:07.403]                         muffled <- grepl(pattern, "muffleWarning")
[15:33:07.403]                         if (muffled) 
[15:33:07.403]                           invokeRestart("muffleWarning")
[15:33:07.403]                       }
[15:33:07.403]                       else if (inherits(cond, "condition")) {
[15:33:07.403]                         if (!is.null(pattern)) {
[15:33:07.403]                           computeRestarts <- base::computeRestarts
[15:33:07.403]                           grepl <- base::grepl
[15:33:07.403]                           restarts <- computeRestarts(cond)
[15:33:07.403]                           for (restart in restarts) {
[15:33:07.403]                             name <- restart$name
[15:33:07.403]                             if (is.null(name)) 
[15:33:07.403]                               next
[15:33:07.403]                             if (!grepl(pattern, name)) 
[15:33:07.403]                               next
[15:33:07.403]                             invokeRestart(restart)
[15:33:07.403]                             muffled <- TRUE
[15:33:07.403]                             break
[15:33:07.403]                           }
[15:33:07.403]                         }
[15:33:07.403]                       }
[15:33:07.403]                       invisible(muffled)
[15:33:07.403]                     }
[15:33:07.403]                     muffleCondition(cond, pattern = "^muffle")
[15:33:07.403]                   }
[15:33:07.403]                 }
[15:33:07.403]             }
[15:33:07.403]         }))
[15:33:07.403]     }, error = function(ex) {
[15:33:07.403]         base::structure(base::list(value = NULL, visible = NULL, 
[15:33:07.403]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:33:07.403]                 ...future.rng), started = ...future.startTime, 
[15:33:07.403]             finished = Sys.time(), session_uuid = NA_character_, 
[15:33:07.403]             version = "1.8"), class = "FutureResult")
[15:33:07.403]     }, finally = {
[15:33:07.403]         if (!identical(...future.workdir, getwd())) 
[15:33:07.403]             setwd(...future.workdir)
[15:33:07.403]         {
[15:33:07.403]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:33:07.403]                 ...future.oldOptions$nwarnings <- NULL
[15:33:07.403]             }
[15:33:07.403]             base::options(...future.oldOptions)
[15:33:07.403]             if (.Platform$OS.type == "windows") {
[15:33:07.403]                 old_names <- names(...future.oldEnvVars)
[15:33:07.403]                 envs <- base::Sys.getenv()
[15:33:07.403]                 names <- names(envs)
[15:33:07.403]                 common <- intersect(names, old_names)
[15:33:07.403]                 added <- setdiff(names, old_names)
[15:33:07.403]                 removed <- setdiff(old_names, names)
[15:33:07.403]                 changed <- common[...future.oldEnvVars[common] != 
[15:33:07.403]                   envs[common]]
[15:33:07.403]                 NAMES <- toupper(changed)
[15:33:07.403]                 args <- list()
[15:33:07.403]                 for (kk in seq_along(NAMES)) {
[15:33:07.403]                   name <- changed[[kk]]
[15:33:07.403]                   NAME <- NAMES[[kk]]
[15:33:07.403]                   if (name != NAME && is.element(NAME, old_names)) 
[15:33:07.403]                     next
[15:33:07.403]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:33:07.403]                 }
[15:33:07.403]                 NAMES <- toupper(added)
[15:33:07.403]                 for (kk in seq_along(NAMES)) {
[15:33:07.403]                   name <- added[[kk]]
[15:33:07.403]                   NAME <- NAMES[[kk]]
[15:33:07.403]                   if (name != NAME && is.element(NAME, old_names)) 
[15:33:07.403]                     next
[15:33:07.403]                   args[[name]] <- ""
[15:33:07.403]                 }
[15:33:07.403]                 NAMES <- toupper(removed)
[15:33:07.403]                 for (kk in seq_along(NAMES)) {
[15:33:07.403]                   name <- removed[[kk]]
[15:33:07.403]                   NAME <- NAMES[[kk]]
[15:33:07.403]                   if (name != NAME && is.element(NAME, old_names)) 
[15:33:07.403]                     next
[15:33:07.403]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:33:07.403]                 }
[15:33:07.403]                 if (length(args) > 0) 
[15:33:07.403]                   base::do.call(base::Sys.setenv, args = args)
[15:33:07.403]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:33:07.403]             }
[15:33:07.403]             else {
[15:33:07.403]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:33:07.403]             }
[15:33:07.403]             {
[15:33:07.403]                 if (base::length(...future.futureOptionsAdded) > 
[15:33:07.403]                   0L) {
[15:33:07.403]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:33:07.403]                   base::names(opts) <- ...future.futureOptionsAdded
[15:33:07.403]                   base::options(opts)
[15:33:07.403]                 }
[15:33:07.403]                 {
[15:33:07.403]                   {
[15:33:07.403]                     base::options(mc.cores = ...future.mc.cores.old)
[15:33:07.403]                     NULL
[15:33:07.403]                   }
[15:33:07.403]                   options(future.plan = NULL)
[15:33:07.403]                   if (is.na(NA_character_)) 
[15:33:07.403]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:33:07.403]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:33:07.403]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:33:07.403]                     .init = FALSE)
[15:33:07.403]                 }
[15:33:07.403]             }
[15:33:07.403]         }
[15:33:07.403]     })
[15:33:07.403]     if (TRUE) {
[15:33:07.403]         base::sink(type = "output", split = FALSE)
[15:33:07.403]         if (FALSE) {
[15:33:07.403]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:33:07.403]         }
[15:33:07.403]         else {
[15:33:07.403]             ...future.result["stdout"] <- base::list(NULL)
[15:33:07.403]         }
[15:33:07.403]         base::close(...future.stdout)
[15:33:07.403]         ...future.stdout <- NULL
[15:33:07.403]     }
[15:33:07.403]     ...future.result$conditions <- ...future.conditions
[15:33:07.403]     ...future.result$finished <- base::Sys.time()
[15:33:07.403]     ...future.result
[15:33:07.403] }
[15:33:07.412] Exporting 5 global objects (6.22 KiB) to cluster node #2 ...
[15:33:07.412] Exporting '...future.FUN' (6.11 KiB) to cluster node #2 ...
[15:33:07.416] Exporting '...future.FUN' (6.11 KiB) to cluster node #2 ... DONE
[15:33:07.416] Exporting 'MoreArgs' (0 bytes) to cluster node #2 ...
[15:33:07.416] Exporting 'MoreArgs' (0 bytes) to cluster node #2 ... DONE
[15:33:07.417] Exporting '...future.elements_ii' (112 bytes) to cluster node #2 ...
[15:33:07.418] Exporting '...future.elements_ii' (112 bytes) to cluster node #2 ... DONE
[15:33:07.418] Exporting '...future.seeds_ii' (0 bytes) to cluster node #2 ...
[15:33:07.419] Exporting '...future.seeds_ii' (0 bytes) to cluster node #2 ... DONE
[15:33:07.419] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #2 ...
[15:33:07.420] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #2 ... DONE
[15:33:07.420] Exporting 5 global objects (6.22 KiB) to cluster node #2 ... DONE
[15:33:07.421] MultisessionFuture started
[15:33:07.421] - Launch lazy future ... done
[15:33:07.422] run() for 'MultisessionFuture' ... done
[15:33:07.422] Created future:
[15:33:07.445] receiveMessageFromWorker() for ClusterFuture ...
[15:33:07.446] - Validating connection of MultisessionFuture
[15:33:07.446] - received message: FutureResult
[15:33:07.447] - Received FutureResult
[15:33:07.447] - Erased future from FutureRegistry
[15:33:07.447] result() for ClusterFuture ...
[15:33:07.448] - result already collected: FutureResult
[15:33:07.448] result() for ClusterFuture ... done
[15:33:07.448] receiveMessageFromWorker() for ClusterFuture ... done
[15:33:07.423] MultisessionFuture:
[15:33:07.423] Label: 'future_mapply-2'
[15:33:07.423] Expression:
[15:33:07.423] {
[15:33:07.423]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:33:07.423]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:33:07.423]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:33:07.423]         on.exit(options(oopts), add = TRUE)
[15:33:07.423]     }
[15:33:07.423]     {
[15:33:07.423]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:33:07.423]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:33:07.423]         do.call(mapply, args = args)
[15:33:07.423]     }
[15:33:07.423] }
[15:33:07.423] Lazy evaluation: FALSE
[15:33:07.423] Asynchronous evaluation: TRUE
[15:33:07.423] Local evaluation: TRUE
[15:33:07.423] Environment: R_GlobalEnv
[15:33:07.423] Capture standard output: FALSE
[15:33:07.423] Capture condition classes: 'condition' (excluding 'nothing')
[15:33:07.423] Globals: 5 objects totaling 6.22 KiB (function '...future.FUN' of 6.11 KiB, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 112 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:33:07.423] Packages: <none>
[15:33:07.423] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:33:07.423] Resolved: TRUE
[15:33:07.423] Value: <not collected>
[15:33:07.423] Conditions captured: <none>
[15:33:07.423] Early signaling: FALSE
[15:33:07.423] Owner process: bdd4bc13-919d-bf34-b2cf-84eb53f6e11f
[15:33:07.423] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:33:07.449] Chunk #2 of 2 ... DONE
[15:33:07.449] Launching 2 futures (chunks) ... DONE
[15:33:07.449] Resolving 2 futures (chunks) ...
[15:33:07.449] resolve() on list ...
[15:33:07.450]  recursive: 0
[15:33:07.450]  length: 2
[15:33:07.450] 
[15:33:07.640] Future #2
[15:33:07.641] result() for ClusterFuture ...
[15:33:07.641] - result already collected: FutureResult
[15:33:07.642] result() for ClusterFuture ... done
[15:33:07.642] result() for ClusterFuture ...
[15:33:07.643] - result already collected: FutureResult
[15:33:07.643] result() for ClusterFuture ... done
[15:33:07.643] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:33:07.644] - nx: 2
[15:33:07.644] - relay: TRUE
[15:33:07.644] - stdout: TRUE
[15:33:07.645] - signal: TRUE
[15:33:07.645] - resignal: FALSE
[15:33:07.645] - force: TRUE
[15:33:07.646] - relayed: [n=2] FALSE, FALSE
[15:33:07.646] - queued futures: [n=2] FALSE, FALSE
[15:33:07.647]  - until=1
[15:33:07.647]  - relaying element #1
[15:33:07.647] - relayed: [n=2] FALSE, FALSE
[15:33:07.648] - queued futures: [n=2] FALSE, TRUE
[15:33:07.648] signalConditionsASAP(NULL, pos=2) ... done
[15:33:07.648]  length: 1 (resolved future 2)
[15:33:07.698] receiveMessageFromWorker() for ClusterFuture ...
[15:33:07.698] - Validating connection of MultisessionFuture
[15:33:07.699] - received message: FutureResult
[15:33:07.699] - Received FutureResult
[15:33:07.699] - Erased future from FutureRegistry
[15:33:07.700] result() for ClusterFuture ...
[15:33:07.700] - result already collected: FutureResult
[15:33:07.700] result() for ClusterFuture ... done
[15:33:07.700] receiveMessageFromWorker() for ClusterFuture ... done
[15:33:07.700] Future #1
[15:33:07.701] result() for ClusterFuture ...
[15:33:07.701] - result already collected: FutureResult
[15:33:07.701] result() for ClusterFuture ... done
[15:33:07.701] result() for ClusterFuture ...
[15:33:07.702] - result already collected: FutureResult
[15:33:07.702] result() for ClusterFuture ... done
[15:33:07.702] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:33:07.702] - nx: 2
[15:33:07.703] - relay: TRUE
[15:33:07.703] - stdout: TRUE
[15:33:07.703] - signal: TRUE
[15:33:07.703] - resignal: FALSE
[15:33:07.703] - force: TRUE
[15:33:07.704] - relayed: [n=2] FALSE, FALSE
[15:33:07.704] - queued futures: [n=2] FALSE, TRUE
[15:33:07.704]  - until=1
[15:33:07.704]  - relaying element #1
[15:33:07.705] result() for ClusterFuture ...
[15:33:07.705] - result already collected: FutureResult
[15:33:07.705] result() for ClusterFuture ... done
[15:33:07.705] result() for ClusterFuture ...
[15:33:07.705] - result already collected: FutureResult
[15:33:07.705] result() for ClusterFuture ... done
[15:33:07.706] result() for ClusterFuture ...
[15:33:07.706] - result already collected: FutureResult
[15:33:07.706] result() for ClusterFuture ... done
[15:33:07.706] result() for ClusterFuture ...
[15:33:07.706] - result already collected: FutureResult
[15:33:07.706] result() for ClusterFuture ... done
[15:33:07.706] - relayed: [n=2] TRUE, FALSE
[15:33:07.707] - queued futures: [n=2] TRUE, TRUE
[15:33:07.707] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:33:07.707]  length: 0 (resolved future 1)
[15:33:07.707] Relaying remaining futures
[15:33:07.707] signalConditionsASAP(NULL, pos=0) ...
[15:33:07.707] - nx: 2
[15:33:07.708] - relay: TRUE
[15:33:07.708] - stdout: TRUE
[15:33:07.708] - signal: TRUE
[15:33:07.708] - resignal: FALSE
[15:33:07.708] - force: TRUE
[15:33:07.709] - relayed: [n=2] TRUE, FALSE
[15:33:07.709] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:33:07.709]  - relaying element #2
[15:33:07.709] result() for ClusterFuture ...
[15:33:07.709] - result already collected: FutureResult
[15:33:07.709] result() for ClusterFuture ... done
[15:33:07.710] result() for ClusterFuture ...
[15:33:07.710] - result already collected: FutureResult
[15:33:07.710] result() for ClusterFuture ... done
[15:33:07.710] result() for ClusterFuture ...
[15:33:07.710] - result already collected: FutureResult
[15:33:07.711] result() for ClusterFuture ... done
[15:33:07.711] result() for ClusterFuture ...
[15:33:07.711] - result already collected: FutureResult
[15:33:07.711] result() for ClusterFuture ... done
[15:33:07.712] - relayed: [n=2] TRUE, TRUE
[15:33:07.712] - queued futures: [n=2] TRUE, TRUE
[15:33:07.712] signalConditionsASAP(MultisessionFuture, pos=0) ... done
[15:33:07.712] resolve() on list ... DONE
[15:33:07.713] result() for ClusterFuture ...
[15:33:07.713] - result already collected: FutureResult
[15:33:07.713] result() for ClusterFuture ... done
[15:33:07.713] result() for ClusterFuture ...
[15:33:07.714] - result already collected: FutureResult
[15:33:07.714] result() for ClusterFuture ... done
[15:33:07.714] result() for ClusterFuture ...
[15:33:07.714] - result already collected: FutureResult
[15:33:07.715] result() for ClusterFuture ... done
[15:33:07.715] result() for ClusterFuture ...
[15:33:07.715] - result already collected: FutureResult
[15:33:07.715] result() for ClusterFuture ... done
[15:33:07.716]  - Number of value chunks collected: 2
[15:33:07.716] Resolving 2 futures (chunks) ... DONE
[15:33:07.716] Reducing values from 2 chunks ...
[15:33:07.716]  - Number of values collected after concatenation: 2
[15:33:07.717]  - Number of values expected: 2
[15:33:07.717] Reducing values from 2 chunks ... DONE
[15:33:07.717] future_mapply() ... DONE
* future_mapply(x, ..., future.stdout = FALSE) ... DONE
* future_mapply(x, ..., future.stdout = TRUE) ...
[15:33:07.718] future_mapply() ...
[15:33:07.722] Number of chunks: 2
[15:33:07.722] getGlobalsAndPackagesXApply() ...
[15:33:07.722]  - future.globals: TRUE
[15:33:07.722] getGlobalsAndPackages() ...
[15:33:07.723] Searching for globals...
[15:33:07.726] - globals found: [6] 'FUN', '{', 'Sys.sleep', '/', 'print', 'list'
[15:33:07.726] Searching for globals ... DONE
[15:33:07.726] Resolving globals: FALSE
[15:33:07.727] The total size of the 1 globals is 6.11 KiB (6256 bytes)
[15:33:07.728] The total size of the 1 globals exported for future expression ('FUN()') is 6.11 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (6.11 KiB of class 'function')
[15:33:07.728] - globals: [1] 'FUN'
[15:33:07.729] 
[15:33:07.729] getGlobalsAndPackages() ... DONE
[15:33:07.729]  - globals found/used: [n=1] 'FUN'
[15:33:07.729]  - needed namespaces: [n=0] 
[15:33:07.730] Finding globals ... DONE
[15:33:07.730] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[15:33:07.730] List of 2
[15:33:07.730]  $ ...future.FUN:function (x, y)  
[15:33:07.730]  $ MoreArgs     : NULL
[15:33:07.730]  - attr(*, "where")=List of 2
[15:33:07.730]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:33:07.730]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[15:33:07.730]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:33:07.730]  - attr(*, "resolved")= logi FALSE
[15:33:07.730]  - attr(*, "total_size")= num NA
[15:33:07.735] Packages to be attached in all futures: [n=0] 
[15:33:07.736] getGlobalsAndPackagesXApply() ... DONE
[15:33:07.736] Number of futures (= number of chunks): 2
[15:33:07.736] Launching 2 futures (chunks) ...
[15:33:07.737] Chunk #1 of 2 ...
[15:33:07.737]  - Finding globals in '...' for chunk #1 ...
[15:33:07.737] getGlobalsAndPackages() ...
[15:33:07.738] Searching for globals...
[15:33:07.738] 
[15:33:07.739] Searching for globals ... DONE
[15:33:07.739] - globals: [0] <none>
[15:33:07.739] getGlobalsAndPackages() ... DONE
[15:33:07.739]    + additional globals found: [n=0] 
[15:33:07.740]    + additional namespaces needed: [n=0] 
[15:33:07.740]  - Finding globals in '...' for chunk #1 ... DONE
[15:33:07.740]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:33:07.740]  - seeds: <none>
[15:33:07.741]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:33:07.741] getGlobalsAndPackages() ...
[15:33:07.741] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:33:07.742] Resolving globals: FALSE
[15:33:07.742] The total size of the 5 globals is 6.22 KiB (6368 bytes)
[15:33:07.744] The total size of the 5 globals exported for future expression ('{; ...future.globals.maxSize.org <- getOption("future.globals.maxSize"); if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {; oopts <- options(future.globals.maxSize = ...future.globals.maxSize); on.exit(options(oopts), add = TRUE); }; ...; do.call(mapply, args = args); }; }') is 6.22 KiB.. This exceeds the maximum allowed size of 0.98 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (6.11 KiB of class 'function'), '...future.elements_ii' (112 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[15:33:07.744] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:33:07.744] 
[15:33:07.744] getGlobalsAndPackages() ... DONE
[15:33:07.745] run() for 'Future' ...
[15:33:07.745] - state: 'created'
[15:33:07.746] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:33:07.763] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:33:07.764] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:33:07.764]   - Field: 'node'
[15:33:07.764]   - Field: 'label'
[15:33:07.765]   - Field: 'local'
[15:33:07.765]   - Field: 'owner'
[15:33:07.765]   - Field: 'envir'
[15:33:07.766]   - Field: 'workers'
[15:33:07.766]   - Field: 'packages'
[15:33:07.766]   - Field: 'gc'
[15:33:07.766]   - Field: 'conditions'
[15:33:07.767]   - Field: 'persistent'
[15:33:07.767]   - Field: 'expr'
[15:33:07.767]   - Field: 'uuid'
[15:33:07.768]   - Field: 'seed'
[15:33:07.768]   - Field: 'version'
[15:33:07.768]   - Field: 'result'
[15:33:07.768]   - Field: 'asynchronous'
[15:33:07.769]   - Field: 'calls'
[15:33:07.769]   - Field: 'globals'
[15:33:07.769]   - Field: 'stdout'
[15:33:07.770]   - Field: 'earlySignal'
[15:33:07.770]   - Field: 'lazy'
[15:33:07.770]   - Field: 'state'
[15:33:07.771] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:33:07.771] - Launch lazy future ...
[15:33:07.771] Packages needed by the future expression (n = 0): <none>
[15:33:07.772] Packages needed by future strategies (n = 0): <none>
[15:33:07.773] {
[15:33:07.773]     {
[15:33:07.773]         {
[15:33:07.773]             ...future.startTime <- base::Sys.time()
[15:33:07.773]             {
[15:33:07.773]                 {
[15:33:07.773]                   {
[15:33:07.773]                     {
[15:33:07.773]                       base::local({
[15:33:07.773]                         has_future <- base::requireNamespace("future", 
[15:33:07.773]                           quietly = TRUE)
[15:33:07.773]                         if (has_future) {
[15:33:07.773]                           ns <- base::getNamespace("future")
[15:33:07.773]                           version <- ns[[".package"]][["version"]]
[15:33:07.773]                           if (is.null(version)) 
[15:33:07.773]                             version <- utils::packageVersion("future")
[15:33:07.773]                         }
[15:33:07.773]                         else {
[15:33:07.773]                           version <- NULL
[15:33:07.773]                         }
[15:33:07.773]                         if (!has_future || version < "1.8.0") {
[15:33:07.773]                           info <- base::c(r_version = base::gsub("R version ", 
[15:33:07.773]                             "", base::R.version$version.string), 
[15:33:07.773]                             platform = base::sprintf("%s (%s-bit)", 
[15:33:07.773]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:33:07.773]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:33:07.773]                               "release", "version")], collapse = " "), 
[15:33:07.773]                             hostname = base::Sys.info()[["nodename"]])
[15:33:07.773]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:33:07.773]                             info)
[15:33:07.773]                           info <- base::paste(info, collapse = "; ")
[15:33:07.773]                           if (!has_future) {
[15:33:07.773]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:33:07.773]                               info)
[15:33:07.773]                           }
[15:33:07.773]                           else {
[15:33:07.773]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:33:07.773]                               info, version)
[15:33:07.773]                           }
[15:33:07.773]                           base::stop(msg)
[15:33:07.773]                         }
[15:33:07.773]                       })
[15:33:07.773]                     }
[15:33:07.773]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:33:07.773]                     base::options(mc.cores = 1L)
[15:33:07.773]                   }
[15:33:07.773]                   ...future.strategy.old <- future::plan("list")
[15:33:07.773]                   options(future.plan = NULL)
[15:33:07.773]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:33:07.773]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:33:07.773]                 }
[15:33:07.773]                 ...future.workdir <- getwd()
[15:33:07.773]             }
[15:33:07.773]             ...future.oldOptions <- base::as.list(base::.Options)
[15:33:07.773]             ...future.oldEnvVars <- base::Sys.getenv()
[15:33:07.773]         }
[15:33:07.773]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:33:07.773]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:33:07.773]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:33:07.773]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:33:07.773]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:33:07.773]             future.stdout.windows.reencode = NULL, width = 80L)
[15:33:07.773]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:33:07.773]             base::names(...future.oldOptions))
[15:33:07.773]     }
[15:33:07.773]     if (FALSE) {
[15:33:07.773]     }
[15:33:07.773]     else {
[15:33:07.773]         if (TRUE) {
[15:33:07.773]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:33:07.773]                 open = "w")
[15:33:07.773]         }
[15:33:07.773]         else {
[15:33:07.773]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:33:07.773]                 windows = "NUL", "/dev/null"), open = "w")
[15:33:07.773]         }
[15:33:07.773]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:33:07.773]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:33:07.773]             base::sink(type = "output", split = FALSE)
[15:33:07.773]             base::close(...future.stdout)
[15:33:07.773]         }, add = TRUE)
[15:33:07.773]     }
[15:33:07.773]     ...future.frame <- base::sys.nframe()
[15:33:07.773]     ...future.conditions <- base::list()
[15:33:07.773]     ...future.rng <- base::globalenv()$.Random.seed
[15:33:07.773]     if (FALSE) {
[15:33:07.773]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:33:07.773]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:33:07.773]     }
[15:33:07.773]     ...future.result <- base::tryCatch({
[15:33:07.773]         base::withCallingHandlers({
[15:33:07.773]             ...future.value <- base::withVisible(base::local({
[15:33:07.773]                 ...future.makeSendCondition <- base::local({
[15:33:07.773]                   sendCondition <- NULL
[15:33:07.773]                   function(frame = 1L) {
[15:33:07.773]                     if (is.function(sendCondition)) 
[15:33:07.773]                       return(sendCondition)
[15:33:07.773]                     ns <- getNamespace("parallel")
[15:33:07.773]                     if (exists("sendData", mode = "function", 
[15:33:07.773]                       envir = ns)) {
[15:33:07.773]                       parallel_sendData <- get("sendData", mode = "function", 
[15:33:07.773]                         envir = ns)
[15:33:07.773]                       envir <- sys.frame(frame)
[15:33:07.773]                       master <- NULL
[15:33:07.773]                       while (!identical(envir, .GlobalEnv) && 
[15:33:07.773]                         !identical(envir, emptyenv())) {
[15:33:07.773]                         if (exists("master", mode = "list", envir = envir, 
[15:33:07.773]                           inherits = FALSE)) {
[15:33:07.773]                           master <- get("master", mode = "list", 
[15:33:07.773]                             envir = envir, inherits = FALSE)
[15:33:07.773]                           if (inherits(master, c("SOCKnode", 
[15:33:07.773]                             "SOCK0node"))) {
[15:33:07.773]                             sendCondition <<- function(cond) {
[15:33:07.773]                               data <- list(type = "VALUE", value = cond, 
[15:33:07.773]                                 success = TRUE)
[15:33:07.773]                               parallel_sendData(master, data)
[15:33:07.773]                             }
[15:33:07.773]                             return(sendCondition)
[15:33:07.773]                           }
[15:33:07.773]                         }
[15:33:07.773]                         frame <- frame + 1L
[15:33:07.773]                         envir <- sys.frame(frame)
[15:33:07.773]                       }
[15:33:07.773]                     }
[15:33:07.773]                     sendCondition <<- function(cond) NULL
[15:33:07.773]                   }
[15:33:07.773]                 })
[15:33:07.773]                 withCallingHandlers({
[15:33:07.773]                   {
[15:33:07.773]                     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:33:07.773]                     if (!identical(...future.globals.maxSize.org, 
[15:33:07.773]                       ...future.globals.maxSize)) {
[15:33:07.773]                       oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:33:07.773]                       on.exit(options(oopts), add = TRUE)
[15:33:07.773]                     }
[15:33:07.773]                     {
[15:33:07.773]                       args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:33:07.773]                         MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:33:07.773]                         USE.NAMES = FALSE)
[15:33:07.773]                       do.call(mapply, args = args)
[15:33:07.773]                     }
[15:33:07.773]                   }
[15:33:07.773]                 }, immediateCondition = function(cond) {
[15:33:07.773]                   sendCondition <- ...future.makeSendCondition()
[15:33:07.773]                   sendCondition(cond)
[15:33:07.773]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:33:07.773]                   {
[15:33:07.773]                     inherits <- base::inherits
[15:33:07.773]                     invokeRestart <- base::invokeRestart
[15:33:07.773]                     is.null <- base::is.null
[15:33:07.773]                     muffled <- FALSE
[15:33:07.773]                     if (inherits(cond, "message")) {
[15:33:07.773]                       muffled <- grepl(pattern, "muffleMessage")
[15:33:07.773]                       if (muffled) 
[15:33:07.773]                         invokeRestart("muffleMessage")
[15:33:07.773]                     }
[15:33:07.773]                     else if (inherits(cond, "warning")) {
[15:33:07.773]                       muffled <- grepl(pattern, "muffleWarning")
[15:33:07.773]                       if (muffled) 
[15:33:07.773]                         invokeRestart("muffleWarning")
[15:33:07.773]                     }
[15:33:07.773]                     else if (inherits(cond, "condition")) {
[15:33:07.773]                       if (!is.null(pattern)) {
[15:33:07.773]                         computeRestarts <- base::computeRestarts
[15:33:07.773]                         grepl <- base::grepl
[15:33:07.773]                         restarts <- computeRestarts(cond)
[15:33:07.773]                         for (restart in restarts) {
[15:33:07.773]                           name <- restart$name
[15:33:07.773]                           if (is.null(name)) 
[15:33:07.773]                             next
[15:33:07.773]                           if (!grepl(pattern, name)) 
[15:33:07.773]                             next
[15:33:07.773]                           invokeRestart(restart)
[15:33:07.773]                           muffled <- TRUE
[15:33:07.773]                           break
[15:33:07.773]                         }
[15:33:07.773]                       }
[15:33:07.773]                     }
[15:33:07.773]                     invisible(muffled)
[15:33:07.773]                   }
[15:33:07.773]                   muffleCondition(cond)
[15:33:07.773]                 })
[15:33:07.773]             }))
[15:33:07.773]             future::FutureResult(value = ...future.value$value, 
[15:33:07.773]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:33:07.773]                   ...future.rng), globalenv = if (FALSE) 
[15:33:07.773]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:33:07.773]                     ...future.globalenv.names))
[15:33:07.773]                 else NULL, started = ...future.startTime, version = "1.8")
[15:33:07.773]         }, condition = base::local({
[15:33:07.773]             c <- base::c
[15:33:07.773]             inherits <- base::inherits
[15:33:07.773]             invokeRestart <- base::invokeRestart
[15:33:07.773]             length <- base::length
[15:33:07.773]             list <- base::list
[15:33:07.773]             seq.int <- base::seq.int
[15:33:07.773]             signalCondition <- base::signalCondition
[15:33:07.773]             sys.calls <- base::sys.calls
[15:33:07.773]             `[[` <- base::`[[`
[15:33:07.773]             `+` <- base::`+`
[15:33:07.773]             `<<-` <- base::`<<-`
[15:33:07.773]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:33:07.773]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:33:07.773]                   3L)]
[15:33:07.773]             }
[15:33:07.773]             function(cond) {
[15:33:07.773]                 is_error <- inherits(cond, "error")
[15:33:07.773]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:33:07.773]                   NULL)
[15:33:07.773]                 if (is_error) {
[15:33:07.773]                   sessionInformation <- function() {
[15:33:07.773]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:33:07.773]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:33:07.773]                       search = base::search(), system = base::Sys.info())
[15:33:07.773]                   }
[15:33:07.773]                   ...future.conditions[[length(...future.conditions) + 
[15:33:07.773]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:33:07.773]                     cond$call), session = sessionInformation(), 
[15:33:07.773]                     timestamp = base::Sys.time(), signaled = 0L)
[15:33:07.773]                   signalCondition(cond)
[15:33:07.773]                 }
[15:33:07.773]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:33:07.773]                 "immediateCondition"))) {
[15:33:07.773]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:33:07.773]                   ...future.conditions[[length(...future.conditions) + 
[15:33:07.773]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:33:07.773]                   if (TRUE && !signal) {
[15:33:07.773]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:33:07.773]                     {
[15:33:07.773]                       inherits <- base::inherits
[15:33:07.773]                       invokeRestart <- base::invokeRestart
[15:33:07.773]                       is.null <- base::is.null
[15:33:07.773]                       muffled <- FALSE
[15:33:07.773]                       if (inherits(cond, "message")) {
[15:33:07.773]                         muffled <- grepl(pattern, "muffleMessage")
[15:33:07.773]                         if (muffled) 
[15:33:07.773]                           invokeRestart("muffleMessage")
[15:33:07.773]                       }
[15:33:07.773]                       else if (inherits(cond, "warning")) {
[15:33:07.773]                         muffled <- grepl(pattern, "muffleWarning")
[15:33:07.773]                         if (muffled) 
[15:33:07.773]                           invokeRestart("muffleWarning")
[15:33:07.773]                       }
[15:33:07.773]                       else if (inherits(cond, "condition")) {
[15:33:07.773]                         if (!is.null(pattern)) {
[15:33:07.773]                           computeRestarts <- base::computeRestarts
[15:33:07.773]                           grepl <- base::grepl
[15:33:07.773]                           restarts <- computeRestarts(cond)
[15:33:07.773]                           for (restart in restarts) {
[15:33:07.773]                             name <- restart$name
[15:33:07.773]                             if (is.null(name)) 
[15:33:07.773]                               next
[15:33:07.773]                             if (!grepl(pattern, name)) 
[15:33:07.773]                               next
[15:33:07.773]                             invokeRestart(restart)
[15:33:07.773]                             muffled <- TRUE
[15:33:07.773]                             break
[15:33:07.773]                           }
[15:33:07.773]                         }
[15:33:07.773]                       }
[15:33:07.773]                       invisible(muffled)
[15:33:07.773]                     }
[15:33:07.773]                     muffleCondition(cond, pattern = "^muffle")
[15:33:07.773]                   }
[15:33:07.773]                 }
[15:33:07.773]                 else {
[15:33:07.773]                   if (TRUE) {
[15:33:07.773]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:33:07.773]                     {
[15:33:07.773]                       inherits <- base::inherits
[15:33:07.773]                       invokeRestart <- base::invokeRestart
[15:33:07.773]                       is.null <- base::is.null
[15:33:07.773]                       muffled <- FALSE
[15:33:07.773]                       if (inherits(cond, "message")) {
[15:33:07.773]                         muffled <- grepl(pattern, "muffleMessage")
[15:33:07.773]                         if (muffled) 
[15:33:07.773]                           invokeRestart("muffleMessage")
[15:33:07.773]                       }
[15:33:07.773]                       else if (inherits(cond, "warning")) {
[15:33:07.773]                         muffled <- grepl(pattern, "muffleWarning")
[15:33:07.773]                         if (muffled) 
[15:33:07.773]                           invokeRestart("muffleWarning")
[15:33:07.773]                       }
[15:33:07.773]                       else if (inherits(cond, "condition")) {
[15:33:07.773]                         if (!is.null(pattern)) {
[15:33:07.773]                           computeRestarts <- base::computeRestarts
[15:33:07.773]                           grepl <- base::grepl
[15:33:07.773]                           restarts <- computeRestarts(cond)
[15:33:07.773]                           for (restart in restarts) {
[15:33:07.773]                             name <- restart$name
[15:33:07.773]                             if (is.null(name)) 
[15:33:07.773]                               next
[15:33:07.773]                             if (!grepl(pattern, name)) 
[15:33:07.773]                               next
[15:33:07.773]                             invokeRestart(restart)
[15:33:07.773]                             muffled <- TRUE
[15:33:07.773]                             break
[15:33:07.773]                           }
[15:33:07.773]                         }
[15:33:07.773]                       }
[15:33:07.773]                       invisible(muffled)
[15:33:07.773]                     }
[15:33:07.773]                     muffleCondition(cond, pattern = "^muffle")
[15:33:07.773]                   }
[15:33:07.773]                 }
[15:33:07.773]             }
[15:33:07.773]         }))
[15:33:07.773]     }, error = function(ex) {
[15:33:07.773]         base::structure(base::list(value = NULL, visible = NULL, 
[15:33:07.773]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:33:07.773]                 ...future.rng), started = ...future.startTime, 
[15:33:07.773]             finished = Sys.time(), session_uuid = NA_character_, 
[15:33:07.773]             version = "1.8"), class = "FutureResult")
[15:33:07.773]     }, finally = {
[15:33:07.773]         if (!identical(...future.workdir, getwd())) 
[15:33:07.773]             setwd(...future.workdir)
[15:33:07.773]         {
[15:33:07.773]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:33:07.773]                 ...future.oldOptions$nwarnings <- NULL
[15:33:07.773]             }
[15:33:07.773]             base::options(...future.oldOptions)
[15:33:07.773]             if (.Platform$OS.type == "windows") {
[15:33:07.773]                 old_names <- names(...future.oldEnvVars)
[15:33:07.773]                 envs <- base::Sys.getenv()
[15:33:07.773]                 names <- names(envs)
[15:33:07.773]                 common <- intersect(names, old_names)
[15:33:07.773]                 added <- setdiff(names, old_names)
[15:33:07.773]                 removed <- setdiff(old_names, names)
[15:33:07.773]                 changed <- common[...future.oldEnvVars[common] != 
[15:33:07.773]                   envs[common]]
[15:33:07.773]                 NAMES <- toupper(changed)
[15:33:07.773]                 args <- list()
[15:33:07.773]                 for (kk in seq_along(NAMES)) {
[15:33:07.773]                   name <- changed[[kk]]
[15:33:07.773]                   NAME <- NAMES[[kk]]
[15:33:07.773]                   if (name != NAME && is.element(NAME, old_names)) 
[15:33:07.773]                     next
[15:33:07.773]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:33:07.773]                 }
[15:33:07.773]                 NAMES <- toupper(added)
[15:33:07.773]                 for (kk in seq_along(NAMES)) {
[15:33:07.773]                   name <- added[[kk]]
[15:33:07.773]                   NAME <- NAMES[[kk]]
[15:33:07.773]                   if (name != NAME && is.element(NAME, old_names)) 
[15:33:07.773]                     next
[15:33:07.773]                   args[[name]] <- ""
[15:33:07.773]                 }
[15:33:07.773]                 NAMES <- toupper(removed)
[15:33:07.773]                 for (kk in seq_along(NAMES)) {
[15:33:07.773]                   name <- removed[[kk]]
[15:33:07.773]                   NAME <- NAMES[[kk]]
[15:33:07.773]                   if (name != NAME && is.element(NAME, old_names)) 
[15:33:07.773]                     next
[15:33:07.773]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:33:07.773]                 }
[15:33:07.773]                 if (length(args) > 0) 
[15:33:07.773]                   base::do.call(base::Sys.setenv, args = args)
[15:33:07.773]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:33:07.773]             }
[15:33:07.773]             else {
[15:33:07.773]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:33:07.773]             }
[15:33:07.773]             {
[15:33:07.773]                 if (base::length(...future.futureOptionsAdded) > 
[15:33:07.773]                   0L) {
[15:33:07.773]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:33:07.773]                   base::names(opts) <- ...future.futureOptionsAdded
[15:33:07.773]                   base::options(opts)
[15:33:07.773]                 }
[15:33:07.773]                 {
[15:33:07.773]                   {
[15:33:07.773]                     base::options(mc.cores = ...future.mc.cores.old)
[15:33:07.773]                     NULL
[15:33:07.773]                   }
[15:33:07.773]                   options(future.plan = NULL)
[15:33:07.773]                   if (is.na(NA_character_)) 
[15:33:07.773]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:33:07.773]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:33:07.773]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:33:07.773]                     .init = FALSE)
[15:33:07.773]                 }
[15:33:07.773]             }
[15:33:07.773]         }
[15:33:07.773]     })
[15:33:07.773]     if (TRUE) {
[15:33:07.773]         base::sink(type = "output", split = FALSE)
[15:33:07.773]         if (TRUE) {
[15:33:07.773]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:33:07.773]         }
[15:33:07.773]         else {
[15:33:07.773]             ...future.result["stdout"] <- base::list(NULL)
[15:33:07.773]         }
[15:33:07.773]         base::close(...future.stdout)
[15:33:07.773]         ...future.stdout <- NULL
[15:33:07.773]     }
[15:33:07.773]     ...future.result$conditions <- ...future.conditions
[15:33:07.773]     ...future.result$finished <- base::Sys.time()
[15:33:07.773]     ...future.result
[15:33:07.773] }
[15:33:07.782] Exporting 5 global objects (6.22 KiB) to cluster node #1 ...
[15:33:07.783] Exporting '...future.FUN' (6.11 KiB) to cluster node #1 ...
[15:33:07.783] Exporting '...future.FUN' (6.11 KiB) to cluster node #1 ... DONE
[15:33:07.784] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ...
[15:33:07.784] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ... DONE
[15:33:07.784] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:33:07.785] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:33:07.785] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:33:07.786] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:33:07.786] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:33:07.787] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:33:07.787] Exporting 5 global objects (6.22 KiB) to cluster node #1 ... DONE
[15:33:07.788] MultisessionFuture started
[15:33:07.788] - Launch lazy future ... done
[15:33:07.789] run() for 'MultisessionFuture' ... done
[15:33:07.789] Created future:
[15:33:07.789] MultisessionFuture:
[15:33:07.789] Label: 'future_mapply-1'
[15:33:07.789] Expression:
[15:33:07.789] {
[15:33:07.789]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:33:07.789]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:33:07.789]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:33:07.789]         on.exit(options(oopts), add = TRUE)
[15:33:07.789]     }
[15:33:07.789]     {
[15:33:07.789]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:33:07.789]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:33:07.789]         do.call(mapply, args = args)
[15:33:07.789]     }
[15:33:07.789] }
[15:33:07.789] Lazy evaluation: FALSE
[15:33:07.789] Asynchronous evaluation: TRUE
[15:33:07.789] Local evaluation: TRUE
[15:33:07.789] Environment: R_GlobalEnv
[15:33:07.789] Capture standard output: TRUE
[15:33:07.789] Capture condition classes: 'condition' (excluding 'nothing')
[15:33:07.789] Globals: 5 objects totaling 6.22 KiB (function '...future.FUN' of 6.11 KiB, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 112 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:33:07.789] Packages: <none>
[15:33:07.789] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:33:07.789] Resolved: FALSE
[15:33:07.789] Value: <not collected>
[15:33:07.789] Conditions captured: <none>
[15:33:07.789] Early signaling: FALSE
[15:33:07.789] Owner process: bdd4bc13-919d-bf34-b2cf-84eb53f6e11f
[15:33:07.789] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:33:07.985] Chunk #1 of 2 ... DONE
[15:33:07.985] Chunk #2 of 2 ...
[15:33:07.985]  - Finding globals in '...' for chunk #2 ...
[15:33:07.986] getGlobalsAndPackages() ...
[15:33:07.986] Searching for globals...
[15:33:07.987] 
[15:33:07.987] Searching for globals ... DONE
[15:33:07.987] - globals: [0] <none>
[15:33:07.987] getGlobalsAndPackages() ... DONE
[15:33:07.988]    + additional globals found: [n=0] 
[15:33:07.988]    + additional namespaces needed: [n=0] 
[15:33:07.988]  - Finding globals in '...' for chunk #2 ... DONE
[15:33:07.988]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:33:07.989]  - seeds: <none>
[15:33:07.989]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:33:07.989] getGlobalsAndPackages() ...
[15:33:07.989] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:33:07.990] Resolving globals: FALSE
[15:33:07.991] The total size of the 5 globals is 6.22 KiB (6368 bytes)
[15:33:07.991] The total size of the 5 globals exported for future expression ('{; ...future.globals.maxSize.org <- getOption("future.globals.maxSize"); if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {; oopts <- options(future.globals.maxSize = ...future.globals.maxSize); on.exit(options(oopts), add = TRUE); }; ...; do.call(mapply, args = args); }; }') is 6.22 KiB.. This exceeds the maximum allowed size of 0.98 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (6.11 KiB of class 'function'), '...future.elements_ii' (112 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[15:33:07.992] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:33:07.992] 
[15:33:07.992] getGlobalsAndPackages() ... DONE
[15:33:07.993] run() for 'Future' ...
[15:33:07.993] - state: 'created'
[15:33:07.993] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:33:08.011] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:33:08.012] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:33:08.012]   - Field: 'node'
[15:33:08.012]   - Field: 'label'
[15:33:08.013]   - Field: 'local'
[15:33:08.013]   - Field: 'owner'
[15:33:08.013]   - Field: 'envir'
[15:33:08.014]   - Field: 'workers'
[15:33:08.014]   - Field: 'packages'
[15:33:08.014]   - Field: 'gc'
[15:33:08.015]   - Field: 'conditions'
[15:33:08.015]   - Field: 'persistent'
[15:33:08.015]   - Field: 'expr'
[15:33:08.016]   - Field: 'uuid'
[15:33:08.016]   - Field: 'seed'
[15:33:08.016]   - Field: 'version'
[15:33:08.017]   - Field: 'result'
[15:33:08.017]   - Field: 'asynchronous'
[15:33:08.017]   - Field: 'calls'
[15:33:08.018]   - Field: 'globals'
[15:33:08.018]   - Field: 'stdout'
[15:33:08.018]   - Field: 'earlySignal'
[15:33:08.019]   - Field: 'lazy'
[15:33:08.019]   - Field: 'state'
[15:33:08.019] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:33:08.020] - Launch lazy future ...
[15:33:08.020] Packages needed by the future expression (n = 0): <none>
[15:33:08.021] Packages needed by future strategies (n = 0): <none>
[15:33:08.022] {
[15:33:08.022]     {
[15:33:08.022]         {
[15:33:08.022]             ...future.startTime <- base::Sys.time()
[15:33:08.022]             {
[15:33:08.022]                 {
[15:33:08.022]                   {
[15:33:08.022]                     {
[15:33:08.022]                       base::local({
[15:33:08.022]                         has_future <- base::requireNamespace("future", 
[15:33:08.022]                           quietly = TRUE)
[15:33:08.022]                         if (has_future) {
[15:33:08.022]                           ns <- base::getNamespace("future")
[15:33:08.022]                           version <- ns[[".package"]][["version"]]
[15:33:08.022]                           if (is.null(version)) 
[15:33:08.022]                             version <- utils::packageVersion("future")
[15:33:08.022]                         }
[15:33:08.022]                         else {
[15:33:08.022]                           version <- NULL
[15:33:08.022]                         }
[15:33:08.022]                         if (!has_future || version < "1.8.0") {
[15:33:08.022]                           info <- base::c(r_version = base::gsub("R version ", 
[15:33:08.022]                             "", base::R.version$version.string), 
[15:33:08.022]                             platform = base::sprintf("%s (%s-bit)", 
[15:33:08.022]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:33:08.022]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:33:08.022]                               "release", "version")], collapse = " "), 
[15:33:08.022]                             hostname = base::Sys.info()[["nodename"]])
[15:33:08.022]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:33:08.022]                             info)
[15:33:08.022]                           info <- base::paste(info, collapse = "; ")
[15:33:08.022]                           if (!has_future) {
[15:33:08.022]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:33:08.022]                               info)
[15:33:08.022]                           }
[15:33:08.022]                           else {
[15:33:08.022]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:33:08.022]                               info, version)
[15:33:08.022]                           }
[15:33:08.022]                           base::stop(msg)
[15:33:08.022]                         }
[15:33:08.022]                       })
[15:33:08.022]                     }
[15:33:08.022]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:33:08.022]                     base::options(mc.cores = 1L)
[15:33:08.022]                   }
[15:33:08.022]                   ...future.strategy.old <- future::plan("list")
[15:33:08.022]                   options(future.plan = NULL)
[15:33:08.022]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:33:08.022]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:33:08.022]                 }
[15:33:08.022]                 ...future.workdir <- getwd()
[15:33:08.022]             }
[15:33:08.022]             ...future.oldOptions <- base::as.list(base::.Options)
[15:33:08.022]             ...future.oldEnvVars <- base::Sys.getenv()
[15:33:08.022]         }
[15:33:08.022]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:33:08.022]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:33:08.022]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:33:08.022]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:33:08.022]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:33:08.022]             future.stdout.windows.reencode = NULL, width = 80L)
[15:33:08.022]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:33:08.022]             base::names(...future.oldOptions))
[15:33:08.022]     }
[15:33:08.022]     if (FALSE) {
[15:33:08.022]     }
[15:33:08.022]     else {
[15:33:08.022]         if (TRUE) {
[15:33:08.022]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:33:08.022]                 open = "w")
[15:33:08.022]         }
[15:33:08.022]         else {
[15:33:08.022]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:33:08.022]                 windows = "NUL", "/dev/null"), open = "w")
[15:33:08.022]         }
[15:33:08.022]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:33:08.022]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:33:08.022]             base::sink(type = "output", split = FALSE)
[15:33:08.022]             base::close(...future.stdout)
[15:33:08.022]         }, add = TRUE)
[15:33:08.022]     }
[15:33:08.022]     ...future.frame <- base::sys.nframe()
[15:33:08.022]     ...future.conditions <- base::list()
[15:33:08.022]     ...future.rng <- base::globalenv()$.Random.seed
[15:33:08.022]     if (FALSE) {
[15:33:08.022]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:33:08.022]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:33:08.022]     }
[15:33:08.022]     ...future.result <- base::tryCatch({
[15:33:08.022]         base::withCallingHandlers({
[15:33:08.022]             ...future.value <- base::withVisible(base::local({
[15:33:08.022]                 ...future.makeSendCondition <- base::local({
[15:33:08.022]                   sendCondition <- NULL
[15:33:08.022]                   function(frame = 1L) {
[15:33:08.022]                     if (is.function(sendCondition)) 
[15:33:08.022]                       return(sendCondition)
[15:33:08.022]                     ns <- getNamespace("parallel")
[15:33:08.022]                     if (exists("sendData", mode = "function", 
[15:33:08.022]                       envir = ns)) {
[15:33:08.022]                       parallel_sendData <- get("sendData", mode = "function", 
[15:33:08.022]                         envir = ns)
[15:33:08.022]                       envir <- sys.frame(frame)
[15:33:08.022]                       master <- NULL
[15:33:08.022]                       while (!identical(envir, .GlobalEnv) && 
[15:33:08.022]                         !identical(envir, emptyenv())) {
[15:33:08.022]                         if (exists("master", mode = "list", envir = envir, 
[15:33:08.022]                           inherits = FALSE)) {
[15:33:08.022]                           master <- get("master", mode = "list", 
[15:33:08.022]                             envir = envir, inherits = FALSE)
[15:33:08.022]                           if (inherits(master, c("SOCKnode", 
[15:33:08.022]                             "SOCK0node"))) {
[15:33:08.022]                             sendCondition <<- function(cond) {
[15:33:08.022]                               data <- list(type = "VALUE", value = cond, 
[15:33:08.022]                                 success = TRUE)
[15:33:08.022]                               parallel_sendData(master, data)
[15:33:08.022]                             }
[15:33:08.022]                             return(sendCondition)
[15:33:08.022]                           }
[15:33:08.022]                         }
[15:33:08.022]                         frame <- frame + 1L
[15:33:08.022]                         envir <- sys.frame(frame)
[15:33:08.022]                       }
[15:33:08.022]                     }
[15:33:08.022]                     sendCondition <<- function(cond) NULL
[15:33:08.022]                   }
[15:33:08.022]                 })
[15:33:08.022]                 withCallingHandlers({
[15:33:08.022]                   {
[15:33:08.022]                     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:33:08.022]                     if (!identical(...future.globals.maxSize.org, 
[15:33:08.022]                       ...future.globals.maxSize)) {
[15:33:08.022]                       oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:33:08.022]                       on.exit(options(oopts), add = TRUE)
[15:33:08.022]                     }
[15:33:08.022]                     {
[15:33:08.022]                       args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:33:08.022]                         MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:33:08.022]                         USE.NAMES = FALSE)
[15:33:08.022]                       do.call(mapply, args = args)
[15:33:08.022]                     }
[15:33:08.022]                   }
[15:33:08.022]                 }, immediateCondition = function(cond) {
[15:33:08.022]                   sendCondition <- ...future.makeSendCondition()
[15:33:08.022]                   sendCondition(cond)
[15:33:08.022]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:33:08.022]                   {
[15:33:08.022]                     inherits <- base::inherits
[15:33:08.022]                     invokeRestart <- base::invokeRestart
[15:33:08.022]                     is.null <- base::is.null
[15:33:08.022]                     muffled <- FALSE
[15:33:08.022]                     if (inherits(cond, "message")) {
[15:33:08.022]                       muffled <- grepl(pattern, "muffleMessage")
[15:33:08.022]                       if (muffled) 
[15:33:08.022]                         invokeRestart("muffleMessage")
[15:33:08.022]                     }
[15:33:08.022]                     else if (inherits(cond, "warning")) {
[15:33:08.022]                       muffled <- grepl(pattern, "muffleWarning")
[15:33:08.022]                       if (muffled) 
[15:33:08.022]                         invokeRestart("muffleWarning")
[15:33:08.022]                     }
[15:33:08.022]                     else if (inherits(cond, "condition")) {
[15:33:08.022]                       if (!is.null(pattern)) {
[15:33:08.022]                         computeRestarts <- base::computeRestarts
[15:33:08.022]                         grepl <- base::grepl
[15:33:08.022]                         restarts <- computeRestarts(cond)
[15:33:08.022]                         for (restart in restarts) {
[15:33:08.022]                           name <- restart$name
[15:33:08.022]                           if (is.null(name)) 
[15:33:08.022]                             next
[15:33:08.022]                           if (!grepl(pattern, name)) 
[15:33:08.022]                             next
[15:33:08.022]                           invokeRestart(restart)
[15:33:08.022]                           muffled <- TRUE
[15:33:08.022]                           break
[15:33:08.022]                         }
[15:33:08.022]                       }
[15:33:08.022]                     }
[15:33:08.022]                     invisible(muffled)
[15:33:08.022]                   }
[15:33:08.022]                   muffleCondition(cond)
[15:33:08.022]                 })
[15:33:08.022]             }))
[15:33:08.022]             future::FutureResult(value = ...future.value$value, 
[15:33:08.022]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:33:08.022]                   ...future.rng), globalenv = if (FALSE) 
[15:33:08.022]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:33:08.022]                     ...future.globalenv.names))
[15:33:08.022]                 else NULL, started = ...future.startTime, version = "1.8")
[15:33:08.022]         }, condition = base::local({
[15:33:08.022]             c <- base::c
[15:33:08.022]             inherits <- base::inherits
[15:33:08.022]             invokeRestart <- base::invokeRestart
[15:33:08.022]             length <- base::length
[15:33:08.022]             list <- base::list
[15:33:08.022]             seq.int <- base::seq.int
[15:33:08.022]             signalCondition <- base::signalCondition
[15:33:08.022]             sys.calls <- base::sys.calls
[15:33:08.022]             `[[` <- base::`[[`
[15:33:08.022]             `+` <- base::`+`
[15:33:08.022]             `<<-` <- base::`<<-`
[15:33:08.022]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:33:08.022]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:33:08.022]                   3L)]
[15:33:08.022]             }
[15:33:08.022]             function(cond) {
[15:33:08.022]                 is_error <- inherits(cond, "error")
[15:33:08.022]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:33:08.022]                   NULL)
[15:33:08.022]                 if (is_error) {
[15:33:08.022]                   sessionInformation <- function() {
[15:33:08.022]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:33:08.022]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:33:08.022]                       search = base::search(), system = base::Sys.info())
[15:33:08.022]                   }
[15:33:08.022]                   ...future.conditions[[length(...future.conditions) + 
[15:33:08.022]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:33:08.022]                     cond$call), session = sessionInformation(), 
[15:33:08.022]                     timestamp = base::Sys.time(), signaled = 0L)
[15:33:08.022]                   signalCondition(cond)
[15:33:08.022]                 }
[15:33:08.022]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:33:08.022]                 "immediateCondition"))) {
[15:33:08.022]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:33:08.022]                   ...future.conditions[[length(...future.conditions) + 
[15:33:08.022]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:33:08.022]                   if (TRUE && !signal) {
[15:33:08.022]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:33:08.022]                     {
[15:33:08.022]                       inherits <- base::inherits
[15:33:08.022]                       invokeRestart <- base::invokeRestart
[15:33:08.022]                       is.null <- base::is.null
[15:33:08.022]                       muffled <- FALSE
[15:33:08.022]                       if (inherits(cond, "message")) {
[15:33:08.022]                         muffled <- grepl(pattern, "muffleMessage")
[15:33:08.022]                         if (muffled) 
[15:33:08.022]                           invokeRestart("muffleMessage")
[15:33:08.022]                       }
[15:33:08.022]                       else if (inherits(cond, "warning")) {
[15:33:08.022]                         muffled <- grepl(pattern, "muffleWarning")
[15:33:08.022]                         if (muffled) 
[15:33:08.022]                           invokeRestart("muffleWarning")
[15:33:08.022]                       }
[15:33:08.022]                       else if (inherits(cond, "condition")) {
[15:33:08.022]                         if (!is.null(pattern)) {
[15:33:08.022]                           computeRestarts <- base::computeRestarts
[15:33:08.022]                           grepl <- base::grepl
[15:33:08.022]                           restarts <- computeRestarts(cond)
[15:33:08.022]                           for (restart in restarts) {
[15:33:08.022]                             name <- restart$name
[15:33:08.022]                             if (is.null(name)) 
[15:33:08.022]                               next
[15:33:08.022]                             if (!grepl(pattern, name)) 
[15:33:08.022]                               next
[15:33:08.022]                             invokeRestart(restart)
[15:33:08.022]                             muffled <- TRUE
[15:33:08.022]                             break
[15:33:08.022]                           }
[15:33:08.022]                         }
[15:33:08.022]                       }
[15:33:08.022]                       invisible(muffled)
[15:33:08.022]                     }
[15:33:08.022]                     muffleCondition(cond, pattern = "^muffle")
[15:33:08.022]                   }
[15:33:08.022]                 }
[15:33:08.022]                 else {
[15:33:08.022]                   if (TRUE) {
[15:33:08.022]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:33:08.022]                     {
[15:33:08.022]                       inherits <- base::inherits
[15:33:08.022]                       invokeRestart <- base::invokeRestart
[15:33:08.022]                       is.null <- base::is.null
[15:33:08.022]                       muffled <- FALSE
[15:33:08.022]                       if (inherits(cond, "message")) {
[15:33:08.022]                         muffled <- grepl(pattern, "muffleMessage")
[15:33:08.022]                         if (muffled) 
[15:33:08.022]                           invokeRestart("muffleMessage")
[15:33:08.022]                       }
[15:33:08.022]                       else if (inherits(cond, "warning")) {
[15:33:08.022]                         muffled <- grepl(pattern, "muffleWarning")
[15:33:08.022]                         if (muffled) 
[15:33:08.022]                           invokeRestart("muffleWarning")
[15:33:08.022]                       }
[15:33:08.022]                       else if (inherits(cond, "condition")) {
[15:33:08.022]                         if (!is.null(pattern)) {
[15:33:08.022]                           computeRestarts <- base::computeRestarts
[15:33:08.022]                           grepl <- base::grepl
[15:33:08.022]                           restarts <- computeRestarts(cond)
[15:33:08.022]                           for (restart in restarts) {
[15:33:08.022]                             name <- restart$name
[15:33:08.022]                             if (is.null(name)) 
[15:33:08.022]                               next
[15:33:08.022]                             if (!grepl(pattern, name)) 
[15:33:08.022]                               next
[15:33:08.022]                             invokeRestart(restart)
[15:33:08.022]                             muffled <- TRUE
[15:33:08.022]                             break
[15:33:08.022]                           }
[15:33:08.022]                         }
[15:33:08.022]                       }
[15:33:08.022]                       invisible(muffled)
[15:33:08.022]                     }
[15:33:08.022]                     muffleCondition(cond, pattern = "^muffle")
[15:33:08.022]                   }
[15:33:08.022]                 }
[15:33:08.022]             }
[15:33:08.022]         }))
[15:33:08.022]     }, error = function(ex) {
[15:33:08.022]         base::structure(base::list(value = NULL, visible = NULL, 
[15:33:08.022]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:33:08.022]                 ...future.rng), started = ...future.startTime, 
[15:33:08.022]             finished = Sys.time(), session_uuid = NA_character_, 
[15:33:08.022]             version = "1.8"), class = "FutureResult")
[15:33:08.022]     }, finally = {
[15:33:08.022]         if (!identical(...future.workdir, getwd())) 
[15:33:08.022]             setwd(...future.workdir)
[15:33:08.022]         {
[15:33:08.022]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:33:08.022]                 ...future.oldOptions$nwarnings <- NULL
[15:33:08.022]             }
[15:33:08.022]             base::options(...future.oldOptions)
[15:33:08.022]             if (.Platform$OS.type == "windows") {
[15:33:08.022]                 old_names <- names(...future.oldEnvVars)
[15:33:08.022]                 envs <- base::Sys.getenv()
[15:33:08.022]                 names <- names(envs)
[15:33:08.022]                 common <- intersect(names, old_names)
[15:33:08.022]                 added <- setdiff(names, old_names)
[15:33:08.022]                 removed <- setdiff(old_names, names)
[15:33:08.022]                 changed <- common[...future.oldEnvVars[common] != 
[15:33:08.022]                   envs[common]]
[15:33:08.022]                 NAMES <- toupper(changed)
[15:33:08.022]                 args <- list()
[15:33:08.022]                 for (kk in seq_along(NAMES)) {
[15:33:08.022]                   name <- changed[[kk]]
[15:33:08.022]                   NAME <- NAMES[[kk]]
[15:33:08.022]                   if (name != NAME && is.element(NAME, old_names)) 
[15:33:08.022]                     next
[15:33:08.022]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:33:08.022]                 }
[15:33:08.022]                 NAMES <- toupper(added)
[15:33:08.022]                 for (kk in seq_along(NAMES)) {
[15:33:08.022]                   name <- added[[kk]]
[15:33:08.022]                   NAME <- NAMES[[kk]]
[15:33:08.022]                   if (name != NAME && is.element(NAME, old_names)) 
[15:33:08.022]                     next
[15:33:08.022]                   args[[name]] <- ""
[15:33:08.022]                 }
[15:33:08.022]                 NAMES <- toupper(removed)
[15:33:08.022]                 for (kk in seq_along(NAMES)) {
[15:33:08.022]                   name <- removed[[kk]]
[15:33:08.022]                   NAME <- NAMES[[kk]]
[15:33:08.022]                   if (name != NAME && is.element(NAME, old_names)) 
[15:33:08.022]                     next
[15:33:08.022]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:33:08.022]                 }
[15:33:08.022]                 if (length(args) > 0) 
[15:33:08.022]                   base::do.call(base::Sys.setenv, args = args)
[15:33:08.022]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:33:08.022]             }
[15:33:08.022]             else {
[15:33:08.022]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:33:08.022]             }
[15:33:08.022]             {
[15:33:08.022]                 if (base::length(...future.futureOptionsAdded) > 
[15:33:08.022]                   0L) {
[15:33:08.022]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:33:08.022]                   base::names(opts) <- ...future.futureOptionsAdded
[15:33:08.022]                   base::options(opts)
[15:33:08.022]                 }
[15:33:08.022]                 {
[15:33:08.022]                   {
[15:33:08.022]                     base::options(mc.cores = ...future.mc.cores.old)
[15:33:08.022]                     NULL
[15:33:08.022]                   }
[15:33:08.022]                   options(future.plan = NULL)
[15:33:08.022]                   if (is.na(NA_character_)) 
[15:33:08.022]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:33:08.022]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:33:08.022]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:33:08.022]                     .init = FALSE)
[15:33:08.022]                 }
[15:33:08.022]             }
[15:33:08.022]         }
[15:33:08.022]     })
[15:33:08.022]     if (TRUE) {
[15:33:08.022]         base::sink(type = "output", split = FALSE)
[15:33:08.022]         if (TRUE) {
[15:33:08.022]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:33:08.022]         }
[15:33:08.022]         else {
[15:33:08.022]             ...future.result["stdout"] <- base::list(NULL)
[15:33:08.022]         }
[15:33:08.022]         base::close(...future.stdout)
[15:33:08.022]         ...future.stdout <- NULL
[15:33:08.022]     }
[15:33:08.022]     ...future.result$conditions <- ...future.conditions
[15:33:08.022]     ...future.result$finished <- base::Sys.time()
[15:33:08.022]     ...future.result
[15:33:08.022] }
[15:33:08.031] Exporting 5 global objects (6.22 KiB) to cluster node #2 ...
[15:33:08.032] Exporting '...future.FUN' (6.11 KiB) to cluster node #2 ...
[15:33:08.032] Exporting '...future.FUN' (6.11 KiB) to cluster node #2 ... DONE
[15:33:08.033] Exporting 'MoreArgs' (0 bytes) to cluster node #2 ...
[15:33:08.033] Exporting 'MoreArgs' (0 bytes) to cluster node #2 ... DONE
[15:33:08.034] Exporting '...future.elements_ii' (112 bytes) to cluster node #2 ...
[15:33:08.034] Exporting '...future.elements_ii' (112 bytes) to cluster node #2 ... DONE
[15:33:08.035] Exporting '...future.seeds_ii' (0 bytes) to cluster node #2 ...
[15:33:08.035] Exporting '...future.seeds_ii' (0 bytes) to cluster node #2 ... DONE
[15:33:08.036] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #2 ...
[15:33:08.036] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #2 ... DONE
[15:33:08.037] Exporting 5 global objects (6.22 KiB) to cluster node #2 ... DONE
[15:33:08.038] MultisessionFuture started
[15:33:08.038] - Launch lazy future ... done
[15:33:08.038] run() for 'MultisessionFuture' ... done
[15:33:08.039] Created future:
[15:33:08.058] receiveMessageFromWorker() for ClusterFuture ...
[15:33:08.059] - Validating connection of MultisessionFuture
[15:33:08.059] - received message: FutureResult
[15:33:08.059] - Received FutureResult
[15:33:08.060] - Erased future from FutureRegistry
[15:33:08.060] result() for ClusterFuture ...
[15:33:08.060] - result already collected: FutureResult
[15:33:08.060] result() for ClusterFuture ... done
[15:33:08.060] receiveMessageFromWorker() for ClusterFuture ... done
[15:33:08.039] MultisessionFuture:
[15:33:08.039] Label: 'future_mapply-2'
[15:33:08.039] Expression:
[15:33:08.039] {
[15:33:08.039]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:33:08.039]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:33:08.039]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:33:08.039]         on.exit(options(oopts), add = TRUE)
[15:33:08.039]     }
[15:33:08.039]     {
[15:33:08.039]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:33:08.039]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:33:08.039]         do.call(mapply, args = args)
[15:33:08.039]     }
[15:33:08.039] }
[15:33:08.039] Lazy evaluation: FALSE
[15:33:08.039] Asynchronous evaluation: TRUE
[15:33:08.039] Local evaluation: TRUE
[15:33:08.039] Environment: R_GlobalEnv
[15:33:08.039] Capture standard output: TRUE
[15:33:08.039] Capture condition classes: 'condition' (excluding 'nothing')
[15:33:08.039] Globals: 5 objects totaling 6.22 KiB (function '...future.FUN' of 6.11 KiB, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 112 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:33:08.039] Packages: <none>
[15:33:08.039] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:33:08.039] Resolved: TRUE
[15:33:08.039] Value: <not collected>
[15:33:08.039] Conditions captured: <none>
[15:33:08.039] Early signaling: FALSE
[15:33:08.039] Owner process: bdd4bc13-919d-bf34-b2cf-84eb53f6e11f
[15:33:08.039] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:33:08.061] Chunk #2 of 2 ... DONE
[15:33:08.061] Launching 2 futures (chunks) ... DONE
[15:33:08.061] Resolving 2 futures (chunks) ...
[15:33:08.061] resolve() on list ...
[15:33:08.062]  recursive: 0
[15:33:08.062]  length: 2
[15:33:08.062] 
[15:33:08.265] Future #2
[15:33:08.266] result() for ClusterFuture ...
[15:33:08.266] - result already collected: FutureResult
[15:33:08.266] result() for ClusterFuture ... done
[15:33:08.267] result() for ClusterFuture ...
[15:33:08.267] - result already collected: FutureResult
[15:33:08.267] result() for ClusterFuture ... done
[15:33:08.267] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:33:08.268] - nx: 2
[15:33:08.268] - relay: TRUE
[15:33:08.268] - stdout: TRUE
[15:33:08.268] - signal: TRUE
[15:33:08.269] - resignal: FALSE
[15:33:08.269] - force: TRUE
[15:33:08.269] - relayed: [n=2] FALSE, FALSE
[15:33:08.269] - queued futures: [n=2] FALSE, FALSE
[15:33:08.270]  - until=1
[15:33:08.270]  - relaying element #1
[15:33:08.270] - relayed: [n=2] FALSE, FALSE
[15:33:08.270] - queued futures: [n=2] FALSE, TRUE
[15:33:08.271] signalConditionsASAP(NULL, pos=2) ... done
[15:33:08.271]  length: 1 (resolved future 2)
[15:33:08.323] receiveMessageFromWorker() for ClusterFuture ...
[15:33:08.324] - Validating connection of MultisessionFuture
[15:33:08.324] - received message: FutureResult
[15:33:08.325] - Received FutureResult
[15:33:08.325] - Erased future from FutureRegistry
[15:33:08.325] result() for ClusterFuture ...
[15:33:08.325] - result already collected: FutureResult
[15:33:08.326] result() for ClusterFuture ... done
[15:33:08.326] receiveMessageFromWorker() for ClusterFuture ... done
[15:33:08.326] Future #1
[15:33:08.326] result() for ClusterFuture ...
[15:33:08.327] - result already collected: FutureResult
[15:33:08.327] result() for ClusterFuture ... done
[15:33:08.327] result() for ClusterFuture ...
[15:33:08.327] - result already collected: FutureResult
[15:33:08.327] result() for ClusterFuture ... done
[15:33:08.328] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:33:08.328] - nx: 2
[15:33:08.328] - relay: TRUE
[15:33:08.329] - stdout: TRUE
[15:33:08.329] - signal: TRUE
[15:33:08.329] - resignal: FALSE
[15:33:08.329] - force: TRUE
[15:33:08.330] - relayed: [n=2] FALSE, FALSE
[15:33:08.330] - queued futures: [n=2] FALSE, TRUE
[15:33:08.330]  - until=1
[15:33:08.330]  - relaying element #1
[15:33:08.331] result() for ClusterFuture ...
[15:33:08.331] - result already collected: FutureResult
[15:33:08.331] result() for ClusterFuture ... done
[15:33:08.331] result() for ClusterFuture ...
[15:33:08.331] - result already collected: FutureResult
[15:33:08.332] result() for ClusterFuture ... done
[15:33:08.332] result() for ClusterFuture ...
[15:33:08.332] - result already collected: FutureResult
[15:33:08.332] result() for ClusterFuture ... done
[15:33:08.333] result() for ClusterFuture ...
[15:33:08.333] - result already collected: FutureResult
[15:33:08.333] result() for ClusterFuture ... done
[15:33:08.333] - relayed: [n=2] TRUE, FALSE
[15:33:08.334] - queued futures: [n=2] TRUE, TRUE
[15:33:08.334] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:33:08.334]  length: 0 (resolved future 1)
[15:33:08.334] Relaying remaining futures
[15:33:08.335] signalConditionsASAP(NULL, pos=0) ...
[15:33:08.335] - nx: 2
[15:33:08.335] - relay: TRUE
[15:33:08.335] - stdout: TRUE
[15:33:08.336] - signal: TRUE
[15:33:08.336] - resignal: FALSE
[15:33:08.336] - force: TRUE
[15:33:08.336] - relayed: [n=2] TRUE, FALSE
[15:33:08.336] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:33:08.337]  - relaying element #2
[15:33:08.337] result() for ClusterFuture ...
[15:33:08.337] - result already collected: FutureResult
[15:33:08.337] result() for ClusterFuture ... done
[15:33:08.338] result() for ClusterFuture ...
[15:33:08.338] - result already collected: FutureResult
[15:33:08.338] result() for ClusterFuture ... done
[15:33:08.338] result() for ClusterFuture ...
[15:33:08.339] - result already collected: FutureResult
[15:33:08.339] result() for ClusterFuture ... done
[15:33:08.339] result() for ClusterFuture ...
[15:33:08.339] - result already collected: FutureResult
[15:33:08.340] result() for ClusterFuture ... done
[15:33:08.340] - relayed: [n=2] TRUE, TRUE
[15:33:08.340] - queued futures: [n=2] TRUE, TRUE
[15:33:08.340] signalConditionsASAP(MultisessionFuture, pos=0) ... done
[15:33:08.341] resolve() on list ... DONE
[15:33:08.341] result() for ClusterFuture ...
[15:33:08.341] - result already collected: FutureResult
[15:33:08.341] result() for ClusterFuture ... done
[15:33:08.341] result() for ClusterFuture ...
[15:33:08.342] - result already collected: FutureResult
[15:33:08.342] result() for ClusterFuture ... done
[15:33:08.342] result() for ClusterFuture ...
[15:33:08.342] - result already collected: FutureResult
[15:33:08.345] result() for ClusterFuture ... done
[15:33:08.346] result() for ClusterFuture ...
[15:33:08.346] - result already collected: FutureResult
[15:33:08.346] result() for ClusterFuture ... done
[15:33:08.346]  - Number of value chunks collected: 2
[15:33:08.346] Resolving 2 futures (chunks) ... DONE
[15:33:08.346] Reducing values from 2 chunks ...
[15:33:08.347]  - Number of values collected after concatenation: 2
[15:33:08.347]  - Number of values expected: 2
[15:33:08.347] Reducing values from 2 chunks ... DONE
[15:33:08.347] future_mapply() ... DONE
* future_mapply(x, ..., future.stdout = TRUE) ... DONE
* future_mapply(x, ..., future.stdout = NA) ...
[15:33:08.348] future_mapply() ...
[15:33:08.351] Number of chunks: 2
[15:33:08.352] getGlobalsAndPackagesXApply() ...
[15:33:08.352]  - future.globals: TRUE
[15:33:08.352] getGlobalsAndPackages() ...
[15:33:08.353] Searching for globals...
[15:33:08.355] - globals found: [6] 'FUN', '{', 'Sys.sleep', '/', 'print', 'list'
[15:33:08.355] Searching for globals ... DONE
[15:33:08.355] Resolving globals: FALSE
[15:33:08.356] The total size of the 1 globals is 6.11 KiB (6256 bytes)
[15:33:08.357] The total size of the 1 globals exported for future expression ('FUN()') is 6.11 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (6.11 KiB of class 'function')
[15:33:08.357] - globals: [1] 'FUN'
[15:33:08.357] 
[15:33:08.357] getGlobalsAndPackages() ... DONE
[15:33:08.358]  - globals found/used: [n=1] 'FUN'
[15:33:08.358]  - needed namespaces: [n=0] 
[15:33:08.358] Finding globals ... DONE
[15:33:08.359] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[15:33:08.359] List of 2
[15:33:08.359]  $ ...future.FUN:function (x, y)  
[15:33:08.359]  $ MoreArgs     : NULL
[15:33:08.359]  - attr(*, "where")=List of 2
[15:33:08.359]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:33:08.359]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[15:33:08.359]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:33:08.359]  - attr(*, "resolved")= logi FALSE
[15:33:08.359]  - attr(*, "total_size")= num NA
[15:33:08.364] Packages to be attached in all futures: [n=0] 
[15:33:08.364] getGlobalsAndPackagesXApply() ... DONE
[15:33:08.365] Number of futures (= number of chunks): 2
[15:33:08.365] Launching 2 futures (chunks) ...
[15:33:08.365] Chunk #1 of 2 ...
[15:33:08.365]  - Finding globals in '...' for chunk #1 ...
[15:33:08.366] getGlobalsAndPackages() ...
[15:33:08.366] Searching for globals...
[15:33:08.367] 
[15:33:08.367] Searching for globals ... DONE
[15:33:08.367] - globals: [0] <none>
[15:33:08.368] getGlobalsAndPackages() ... DONE
[15:33:08.368]    + additional globals found: [n=0] 
[15:33:08.368]    + additional namespaces needed: [n=0] 
[15:33:08.368]  - Finding globals in '...' for chunk #1 ... DONE
[15:33:08.369]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:33:08.369]  - seeds: <none>
[15:33:08.369]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:33:08.370] getGlobalsAndPackages() ...
[15:33:08.370] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:33:08.370] Resolving globals: FALSE
[15:33:08.371] The total size of the 5 globals is 6.22 KiB (6368 bytes)
[15:33:08.372] The total size of the 5 globals exported for future expression ('{; ...future.globals.maxSize.org <- getOption("future.globals.maxSize"); if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {; oopts <- options(future.globals.maxSize = ...future.globals.maxSize); on.exit(options(oopts), add = TRUE); }; ...; do.call(mapply, args = args); }; }') is 6.22 KiB.. This exceeds the maximum allowed size of 0.98 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (6.11 KiB of class 'function'), '...future.elements_ii' (112 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[15:33:08.373] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:33:08.373] 
[15:33:08.373] getGlobalsAndPackages() ... DONE
[15:33:08.374] run() for 'Future' ...
[15:33:08.374] - state: 'created'
[15:33:08.374] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:33:08.393] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:33:08.393] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:33:08.393]   - Field: 'node'
[15:33:08.393]   - Field: 'label'
[15:33:08.394]   - Field: 'local'
[15:33:08.394]   - Field: 'owner'
[15:33:08.394]   - Field: 'envir'
[15:33:08.394]   - Field: 'workers'
[15:33:08.394]   - Field: 'packages'
[15:33:08.394]   - Field: 'gc'
[15:33:08.395]   - Field: 'conditions'
[15:33:08.395]   - Field: 'persistent'
[15:33:08.395]   - Field: 'expr'
[15:33:08.395]   - Field: 'uuid'
[15:33:08.396]   - Field: 'seed'
[15:33:08.396]   - Field: 'version'
[15:33:08.396]   - Field: 'result'
[15:33:08.396]   - Field: 'asynchronous'
[15:33:08.396]   - Field: 'calls'
[15:33:08.397]   - Field: 'globals'
[15:33:08.397]   - Field: 'stdout'
[15:33:08.397]   - Field: 'earlySignal'
[15:33:08.397]   - Field: 'lazy'
[15:33:08.397]   - Field: 'state'
[15:33:08.397] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:33:08.398] - Launch lazy future ...
[15:33:08.398] Packages needed by the future expression (n = 0): <none>
[15:33:08.398] Packages needed by future strategies (n = 0): <none>
[15:33:08.399] {
[15:33:08.399]     {
[15:33:08.399]         {
[15:33:08.399]             ...future.startTime <- base::Sys.time()
[15:33:08.399]             {
[15:33:08.399]                 {
[15:33:08.399]                   {
[15:33:08.399]                     {
[15:33:08.399]                       base::local({
[15:33:08.399]                         has_future <- base::requireNamespace("future", 
[15:33:08.399]                           quietly = TRUE)
[15:33:08.399]                         if (has_future) {
[15:33:08.399]                           ns <- base::getNamespace("future")
[15:33:08.399]                           version <- ns[[".package"]][["version"]]
[15:33:08.399]                           if (is.null(version)) 
[15:33:08.399]                             version <- utils::packageVersion("future")
[15:33:08.399]                         }
[15:33:08.399]                         else {
[15:33:08.399]                           version <- NULL
[15:33:08.399]                         }
[15:33:08.399]                         if (!has_future || version < "1.8.0") {
[15:33:08.399]                           info <- base::c(r_version = base::gsub("R version ", 
[15:33:08.399]                             "", base::R.version$version.string), 
[15:33:08.399]                             platform = base::sprintf("%s (%s-bit)", 
[15:33:08.399]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:33:08.399]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:33:08.399]                               "release", "version")], collapse = " "), 
[15:33:08.399]                             hostname = base::Sys.info()[["nodename"]])
[15:33:08.399]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:33:08.399]                             info)
[15:33:08.399]                           info <- base::paste(info, collapse = "; ")
[15:33:08.399]                           if (!has_future) {
[15:33:08.399]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:33:08.399]                               info)
[15:33:08.399]                           }
[15:33:08.399]                           else {
[15:33:08.399]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:33:08.399]                               info, version)
[15:33:08.399]                           }
[15:33:08.399]                           base::stop(msg)
[15:33:08.399]                         }
[15:33:08.399]                       })
[15:33:08.399]                     }
[15:33:08.399]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:33:08.399]                     base::options(mc.cores = 1L)
[15:33:08.399]                   }
[15:33:08.399]                   ...future.strategy.old <- future::plan("list")
[15:33:08.399]                   options(future.plan = NULL)
[15:33:08.399]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:33:08.399]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:33:08.399]                 }
[15:33:08.399]                 ...future.workdir <- getwd()
[15:33:08.399]             }
[15:33:08.399]             ...future.oldOptions <- base::as.list(base::.Options)
[15:33:08.399]             ...future.oldEnvVars <- base::Sys.getenv()
[15:33:08.399]         }
[15:33:08.399]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:33:08.399]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:33:08.399]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:33:08.399]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:33:08.399]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:33:08.399]             future.stdout.windows.reencode = NULL, width = 80L)
[15:33:08.399]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:33:08.399]             base::names(...future.oldOptions))
[15:33:08.399]     }
[15:33:08.399]     if (TRUE) {
[15:33:08.399]     }
[15:33:08.399]     else {
[15:33:08.399]         if (NA) {
[15:33:08.399]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:33:08.399]                 open = "w")
[15:33:08.399]         }
[15:33:08.399]         else {
[15:33:08.399]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:33:08.399]                 windows = "NUL", "/dev/null"), open = "w")
[15:33:08.399]         }
[15:33:08.399]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:33:08.399]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:33:08.399]             base::sink(type = "output", split = FALSE)
[15:33:08.399]             base::close(...future.stdout)
[15:33:08.399]         }, add = TRUE)
[15:33:08.399]     }
[15:33:08.399]     ...future.frame <- base::sys.nframe()
[15:33:08.399]     ...future.conditions <- base::list()
[15:33:08.399]     ...future.rng <- base::globalenv()$.Random.seed
[15:33:08.399]     if (FALSE) {
[15:33:08.399]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:33:08.399]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:33:08.399]     }
[15:33:08.399]     ...future.result <- base::tryCatch({
[15:33:08.399]         base::withCallingHandlers({
[15:33:08.399]             ...future.value <- base::withVisible(base::local({
[15:33:08.399]                 ...future.makeSendCondition <- base::local({
[15:33:08.399]                   sendCondition <- NULL
[15:33:08.399]                   function(frame = 1L) {
[15:33:08.399]                     if (is.function(sendCondition)) 
[15:33:08.399]                       return(sendCondition)
[15:33:08.399]                     ns <- getNamespace("parallel")
[15:33:08.399]                     if (exists("sendData", mode = "function", 
[15:33:08.399]                       envir = ns)) {
[15:33:08.399]                       parallel_sendData <- get("sendData", mode = "function", 
[15:33:08.399]                         envir = ns)
[15:33:08.399]                       envir <- sys.frame(frame)
[15:33:08.399]                       master <- NULL
[15:33:08.399]                       while (!identical(envir, .GlobalEnv) && 
[15:33:08.399]                         !identical(envir, emptyenv())) {
[15:33:08.399]                         if (exists("master", mode = "list", envir = envir, 
[15:33:08.399]                           inherits = FALSE)) {
[15:33:08.399]                           master <- get("master", mode = "list", 
[15:33:08.399]                             envir = envir, inherits = FALSE)
[15:33:08.399]                           if (inherits(master, c("SOCKnode", 
[15:33:08.399]                             "SOCK0node"))) {
[15:33:08.399]                             sendCondition <<- function(cond) {
[15:33:08.399]                               data <- list(type = "VALUE", value = cond, 
[15:33:08.399]                                 success = TRUE)
[15:33:08.399]                               parallel_sendData(master, data)
[15:33:08.399]                             }
[15:33:08.399]                             return(sendCondition)
[15:33:08.399]                           }
[15:33:08.399]                         }
[15:33:08.399]                         frame <- frame + 1L
[15:33:08.399]                         envir <- sys.frame(frame)
[15:33:08.399]                       }
[15:33:08.399]                     }
[15:33:08.399]                     sendCondition <<- function(cond) NULL
[15:33:08.399]                   }
[15:33:08.399]                 })
[15:33:08.399]                 withCallingHandlers({
[15:33:08.399]                   {
[15:33:08.399]                     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:33:08.399]                     if (!identical(...future.globals.maxSize.org, 
[15:33:08.399]                       ...future.globals.maxSize)) {
[15:33:08.399]                       oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:33:08.399]                       on.exit(options(oopts), add = TRUE)
[15:33:08.399]                     }
[15:33:08.399]                     {
[15:33:08.399]                       args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:33:08.399]                         MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:33:08.399]                         USE.NAMES = FALSE)
[15:33:08.399]                       do.call(mapply, args = args)
[15:33:08.399]                     }
[15:33:08.399]                   }
[15:33:08.399]                 }, immediateCondition = function(cond) {
[15:33:08.399]                   sendCondition <- ...future.makeSendCondition()
[15:33:08.399]                   sendCondition(cond)
[15:33:08.399]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:33:08.399]                   {
[15:33:08.399]                     inherits <- base::inherits
[15:33:08.399]                     invokeRestart <- base::invokeRestart
[15:33:08.399]                     is.null <- base::is.null
[15:33:08.399]                     muffled <- FALSE
[15:33:08.399]                     if (inherits(cond, "message")) {
[15:33:08.399]                       muffled <- grepl(pattern, "muffleMessage")
[15:33:08.399]                       if (muffled) 
[15:33:08.399]                         invokeRestart("muffleMessage")
[15:33:08.399]                     }
[15:33:08.399]                     else if (inherits(cond, "warning")) {
[15:33:08.399]                       muffled <- grepl(pattern, "muffleWarning")
[15:33:08.399]                       if (muffled) 
[15:33:08.399]                         invokeRestart("muffleWarning")
[15:33:08.399]                     }
[15:33:08.399]                     else if (inherits(cond, "condition")) {
[15:33:08.399]                       if (!is.null(pattern)) {
[15:33:08.399]                         computeRestarts <- base::computeRestarts
[15:33:08.399]                         grepl <- base::grepl
[15:33:08.399]                         restarts <- computeRestarts(cond)
[15:33:08.399]                         for (restart in restarts) {
[15:33:08.399]                           name <- restart$name
[15:33:08.399]                           if (is.null(name)) 
[15:33:08.399]                             next
[15:33:08.399]                           if (!grepl(pattern, name)) 
[15:33:08.399]                             next
[15:33:08.399]                           invokeRestart(restart)
[15:33:08.399]                           muffled <- TRUE
[15:33:08.399]                           break
[15:33:08.399]                         }
[15:33:08.399]                       }
[15:33:08.399]                     }
[15:33:08.399]                     invisible(muffled)
[15:33:08.399]                   }
[15:33:08.399]                   muffleCondition(cond)
[15:33:08.399]                 })
[15:33:08.399]             }))
[15:33:08.399]             future::FutureResult(value = ...future.value$value, 
[15:33:08.399]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:33:08.399]                   ...future.rng), globalenv = if (FALSE) 
[15:33:08.399]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:33:08.399]                     ...future.globalenv.names))
[15:33:08.399]                 else NULL, started = ...future.startTime, version = "1.8")
[15:33:08.399]         }, condition = base::local({
[15:33:08.399]             c <- base::c
[15:33:08.399]             inherits <- base::inherits
[15:33:08.399]             invokeRestart <- base::invokeRestart
[15:33:08.399]             length <- base::length
[15:33:08.399]             list <- base::list
[15:33:08.399]             seq.int <- base::seq.int
[15:33:08.399]             signalCondition <- base::signalCondition
[15:33:08.399]             sys.calls <- base::sys.calls
[15:33:08.399]             `[[` <- base::`[[`
[15:33:08.399]             `+` <- base::`+`
[15:33:08.399]             `<<-` <- base::`<<-`
[15:33:08.399]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:33:08.399]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:33:08.399]                   3L)]
[15:33:08.399]             }
[15:33:08.399]             function(cond) {
[15:33:08.399]                 is_error <- inherits(cond, "error")
[15:33:08.399]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:33:08.399]                   NULL)
[15:33:08.399]                 if (is_error) {
[15:33:08.399]                   sessionInformation <- function() {
[15:33:08.399]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:33:08.399]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:33:08.399]                       search = base::search(), system = base::Sys.info())
[15:33:08.399]                   }
[15:33:08.399]                   ...future.conditions[[length(...future.conditions) + 
[15:33:08.399]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:33:08.399]                     cond$call), session = sessionInformation(), 
[15:33:08.399]                     timestamp = base::Sys.time(), signaled = 0L)
[15:33:08.399]                   signalCondition(cond)
[15:33:08.399]                 }
[15:33:08.399]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:33:08.399]                 "immediateCondition"))) {
[15:33:08.399]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:33:08.399]                   ...future.conditions[[length(...future.conditions) + 
[15:33:08.399]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:33:08.399]                   if (TRUE && !signal) {
[15:33:08.399]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:33:08.399]                     {
[15:33:08.399]                       inherits <- base::inherits
[15:33:08.399]                       invokeRestart <- base::invokeRestart
[15:33:08.399]                       is.null <- base::is.null
[15:33:08.399]                       muffled <- FALSE
[15:33:08.399]                       if (inherits(cond, "message")) {
[15:33:08.399]                         muffled <- grepl(pattern, "muffleMessage")
[15:33:08.399]                         if (muffled) 
[15:33:08.399]                           invokeRestart("muffleMessage")
[15:33:08.399]                       }
[15:33:08.399]                       else if (inherits(cond, "warning")) {
[15:33:08.399]                         muffled <- grepl(pattern, "muffleWarning")
[15:33:08.399]                         if (muffled) 
[15:33:08.399]                           invokeRestart("muffleWarning")
[15:33:08.399]                       }
[15:33:08.399]                       else if (inherits(cond, "condition")) {
[15:33:08.399]                         if (!is.null(pattern)) {
[15:33:08.399]                           computeRestarts <- base::computeRestarts
[15:33:08.399]                           grepl <- base::grepl
[15:33:08.399]                           restarts <- computeRestarts(cond)
[15:33:08.399]                           for (restart in restarts) {
[15:33:08.399]                             name <- restart$name
[15:33:08.399]                             if (is.null(name)) 
[15:33:08.399]                               next
[15:33:08.399]                             if (!grepl(pattern, name)) 
[15:33:08.399]                               next
[15:33:08.399]                             invokeRestart(restart)
[15:33:08.399]                             muffled <- TRUE
[15:33:08.399]                             break
[15:33:08.399]                           }
[15:33:08.399]                         }
[15:33:08.399]                       }
[15:33:08.399]                       invisible(muffled)
[15:33:08.399]                     }
[15:33:08.399]                     muffleCondition(cond, pattern = "^muffle")
[15:33:08.399]                   }
[15:33:08.399]                 }
[15:33:08.399]                 else {
[15:33:08.399]                   if (TRUE) {
[15:33:08.399]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:33:08.399]                     {
[15:33:08.399]                       inherits <- base::inherits
[15:33:08.399]                       invokeRestart <- base::invokeRestart
[15:33:08.399]                       is.null <- base::is.null
[15:33:08.399]                       muffled <- FALSE
[15:33:08.399]                       if (inherits(cond, "message")) {
[15:33:08.399]                         muffled <- grepl(pattern, "muffleMessage")
[15:33:08.399]                         if (muffled) 
[15:33:08.399]                           invokeRestart("muffleMessage")
[15:33:08.399]                       }
[15:33:08.399]                       else if (inherits(cond, "warning")) {
[15:33:08.399]                         muffled <- grepl(pattern, "muffleWarning")
[15:33:08.399]                         if (muffled) 
[15:33:08.399]                           invokeRestart("muffleWarning")
[15:33:08.399]                       }
[15:33:08.399]                       else if (inherits(cond, "condition")) {
[15:33:08.399]                         if (!is.null(pattern)) {
[15:33:08.399]                           computeRestarts <- base::computeRestarts
[15:33:08.399]                           grepl <- base::grepl
[15:33:08.399]                           restarts <- computeRestarts(cond)
[15:33:08.399]                           for (restart in restarts) {
[15:33:08.399]                             name <- restart$name
[15:33:08.399]                             if (is.null(name)) 
[15:33:08.399]                               next
[15:33:08.399]                             if (!grepl(pattern, name)) 
[15:33:08.399]                               next
[15:33:08.399]                             invokeRestart(restart)
[15:33:08.399]                             muffled <- TRUE
[15:33:08.399]                             break
[15:33:08.399]                           }
[15:33:08.399]                         }
[15:33:08.399]                       }
[15:33:08.399]                       invisible(muffled)
[15:33:08.399]                     }
[15:33:08.399]                     muffleCondition(cond, pattern = "^muffle")
[15:33:08.399]                   }
[15:33:08.399]                 }
[15:33:08.399]             }
[15:33:08.399]         }))
[15:33:08.399]     }, error = function(ex) {
[15:33:08.399]         base::structure(base::list(value = NULL, visible = NULL, 
[15:33:08.399]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:33:08.399]                 ...future.rng), started = ...future.startTime, 
[15:33:08.399]             finished = Sys.time(), session_uuid = NA_character_, 
[15:33:08.399]             version = "1.8"), class = "FutureResult")
[15:33:08.399]     }, finally = {
[15:33:08.399]         if (!identical(...future.workdir, getwd())) 
[15:33:08.399]             setwd(...future.workdir)
[15:33:08.399]         {
[15:33:08.399]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:33:08.399]                 ...future.oldOptions$nwarnings <- NULL
[15:33:08.399]             }
[15:33:08.399]             base::options(...future.oldOptions)
[15:33:08.399]             if (.Platform$OS.type == "windows") {
[15:33:08.399]                 old_names <- names(...future.oldEnvVars)
[15:33:08.399]                 envs <- base::Sys.getenv()
[15:33:08.399]                 names <- names(envs)
[15:33:08.399]                 common <- intersect(names, old_names)
[15:33:08.399]                 added <- setdiff(names, old_names)
[15:33:08.399]                 removed <- setdiff(old_names, names)
[15:33:08.399]                 changed <- common[...future.oldEnvVars[common] != 
[15:33:08.399]                   envs[common]]
[15:33:08.399]                 NAMES <- toupper(changed)
[15:33:08.399]                 args <- list()
[15:33:08.399]                 for (kk in seq_along(NAMES)) {
[15:33:08.399]                   name <- changed[[kk]]
[15:33:08.399]                   NAME <- NAMES[[kk]]
[15:33:08.399]                   if (name != NAME && is.element(NAME, old_names)) 
[15:33:08.399]                     next
[15:33:08.399]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:33:08.399]                 }
[15:33:08.399]                 NAMES <- toupper(added)
[15:33:08.399]                 for (kk in seq_along(NAMES)) {
[15:33:08.399]                   name <- added[[kk]]
[15:33:08.399]                   NAME <- NAMES[[kk]]
[15:33:08.399]                   if (name != NAME && is.element(NAME, old_names)) 
[15:33:08.399]                     next
[15:33:08.399]                   args[[name]] <- ""
[15:33:08.399]                 }
[15:33:08.399]                 NAMES <- toupper(removed)
[15:33:08.399]                 for (kk in seq_along(NAMES)) {
[15:33:08.399]                   name <- removed[[kk]]
[15:33:08.399]                   NAME <- NAMES[[kk]]
[15:33:08.399]                   if (name != NAME && is.element(NAME, old_names)) 
[15:33:08.399]                     next
[15:33:08.399]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:33:08.399]                 }
[15:33:08.399]                 if (length(args) > 0) 
[15:33:08.399]                   base::do.call(base::Sys.setenv, args = args)
[15:33:08.399]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:33:08.399]             }
[15:33:08.399]             else {
[15:33:08.399]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:33:08.399]             }
[15:33:08.399]             {
[15:33:08.399]                 if (base::length(...future.futureOptionsAdded) > 
[15:33:08.399]                   0L) {
[15:33:08.399]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:33:08.399]                   base::names(opts) <- ...future.futureOptionsAdded
[15:33:08.399]                   base::options(opts)
[15:33:08.399]                 }
[15:33:08.399]                 {
[15:33:08.399]                   {
[15:33:08.399]                     base::options(mc.cores = ...future.mc.cores.old)
[15:33:08.399]                     NULL
[15:33:08.399]                   }
[15:33:08.399]                   options(future.plan = NULL)
[15:33:08.399]                   if (is.na(NA_character_)) 
[15:33:08.399]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:33:08.399]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:33:08.399]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:33:08.399]                     .init = FALSE)
[15:33:08.399]                 }
[15:33:08.399]             }
[15:33:08.399]         }
[15:33:08.399]     })
[15:33:08.399]     if (FALSE) {
[15:33:08.399]         base::sink(type = "output", split = FALSE)
[15:33:08.399]         if (NA) {
[15:33:08.399]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:33:08.399]         }
[15:33:08.399]         else {
[15:33:08.399]             ...future.result["stdout"] <- base::list(NULL)
[15:33:08.399]         }
[15:33:08.399]         base::close(...future.stdout)
[15:33:08.399]         ...future.stdout <- NULL
[15:33:08.399]     }
[15:33:08.399]     ...future.result$conditions <- ...future.conditions
[15:33:08.399]     ...future.result$finished <- base::Sys.time()
[15:33:08.399]     ...future.result
[15:33:08.399] }
[15:33:08.405] Exporting 5 global objects (6.22 KiB) to cluster node #1 ...
[15:33:08.405] Exporting '...future.FUN' (6.11 KiB) to cluster node #1 ...
[15:33:08.406] Exporting '...future.FUN' (6.11 KiB) to cluster node #1 ... DONE
[15:33:08.406] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ...
[15:33:08.407] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ... DONE
[15:33:08.407] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:33:08.408] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:33:08.408] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:33:08.409] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:33:08.409] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:33:08.410] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:33:08.410] Exporting 5 global objects (6.22 KiB) to cluster node #1 ... DONE
[15:33:08.411] MultisessionFuture started
[15:33:08.411] - Launch lazy future ... done
[15:33:08.412] run() for 'MultisessionFuture' ... done
[15:33:08.412] Created future:
[15:33:08.412] MultisessionFuture:
[15:33:08.412] Label: 'future_mapply-1'
[15:33:08.412] Expression:
[15:33:08.412] {
[15:33:08.412]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:33:08.412]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:33:08.412]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:33:08.412]         on.exit(options(oopts), add = TRUE)
[15:33:08.412]     }
[15:33:08.412]     {
[15:33:08.412]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:33:08.412]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:33:08.412]         do.call(mapply, args = args)
[15:33:08.412]     }
[15:33:08.412] }
[15:33:08.412] Lazy evaluation: FALSE
[15:33:08.412] Asynchronous evaluation: TRUE
[15:33:08.412] Local evaluation: TRUE
[15:33:08.412] Environment: R_GlobalEnv
[15:33:08.412] Capture standard output: NA
[15:33:08.412] Capture condition classes: 'condition' (excluding 'nothing')
[15:33:08.412] Globals: 5 objects totaling 6.22 KiB (function '...future.FUN' of 6.11 KiB, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 112 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:33:08.412] Packages: <none>
[15:33:08.412] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:33:08.412] Resolved: FALSE
[15:33:08.412] Value: <not collected>
[15:33:08.412] Conditions captured: <none>
[15:33:08.412] Early signaling: FALSE
[15:33:08.412] Owner process: bdd4bc13-919d-bf34-b2cf-84eb53f6e11f
[15:33:08.412] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:33:08.610] Chunk #1 of 2 ... DONE
[15:33:08.610] Chunk #2 of 2 ...
[15:33:08.611]  - Finding globals in '...' for chunk #2 ...
[15:33:08.611] getGlobalsAndPackages() ...
[15:33:08.611] Searching for globals...
[15:33:08.612] 
[15:33:08.612] Searching for globals ... DONE
[15:33:08.612] - globals: [0] <none>
[15:33:08.613] getGlobalsAndPackages() ... DONE
[15:33:08.613]    + additional globals found: [n=0] 
[15:33:08.613]    + additional namespaces needed: [n=0] 
[15:33:08.613]  - Finding globals in '...' for chunk #2 ... DONE
[15:33:08.614]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:33:08.614]  - seeds: <none>
[15:33:08.614]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:33:08.614] getGlobalsAndPackages() ...
[15:33:08.615] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:33:08.615] Resolving globals: FALSE
[15:33:08.616] The total size of the 5 globals is 6.22 KiB (6368 bytes)
[15:33:08.616] The total size of the 5 globals exported for future expression ('{; ...future.globals.maxSize.org <- getOption("future.globals.maxSize"); if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {; oopts <- options(future.globals.maxSize = ...future.globals.maxSize); on.exit(options(oopts), add = TRUE); }; ...; do.call(mapply, args = args); }; }') is 6.22 KiB.. This exceeds the maximum allowed size of 0.98 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (6.11 KiB of class 'function'), '...future.elements_ii' (112 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[15:33:08.617] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:33:08.617] 
[15:33:08.617] getGlobalsAndPackages() ... DONE
[15:33:08.617] run() for 'Future' ...
[15:33:08.618] - state: 'created'
[15:33:08.618] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:33:08.635] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:33:08.636] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:33:08.636]   - Field: 'node'
[15:33:08.636]   - Field: 'label'
[15:33:08.636]   - Field: 'local'
[15:33:08.637]   - Field: 'owner'
[15:33:08.637]   - Field: 'envir'
[15:33:08.637]   - Field: 'workers'
[15:33:08.638]   - Field: 'packages'
[15:33:08.638]   - Field: 'gc'
[15:33:08.638]   - Field: 'conditions'
[15:33:08.638]   - Field: 'persistent'
[15:33:08.639]   - Field: 'expr'
[15:33:08.639]   - Field: 'uuid'
[15:33:08.639]   - Field: 'seed'
[15:33:08.640]   - Field: 'version'
[15:33:08.640]   - Field: 'result'
[15:33:08.640]   - Field: 'asynchronous'
[15:33:08.640]   - Field: 'calls'
[15:33:08.641]   - Field: 'globals'
[15:33:08.641]   - Field: 'stdout'
[15:33:08.641]   - Field: 'earlySignal'
[15:33:08.641]   - Field: 'lazy'
[15:33:08.642]   - Field: 'state'
[15:33:08.642] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:33:08.642] - Launch lazy future ...
[15:33:08.643] Packages needed by the future expression (n = 0): <none>
[15:33:08.643] Packages needed by future strategies (n = 0): <none>
[15:33:08.644] {
[15:33:08.644]     {
[15:33:08.644]         {
[15:33:08.644]             ...future.startTime <- base::Sys.time()
[15:33:08.644]             {
[15:33:08.644]                 {
[15:33:08.644]                   {
[15:33:08.644]                     {
[15:33:08.644]                       base::local({
[15:33:08.644]                         has_future <- base::requireNamespace("future", 
[15:33:08.644]                           quietly = TRUE)
[15:33:08.644]                         if (has_future) {
[15:33:08.644]                           ns <- base::getNamespace("future")
[15:33:08.644]                           version <- ns[[".package"]][["version"]]
[15:33:08.644]                           if (is.null(version)) 
[15:33:08.644]                             version <- utils::packageVersion("future")
[15:33:08.644]                         }
[15:33:08.644]                         else {
[15:33:08.644]                           version <- NULL
[15:33:08.644]                         }
[15:33:08.644]                         if (!has_future || version < "1.8.0") {
[15:33:08.644]                           info <- base::c(r_version = base::gsub("R version ", 
[15:33:08.644]                             "", base::R.version$version.string), 
[15:33:08.644]                             platform = base::sprintf("%s (%s-bit)", 
[15:33:08.644]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:33:08.644]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:33:08.644]                               "release", "version")], collapse = " "), 
[15:33:08.644]                             hostname = base::Sys.info()[["nodename"]])
[15:33:08.644]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:33:08.644]                             info)
[15:33:08.644]                           info <- base::paste(info, collapse = "; ")
[15:33:08.644]                           if (!has_future) {
[15:33:08.644]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:33:08.644]                               info)
[15:33:08.644]                           }
[15:33:08.644]                           else {
[15:33:08.644]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:33:08.644]                               info, version)
[15:33:08.644]                           }
[15:33:08.644]                           base::stop(msg)
[15:33:08.644]                         }
[15:33:08.644]                       })
[15:33:08.644]                     }
[15:33:08.644]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:33:08.644]                     base::options(mc.cores = 1L)
[15:33:08.644]                   }
[15:33:08.644]                   ...future.strategy.old <- future::plan("list")
[15:33:08.644]                   options(future.plan = NULL)
[15:33:08.644]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:33:08.644]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:33:08.644]                 }
[15:33:08.644]                 ...future.workdir <- getwd()
[15:33:08.644]             }
[15:33:08.644]             ...future.oldOptions <- base::as.list(base::.Options)
[15:33:08.644]             ...future.oldEnvVars <- base::Sys.getenv()
[15:33:08.644]         }
[15:33:08.644]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:33:08.644]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:33:08.644]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:33:08.644]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:33:08.644]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:33:08.644]             future.stdout.windows.reencode = NULL, width = 80L)
[15:33:08.644]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:33:08.644]             base::names(...future.oldOptions))
[15:33:08.644]     }
[15:33:08.644]     if (TRUE) {
[15:33:08.644]     }
[15:33:08.644]     else {
[15:33:08.644]         if (NA) {
[15:33:08.644]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:33:08.644]                 open = "w")
[15:33:08.644]         }
[15:33:08.644]         else {
[15:33:08.644]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:33:08.644]                 windows = "NUL", "/dev/null"), open = "w")
[15:33:08.644]         }
[15:33:08.644]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:33:08.644]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:33:08.644]             base::sink(type = "output", split = FALSE)
[15:33:08.644]             base::close(...future.stdout)
[15:33:08.644]         }, add = TRUE)
[15:33:08.644]     }
[15:33:08.644]     ...future.frame <- base::sys.nframe()
[15:33:08.644]     ...future.conditions <- base::list()
[15:33:08.644]     ...future.rng <- base::globalenv()$.Random.seed
[15:33:08.644]     if (FALSE) {
[15:33:08.644]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:33:08.644]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:33:08.644]     }
[15:33:08.644]     ...future.result <- base::tryCatch({
[15:33:08.644]         base::withCallingHandlers({
[15:33:08.644]             ...future.value <- base::withVisible(base::local({
[15:33:08.644]                 ...future.makeSendCondition <- base::local({
[15:33:08.644]                   sendCondition <- NULL
[15:33:08.644]                   function(frame = 1L) {
[15:33:08.644]                     if (is.function(sendCondition)) 
[15:33:08.644]                       return(sendCondition)
[15:33:08.644]                     ns <- getNamespace("parallel")
[15:33:08.644]                     if (exists("sendData", mode = "function", 
[15:33:08.644]                       envir = ns)) {
[15:33:08.644]                       parallel_sendData <- get("sendData", mode = "function", 
[15:33:08.644]                         envir = ns)
[15:33:08.644]                       envir <- sys.frame(frame)
[15:33:08.644]                       master <- NULL
[15:33:08.644]                       while (!identical(envir, .GlobalEnv) && 
[15:33:08.644]                         !identical(envir, emptyenv())) {
[15:33:08.644]                         if (exists("master", mode = "list", envir = envir, 
[15:33:08.644]                           inherits = FALSE)) {
[15:33:08.644]                           master <- get("master", mode = "list", 
[15:33:08.644]                             envir = envir, inherits = FALSE)
[15:33:08.644]                           if (inherits(master, c("SOCKnode", 
[15:33:08.644]                             "SOCK0node"))) {
[15:33:08.644]                             sendCondition <<- function(cond) {
[15:33:08.644]                               data <- list(type = "VALUE", value = cond, 
[15:33:08.644]                                 success = TRUE)
[15:33:08.644]                               parallel_sendData(master, data)
[15:33:08.644]                             }
[15:33:08.644]                             return(sendCondition)
[15:33:08.644]                           }
[15:33:08.644]                         }
[15:33:08.644]                         frame <- frame + 1L
[15:33:08.644]                         envir <- sys.frame(frame)
[15:33:08.644]                       }
[15:33:08.644]                     }
[15:33:08.644]                     sendCondition <<- function(cond) NULL
[15:33:08.644]                   }
[15:33:08.644]                 })
[15:33:08.644]                 withCallingHandlers({
[15:33:08.644]                   {
[15:33:08.644]                     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:33:08.644]                     if (!identical(...future.globals.maxSize.org, 
[15:33:08.644]                       ...future.globals.maxSize)) {
[15:33:08.644]                       oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:33:08.644]                       on.exit(options(oopts), add = TRUE)
[15:33:08.644]                     }
[15:33:08.644]                     {
[15:33:08.644]                       args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:33:08.644]                         MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:33:08.644]                         USE.NAMES = FALSE)
[15:33:08.644]                       do.call(mapply, args = args)
[15:33:08.644]                     }
[15:33:08.644]                   }
[15:33:08.644]                 }, immediateCondition = function(cond) {
[15:33:08.644]                   sendCondition <- ...future.makeSendCondition()
[15:33:08.644]                   sendCondition(cond)
[15:33:08.644]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:33:08.644]                   {
[15:33:08.644]                     inherits <- base::inherits
[15:33:08.644]                     invokeRestart <- base::invokeRestart
[15:33:08.644]                     is.null <- base::is.null
[15:33:08.644]                     muffled <- FALSE
[15:33:08.644]                     if (inherits(cond, "message")) {
[15:33:08.644]                       muffled <- grepl(pattern, "muffleMessage")
[15:33:08.644]                       if (muffled) 
[15:33:08.644]                         invokeRestart("muffleMessage")
[15:33:08.644]                     }
[15:33:08.644]                     else if (inherits(cond, "warning")) {
[15:33:08.644]                       muffled <- grepl(pattern, "muffleWarning")
[15:33:08.644]                       if (muffled) 
[15:33:08.644]                         invokeRestart("muffleWarning")
[15:33:08.644]                     }
[15:33:08.644]                     else if (inherits(cond, "condition")) {
[15:33:08.644]                       if (!is.null(pattern)) {
[15:33:08.644]                         computeRestarts <- base::computeRestarts
[15:33:08.644]                         grepl <- base::grepl
[15:33:08.644]                         restarts <- computeRestarts(cond)
[15:33:08.644]                         for (restart in restarts) {
[15:33:08.644]                           name <- restart$name
[15:33:08.644]                           if (is.null(name)) 
[15:33:08.644]                             next
[15:33:08.644]                           if (!grepl(pattern, name)) 
[15:33:08.644]                             next
[15:33:08.644]                           invokeRestart(restart)
[15:33:08.644]                           muffled <- TRUE
[15:33:08.644]                           break
[15:33:08.644]                         }
[15:33:08.644]                       }
[15:33:08.644]                     }
[15:33:08.644]                     invisible(muffled)
[15:33:08.644]                   }
[15:33:08.644]                   muffleCondition(cond)
[15:33:08.644]                 })
[15:33:08.644]             }))
[15:33:08.644]             future::FutureResult(value = ...future.value$value, 
[15:33:08.644]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:33:08.644]                   ...future.rng), globalenv = if (FALSE) 
[15:33:08.644]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:33:08.644]                     ...future.globalenv.names))
[15:33:08.644]                 else NULL, started = ...future.startTime, version = "1.8")
[15:33:08.644]         }, condition = base::local({
[15:33:08.644]             c <- base::c
[15:33:08.644]             inherits <- base::inherits
[15:33:08.644]             invokeRestart <- base::invokeRestart
[15:33:08.644]             length <- base::length
[15:33:08.644]             list <- base::list
[15:33:08.644]             seq.int <- base::seq.int
[15:33:08.644]             signalCondition <- base::signalCondition
[15:33:08.644]             sys.calls <- base::sys.calls
[15:33:08.644]             `[[` <- base::`[[`
[15:33:08.644]             `+` <- base::`+`
[15:33:08.644]             `<<-` <- base::`<<-`
[15:33:08.644]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:33:08.644]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:33:08.644]                   3L)]
[15:33:08.644]             }
[15:33:08.644]             function(cond) {
[15:33:08.644]                 is_error <- inherits(cond, "error")
[15:33:08.644]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:33:08.644]                   NULL)
[15:33:08.644]                 if (is_error) {
[15:33:08.644]                   sessionInformation <- function() {
[15:33:08.644]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:33:08.644]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:33:08.644]                       search = base::search(), system = base::Sys.info())
[15:33:08.644]                   }
[15:33:08.644]                   ...future.conditions[[length(...future.conditions) + 
[15:33:08.644]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:33:08.644]                     cond$call), session = sessionInformation(), 
[15:33:08.644]                     timestamp = base::Sys.time(), signaled = 0L)
[15:33:08.644]                   signalCondition(cond)
[15:33:08.644]                 }
[15:33:08.644]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:33:08.644]                 "immediateCondition"))) {
[15:33:08.644]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:33:08.644]                   ...future.conditions[[length(...future.conditions) + 
[15:33:08.644]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:33:08.644]                   if (TRUE && !signal) {
[15:33:08.644]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:33:08.644]                     {
[15:33:08.644]                       inherits <- base::inherits
[15:33:08.644]                       invokeRestart <- base::invokeRestart
[15:33:08.644]                       is.null <- base::is.null
[15:33:08.644]                       muffled <- FALSE
[15:33:08.644]                       if (inherits(cond, "message")) {
[15:33:08.644]                         muffled <- grepl(pattern, "muffleMessage")
[15:33:08.644]                         if (muffled) 
[15:33:08.644]                           invokeRestart("muffleMessage")
[15:33:08.644]                       }
[15:33:08.644]                       else if (inherits(cond, "warning")) {
[15:33:08.644]                         muffled <- grepl(pattern, "muffleWarning")
[15:33:08.644]                         if (muffled) 
[15:33:08.644]                           invokeRestart("muffleWarning")
[15:33:08.644]                       }
[15:33:08.644]                       else if (inherits(cond, "condition")) {
[15:33:08.644]                         if (!is.null(pattern)) {
[15:33:08.644]                           computeRestarts <- base::computeRestarts
[15:33:08.644]                           grepl <- base::grepl
[15:33:08.644]                           restarts <- computeRestarts(cond)
[15:33:08.644]                           for (restart in restarts) {
[15:33:08.644]                             name <- restart$name
[15:33:08.644]                             if (is.null(name)) 
[15:33:08.644]                               next
[15:33:08.644]                             if (!grepl(pattern, name)) 
[15:33:08.644]                               next
[15:33:08.644]                             invokeRestart(restart)
[15:33:08.644]                             muffled <- TRUE
[15:33:08.644]                             break
[15:33:08.644]                           }
[15:33:08.644]                         }
[15:33:08.644]                       }
[15:33:08.644]                       invisible(muffled)
[15:33:08.644]                     }
[15:33:08.644]                     muffleCondition(cond, pattern = "^muffle")
[15:33:08.644]                   }
[15:33:08.644]                 }
[15:33:08.644]                 else {
[15:33:08.644]                   if (TRUE) {
[15:33:08.644]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:33:08.644]                     {
[15:33:08.644]                       inherits <- base::inherits
[15:33:08.644]                       invokeRestart <- base::invokeRestart
[15:33:08.644]                       is.null <- base::is.null
[15:33:08.644]                       muffled <- FALSE
[15:33:08.644]                       if (inherits(cond, "message")) {
[15:33:08.644]                         muffled <- grepl(pattern, "muffleMessage")
[15:33:08.644]                         if (muffled) 
[15:33:08.644]                           invokeRestart("muffleMessage")
[15:33:08.644]                       }
[15:33:08.644]                       else if (inherits(cond, "warning")) {
[15:33:08.644]                         muffled <- grepl(pattern, "muffleWarning")
[15:33:08.644]                         if (muffled) 
[15:33:08.644]                           invokeRestart("muffleWarning")
[15:33:08.644]                       }
[15:33:08.644]                       else if (inherits(cond, "condition")) {
[15:33:08.644]                         if (!is.null(pattern)) {
[15:33:08.644]                           computeRestarts <- base::computeRestarts
[15:33:08.644]                           grepl <- base::grepl
[15:33:08.644]                           restarts <- computeRestarts(cond)
[15:33:08.644]                           for (restart in restarts) {
[15:33:08.644]                             name <- restart$name
[15:33:08.644]                             if (is.null(name)) 
[15:33:08.644]                               next
[15:33:08.644]                             if (!grepl(pattern, name)) 
[15:33:08.644]                               next
[15:33:08.644]                             invokeRestart(restart)
[15:33:08.644]                             muffled <- TRUE
[15:33:08.644]                             break
[15:33:08.644]                           }
[15:33:08.644]                         }
[15:33:08.644]                       }
[15:33:08.644]                       invisible(muffled)
[15:33:08.644]                     }
[15:33:08.644]                     muffleCondition(cond, pattern = "^muffle")
[15:33:08.644]                   }
[15:33:08.644]                 }
[15:33:08.644]             }
[15:33:08.644]         }))
[15:33:08.644]     }, error = function(ex) {
[15:33:08.644]         base::structure(base::list(value = NULL, visible = NULL, 
[15:33:08.644]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:33:08.644]                 ...future.rng), started = ...future.startTime, 
[15:33:08.644]             finished = Sys.time(), session_uuid = NA_character_, 
[15:33:08.644]             version = "1.8"), class = "FutureResult")
[15:33:08.644]     }, finally = {
[15:33:08.644]         if (!identical(...future.workdir, getwd())) 
[15:33:08.644]             setwd(...future.workdir)
[15:33:08.644]         {
[15:33:08.644]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:33:08.644]                 ...future.oldOptions$nwarnings <- NULL
[15:33:08.644]             }
[15:33:08.644]             base::options(...future.oldOptions)
[15:33:08.644]             if (.Platform$OS.type == "windows") {
[15:33:08.644]                 old_names <- names(...future.oldEnvVars)
[15:33:08.644]                 envs <- base::Sys.getenv()
[15:33:08.644]                 names <- names(envs)
[15:33:08.644]                 common <- intersect(names, old_names)
[15:33:08.644]                 added <- setdiff(names, old_names)
[15:33:08.644]                 removed <- setdiff(old_names, names)
[15:33:08.644]                 changed <- common[...future.oldEnvVars[common] != 
[15:33:08.644]                   envs[common]]
[15:33:08.644]                 NAMES <- toupper(changed)
[15:33:08.644]                 args <- list()
[15:33:08.644]                 for (kk in seq_along(NAMES)) {
[15:33:08.644]                   name <- changed[[kk]]
[15:33:08.644]                   NAME <- NAMES[[kk]]
[15:33:08.644]                   if (name != NAME && is.element(NAME, old_names)) 
[15:33:08.644]                     next
[15:33:08.644]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:33:08.644]                 }
[15:33:08.644]                 NAMES <- toupper(added)
[15:33:08.644]                 for (kk in seq_along(NAMES)) {
[15:33:08.644]                   name <- added[[kk]]
[15:33:08.644]                   NAME <- NAMES[[kk]]
[15:33:08.644]                   if (name != NAME && is.element(NAME, old_names)) 
[15:33:08.644]                     next
[15:33:08.644]                   args[[name]] <- ""
[15:33:08.644]                 }
[15:33:08.644]                 NAMES <- toupper(removed)
[15:33:08.644]                 for (kk in seq_along(NAMES)) {
[15:33:08.644]                   name <- removed[[kk]]
[15:33:08.644]                   NAME <- NAMES[[kk]]
[15:33:08.644]                   if (name != NAME && is.element(NAME, old_names)) 
[15:33:08.644]                     next
[15:33:08.644]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:33:08.644]                 }
[15:33:08.644]                 if (length(args) > 0) 
[15:33:08.644]                   base::do.call(base::Sys.setenv, args = args)
[15:33:08.644]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:33:08.644]             }
[15:33:08.644]             else {
[15:33:08.644]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:33:08.644]             }
[15:33:08.644]             {
[15:33:08.644]                 if (base::length(...future.futureOptionsAdded) > 
[15:33:08.644]                   0L) {
[15:33:08.644]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:33:08.644]                   base::names(opts) <- ...future.futureOptionsAdded
[15:33:08.644]                   base::options(opts)
[15:33:08.644]                 }
[15:33:08.644]                 {
[15:33:08.644]                   {
[15:33:08.644]                     base::options(mc.cores = ...future.mc.cores.old)
[15:33:08.644]                     NULL
[15:33:08.644]                   }
[15:33:08.644]                   options(future.plan = NULL)
[15:33:08.644]                   if (is.na(NA_character_)) 
[15:33:08.644]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:33:08.644]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:33:08.644]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:33:08.644]                     .init = FALSE)
[15:33:08.644]                 }
[15:33:08.644]             }
[15:33:08.644]         }
[15:33:08.644]     })
[15:33:08.644]     if (FALSE) {
[15:33:08.644]         base::sink(type = "output", split = FALSE)
[15:33:08.644]         if (NA) {
[15:33:08.644]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:33:08.644]         }
[15:33:08.644]         else {
[15:33:08.644]             ...future.result["stdout"] <- base::list(NULL)
[15:33:08.644]         }
[15:33:08.644]         base::close(...future.stdout)
[15:33:08.644]         ...future.stdout <- NULL
[15:33:08.644]     }
[15:33:08.644]     ...future.result$conditions <- ...future.conditions
[15:33:08.644]     ...future.result$finished <- base::Sys.time()
[15:33:08.644]     ...future.result
[15:33:08.644] }
[15:33:08.653] Exporting 5 global objects (6.22 KiB) to cluster node #2 ...
[15:33:08.653] Exporting '...future.FUN' (6.11 KiB) to cluster node #2 ...
[15:33:08.654] Exporting '...future.FUN' (6.11 KiB) to cluster node #2 ... DONE
[15:33:08.654] Exporting 'MoreArgs' (0 bytes) to cluster node #2 ...
[15:33:08.655] Exporting 'MoreArgs' (0 bytes) to cluster node #2 ... DONE
[15:33:08.655] Exporting '...future.elements_ii' (112 bytes) to cluster node #2 ...
[15:33:08.656] Exporting '...future.elements_ii' (112 bytes) to cluster node #2 ... DONE
[15:33:08.656] Exporting '...future.seeds_ii' (0 bytes) to cluster node #2 ...
[15:33:08.657] Exporting '...future.seeds_ii' (0 bytes) to cluster node #2 ... DONE
[15:33:08.658] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #2 ...
[15:33:08.658] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #2 ... DONE
[15:33:08.658] Exporting 5 global objects (6.22 KiB) to cluster node #2 ... DONE
[15:33:08.659] MultisessionFuture started
[15:33:08.660] - Launch lazy future ... done
[15:33:08.660] run() for 'MultisessionFuture' ... done
[15:33:08.661] Created future:
[15:33:08.679] receiveMessageFromWorker() for ClusterFuture ...
[15:33:08.679] - Validating connection of MultisessionFuture
[15:33:08.680] - received message: FutureResult
[15:33:08.680] - Received FutureResult
[15:33:08.680] - Erased future from FutureRegistry
[15:33:08.680] result() for ClusterFuture ...
[15:33:08.680] - result already collected: FutureResult
[15:33:08.681] result() for ClusterFuture ... done
[15:33:08.681] receiveMessageFromWorker() for ClusterFuture ... done
[15:33:08.661] MultisessionFuture:
[15:33:08.661] Label: 'future_mapply-2'
[15:33:08.661] Expression:
[15:33:08.661] {
[15:33:08.661]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:33:08.661]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:33:08.661]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:33:08.661]         on.exit(options(oopts), add = TRUE)
[15:33:08.661]     }
[15:33:08.661]     {
[15:33:08.661]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:33:08.661]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:33:08.661]         do.call(mapply, args = args)
[15:33:08.661]     }
[15:33:08.661] }
[15:33:08.661] Lazy evaluation: FALSE
[15:33:08.661] Asynchronous evaluation: TRUE
[15:33:08.661] Local evaluation: TRUE
[15:33:08.661] Environment: R_GlobalEnv
[15:33:08.661] Capture standard output: NA
[15:33:08.661] Capture condition classes: 'condition' (excluding 'nothing')
[15:33:08.661] Globals: 5 objects totaling 6.22 KiB (function '...future.FUN' of 6.11 KiB, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 112 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:33:08.661] Packages: <none>
[15:33:08.661] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:33:08.661] Resolved: TRUE
[15:33:08.661] Value: <not collected>
[15:33:08.661] Conditions captured: <none>
[15:33:08.661] Early signaling: FALSE
[15:33:08.661] Owner process: bdd4bc13-919d-bf34-b2cf-84eb53f6e11f
[15:33:08.661] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:33:08.681] Chunk #2 of 2 ... DONE
[15:33:08.682] Launching 2 futures (chunks) ... DONE
[15:33:08.682] Resolving 2 futures (chunks) ...
[15:33:08.682] resolve() on list ...
[15:33:08.682]  recursive: 0
[15:33:08.682]  length: 2
[15:33:08.683] 
[15:33:08.875] Future #2
[15:33:08.875] result() for ClusterFuture ...
[15:33:08.876] - result already collected: FutureResult
[15:33:08.876] result() for ClusterFuture ... done
[15:33:08.876] result() for ClusterFuture ...
[15:33:08.876] - result already collected: FutureResult
[15:33:08.877] result() for ClusterFuture ... done
[15:33:08.877] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:33:08.877] - nx: 2
[15:33:08.878] - relay: TRUE
[15:33:08.878] - stdout: TRUE
[15:33:08.878] - signal: TRUE
[15:33:08.879] - resignal: FALSE
[15:33:08.879] - force: TRUE
[15:33:08.879] - relayed: [n=2] FALSE, FALSE
[15:33:08.879] - queued futures: [n=2] FALSE, FALSE
[15:33:08.880]  - until=1
[15:33:08.880]  - relaying element #1
[15:33:08.880] - relayed: [n=2] FALSE, FALSE
[15:33:08.880] - queued futures: [n=2] FALSE, TRUE
[15:33:08.881] signalConditionsASAP(NULL, pos=2) ... done
[15:33:08.881]  length: 1 (resolved future 2)
[15:33:08.946] receiveMessageFromWorker() for ClusterFuture ...
[15:33:08.946] - Validating connection of MultisessionFuture
[15:33:08.947] - received message: FutureResult
[15:33:08.947] - Received FutureResult
[15:33:08.947] - Erased future from FutureRegistry
[15:33:08.947] result() for ClusterFuture ...
[15:33:08.948] - result already collected: FutureResult
[15:33:08.948] result() for ClusterFuture ... done
[15:33:08.948] receiveMessageFromWorker() for ClusterFuture ... done
[15:33:08.949] Future #1
[15:33:08.949] result() for ClusterFuture ...
[15:33:08.949] - result already collected: FutureResult
[15:33:08.949] result() for ClusterFuture ... done
[15:33:08.950] result() for ClusterFuture ...
[15:33:08.950] - result already collected: FutureResult
[15:33:08.950] result() for ClusterFuture ... done
[15:33:08.951] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:33:08.951] - nx: 2
[15:33:08.951] - relay: TRUE
[15:33:08.951] - stdout: TRUE
[15:33:08.952] - signal: TRUE
[15:33:08.952] - resignal: FALSE
[15:33:08.952] - force: TRUE
[15:33:08.952] - relayed: [n=2] FALSE, FALSE
[15:33:08.953] - queued futures: [n=2] FALSE, TRUE
[15:33:08.953]  - until=1
[15:33:08.953]  - relaying element #1
[15:33:08.954] result() for ClusterFuture ...
[15:33:08.954] - result already collected: FutureResult
[15:33:08.954] result() for ClusterFuture ... done
[15:33:08.954] result() for ClusterFuture ...
[15:33:08.955] - result already collected: FutureResult
[15:33:08.955] result() for ClusterFuture ... done
[15:33:08.955] result() for ClusterFuture ...
[15:33:08.956] - result already collected: FutureResult
[15:33:08.956] result() for ClusterFuture ... done
[15:33:08.956] result() for ClusterFuture ...
[15:33:08.957] - result already collected: FutureResult
[15:33:08.957] result() for ClusterFuture ... done
[15:33:08.957] - relayed: [n=2] TRUE, FALSE
[15:33:08.957] - queued futures: [n=2] TRUE, TRUE
[15:33:08.958] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:33:08.958]  length: 0 (resolved future 1)
[15:33:08.958] Relaying remaining futures
[15:33:08.959] signalConditionsASAP(NULL, pos=0) ...
[15:33:08.959] - nx: 2
[15:33:08.959] - relay: TRUE
[15:33:08.959] - stdout: TRUE
[15:33:08.960] - signal: TRUE
[15:33:08.960] - resignal: FALSE
[15:33:08.960] - force: TRUE
[15:33:08.960] - relayed: [n=2] TRUE, FALSE
[15:33:08.961] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:33:08.961]  - relaying element #2
[15:33:08.961] result() for ClusterFuture ...
[15:33:08.962] - result already collected: FutureResult
[15:33:08.962] result() for ClusterFuture ... done
[15:33:08.962] result() for ClusterFuture ...
[15:33:08.963] - result already collected: FutureResult
[15:33:08.963] result() for ClusterFuture ... done
[15:33:08.963] result() for ClusterFuture ...
[15:33:08.963] - result already collected: FutureResult
[15:33:08.964] result() for ClusterFuture ... done
[15:33:08.964] result() for ClusterFuture ...
[15:33:08.964] - result already collected: FutureResult
[15:33:08.964] result() for ClusterFuture ... done
[15:33:08.965] - relayed: [n=2] TRUE, TRUE
[15:33:08.965] - queued futures: [n=2] TRUE, TRUE
[15:33:08.965] signalConditionsASAP(MultisessionFuture, pos=0) ... done
[15:33:08.966] resolve() on list ... DONE
[15:33:08.966] result() for ClusterFuture ...
[15:33:08.966] - result already collected: FutureResult
[15:33:08.966] result() for ClusterFuture ... done
[15:33:08.967] result() for ClusterFuture ...
[15:33:08.967] - result already collected: FutureResult
[15:33:08.967] result() for ClusterFuture ... done
[15:33:08.968] result() for ClusterFuture ...
[15:33:08.968] - result already collected: FutureResult
[15:33:08.968] result() for ClusterFuture ... done
[15:33:08.968] result() for ClusterFuture ...
[15:33:08.969] - result already collected: FutureResult
[15:33:08.969] result() for ClusterFuture ... done
[15:33:08.969]  - Number of value chunks collected: 2
[15:33:08.970] Resolving 2 futures (chunks) ... DONE
[15:33:08.970] Reducing values from 2 chunks ...
[15:33:08.970]  - Number of values collected after concatenation: 2
[15:33:08.970]  - Number of values expected: 2
[15:33:08.971] Reducing values from 2 chunks ... DONE
[15:33:08.971] future_mapply() ... DONE
* future_mapply(x, ..., future.stdout = NA) ... DONE
* plan('multisession') ... DONE
  - Testing with 2 cores ... DONE
> 
> message("*** future_*apply() and 'future.stdout' ... DONE")
*** future_*apply() and 'future.stdout' ... DONE
> 
> source("incl/end.R")
[15:33:08.973] plan(): Setting new future strategy stack:
[15:33:08.973] List of future strategies:
[15:33:08.973] 1. FutureStrategy:
[15:33:08.973]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:33:08.973]    - tweaked: FALSE
[15:33:08.973]    - call: future::plan(oplan)
[15:33:08.975] plan(): nbrOfWorkers() = 1
> 
> proc.time()
   user  system elapsed 
   2.46    0.23   12.53